@optifye/dashboard-core 6.10.21 → 6.10.22

package/dist/index.mjs

@@ -7,7 +7,7 @@ import { startOfMonth, endOfMonth, eachDayOfInterval, getDay, isSameDay, isWithi
 import mixpanel from 'mixpanel-browser';
 import { EventEmitter } from 'events';
 import { createClient, REALTIME_SUBSCRIBE_STATES } from '@supabase/supabase-js';
-import Hls3, { Events, ErrorTypes } from 'hls.js';
+import Hls, { Events, ErrorTypes } from 'hls.js';
 import useSWR from 'swr';
 import { noop, warning, invariant, progress, secondsToMilliseconds, millisecondsToSeconds, memo as memo$1 } from 'motion-utils';
 import { getValueTransition, hover, press, isPrimaryPointer, GroupPlaybackControls, setDragLock, supportsLinearEasing, attachTimeline, isGenerator, calcGeneratorDuration, isWaapiSupportedEasing, mapEasingToNativeEasing, maxGeneratorDuration, generateLinearEasing, isBezierDefinition } from 'motion-dom';
@@ -429,6 +429,9 @@ var _getSupabaseInstance = () => {
   }
   return supabaseInstance;
 };
+var _getSupabaseInstanceOptional = () => {
+  return supabaseInstance;
+};
 
 // src/lib/services/actionService.ts
 var actionService = {
@@ -2060,6 +2063,11 @@ var workspaceService = {
   _workspacesInFlight: /* @__PURE__ */ new Map(),
   _workspacesCacheExpiryMs: 10 * 60 * 1e3,
   // 10 minutes cache
+  // Cache for workspace video streams (R2 mapping + crops)
+  _workspaceVideoStreamsCache: /* @__PURE__ */ new Map(),
+  _workspaceVideoStreamsInFlight: /* @__PURE__ */ new Map(),
+  _workspaceVideoStreamsCacheExpiryMs: 5 * 60 * 1e3,
+  // 5 minutes cache
   async getWorkspaces(lineId, options) {
     const enabledOnly = options?.enabledOnly ?? false;
     const force = options?.force ?? false;
@@ -2106,6 +2114,61 @@ var workspaceService = {
   async getEnabledWorkspaces(lineId, options) {
     return this.getWorkspaces(lineId, { enabledOnly: true, force: options?.force });
   },
+  async getWorkspaceVideoStreams(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 now2 = Date.now();
+    const cached = this._workspaceVideoStreamsCache.get(cacheKey);
+    if (!force && cached && now2 - cached.timestamp < this._workspaceVideoStreamsCacheExpiryMs) {
+      return cached.streams;
+    }
+    const inFlight = this._workspaceVideoStreamsInFlight.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/video-streams`, {
+          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 streams = data.streams || {};
+        this._workspaceVideoStreamsCache.set(cacheKey, {
+          streams,
+          timestamp: Date.now()
+        });
+        return streams;
+      } catch (error) {
+        console.error("Error fetching workspace video streams:", error);
+        throw error;
+      } finally {
+        this._workspaceVideoStreamsInFlight.delete(cacheKey);
+      }
+    })();
+    this._workspaceVideoStreamsInFlight.set(cacheKey, fetchPromise);
+    return fetchPromise;
+  },
   /**
    * Fetches workspace display names from the database
    * Returns a map of workspace_id -> display_name
@@ -4915,13 +4978,98 @@ function isValidShiftId(shiftId) {
   const id3 = typeof shiftId === "string" ? parseInt(shiftId, 10) : shiftId;
   return Number.isFinite(id3) && id3 >= 0;
 }
+var createSupabaseClient = (url, key) => createClient(url, key, {
+  auth: {
+    autoRefreshToken: true,
+    persistSession: true,
+    detectSessionInUrl: true,
+    flowType: "pkce",
+    // Enable debug logging in development
+    debug: process.env.NODE_ENV === "development"
+  },
+  db: {
+    schema: "public"
+    // Default schema, we'll use .schema('ai') in queries
+  },
+  global: {
+    headers: {
+      "x-application-name": "optifye-dashboard"
+    },
+    // Add global fetch timeout (5 minutes)
+    fetch: async (url2, options = {}) => {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 3e5);
+      try {
+        const response = await fetch(url2, {
+          ...options,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        return response;
+      } catch (error) {
+        clearTimeout(timeoutId);
+        throw error;
+      }
+    }
+  }
+});
+var getAnonClient = () => {
+  const url = process.env.NEXT_PUBLIC_SUPABASE_URL || "";
+  const key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "";
+  if (!url || !key) {
+    console.warn("[dashboard-core] Missing supabase env variables");
+  }
+  return createClient(url, key, {
+    auth: {
+      autoRefreshToken: true,
+      persistSession: true,
+      detectSessionInUrl: true,
+      flowType: "pkce",
+      debug: process.env.NODE_ENV === "development"
+    },
+    global: {
+      headers: {
+        "x-application-name": "optifye-dashboard"
+      },
+      // Add global fetch timeout (5 minutes)
+      fetch: async (url2, options = {}) => {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3e5);
+        try {
+          const response = await fetch(url2, {
+            ...options,
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          return response;
+        } catch (error) {
+          clearTimeout(timeoutId);
+          throw error;
+        }
+      }
+    }
+  });
+};
+
+// src/lib/api/s3-clips-supabase.ts
+var cachedClient = null;
+var cachedConfig = null;
 var getSupabaseClient = () => {
+  const existing = _getSupabaseInstanceOptional();
+  if (existing) {
+    return existing;
+  }
   const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
   const key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
   if (!url || !key) {
     throw new Error("Supabase configuration missing");
   }
-  return createClient(url, key);
+  if (!cachedClient || cachedConfig?.url !== url || cachedConfig?.key !== key) {
+    cachedClient = createSupabaseClient(url, key);
+    cachedConfig = { url, key };
+    _setSupabaseInstance(cachedClient);
+  }
+  return cachedClient;
 };
 var getAuthToken3 = async () => {
   try {
@@ -5983,9 +6131,13 @@ var createSupervisorService = (supabase) => {
 var simulateApiDelay = (ms = 1e3) => {
   return new Promise((resolve) => setTimeout(resolve, ms));
 };
+
+// src/lib/services/timezone.ts
 var TimezoneService = class _TimezoneService {
   constructor() {
     this.timezoneCache = /* @__PURE__ */ new Map();
+    this.fallbackClient = null;
+    this.fallbackConfig = null;
     this.supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL || "";
     this.supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "";
   }
@@ -5995,6 +6147,21 @@ var TimezoneService = class _TimezoneService {
     }
     return _TimezoneService.instance;
   }
+  getClient() {
+    const existing = _getSupabaseInstanceOptional();
+    if (existing) {
+      return existing;
+    }
+    if (!this.supabaseUrl || !this.supabaseAnonKey) {
+      throw new Error("Supabase configuration missing");
+    }
+    if (!this.fallbackClient || this.fallbackConfig?.url !== this.supabaseUrl || this.fallbackConfig?.key !== this.supabaseAnonKey) {
+      this.fallbackClient = createSupabaseClient(this.supabaseUrl, this.supabaseAnonKey);
+      this.fallbackConfig = { url: this.supabaseUrl, key: this.supabaseAnonKey };
+      _setSupabaseInstance(this.fallbackClient);
+    }
+    return this.fallbackClient;
+  }
   /**
    * Fetch timezone for a specific line from Supabase
    */
@@ -6003,7 +6170,7 @@ var TimezoneService = class _TimezoneService {
       return this.timezoneCache.get(lineId);
     }
     try {
-      const supabase = createClient(this.supabaseUrl, this.supabaseAnonKey);
+      const supabase = this.getClient();
       const { data, error } = await supabase.from("line_operating_hours").select("timezone").eq("line_id", lineId).order("created_at", { ascending: false }).limit(1).single();
       if (error) {
         console.warn(`Failed to fetch timezone for line ${lineId}:`, error);
@@ -6028,7 +6195,7 @@ var TimezoneService = class _TimezoneService {
       return this.timezoneCache.get(cacheKey);
     }
     try {
-      const supabase = createClient(this.supabaseUrl, this.supabaseAnonKey);
+      const supabase = this.getClient();
       const { data, error } = await supabase.from("line_operating_hours").select(`
           timezone,
           line:lines!inner(
@@ -6058,7 +6225,7 @@ var TimezoneService = class _TimezoneService {
       return this.timezoneCache.get(cacheKey);
     }
     try {
-      const supabase = createClient(this.supabaseUrl, this.supabaseAnonKey);
+      const supabase = this.getClient();
       const { data: workspaceData, error: workspaceError } = await supabase.from("workspaces").select("line_id").eq("id", workspaceId).single();
       if (workspaceError) {
         console.warn(`Failed to fetch workspace ${workspaceId}:`, workspaceError);
@@ -6090,7 +6257,7 @@ var TimezoneService = class _TimezoneService {
       return result;
     }
     try {
-      const supabase = createClient(this.supabaseUrl, this.supabaseAnonKey);
+      const supabase = this.getClient();
       const { data, error } = await supabase.from("line_operating_hours").select("line_id, timezone").in("line_id", uncachedLineIds).order("created_at", { ascending: false });
       if (error) {
         console.warn("Failed to fetch timezones for lines:", error);
@@ -7108,12 +7275,16 @@ var SupabaseProvider = ({ client, children }) => {
   const contextValue = useMemo(() => ({ supabase: client }), [client]);
   return /* @__PURE__ */ jsx(SupabaseContext.Provider, { value: contextValue, children });
 };
-var useSupabase = () => {
+var useOptionalSupabase = () => {
   const context = useContext(SupabaseContext);
-  if (context === void 0) {
+  return context?.supabase ?? null;
+};
+var useSupabase = () => {
+  const client = useOptionalSupabase();
+  if (!client) {
     throw new Error("useSupabase must be used within a SupabaseProvider.");
   }
-  return context.supabase;
+  return client;
 };
 
 // src/lib/hooks/useSessionKeepAlive.ts
@@ -10870,16 +11041,63 @@ var useWorkspaceOperators = (workspaceId, options) => {
     refetch: fetchData
   };
 };
+
+// src/lib/services/hlsAuthService.ts
+async function getAuthTokenForHls(supabase) {
+  try {
+    const { data: { session } } = await supabase.auth.getSession();
+    if (!session?.access_token) {
+      console.warn("[HLS Auth] No active session, R2 streaming may fail");
+      return null;
+    }
+    console.log("[HLS Auth] Retrieved token for HLS.js requests");
+    return session.access_token;
+  } catch (error) {
+    console.error("[HLS Auth] Error getting auth token:", error);
+    return null;
+  }
+}
+
+// src/lib/utils/r2Detection.ts
+function isR2WorkerUrl(url, r2WorkerDomain) {
+  if (!url || !r2WorkerDomain) return false;
+  try {
+    const workerDomain = new URL(r2WorkerDomain).hostname;
+    return url.includes(workerDomain);
+  } catch {
+    return url.includes(r2WorkerDomain.replace(/https?:\/\//, ""));
+  }
+}
+
+// src/lib/utils/browser.ts
+function isSafari() {
+  if (typeof window === "undefined") return false;
+  const ua = window.navigator.userAgent;
+  const isSafariUA = /^((?!chrome|android).)*safari/i.test(ua);
+  const isIOS = /iPad|iPhone|iPod/.test(ua) && !window.MSStream;
+  return isSafariUA || isIOS;
+}
+function getBrowserName() {
+  if (typeof window === "undefined") return "server";
+  const ua = window.navigator.userAgent;
+  if (/chrome/i.test(ua) && !/edge/i.test(ua)) return "chrome";
+  if (/safari/i.test(ua) && !/chrome/i.test(ua)) return "safari";
+  if (/firefox/i.test(ua)) return "firefox";
+  if (/edge/i.test(ua)) return "edge";
+  return "unknown";
+}
+
+// src/lib/hooks/useHlsStream.ts
 var HLS_CONFIG = {
-  // Buffer configuration for instant playback
-  maxBufferLength: 30,
-  // Increased for smoother playback
+  // Buffer configuration for 60s segments
+  maxBufferLength: 180,
+  // Allow ~3 segments buffered for stability
   maxMaxBufferLength: 600,
   // 10 minutes max buffer
   maxBufferSize: 120 * 1e3 * 1e3,
   // 120MB buffer size
-  maxBufferHole: 0.1,
-  // Minimal tolerance for buffer holes
+  maxBufferHole: 0.5,
+  // Tolerate minor timestamp gaps
   // Low latency optimizations
   lowLatencyMode: false,
   // We prioritize stability over latency
@@ -10890,7 +11108,7 @@ var HLS_CONFIG = {
   // Auto-select quality
   autoStartLoad: true,
   startPosition: -1,
-  // Start from beginning
+  // Start at live edge when available
   // Network optimization
   manifestLoadingMaxRetry: 6,
   levelLoadingMaxRetry: 6,
@@ -10899,9 +11117,10 @@ var HLS_CONFIG = {
   // Faster retries
   levelLoadingRetryDelay: 250,
   fragLoadingRetryDelay: 250,
-  manifestLoadingTimeOut: 2e4,
-  levelLoadingTimeOut: 2e4,
-  fragLoadingTimeOut: 2e4,
+  manifestLoadingTimeOut: 9e4,
+  levelLoadingTimeOut: 9e4,
+  fragLoadingTimeOut: 9e4,
+  maxConcurrentLoading: 2,
   // ABR (Adaptive Bitrate) settings
   abrEwmaFastLive: 3,
   abrEwmaSlowLive: 9,
@@ -10913,7 +11132,7 @@ var HLS_CONFIG = {
   abrBandWidthUpFactor: 0.7,
   abrMaxWithRealBitrate: true,
   // Fragment loading optimization
-  maxFragLookUpTolerance: 0.25,
+  maxFragLookUpTolerance: 1,
   // Enable all optimizations
   enableCEA708Captions: false,
   // Disable if not needed
@@ -10923,12 +11142,21 @@ var HLS_CONFIG = {
   // Disable if not needed
   // Progressive loading
   progressive: true,
-  liveSyncDurationCount: 2
-  // Follow live edge aggressively
+  liveSyncDurationCount: 2,
+  // Stay ~2 segments behind live for a full segment buffer
+  liveMaxLatencyDurationCount: 3,
+  // Cap drift to ~3 segments
+  maxLiveSyncPlaybackRate: 1
+  // Do not chase live edge; prioritize continuity
 };
 var failedUrls = /* @__PURE__ */ new Map();
 var MAX_FAILURES_PER_URL = 3;
 var FAILURE_EXPIRY_MS = 5 * 60 * 1e3;
+var LIVE_RELOAD_MIN_INTERVAL_MS = 15 * 1e3;
+var DEFAULT_LIVE_OFFSET_SECONDS = 120;
+var DEFAULT_MAX_MANIFEST_AGE_MS = 10 * 60 * 1e3;
+var STALE_MANIFEST_POLL_INITIAL_DELAY_MS = 15 * 1e3;
+var STALE_MANIFEST_POLL_MAX_DELAY_MS = 60 * 1e3;
 function resetFailedUrl(url) {
   if (failedUrls.has(url)) {
     console.log(`[HLS] Manually resetting failed URL: ${url}`);
@@ -10939,7 +11167,11 @@ function isUrlPermanentlyFailed(url) {
   const failure = failedUrls.get(url);
   return failure?.permanentlyFailed || false;
 }
-function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
+function useHlsStream(videoRef, { src, shouldPlay, onFatalError, hlsConfig }) {
+  const latestSrcRef = useRef(src);
+  latestSrcRef.current = src;
+  const shouldPlayRef = useRef(shouldPlay);
+  shouldPlayRef.current = shouldPlay;
   const urlFailure = failedUrls.get(src);
   const isPermanentlyFailed = urlFailure?.permanentlyFailed || false;
   const cleanupFailedUrls = () => {
@@ -10962,7 +11194,194 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
   const lastTimeUpdateRef = useRef(0);
   const softRestartCountRef = useRef(0);
   const isNativeHlsRef = useRef(false);
+  const playbackRateIntervalRef = useRef(null);
   const waitingTimerRef = useRef(null);
+  const playRetryTimerRef = useRef(null);
+  const playRetryCountRef = useRef(0);
+  const manifestWatchdogRef = useRef(null);
+  const lastHiddenAtRef = useRef(null);
+  const manifestRetryTimerRef = useRef(null);
+  const manifestRetryDelayRef = useRef(5e3);
+  const lastLiveReloadRef = useRef(0);
+  const isR2StreamRef = useRef(false);
+  const nativeStreamUrlRef = useRef(null);
+  const forcedLiveStartRef = useRef(false);
+  const activeStreamUrlRef = useRef(null);
+  const targetDurationRef = useRef(null);
+  const lastManifestLoadRef = useRef(0);
+  const lastFragLoadRef = useRef(0);
+  const lastFragSnRef = useRef(null);
+  const lastWindowStartSnRef = useRef(null);
+  const lastWindowEndSnRef = useRef(null);
+  const lastFragTimeoutSnRef = useRef(null);
+  const lastFragTimeoutAtRef = useRef(null);
+  const fragTimeoutCountRef = useRef(0);
+  const lastManifestEndSnRef = useRef(null);
+  const lastManifestEndSnUpdatedAtRef = useRef(null);
+  const staleManifestTriggeredRef = useRef(false);
+  const staleManifestUrlRef = useRef(null);
+  const staleManifestEndSnRef = useRef(null);
+  const staleManifestPollTimerRef = useRef(null);
+  const staleManifestPollDelayRef = useRef(STALE_MANIFEST_POLL_INITIAL_DELAY_MS);
+  const authTokenRef = useRef(null);
+  const proxyEnabled = process.env.NEXT_PUBLIC_HLS_PROXY_ENABLED === "true";
+  const proxyBaseUrl = (process.env.NEXT_PUBLIC_HLS_PROXY_URL || "/api/stream").replace(/\/$/, "");
+  const debugEnabled = process.env.NEXT_PUBLIC_HLS_DEBUG === "true";
+  const maxManifestAgeMs = (() => {
+    const raw = process.env.NEXT_PUBLIC_HLS_MAX_MANIFEST_AGE_MS;
+    const parsed = raw ? Number(raw) : NaN;
+    return Number.isFinite(parsed) ? parsed : DEFAULT_MAX_MANIFEST_AGE_MS;
+  })();
+  const debugLog = (...args) => {
+    if (debugEnabled) {
+      console.log(...args);
+    }
+  };
+  const getProgramDateTimeMs = (value) => {
+    if (value instanceof Date) return value.getTime();
+    if (typeof value === "number") return value;
+    if (typeof value === "string") {
+      const parsed = Date.parse(value);
+      return Number.isNaN(parsed) ? null : parsed;
+    }
+    return null;
+  };
+  const parseManifestStatus = (manifestText) => {
+    let mediaSequence = null;
+    let segmentCount = 0;
+    let lastProgramDateTimeMs = null;
+    const lines = manifestText.split(/\r?\n/);
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      if (line.startsWith("#EXT-X-MEDIA-SEQUENCE:")) {
+        const value = Number.parseInt(line.replace("#EXT-X-MEDIA-SEQUENCE:", ""), 10);
+        if (Number.isFinite(value)) {
+          mediaSequence = value;
+        }
+      } else if (line.startsWith("#EXT-X-PROGRAM-DATE-TIME:")) {
+        const timestamp = line.replace("#EXT-X-PROGRAM-DATE-TIME:", "").trim();
+        const parsed = Date.parse(timestamp);
+        if (!Number.isNaN(parsed)) {
+          lastProgramDateTimeMs = parsed;
+        }
+      } else if (line.startsWith("#EXTINF:")) {
+        segmentCount += 1;
+      }
+    }
+    let lastSequenceNumber = null;
+    if (mediaSequence !== null && segmentCount > 0) {
+      lastSequenceNumber = mediaSequence + segmentCount - 1;
+    }
+    return { lastProgramDateTimeMs, lastSequenceNumber };
+  };
+  const stopStaleManifestPolling = () => {
+    if (staleManifestPollTimerRef.current) {
+      clearTimeout(staleManifestPollTimerRef.current);
+      staleManifestPollTimerRef.current = null;
+    }
+    staleManifestTriggeredRef.current = false;
+    staleManifestUrlRef.current = null;
+    staleManifestEndSnRef.current = null;
+    staleManifestPollDelayRef.current = STALE_MANIFEST_POLL_INITIAL_DELAY_MS;
+  };
+  const pollStaleManifestOnce = async () => {
+    if (!staleManifestTriggeredRef.current) return;
+    if (!shouldPlayRef.current) {
+      stopStaleManifestPolling();
+      return;
+    }
+    const manifestUrl = staleManifestUrlRef.current;
+    if (!manifestUrl) {
+      stopStaleManifestPolling();
+      return;
+    }
+    try {
+      const headers = {};
+      if (authTokenRef.current) {
+        headers.Authorization = `Bearer ${authTokenRef.current}`;
+      }
+      const response = await fetch(buildCacheBustedUrl(manifestUrl), {
+        method: "GET",
+        cache: "no-store",
+        headers
+      });
+      if (!response.ok) {
+        throw new Error(`Manifest poll failed: ${response.status}`);
+      }
+      const manifestText = await response.text();
+      const { lastProgramDateTimeMs, lastSequenceNumber } = parseManifestStatus(manifestText);
+      const now2 = Date.now();
+      const isFreshByProgramDateTime = lastProgramDateTimeMs !== null && now2 - lastProgramDateTimeMs <= maxManifestAgeMs;
+      const priorEndSn = staleManifestEndSnRef.current;
+      const isSequenceAdvanced = typeof lastSequenceNumber === "number" && (priorEndSn === null || lastSequenceNumber > priorEndSn);
+      if (isFreshByProgramDateTime || isSequenceAdvanced) {
+        stopStaleManifestPolling();
+        if (hlsRef.current) {
+          hlsRef.current.startLoad(-1);
+          seekToLiveEdge();
+          attemptPlay("stale manifest recovered");
+        } else {
+          setRestartKey((k) => k + 1);
+        }
+        return;
+      }
+    } catch (error) {
+      debugLog("[HLS] Stale manifest poll failed", error);
+    }
+    staleManifestPollDelayRef.current = Math.min(
+      staleManifestPollDelayRef.current + 5e3,
+      STALE_MANIFEST_POLL_MAX_DELAY_MS
+    );
+    scheduleStaleManifestPoll();
+  };
+  const scheduleStaleManifestPoll = () => {
+    if (!staleManifestTriggeredRef.current) return;
+    if (staleManifestPollTimerRef.current) return;
+    const delay2 = staleManifestPollDelayRef.current;
+    staleManifestPollTimerRef.current = setTimeout(() => {
+      staleManifestPollTimerRef.current = null;
+      void pollStaleManifestOnce();
+    }, delay2);
+  };
+  const startStaleManifestPolling = (reason) => {
+    if (staleManifestTriggeredRef.current) return;
+    staleManifestTriggeredRef.current = true;
+    staleManifestUrlRef.current = activeStreamUrlRef.current || latestSrcRef.current;
+    staleManifestEndSnRef.current = lastManifestEndSnRef.current;
+    staleManifestPollDelayRef.current = STALE_MANIFEST_POLL_INITIAL_DELAY_MS;
+    const hls = hlsRef.current;
+    if (hls) {
+      hls.stopLoad();
+    }
+    const video = videoRef.current;
+    if (video) {
+      video.pause();
+    }
+    console.warn(`[HLS] Manifest stale, pausing playback (${reason})`);
+    scheduleStaleManifestPoll();
+  };
+  const isProxyUrl = (url) => {
+    if (!proxyEnabled || !proxyBaseUrl) return false;
+    try {
+      const base = proxyBaseUrl.startsWith("http") ? proxyBaseUrl : new URL(proxyBaseUrl, window.location.origin).toString();
+      return url.startsWith(base);
+    } catch {
+      return url.includes(proxyBaseUrl);
+    }
+  };
+  const getR2CameraUuid = (url) => {
+    try {
+      const parsed = new URL(url);
+      const match2 = parsed.pathname.match(/\/segments\/([^\/]+)\/index\.m3u8$/);
+      if (match2) {
+        return match2[1];
+      }
+    } catch {
+    }
+    const match = url.match(/\/segments\/([^\/]+)\/index\.m3u8/);
+    return match ? match[1] : null;
+  };
   const cleanup = () => {
     if (stallCheckIntervalRef.current) {
       clearInterval(stallCheckIntervalRef.current);
@@ -10972,10 +11391,48 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
       clearTimeout(noProgressTimerRef.current);
       noProgressTimerRef.current = null;
     }
+    if (playbackRateIntervalRef.current) {
+      clearInterval(playbackRateIntervalRef.current);
+      playbackRateIntervalRef.current = null;
+    }
     if (waitingTimerRef.current) {
       clearTimeout(waitingTimerRef.current);
       waitingTimerRef.current = null;
     }
+    if (playRetryTimerRef.current) {
+      clearTimeout(playRetryTimerRef.current);
+      playRetryTimerRef.current = null;
+    }
+    if (manifestWatchdogRef.current) {
+      clearInterval(manifestWatchdogRef.current);
+      manifestWatchdogRef.current = null;
+    }
+    if (manifestRetryTimerRef.current) {
+      clearTimeout(manifestRetryTimerRef.current);
+      manifestRetryTimerRef.current = null;
+    }
+    stopStaleManifestPolling();
+    lastHiddenAtRef.current = null;
+    if (nativeStreamUrlRef.current) {
+      nativeStreamUrlRef.current = null;
+    }
+    activeStreamUrlRef.current = null;
+    forcedLiveStartRef.current = false;
+    lastLiveReloadRef.current = 0;
+    targetDurationRef.current = null;
+    lastManifestLoadRef.current = 0;
+    lastFragLoadRef.current = 0;
+    lastFragSnRef.current = null;
+    lastWindowStartSnRef.current = null;
+    lastWindowEndSnRef.current = null;
+    lastFragTimeoutSnRef.current = null;
+    lastFragTimeoutAtRef.current = null;
+    fragTimeoutCountRef.current = 0;
+    lastManifestEndSnRef.current = null;
+    lastManifestEndSnUpdatedAtRef.current = null;
+    staleManifestTriggeredRef.current = false;
+    manifestRetryDelayRef.current = 5e3;
+    playRetryCountRef.current = 0;
     if (hlsRef.current) {
       hlsRef.current.destroy();
       hlsRef.current = null;
@@ -10987,11 +11444,24 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
       video.load();
       video.removeEventListener("waiting", handleWaiting);
       video.removeEventListener("timeupdate", handleTimeUpdate);
+      video.removeEventListener("loadedmetadata", handleLoadedMetadata);
+      video.removeEventListener("canplay", handleCanPlay);
+      video.removeEventListener("ended", handleEnded);
       video.removeEventListener("error", handleNativeError);
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", handleVisibilityChange);
+      }
     }
     lastTimeUpdateRef.current = 0;
     softRestartCountRef.current = 0;
   };
+  const getLiveOffsetSeconds = () => {
+    const targetDuration = targetDurationRef.current;
+    if (targetDuration && Number.isFinite(targetDuration)) {
+      return Math.max(targetDuration * 2, targetDuration);
+    }
+    return DEFAULT_LIVE_OFFSET_SECONDS;
+  };
   const seekToLiveEdge = () => {
     const hls = hlsRef.current;
     const video = videoRef.current;
@@ -11000,19 +11470,237 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
       video.currentTime = hls.liveSyncPosition;
     } else if (hls.levels?.[hls.currentLevel]?.details) {
       const levelDetails = hls.levels[hls.currentLevel].details;
-      if (levelDetails && levelDetails.edge !== void 0) {
-        video.currentTime = Math.max(0, levelDetails.edge - 5);
+      const edge = levelDetails?.edge;
+      if (edge !== void 0 && edge !== null) {
+        const offset = getLiveOffsetSeconds();
+        video.currentTime = Math.max(0, edge - offset);
+      }
+    }
+  };
+  const getLiveEdgeTime = () => {
+    const video = videoRef.current;
+    if (!video || video.seekable.length === 0) return null;
+    const end = video.seekable.end(video.seekable.length - 1);
+    if (!Number.isFinite(end)) return null;
+    const offset = getLiveOffsetSeconds();
+    return Math.max(0, end - offset);
+  };
+  const getWaitingTimeoutMs = () => {
+    const targetDuration = targetDurationRef.current;
+    if (targetDuration && Number.isFinite(targetDuration)) {
+      return Math.max(2e4, targetDuration * 1e3 * 0.5);
+    }
+    return 3e4;
+  };
+  const getManifestStaleTimeoutMs = () => {
+    const targetDuration = targetDurationRef.current;
+    if (targetDuration && Number.isFinite(targetDuration)) {
+      return Math.max(targetDuration * 2e3, 12e4);
+    }
+    return 12e4;
+  };
+  const isManifestUrl = (url) => url.includes(".m3u8");
+  const getBufferGap = (video) => {
+    if (!video.buffered.length) return null;
+    const end = video.buffered.end(video.buffered.length - 1);
+    if (!Number.isFinite(end)) return null;
+    return Math.max(0, end - video.currentTime);
+  };
+  const getBufferThresholds = () => {
+    const targetDuration = targetDurationRef.current ?? 60;
+    return {
+      low: Math.max(5, targetDuration * 0.1),
+      mid: Math.max(10, targetDuration * 0.2),
+      high: Math.max(18, targetDuration * 0.35)
+    };
+  };
+  const shouldAttemptRecovery = () => {
+    if (!isR2StreamRef.current) return true;
+    if (!lastManifestLoadRef.current) return false;
+    const now2 = Date.now();
+    const timeoutMs = getManifestStaleTimeoutMs();
+    const manifestAge = now2 - lastManifestLoadRef.current;
+    return manifestAge > timeoutMs;
+  };
+  const getDesiredLivePosition = () => {
+    const hls = hlsRef.current;
+    if (hls?.liveSyncPosition !== null && hls?.liveSyncPosition !== void 0) {
+      if (Number.isFinite(hls.liveSyncPosition)) {
+        return hls.liveSyncPosition;
+      }
+    }
+    if (hls?.levels?.[hls.currentLevel]?.details) {
+      const levelDetails = hls.levels[hls.currentLevel].details;
+      const edge = levelDetails?.edge;
+      if (edge !== void 0 && edge !== null) {
+        return Math.max(0, edge - getLiveOffsetSeconds());
+      }
+    }
+    return getLiveEdgeTime();
+  };
+  const schedulePlayRetry = (reason) => {
+    if (playRetryTimerRef.current) return;
+    if (playRetryCountRef.current >= 3) return;
+    playRetryCountRef.current += 1;
+    playRetryTimerRef.current = setTimeout(() => {
+      playRetryTimerRef.current = null;
+      attemptPlay();
+    }, 1e3);
+  };
+  const attemptPlay = (reason) => {
+    const video = videoRef.current;
+    if (!video || !shouldPlayRef.current) return;
+    if (!video.paused || video.seeking) return;
+    if (video.readyState < 2) return;
+    video.play().then(() => {
+      playRetryCountRef.current = 0;
+    }).catch((err) => {
+      if (err?.name === "AbortError") {
+        schedulePlayRetry();
+        return;
       }
+      console.error("[HLS] Play failed:", err);
+    });
+  };
+  const handleCanPlay = () => {
+    attemptPlay();
+  };
+  const handleVisibilityChange = () => {
+    if (typeof document === "undefined") return;
+    if (document.hidden) {
+      lastHiddenAtRef.current = Date.now();
+      return;
+    }
+    const lastHiddenAt = lastHiddenAtRef.current;
+    lastHiddenAtRef.current = null;
+    if (!lastHiddenAt) return;
+    if (Date.now() - lastHiddenAt < 3e4) return;
+    refreshLiveStream("tab visible after idle");
+    attemptPlay();
+  };
+  const startManifestWatchdog = () => {
+    if (manifestWatchdogRef.current) return;
+    if (!isR2StreamRef.current) return;
+    manifestWatchdogRef.current = setInterval(() => {
+      if (staleManifestTriggeredRef.current) return;
+      if (!lastManifestLoadRef.current) return;
+      const now2 = Date.now();
+      const staleTimeoutMs = getManifestStaleTimeoutMs();
+      if (now2 - lastManifestLoadRef.current < staleTimeoutMs) return;
+      if (now2 - lastLiveReloadRef.current < LIVE_RELOAD_MIN_INTERVAL_MS) return;
+      lastLiveReloadRef.current = now2;
+      softRestart("manifest stale watchdog");
+    }, 15e3);
+  };
+  const scheduleManifestRetry = (reason) => {
+    if (manifestRetryTimerRef.current) return;
+    const delay2 = manifestRetryDelayRef.current;
+    manifestRetryTimerRef.current = setTimeout(() => {
+      manifestRetryTimerRef.current = null;
+      softRestart(reason);
+      manifestRetryDelayRef.current = Math.min(manifestRetryDelayRef.current + 5e3, 3e4);
+    }, delay2);
+  };
+  const resetManifestRetry = () => {
+    if (manifestRetryTimerRef.current) {
+      clearTimeout(manifestRetryTimerRef.current);
+      manifestRetryTimerRef.current = null;
+    }
+    manifestRetryDelayRef.current = 5e3;
+  };
+  const markStaleStream = (reason) => {
+    startStaleManifestPolling(reason);
+  };
+  const setPlaybackRate = (rate) => {
+    const video = videoRef.current;
+    if (!video) return;
+    if (!Number.isFinite(rate)) return;
+    if (Math.abs(video.playbackRate - rate) < 0.01) return;
+    video.playbackRate = rate;
+  };
+  const startPlaybackGovernor = () => {
+    if (playbackRateIntervalRef.current) return;
+    playbackRateIntervalRef.current = setInterval(() => {
+      const video = videoRef.current;
+      if (!video || video.paused || video.seeking) return;
+      if (!isR2StreamRef.current) return;
+      const bufferGap = getBufferGap(video);
+      if (bufferGap === null) return;
+      const { low, mid, high } = getBufferThresholds();
+      let desiredRate = 1;
+      if (bufferGap < low) {
+        desiredRate = 0.8;
+      } else if (bufferGap < mid) {
+        desiredRate = 0.9;
+      } else if (bufferGap < high) {
+        desiredRate = 0.95;
+      }
+      setPlaybackRate(desiredRate);
+    }, 2e3);
+  };
+  const buildCacheBustedUrl = (url) => {
+    if (typeof window === "undefined") {
+      return url;
+    }
+    try {
+      const parsed = new URL(url, window.location.origin);
+      parsed.searchParams.set("ts", Date.now().toString());
+      return parsed.toString();
+    } catch {
+      const separator = url.includes("?") ? "&" : "?";
+      return `${url}${separator}ts=${Date.now()}`;
+    }
+  };
+  const refreshLiveStream = (reason) => {
+    if (!isR2StreamRef.current) return;
+    const now2 = Date.now();
+    if (now2 - lastLiveReloadRef.current < LIVE_RELOAD_MIN_INTERVAL_MS) {
+      return;
+    }
+    lastLiveReloadRef.current = now2;
+    const video = videoRef.current;
+    const hls = hlsRef.current;
+    if (hls) {
+      console.log(`[HLS] Live reload (${reason})`);
+      softRestart(reason);
+      return;
+    }
+    if (video && nativeStreamUrlRef.current) {
+      console.log(`[HLS] Native live reload (${reason})`);
+      const refreshedUrl = buildCacheBustedUrl(nativeStreamUrlRef.current);
+      video.src = refreshedUrl;
+      video.load();
+      const edgeTime = getLiveEdgeTime();
+      if (edgeTime !== null) {
+        video.currentTime = edgeTime;
+      }
+      attemptPlay();
     }
   };
   const softRestart = (reason) => {
+    if (staleManifestTriggeredRef.current) {
+      debugLog("[HLS] Skip soft restart while manifest is stale", reason);
+      return;
+    }
     console.warn(`[HLS] Soft restart: ${reason}`);
     const hls = hlsRef.current;
     if (!hls) return;
     try {
+      const video = videoRef.current;
+      const isR2Stream = isR2StreamRef.current;
+      const desiredPosition = isR2Stream ? getDesiredLivePosition() : null;
       hls.stopLoad();
-      hls.startLoad(-1);
-      seekToLiveEdge();
+      if (desiredPosition !== null && Number.isFinite(desiredPosition)) {
+        hls.startLoad(desiredPosition);
+        if (video) {
+          video.currentTime = desiredPosition;
+        }
+      } else {
+        hls.startLoad(-1);
+        if (!isR2Stream) {
+          seekToLiveEdge();
+        }
+      }
       softRestartCountRef.current++;
       if (softRestartCountRef.current >= 5) {
         hardRestart(`${reason} (escalated after ${softRestartCountRef.current} soft restarts)`);
@@ -11023,11 +11711,16 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
     }
   };
   const hardRestart = (reason) => {
+    if (staleManifestTriggeredRef.current) {
+      debugLog("[HLS] Skip hard restart while manifest is stale", reason);
+      return;
+    }
     console.warn(`[HLS] Hard restart: ${reason}`);
     cleanupFailedUrls();
     const failure = failedUrls.get(src);
     const failureCount = failure ? failure.count : 0;
-    if (failureCount >= MAX_FAILURES_PER_URL) {
+    const isR2Stream = isR2StreamRef.current;
+    if (!isR2Stream && failureCount >= MAX_FAILURES_PER_URL) {
       console.error(`[HLS] URL has failed ${failureCount} times. Marking as permanently failed: ${src}`);
       failedUrls.set(src, {
         count: failureCount,
@@ -11040,11 +11733,15 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
       }
       return;
     }
-    failedUrls.set(src, {
-      count: failureCount + 1,
-      timestamp: Date.now(),
-      permanentlyFailed: false
-    });
+    if (!isR2Stream) {
+      failedUrls.set(src, {
+        count: failureCount + 1,
+        timestamp: Date.now(),
+        permanentlyFailed: false
+      });
+    } else if (failedUrls.has(src)) {
+      failedUrls.delete(src);
+    }
     cleanup();
     setRestartKey((k) => k + 1);
     softRestartCountRef.current = 0;
@@ -11054,12 +11751,49 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
       }
     }
   };
+  const handleLoadedMetadata = () => {
+    if (!isR2StreamRef.current) return;
+    const video = videoRef.current;
+    if (!video) return;
+    const edgeTime = getLiveEdgeTime();
+    if (edgeTime !== null) {
+      video.currentTime = edgeTime;
+    }
+  };
+  const handleEnded = () => {
+    if (isNativeHlsRef.current) {
+      refreshLiveStream("ended");
+      return;
+    }
+    if (isR2StreamRef.current) {
+      softRestart("ended");
+    }
+  };
   const handleWaiting = () => {
-    if (isNativeHlsRef.current) return;
-    console.log("[HLS] Video waiting (buffer underrun)");
     if (waitingTimerRef.current) {
       clearTimeout(waitingTimerRef.current);
     }
+    if (isNativeHlsRef.current) {
+      if (!isR2StreamRef.current) return;
+      waitingTimerRef.current = setTimeout(() => {
+        refreshLiveStream("native waiting timeout");
+      }, getWaitingTimeoutMs());
+      return;
+    }
+    console.log("[HLS] Video waiting (buffer underrun)");
+    if (isR2StreamRef.current) {
+      waitingTimerRef.current = setTimeout(() => {
+        const video = videoRef.current;
+        if (video && video.readyState < 3) {
+          if (shouldAttemptRecovery()) {
+            softRestart("waiting timeout");
+          } else {
+            handleWaiting();
+          }
+        }
+      }, getWaitingTimeoutMs());
+      return;
+    }
     waitingTimerRef.current = setTimeout(() => {
       const video = videoRef.current;
       if (video && video.readyState < 3) {
@@ -11071,6 +11805,7 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
     const video = videoRef.current;
     if (!video) return;
     lastTimeUpdateRef.current = video.currentTime;
+    playRetryCountRef.current = 0;
     if (waitingTimerRef.current) {
       clearTimeout(waitingTimerRef.current);
       waitingTimerRef.current = null;
@@ -11081,19 +11816,33 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
     hardRestart("native video error");
   };
   const startStallDetection = () => {
-    if (isNativeHlsRef.current) return;
+    if (isNativeHlsRef.current || isR2StreamRef.current) return;
     stallCheckIntervalRef.current = setInterval(() => {
       const video = videoRef.current;
       if (!video || video.paused || video.ended) return;
+      if (video.readyState < 3 || video.seeking) return;
       const currentTime = video.currentTime;
       const lastTime = lastTimeUpdateRef.current;
+      const bufferGap = getBufferGap(video);
+      const nearBufferEnd = bufferGap !== null && bufferGap < 0.5;
       if (Math.abs(currentTime - lastTime) < 0.1 && video.readyState >= 2) {
+        if (nearBufferEnd && !shouldAttemptRecovery()) {
+          if (noProgressTimerRef.current) {
+            clearTimeout(noProgressTimerRef.current);
+            noProgressTimerRef.current = null;
+          }
+          return;
+        }
         console.warn("[HLS] Playback stall detected");
         if (!noProgressTimerRef.current) {
           noProgressTimerRef.current = setTimeout(() => {
+            if (nearBufferEnd && !shouldAttemptRecovery()) {
+              noProgressTimerRef.current = null;
+              return;
+            }
             softRestart("playback stall");
             noProgressTimerRef.current = null;
-          }, 8e3);
+          }, nearBufferEnd ? getWaitingTimeoutMs() : 12e3);
         }
       } else {
         if (noProgressTimerRef.current) {
@@ -11104,65 +11853,311 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
     }, 7e3);
   };
   useEffect(() => {
-    if (isPermanentlyFailed) {
+    if (!src || !shouldPlay) {
+      cleanup();
+      return;
+    }
+    let isCancelled = false;
+    const r2WorkerDomain = process.env.NEXT_PUBLIC_R2_WORKER_DOMAIN || "https://r2-stream-proxy.optifye-r2.workers.dev";
+    const isR2Stream = isR2WorkerUrl(src, r2WorkerDomain);
+    isR2StreamRef.current = isR2Stream;
+    if (isPermanentlyFailed && !isR2Stream) {
       console.warn(`[HLS] URL is permanently failed, not attempting to load: ${src}`);
       if (onFatalError) {
         onFatalError();
       }
       return;
     }
-    if (!src || !shouldPlay) {
-      cleanup();
-      return;
+    if (isPermanentlyFailed && isR2Stream && failedUrls.has(src)) {
+      failedUrls.delete(src);
     }
     const video = videoRef.current;
     if (!video) return;
-    isNativeHlsRef.current = video.canPlayType("application/vnd.apple.mpegurl") === "probably";
-    if (Hls3.isSupported() && !isNativeHlsRef.current) {
-      const hls = new Hls3(HLS_CONFIG);
-      hlsRef.current = hls;
-      hls.attachMedia(video);
-      hls.loadSource(src);
-      hls.on(Hls3.Events.ERROR, (_, data) => {
-        if (!data.fatal) return;
-        console.error("[HLS] Fatal error:", data.type, data.details);
-        if (data.response?.code === 404) {
-          hardRestart("404 hard restart");
+    if (typeof document !== "undefined") {
+      document.addEventListener("visibilitychange", handleVisibilityChange);
+    }
+    const initialize = async () => {
+      const canUseNative = video.canPlayType("application/vnd.apple.mpegurl") === "probably";
+      isNativeHlsRef.current = canUseNative && !isR2Stream;
+      let authToken = null;
+      if (isR2Stream) {
+        try {
+          const supabase = _getSupabaseInstance();
+          authToken = await getAuthTokenForHls(supabase);
+        } catch (error) {
+          console.warn("[HLS] Unable to retrieve auth token for R2 streaming:", error);
+        }
+      }
+      authTokenRef.current = authToken;
+      if (isCancelled) return;
+      const cameraUuid = isR2Stream ? getR2CameraUuid(src) : null;
+      const proxyPlaylistUrl = proxyEnabled && isR2Stream && proxyBaseUrl && cameraUuid ? `${proxyBaseUrl}/segments/${cameraUuid}/index.m3u8` : null;
+      const resolvedSrc = proxyPlaylistUrl || src;
+      const resolvedHlsSrc = src;
+      const shouldUseProxy = proxyEnabled && isR2Stream && canUseNative && !Hls.isSupported() && isSafari();
+      if (shouldUseProxy) {
+        if (cameraUuid) {
+          isNativeHlsRef.current = true;
+          nativeStreamUrlRef.current = resolvedSrc;
+          activeStreamUrlRef.current = resolvedSrc;
+          console.log("[HLS] Using proxy playlist for Safari R2 stream");
+          video.src = resolvedSrc;
+          video.addEventListener("waiting", handleWaiting);
+          video.addEventListener("loadedmetadata", handleLoadedMetadata);
+          video.addEventListener("canplay", handleCanPlay);
+          video.addEventListener("ended", handleEnded);
+          video.addEventListener("error", handleNativeError);
+          attemptPlay();
           return;
         }
-        switch (data.type) {
-          case Hls3.ErrorTypes.NETWORK_ERROR:
-          case Hls3.ErrorTypes.MEDIA_ERROR:
-            softRestart(`${data.type}: ${data.details}`);
-            break;
-          default:
-            hardRestart(`Fatal ${data.type}: ${data.details}`);
-            break;
-        }
-      });
-      hls.on(Hls3.Events.MANIFEST_PARSED, () => {
-        if (failedUrls.has(src)) {
-          console.log(`[HLS] Stream loaded successfully, resetting failure count for: ${src}`);
-          failedUrls.delete(src);
+        console.warn("[HLS] Safari R2 proxy unavailable, falling back to direct URL");
+      }
+      if (!proxyEnabled && isR2Stream && canUseNative && !Hls.isSupported() && isSafari()) {
+        console.warn("[HLS] Safari native R2 streaming requires proxy. Falling back.");
+        if (onFatalError) {
+          onFatalError();
         }
-        video.play().catch((err) => {
-          console.error("[HLS] Play failed:", err);
+        return;
+      }
+      if (Hls.isSupported() && !isNativeHlsRef.current) {
+        const mergedConfig = {
+          ...HLS_CONFIG,
+          ...hlsConfig,
+          xhrSetup: (xhr, url) => {
+            const usesProxy = isProxyUrl(url);
+            if (isR2WorkerUrl(url, r2WorkerDomain) || usesProxy) {
+              if (isManifestUrl(url)) {
+                xhr.open("GET", buildCacheBustedUrl(url), true);
+              }
+              if (authToken) {
+                xhr.setRequestHeader("Authorization", `Bearer ${authToken}`);
+              }
+            }
+          },
+          fetchSetup: (context, initParams) => {
+            const isR2Url = isR2WorkerUrl(context.url, r2WorkerDomain);
+            const isManifestRequest = isManifestUrl(context.url);
+            const usesProxy = isProxyUrl(context.url);
+            let requestUrl = context.url;
+            if (isR2Url || usesProxy) {
+              if (authToken) {
+                initParams.headers = {
+                  ...initParams.headers,
+                  "Authorization": `Bearer ${authToken}`
+                };
+              }
+              if (isManifestRequest) {
+                requestUrl = buildCacheBustedUrl(context.url);
+                initParams.cache = "no-store";
+              }
+            }
+            return new Request(requestUrl, initParams);
+          }
+        };
+        const hls = new Hls(mergedConfig);
+        hlsRef.current = hls;
+        hls.attachMedia(video);
+        hls.loadSource(resolvedHlsSrc);
+        activeStreamUrlRef.current = resolvedHlsSrc;
+        hls.on(Hls.Events.ERROR, (_, data) => {
+          debugLog("[HLS] Error", {
+            type: data.type,
+            details: data.details,
+            fatal: data.fatal,
+            response: data.response?.code,
+            frag: data.frag?.sn
+          });
+          if (data.type === Hls.ErrorTypes.MEDIA_ERROR && data.details === Hls.ErrorDetails.BUFFER_STALLED_ERROR) {
+            debugLog("[HLS] Buffer stalled, waiting for next segment");
+            attemptPlay();
+            return;
+          }
+          if (data.type === Hls.ErrorTypes.NETWORK_ERROR && (data.details === Hls.ErrorDetails.FRAG_LOAD_TIMEOUT || data.details === Hls.ErrorDetails.FRAG_LOAD_ERROR)) {
+            const fragSn = data.frag?.sn;
+            const windowStart = lastWindowStartSnRef.current;
+            const windowEnd = lastWindowEndSnRef.current;
+            if (typeof fragSn === "number" && typeof windowStart === "number" && fragSn < windowStart) {
+              softRestart("frag fell out of window");
+              return;
+            }
+            if (typeof fragSn === "number" && typeof windowEnd === "number" && fragSn > windowEnd) {
+              softRestart("frag ahead of window");
+              return;
+            }
+            const now2 = Date.now();
+            if (lastFragTimeoutSnRef.current === fragSn && lastFragTimeoutAtRef.current) {
+              if (now2 - lastFragTimeoutAtRef.current < 12e4) {
+                fragTimeoutCountRef.current += 1;
+              } else {
+                fragTimeoutCountRef.current = 1;
+              }
+            } else {
+              fragTimeoutCountRef.current = 1;
+              lastFragTimeoutSnRef.current = fragSn ?? null;
+            }
+            lastFragTimeoutAtRef.current = now2;
+            if (fragTimeoutCountRef.current >= 2) {
+              softRestart("frag load timeout");
+            }
+            return;
+          }
+          if (data.type === Hls.ErrorTypes.NETWORK_ERROR && (data.details === Hls.ErrorDetails.MANIFEST_LOAD_TIMEOUT || data.details === Hls.ErrorDetails.MANIFEST_LOAD_ERROR)) {
+            scheduleManifestRetry("manifest load timeout");
+            return;
+          }
+          if (!data.fatal) return;
+          console.error("[HLS] Fatal error:", data.type, data.details);
+          if (data.response?.code === 404) {
+            if (data.details === Hls.ErrorDetails.MANIFEST_LOAD_ERROR || data.details === Hls.ErrorDetails.LEVEL_LOAD_ERROR) {
+              if (isR2StreamRef.current) {
+                scheduleManifestRetry("manifest 404");
+                return;
+              }
+              hardRestart("404 manifest hard restart");
+              return;
+            }
+            softRestart("frag 404");
+            return;
+          }
+          switch (data.type) {
+            case Hls.ErrorTypes.NETWORK_ERROR:
+              if (isR2StreamRef.current && data.details === Hls.ErrorDetails.MANIFEST_LOAD_TIMEOUT) {
+                softRestart("manifest load timeout");
+                break;
+              }
+              softRestart(`${data.type}: ${data.details}`);
+              break;
+            case Hls.ErrorTypes.MEDIA_ERROR:
+              softRestart(`${data.type}: ${data.details}`);
+              break;
+            default:
+              hardRestart(`Fatal ${data.type}: ${data.details}`);
+              break;
+          }
         });
-      });
-      video.addEventListener("waiting", handleWaiting);
-      video.addEventListener("timeupdate", handleTimeUpdate);
-      startStallDetection();
-    } else if (isNativeHlsRef.current) {
-      console.log("[HLS] Using native HLS");
-      video.src = src;
-      video.addEventListener("error", handleNativeError);
-      video.play().catch((err) => {
-        console.error("[HLS] Native play failed:", err);
-      });
-    } else {
-      console.error("[HLS] HLS not supported");
-    }
-    return cleanup;
+        hls.on(Hls.Events.MANIFEST_PARSED, () => {
+          if (failedUrls.has(src)) {
+            console.log(`[HLS] Stream loaded successfully, resetting failure count for: ${src}`);
+            failedUrls.delete(src);
+          }
+          if (isR2Stream) {
+            seekToLiveEdge();
+          }
+          attemptPlay();
+        });
+        hls.on(Hls.Events.LEVEL_LOADED, (_event, data) => {
+          if (!data?.details) return;
+          const details = data.details;
+          if (isR2Stream) {
+            lastManifestLoadRef.current = Date.now();
+            resetManifestRetry();
+            if (details.endList) {
+              details.endList = false;
+            }
+            details.live = true;
+            details.type = "LIVE";
+            if (details.targetduration && Number.isFinite(details.targetduration)) {
+              targetDurationRef.current = details.targetduration;
+            }
+            if (typeof details.startSN === "number") {
+              lastWindowStartSnRef.current = details.startSN;
+            }
+            if (typeof details.endSN === "number") {
+              lastWindowEndSnRef.current = Math.max(details.endSN - 1, details.startSN ?? details.endSN);
+            }
+            if (Array.isArray(details.fragments) && details.fragments.length > 0) {
+              const firstSn = details.fragments[0]?.sn;
+              const lastSn = details.fragments[details.fragments.length - 1]?.sn;
+              if (typeof firstSn === "number") {
+                lastWindowStartSnRef.current = firstSn;
+              }
+              if (typeof lastSn === "number") {
+                lastWindowEndSnRef.current = lastSn;
+              }
+            }
+          }
+          if (maxManifestAgeMs > 0 && !details.endList) {
+            const now2 = Date.now();
+            const fragments = Array.isArray(details.fragments) ? details.fragments : [];
+            const lastFragment = fragments.length ? fragments[fragments.length - 1] : void 0;
+            const programDateTimeMs = getProgramDateTimeMs(lastFragment?.programDateTime);
+            if (programDateTimeMs && now2 - programDateTimeMs > maxManifestAgeMs) {
+              markStaleStream(`segment age ${Math.round((now2 - programDateTimeMs) / 1e3)}s`);
+              return;
+            }
+            const endSn = typeof details.endSN === "number" ? details.endSN : lastFragment?.sn;
+            if (typeof endSn === "number") {
+              if (lastManifestEndSnRef.current === endSn) {
+                const lastUpdatedAt = lastManifestEndSnUpdatedAtRef.current;
+                if (lastUpdatedAt && now2 - lastUpdatedAt > maxManifestAgeMs) {
+                  markStaleStream(`sequence stalled at ${endSn}`);
+                  return;
+                }
+              } else {
+                lastManifestEndSnRef.current = endSn;
+                lastManifestEndSnUpdatedAtRef.current = now2;
+              }
+            }
+          }
+          debugLog("[HLS] Level loaded", {
+            targetduration: details.targetduration,
+            edge: details.edge,
+            fragments: data.details?.fragments?.length
+          });
+          if (isR2Stream && !forcedLiveStartRef.current) {
+            forcedLiveStartRef.current = true;
+            seekToLiveEdge();
+          }
+        });
+        hls.on(Hls.Events.MANIFEST_LOADED, () => {
+          if (!isR2Stream) return;
+          lastManifestLoadRef.current = Date.now();
+          resetManifestRetry();
+        });
+        hls.on(Hls.Events.FRAG_LOADED, (_event, data) => {
+          if (!isR2Stream) return;
+          lastFragLoadRef.current = Date.now();
+          if (typeof data?.frag?.sn === "number") {
+            lastFragSnRef.current = data.frag.sn;
+          }
+        });
+        hls.on(Hls.Events.FRAG_BUFFERED, () => {
+          attemptPlay();
+        });
+        video.addEventListener("waiting", handleWaiting);
+        video.addEventListener("timeupdate", handleTimeUpdate);
+        video.addEventListener("loadedmetadata", handleLoadedMetadata);
+        video.addEventListener("canplay", handleCanPlay);
+        video.addEventListener("ended", handleEnded);
+        startStallDetection();
+        startPlaybackGovernor();
+        startManifestWatchdog();
+        startManifestWatchdog();
+        return;
+      }
+      if (canUseNative) {
+        isNativeHlsRef.current = true;
+        console.log("[HLS] Using native HLS");
+        video.src = resolvedSrc;
+        nativeStreamUrlRef.current = resolvedSrc;
+        activeStreamUrlRef.current = resolvedSrc;
+        video.addEventListener("waiting", handleWaiting);
+        video.addEventListener("loadedmetadata", handleLoadedMetadata);
+        video.addEventListener("canplay", handleCanPlay);
+        video.addEventListener("ended", handleEnded);
+        video.addEventListener("error", handleNativeError);
+        startPlaybackGovernor();
+        startManifestWatchdog();
+        attemptPlay();
+      } else {
+        console.error("[HLS] HLS not supported");
+      }
+    };
+    initialize();
+    return () => {
+      isCancelled = true;
+      cleanup();
+    };
   }, [src, shouldPlay, restartKey, onFatalError, isPermanentlyFailed]);
   return {
     restartKey,
@@ -11170,11 +12165,11 @@ function useHlsStream(videoRef, { src, shouldPlay, onFatalError }) {
   };
 }
 function useHlsStreamWithCropping(videoRef, canvasRef, options) {
-  const { src, shouldPlay, cropping, canvasFps = 30, useRAF = true, onFatalError } = options;
+  const { src, shouldPlay, cropping, canvasFps = 30, useRAF = true, onFatalError, hlsConfig } = options;
   const animationFrameRef = useRef(null);
   const intervalRef = useRef(null);
   const isDrawingRef = useRef(false);
-  const hlsState = useHlsStream(videoRef, { src, shouldPlay, onFatalError });
+  const hlsState = useHlsStream(videoRef, { src, shouldPlay, onFatalError, hlsConfig });
   const calculateCropRect = useCallback((video, cropping2) => {
     const videoWidth = video.videoWidth;
     const videoHeight = video.videoHeight;
@@ -11908,6 +12903,95 @@ var useWorkspaceDisplayNamesMap = (workspaceIds, lineId, companyId) => {
     refetch: fetchDisplayNames
   };
 };
+var useWorkspaceVideoStreams = (workspaces) => {
+  const workspaceIdsKey = useMemo(() => {
+    const ids = /* @__PURE__ */ new Set();
+    for (const workspace of workspaces) {
+      if (workspace.workspace_uuid) {
+        ids.add(workspace.workspace_uuid);
+      }
+    }
+    return Array.from(ids).sort().join(",");
+  }, [workspaces]);
+  const lineIdsKey = useMemo(() => {
+    const ids = /* @__PURE__ */ new Set();
+    for (const workspace of workspaces) {
+      if (workspace.line_id) {
+        ids.add(workspace.line_id);
+      }
+    }
+    return Array.from(ids).sort().join(",");
+  }, [workspaces]);
+  const requestKey = useMemo(() => {
+    if (workspaceIdsKey) {
+      return `workspaces:${workspaceIdsKey}`;
+    }
+    if (lineIdsKey) {
+      return `lines:${lineIdsKey}`;
+    }
+    return "";
+  }, [workspaceIdsKey, lineIdsKey]);
+  const workspaceIds = useMemo(
+    () => workspaceIdsKey ? workspaceIdsKey.split(",") : [],
+    [workspaceIdsKey]
+  );
+  const lineIds = useMemo(
+    () => lineIdsKey ? lineIdsKey.split(",") : [],
+    [lineIdsKey]
+  );
+  const [state, setState] = useState(() => ({
+    streamsByWorkspaceId: {},
+    isLoading: Boolean(requestKey),
+    error: null
+  }));
+  const lastKeyRef = useRef(requestKey);
+  useEffect(() => {
+    lastKeyRef.current = requestKey;
+    if (!workspaceIds.length && !lineIds.length) {
+      setState({
+        streamsByWorkspaceId: {},
+        isLoading: false,
+        error: null
+      });
+      return;
+    }
+    let isCancelled = false;
+    setState((prev) => ({ ...prev, isLoading: true, error: null }));
+    const fetchStreams = async () => {
+      try {
+        const streams = await workspaceService.getWorkspaceVideoStreams({
+          workspaceIds,
+          lineIds
+        });
+        if (!isCancelled) {
+          setState({
+            streamsByWorkspaceId: streams,
+            isLoading: false,
+            error: null
+          });
+        }
+      } catch (error) {
+        if (!isCancelled) {
+          setState((prev) => ({
+            ...prev,
+            isLoading: false,
+            error: error instanceof Error ? error.message : "Failed to load video streams"
+          }));
+        }
+      }
+    };
+    fetchStreams();
+    return () => {
+      isCancelled = true;
+    };
+  }, [workspaceIdsKey, lineIdsKey]);
+  const isLoading = state.isLoading || lastKeyRef.current !== requestKey;
+  return {
+    streamsByWorkspaceId: state.streamsByWorkspaceId,
+    isLoading,
+    error: state.error
+  };
+};
 var useActiveBreaks = (lineIds) => {
   const [activeBreaks, setActiveBreaks] = useState([]);
   const [isLoading, setIsLoading] = useState(true);
@@ -17440,24 +18524,6 @@ var createThrottledReload = (interval = 5e3, maxReloads = 3) => {
 };
 var throttledReloadDashboard = createThrottledReload(5e3, 3);
 
-// src/lib/utils/browser.ts
-function isSafari() {
-  if (typeof window === "undefined") return false;
-  const ua = window.navigator.userAgent;
-  const isSafariUA = /^((?!chrome|android).)*safari/i.test(ua);
-  const isIOS = /iPad|iPhone|iPod/.test(ua) && !window.MSStream;
-  return isSafariUA || isIOS;
-}
-function getBrowserName() {
-  if (typeof window === "undefined") return "server";
-  const ua = window.navigator.userAgent;
-  if (/chrome/i.test(ua) && !/edge/i.test(ua)) return "chrome";
-  if (/safari/i.test(ua) && !/chrome/i.test(ua)) return "safari";
-  if (/firefox/i.test(ua)) return "firefox";
-  if (/edge/i.test(ua)) return "edge";
-  return "unknown";
-}
-
 // src/lib/utils/index.ts
 var formatIdleTime = (idleTimeInSeconds) => {
   if (!idleTimeInSeconds || idleTimeInSeconds <= 0) {
@@ -17476,83 +18542,29 @@ var formatIdleTime = (idleTimeInSeconds) => {
   parts.push(`${seconds}s`);
   return parts.join(" ");
 };
-var createSupabaseClient = (url, key) => createClient(url, key, {
-  auth: {
-    autoRefreshToken: true,
-    persistSession: true,
-    detectSessionInUrl: true,
-    flowType: "pkce",
-    // Enable debug logging in development
-    debug: process.env.NODE_ENV === "development"
-  },
-  db: {
-    schema: "public"
-    // Default schema, we'll use .schema('ai') in queries
-  },
-  global: {
-    headers: {
-      "x-application-name": "optifye-dashboard"
-    },
-    // Add global fetch timeout (5 minutes)
-    fetch: async (url2, options = {}) => {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 3e5);
-      try {
-        const response = await fetch(url2, {
-          ...options,
-          signal: controller.signal
-        });
-        clearTimeout(timeoutId);
-        return response;
-      } catch (error) {
-        clearTimeout(timeoutId);
-        throw error;
-      }
-    }
+var cachedClient2 = null;
+var cachedConfig2 = null;
+var getCachedClient = (url, key) => {
+  if (cachedClient2 && cachedConfig2?.url === url && cachedConfig2?.key === key) {
+    return cachedClient2;
   }
-});
-var getAnonClient = () => {
-  const url = process.env.NEXT_PUBLIC_SUPABASE_URL || "";
-  const key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "";
-  if (!url || !key) {
-    console.warn("[dashboard-core] Missing supabase env variables");
-  }
-  return createClient(url, key, {
-    auth: {
-      autoRefreshToken: true,
-      persistSession: true,
-      detectSessionInUrl: true,
-      flowType: "pkce",
-      debug: process.env.NODE_ENV === "development"
-    },
-    global: {
-      headers: {
-        "x-application-name": "optifye-dashboard"
-      },
-      // Add global fetch timeout (5 minutes)
-      fetch: async (url2, options = {}) => {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 3e5);
-        try {
-          const response = await fetch(url2, {
-            ...options,
-            signal: controller.signal
-          });
-          clearTimeout(timeoutId);
-          return response;
-        } catch (error) {
-          clearTimeout(timeoutId);
-          throw error;
-        }
-      }
-    }
-  });
+  cachedClient2 = createSupabaseClient(url, key);
+  cachedConfig2 = { url, key };
+  _setSupabaseInstance(cachedClient2);
+  return cachedClient2;
 };
-
-// src/lib/supabaseClient.ts
 function useSupabaseClient() {
   const { supabaseUrl, supabaseKey } = useDashboardConfig();
-  const supabase = useMemo(() => createSupabaseClient(supabaseUrl, supabaseKey), [supabaseUrl, supabaseKey]);
+  const providerClient = useOptionalSupabase();
+  const supabase = useMemo(() => {
+    if (providerClient) {
+      return providerClient;
+    }
+    if (!supabaseUrl || !supabaseKey) {
+      throw new Error("Supabase configuration missing in DashboardConfig");
+    }
+    return getCachedClient(supabaseUrl, supabaseKey);
+  }, [providerClient, supabaseUrl, supabaseKey]);
   return supabase;
 }
 var LayoutGroupContext = createContext({});
@@ -27633,22 +28645,14 @@ var VideoCard = React25__default.memo(({
   const videoRef = useRef(null);
   const canvasRef = useRef(null);
   const effectiveLegend = legend || DEFAULT_EFFICIENCY_LEGEND;
-  if (cropping) {
-    useHlsStreamWithCropping(videoRef, canvasRef, {
-      src: hlsUrl,
-      shouldPlay,
-      cropping,
-      canvasFps,
-      useRAF,
-      onFatalError: onFatalError ?? (() => throttledReloadDashboard())
-    });
-  } else {
-    useHlsStream(videoRef, {
-      src: hlsUrl,
-      shouldPlay,
-      onFatalError: onFatalError ?? (() => throttledReloadDashboard())
-    });
-  }
+  useHlsStreamWithCropping(videoRef, canvasRef, {
+    src: hlsUrl,
+    shouldPlay,
+    cropping,
+    canvasFps,
+    useRAF,
+    onFatalError: onFatalError ?? (() => throttledReloadDashboard())
+  });
   const workspaceDisplayName = displayName || getWorkspaceDisplayName(workspace.workspace_name, workspace.line_id);
   const efficiencyColor = getEfficiencyColor(workspace.efficiency, effectiveLegend);
   const efficiencyOverlayClass = efficiencyColor === "green" ? "bg-[#00D654]/25" : efficiencyColor === "yellow" ? "bg-[#FFD700]/30" : "bg-[#FF2D0A]/30";
@@ -27783,6 +28787,8 @@ var VideoGridView = React25__default.memo(({
   className = "",
   legend,
   videoSources = {},
+  videoStreamsByWorkspaceId,
+  videoStreamsLoading = false,
   displayNames = {},
   onWorkspaceHover,
   onWorkspaceHoverEnd
@@ -27794,6 +28800,15 @@ var VideoGridView = React25__default.memo(({
   const [gridRows, setGridRows] = useState(1);
   const [visibleWorkspaces, setVisibleWorkspaces] = useState(/* @__PURE__ */ new Set());
   const [failedStreams, setFailedStreams] = useState(/* @__PURE__ */ new Set());
+  const [r2FallbackWorkspaces, setR2FallbackWorkspaces] = useState(/* @__PURE__ */ new Set());
+  const workspaceIdsKey = useMemo(() => {
+    const ids = workspaces.map((ws) => ws.workspace_uuid || ws.workspace_name);
+    return ids.sort().join(",");
+  }, [workspaces]);
+  useEffect(() => {
+    setFailedStreams(/* @__PURE__ */ new Set());
+    setR2FallbackWorkspaces(/* @__PURE__ */ new Set());
+  }, [workspaceIdsKey]);
   const videoConfig = useVideoConfig();
   const dashboardConfig = useDashboardConfig();
   const { cropping, canvasConfig, hlsUrls } = videoConfig;
@@ -27813,13 +28828,16 @@ var VideoGridView = React25__default.memo(({
     }
     return mergedVideoSources.workspaceHlsUrls[wsName] || mergedVideoSources.defaultHlsUrl;
   }, [mergedVideoSources]);
-  const getWorkspaceCropping = useCallback((workspaceName) => {
+  const getWorkspaceCropping = useCallback((workspaceId, workspaceName) => {
+    if (videoStreamsByWorkspaceId) {
+      return videoStreamsByWorkspaceId[workspaceId]?.crop ?? void 0;
+    }
     if (!cropping) return void 0;
     if (cropping.workspaceOverrides?.[workspaceName]) {
       return cropping.workspaceOverrides[workspaceName];
     }
     return cropping.default;
-  }, [cropping]);
+  }, [cropping, videoStreamsByWorkspaceId]);
   const filteredWorkspaces = useMemo(() => {
     return selectedLine === 1 ? workspaces.filter((w) => {
       if (w.workspace_name === "WS5-5") return true;
@@ -27841,6 +28859,7 @@ var VideoGridView = React25__default.memo(({
       }
     }) : workspaces;
   }, [workspaces, selectedLine]);
+  const streamsReady = !videoStreamsLoading;
   const calculateOptimalGrid = useCallback(() => {
     if (!containerRef.current) return;
     const containerPadding = 16;
@@ -27944,12 +28963,31 @@ var VideoGridView = React25__default.memo(({
     const navParams = getWorkspaceNavigationParams(workspaceId, displayName, workspace.line_id);
     router.push(`/workspace/${workspaceId}${navParams}`);
   }, [router, dashboardConfig]);
-  const handleStreamError = useCallback((workspaceId) => {
+  const handleStreamError = useCallback((workspaceId, options) => {
+    const isR2Stream = options?.isR2Stream ?? false;
+    const hasFallback = Boolean(options?.fallbackUrl);
+    if (isR2Stream && hasFallback) {
+      console.warn(`[VideoGridView] R2 stream failed for workspace: ${workspaceId}. Falling back to media config.`);
+      setR2FallbackWorkspaces((prev) => new Set(prev).add(workspaceId));
+      setFailedStreams((prev) => {
+        const next = new Set(prev);
+        next.delete(workspaceId);
+        return next;
+      });
+      trackCoreEvent("Video Stream Error", {
+        workspace_id: workspaceId,
+        view_type: "video_grid",
+        stream_source: "r2",
+        fallback: "media_config"
+      });
+      return;
+    }
     console.error(`[VideoGridView] Stream failed for workspace: ${workspaceId}`);
     setFailedStreams((prev) => new Set(prev).add(workspaceId));
     trackCoreEvent("Video Stream Error", {
       workspace_id: workspaceId,
-      view_type: "video_grid"
+      view_type: "video_grid",
+      stream_source: isR2Stream ? "r2" : "media_config"
     });
   }, []);
   return /* @__PURE__ */ jsx("div", { className: `relative overflow-hidden h-full w-full ${className}`, children: /* @__PURE__ */ jsx("div", { ref: containerRef, className: "h-full w-full p-3 sm:p-2", children: /* @__PURE__ */ jsx(
@@ -27961,57 +28999,92 @@ var VideoGridView = React25__default.memo(({
         gridTemplateRows: `repeat(${gridRows}, 1fr)`,
         gridAutoFlow: "row"
       },
-      children: filteredWorkspaces.sort((a, b) => {
-        if (a.line_id !== b.line_id) {
-          return (a.line_id || "").localeCompare(b.line_id || "");
-        }
-        const aMatch = a.workspace_name.match(/WS(\d+)/);
-        const bMatch = b.workspace_name.match(/WS(\d+)/);
-        if (aMatch && bMatch) {
-          const aNum = parseInt(aMatch[1]);
-          const bNum = parseInt(bMatch[1]);
-          return aNum - bNum;
-        }
-        return a.workspace_name.localeCompare(b.workspace_name);
-      }).map((workspace) => {
-        const workspaceId = workspace.workspace_uuid || workspace.workspace_name;
-        const workspaceKey = `${workspace.line_id || "unknown"}-${workspaceId}`;
-        const isVisible = visibleWorkspaces.has(workspaceId);
-        const isVeryLowEfficiency = workspace.show_exclamation ?? (workspace.efficiency < 50 && workspace.efficiency >= 10);
-        const workspaceCropping = getWorkspaceCropping(workspace.workspace_name);
-        return /* @__PURE__ */ jsx(
+      children: (() => {
+        const sortedWorkspaces = [...filteredWorkspaces].sort((a, b) => {
+          if (a.line_id !== b.line_id) {
+            return (a.line_id || "").localeCompare(b.line_id || "");
+          }
+          const aMatch = a.workspace_name.match(/WS(\d+)/);
+          const bMatch = b.workspace_name.match(/WS(\d+)/);
+          if (aMatch && bMatch) {
+            const aNum = parseInt(aMatch[1]);
+            const bNum = parseInt(bMatch[1]);
+            return aNum - bNum;
+          }
+          return a.workspace_name.localeCompare(b.workspace_name);
+        });
+        const workspaceCards = sortedWorkspaces.map((workspace) => {
+          const workspaceId = workspace.workspace_uuid || workspace.workspace_name;
+          `${workspace.line_id || "unknown"}-${workspaceId}`;
+          const isVisible = visibleWorkspaces.has(workspaceId);
+          const isVeryLowEfficiency = workspace.show_exclamation ?? (workspace.efficiency < 50 && workspace.efficiency >= 10);
+          const workspaceCropping = getWorkspaceCropping(workspaceId, workspace.workspace_name);
+          const workspaceStream = videoStreamsByWorkspaceId?.[workspaceId];
+          const r2Url = workspaceStream?.hls_url;
+          const fallbackUrl = getWorkspaceHlsUrl(workspace.workspace_name, workspace.line_id);
+          const hasR2Stream = Boolean(r2Url);
+          const useFallback = r2FallbackWorkspaces.has(workspaceId) || streamsReady && !hasR2Stream;
+          const hlsUrl = useFallback ? fallbackUrl : r2Url ?? "";
+          const isR2Stream = !useFallback && hasR2Stream;
+          const canAttemptR2 = hasR2Stream && !r2FallbackWorkspaces.has(workspaceId);
+          const shouldPlay = isVisible && Boolean(hlsUrl) && (!failedStreams.has(workspaceId) || canAttemptR2);
+          return {
+            workspace,
+            workspaceId,
+            isVisible,
+            isVeryLowEfficiency,
+            workspaceCropping,
+            fallbackUrl,
+            hlsUrl,
+            isR2Stream,
+            shouldPlay
+          };
+        });
+        const croppedActiveCount = workspaceCards.reduce((count, card) => {
+          if (card.shouldPlay && card.workspaceCropping) {
+            return count + 1;
+          }
+          return count;
+        }, 0);
+        const throttleCropping = croppedActiveCount > 10;
+        const effectiveCanvasFps = throttleCropping ? 10 : canvasConfig?.fps;
+        const effectiveUseRAF = throttleCropping ? false : canvasConfig?.useRAF;
+        return workspaceCards.map((card) => /* @__PURE__ */ jsx(
           "div",
           {
-            "data-workspace-id": workspaceId,
+            "data-workspace-id": card.workspaceId,
             className: "workspace-card relative w-full h-full",
             children: /* @__PURE__ */ jsx("div", { className: "absolute inset-0", children: /* @__PURE__ */ jsx(
               VideoCard,
               {
-                workspace,
-                hlsUrl: getWorkspaceHlsUrl(workspace.workspace_name, workspace.line_id),
-                shouldPlay: isVisible && !failedStreams.has(workspaceId),
-                onClick: () => handleWorkspaceClick(workspace),
-                onFatalError: () => handleStreamError(workspaceId),
-                isVeryLowEfficiency,
+                workspace: card.workspace,
+                hlsUrl: card.hlsUrl,
+                shouldPlay: card.shouldPlay,
+                onClick: () => handleWorkspaceClick(card.workspace),
+                onFatalError: () => handleStreamError(card.workspaceId, {
+                  isR2Stream: card.isR2Stream,
+                  fallbackUrl: card.fallbackUrl
+                }),
+                isVeryLowEfficiency: card.isVeryLowEfficiency,
                 legend: effectiveLegend,
-                cropping: workspaceCropping,
-                canvasFps: canvasConfig?.fps,
+                cropping: card.workspaceCropping,
+                canvasFps: effectiveCanvasFps,
                 displayName: (
                   // Create line-aware lookup key: lineId_workspaceName
                   // This ensures correct mapping when multiple lines have same workspace names
-                  displayNames[`${workspace.line_id}_${workspace.workspace_name}`] || // Always pass line_id to fallback to ensure correct mapping per line
-                  getWorkspaceDisplayName(workspace.workspace_name, workspace.line_id)
+                  displayNames[`${card.workspace.line_id}_${card.workspace.workspace_name}`] || // Always pass line_id to fallback to ensure correct mapping per line
+                  getWorkspaceDisplayName(card.workspace.workspace_name, card.workspace.line_id)
                 ),
-                useRAF: canvasConfig?.useRAF,
+                useRAF: effectiveUseRAF,
                 compact: !selectedLine,
-                onMouseEnter: onWorkspaceHover ? () => onWorkspaceHover(workspaceId) : void 0,
-                onMouseLeave: onWorkspaceHoverEnd ? () => onWorkspaceHoverEnd(workspaceId) : void 0
+                onMouseEnter: onWorkspaceHover ? () => onWorkspaceHover(card.workspaceId) : void 0,
+                onMouseLeave: onWorkspaceHoverEnd ? () => onWorkspaceHoverEnd(card.workspaceId) : void 0
               }
             ) })
           },
-          workspaceKey
-        );
-      })
+          card.workspaceId
+        ));
+      })()
     }
   ) }) });
 });
@@ -29647,33 +30720,6 @@ var VideoControls = ({
     }
   );
 };
-
-// src/lib/utils/r2Detection.ts
-function isR2WorkerUrl(url, r2WorkerDomain) {
-  if (!url || !r2WorkerDomain) return false;
-  try {
-    const workerDomain = new URL(r2WorkerDomain).hostname;
-    return url.includes(workerDomain);
-  } catch {
-    return url.includes(r2WorkerDomain.replace(/https?:\/\//, ""));
-  }
-}
-
-// src/lib/services/hlsAuthService.ts
-async function getAuthTokenForHls(supabase) {
-  try {
-    const { data: { session } } = await supabase.auth.getSession();
-    if (!session?.access_token) {
-      console.warn("[HLS Auth] No active session, R2 streaming may fail");
-      return null;
-    }
-    console.log("[HLS Auth] Retrieved token for HLS.js requests");
-    return session.access_token;
-  } catch (error) {
-    console.error("[HLS Auth] Error getting auth token:", error);
-    return null;
-  }
-}
 var ERROR_MAPPING = {
   "networkError": {
     code: 2,
@@ -30058,8 +31104,8 @@ var HlsVideoPlayer = forwardRef(({
           console.log(`[HlsVideoPlayer] Remuxing enabled - using remux playlist URL: ${remuxUrl}`);
           if (safariMode) {
             video.src = remuxUrl;
-          } else if (Hls3.isSupported()) {
-            const hls = new Hls3(mergedHlsConfig);
+          } else if (Hls.isSupported()) {
+            const hls = new Hls(mergedHlsConfig);
             hlsRef.current = hls;
             hls.on(Events.MANIFEST_PARSED, () => {
               console.log("[HlsVideoPlayer] Remuxed manifest parsed, ready to play");
@@ -30109,12 +31155,12 @@ var HlsVideoPlayer = forwardRef(({
             blobUrlRef.current = blobUrl;
             video.src = blobUrl;
           }
-        } else if (Hls3.isSupported()) {
+        } else if (Hls.isSupported()) {
           const blob = new Blob([effectiveSrc], { type: "application/vnd.apple.mpegurl" });
           const blobUrl = URL.createObjectURL(blob);
           blobUrlRef.current = blobUrl;
           console.log(`[HlsVideoPlayer] Non-Safari browser (${browserName}) - using HLS.js with blob URL`);
-          const hls = new Hls3(mergedHlsConfig);
+          const hls = new Hls(mergedHlsConfig);
           hlsRef.current = hls;
           hls.on(Events.MANIFEST_PARSED, () => {
             console.log("[HlsVideoPlayer] Manifest parsed, ready to play");
@@ -30164,8 +31210,8 @@ var HlsVideoPlayer = forwardRef(({
           onError?.(player, errorInfo);
         }
       } else {
-        if (Hls3.isSupported() && !isSafari()) {
-          const hls = new Hls3(mergedHlsConfig);
+        if (Hls.isSupported() && !isSafari()) {
+          const hls = new Hls(mergedHlsConfig);
           hlsRef.current = hls;
           hls.on(Events.MANIFEST_PARSED, () => {
             setIsReady(true);
@@ -31017,25 +32063,8 @@ var CroppedHlsVideoPlayer = forwardRef(({
 });
 CroppedHlsVideoPlayer.displayName = "CroppedHlsVideoPlayer";
 var CroppedVideoPlayer = CroppedHlsVideoPlayer;
-var getSupabaseClient2 = () => {
-  const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
-  const key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
-  if (!url || !key) {
-    throw new Error("Supabase configuration missing");
-  }
-  return createClient(url, key);
-};
-var getAuthToken4 = async () => {
-  try {
-    const supabase = getSupabaseClient2();
-    const { data: { session } } = await supabase.auth.getSession();
-    return session?.access_token || null;
-  } catch (error) {
-    console.error("[useWorkspaceCrop] Error getting auth token:", error);
-    return null;
-  }
-};
 function useWorkspaceCrop(workspaceId) {
+  const supabase = useSupabase();
   const [crop, setCrop] = useState(null);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState(null);
@@ -31048,7 +32077,8 @@ function useWorkspaceCrop(workspaceId) {
       setIsLoading(true);
       setError(null);
       try {
-        const token = await getAuthToken4();
+        const { data: { session } } = await supabase.auth.getSession();
+        const token = session?.access_token || null;
         if (!token) {
           throw new Error("Authentication required");
         }
@@ -31078,7 +32108,7 @@ function useWorkspaceCrop(workspaceId) {
       }
     };
     fetchCrop();
-  }, [workspaceId]);
+  }, [workspaceId, supabase]);
   return { crop, isLoading, error };
 }
 function Skeleton({ className, ...props }) {
@@ -32067,6 +33097,7 @@ var FileManagerFilters = ({
   const [idleLabelFilter, setIdleLabelFilter] = useState(null);
   const [showIdleLabelFilterModal, setShowIdleLabelFilterModal] = useState(false);
   const timezone = useAppTimezone();
+  const supabase = useSupabase();
   const [clipMetadata, setClipMetadata] = useState({});
   const [loadingCategories, setLoadingCategories] = useState(/* @__PURE__ */ new Set());
   const [categoryPages, setCategoryPages] = useState({});
@@ -32137,7 +33168,7 @@ var FileManagerFilters = ({
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "Authorization": `Bearer ${await getAuthToken5()}`
+          "Authorization": `Bearer ${await getAuthToken4()}`
         },
         body: JSON.stringify({
           action: "clip-metadata",
@@ -32170,13 +33201,8 @@ var FileManagerFilters = ({
       });
     }
   }, [workspaceId, date, shift]);
-  const getAuthToken5 = async () => {
+  const getAuthToken4 = async () => {
     try {
-      const { createClient: createClient5 } = await import('@supabase/supabase-js');
-      const supabase = createClient5(
-        process.env.NEXT_PUBLIC_SUPABASE_URL || "",
-        process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || ""
-      );
       const { data: { session } } = await supabase.auth.getSession();
       return session?.access_token || null;
     } catch (error) {
@@ -32196,7 +33222,7 @@ var FileManagerFilters = ({
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "Authorization": `Bearer ${await getAuthToken5()}`
+          "Authorization": `Bearer ${await getAuthToken4()}`
         },
         body: JSON.stringify({
           action: "percentile-clips",
@@ -33403,6 +34429,7 @@ var BottlenecksContent = ({
 }) => {
   console.log("\u{1F3AB} [BottlenecksContent] Rendered with ticketId:", ticketId || "NONE", "workspaceId:", workspaceId, "date:", date, "shift:", shift);
   const dashboardConfig = useDashboardConfig();
+  const supabase = useSupabase();
   const { session } = useAuth();
   const timezone = useAppTimezone();
   const { shiftConfig, isLoading: isShiftConfigLoading } = useDynamicShiftConfig(lineId);
@@ -33768,26 +34795,21 @@ var BottlenecksContent = ({
       fetchClipCounts();
     }
   }, [workspaceId, effectiveDateString, effectiveShiftId, s3ClipsService, fetchClipCounts, isEffectiveShiftReady]);
-  const getAuthToken5 = useCallback(async () => {
+  const getAuthToken4 = useCallback(async () => {
     try {
-      const { createClient: createClient5 } = await import('@supabase/supabase-js');
-      const supabase = createClient5(
-        process.env.NEXT_PUBLIC_SUPABASE_URL || "",
-        process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || ""
-      );
       const { data: { session: session2 } } = await supabase.auth.getSession();
       return session2?.access_token || null;
     } catch (error2) {
       console.error("[BottlenecksContent] Error getting auth token:", error2);
       return null;
     }
-  }, []);
+  }, [supabase]);
   useEffect(() => {
     if (!triageMode || !workspaceId || !isEffectiveShiftReady) return;
     const fetchTriageClips = async () => {
       setIsLoadingTriageClips(true);
       try {
-        const token = await getAuthToken5();
+        const token = await getAuthToken4();
         if (!token) {
           console.error("[BottlenecksContent] No auth token available");
           return;
@@ -33835,7 +34857,7 @@ var BottlenecksContent = ({
       }
     };
     fetchTriageClips();
-  }, [triageMode, workspaceId, effectiveDateString, effectiveShiftId, getAuthToken5, isEffectiveShiftReady]);
+  }, [triageMode, workspaceId, effectiveDateString, effectiveShiftId, getAuthToken4, isEffectiveShiftReady]);
   useEffect(() => {
     if (!triageMode || triageClips.length === 0 || !session?.access_token) {
       return;
@@ -34028,13 +35050,7 @@ var BottlenecksContent = ({
         return;
       }
       console.log(`[BottlenecksContent] Loading metadata for category: ${categoryId}${forceRefresh ? " (force refresh)" : ""}`);
-      const { createClient: createClient5 } = await import('@supabase/supabase-js');
-      const supabase = createClient5(
-        process.env.NEXT_PUBLIC_SUPABASE_URL || "",
-        process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || ""
-      );
-      const { data: { session: session2 } } = await supabase.auth.getSession();
-      const authToken = session2?.access_token;
+      const authToken = await getAuthToken4();
       if (!authToken) {
         console.error("Authentication required for metadata loading");
         return;
@@ -34104,10 +35120,10 @@ var BottlenecksContent = ({
         setCategoryMetadata(metadataClips);
         categoryMetadataRef.current = metadataClips;
         console.log(`[BottlenecksContent] Loaded metadata for ${categoryId}: ${metadataClips.length} clips`);
-        if (categoryId === "idle_time" && metadataClips.length > 0 && session2?.access_token) {
+        if (categoryId === "idle_time" && metadataClips.length > 0 && session?.access_token) {
           const idleClipIds2 = metadataClips.map((c) => c.clipId).filter(Boolean);
           console.log(`[BottlenecksContent] Fetching classifications for ${idleClipIds2.length} metadata clips`);
-          fetchClassifications(idleClipIds2, session2.access_token).then((classifications) => {
+          fetchClassifications(idleClipIds2, session.access_token).then((classifications) => {
             console.log("[BottlenecksContent] Received metadata classifications:", Object.keys(classifications).length);
             setClipClassifications((prev) => ({
               ...prev,
@@ -40523,6 +41539,8 @@ var WorkspaceGrid = React25__default.memo(({
   hasFlowBuffers = false,
   legend = DEFAULT_EFFICIENCY_LEGEND,
   videoSources = {},
+  videoStreamsByWorkspaceId = {},
+  videoStreamsLoading = false,
   displayNames = {},
   onWorkspaceHover,
   onWorkspaceHoverEnd
@@ -40590,6 +41608,8 @@ var WorkspaceGrid = React25__default.memo(({
           {
             workspaces,
             videoSources,
+            videoStreamsByWorkspaceId,
+            videoStreamsLoading,
             displayNames,
             legend,
             onWorkspaceHover,
@@ -43541,26 +44561,26 @@ var SingleVideoStream = ({
     const hlsStreamUrl = streamUrl || getCameraStreamUrl(workspaceName, baseUrl);
     console.log(`Using camera URL for ${workspaceName}: ${hlsStreamUrl}`);
     const mergedHlsConfig = { ...DEFAULT_HLS_CONFIG, ...hlsConfig };
-    if (Hls3.isSupported()) {
-      const hls = new Hls3(mergedHlsConfig);
+    if (Hls.isSupported()) {
+      const hls = new Hls(mergedHlsConfig);
       hlsRef.current = hls;
-      hls.on(Hls3.Events.MEDIA_ATTACHED, () => {
+      hls.on(Hls.Events.MEDIA_ATTACHED, () => {
         console.log("HLS media attached");
         hls.loadSource(hlsStreamUrl);
       });
-      hls.on(Hls3.Events.MANIFEST_PARSED, () => {
+      hls.on(Hls.Events.MANIFEST_PARSED, () => {
         console.log("HLS manifest parsed");
         attemptPlay(video);
       });
-      hls.on(Hls3.Events.ERROR, (_, data) => {
+      hls.on(Hls.Events.ERROR, (_, data) => {
         if (data.fatal) {
           console.error("Fatal HLS error:", data.type, data.details);
           switch (data.type) {
-            case Hls3.ErrorTypes.NETWORK_ERROR:
+            case Hls.ErrorTypes.NETWORK_ERROR:
               console.error("Fatal network error encountered");
               setError("Network error: Please check your connection");
               break;
-            case Hls3.ErrorTypes.MEDIA_ERROR:
+            case Hls.ErrorTypes.MEDIA_ERROR:
               console.error("Fatal media error encountered, trying to recover");
               hls.recoverMediaError();
               break;
@@ -48527,6 +49547,10 @@ function HomeView({
     JSON.stringify(workspaceMetrics.map((w) => `${w.workspace_uuid}-${Math.round(w.efficiency)}-${w.trend}`)),
     selectedLineId
   ]);
+  const {
+    streamsByWorkspaceId: videoStreamsByWorkspaceId,
+    isLoading: videoStreamsLoading
+  } = useWorkspaceVideoStreams(workspaceMetrics);
   const memoizedKPIs = useMemo(() => kpis, [
     // Only update reference when values change by at least 1%
     kpis?.efficiency?.value ? Math.round(kpis.efficiency.value) : null,
@@ -48721,6 +49745,8 @@ function HomeView({
                   factoryView: factoryViewId,
                   legend: efficiencyLegend,
                   videoSources,
+                  videoStreamsByWorkspaceId,
+                  videoStreamsLoading,
                   displayNames: workspaceDisplayNames,
                   hasFlowBuffers,
                   className: "h-full",
@@ -48751,6 +49777,8 @@ function HomeView({
                   factoryView: factoryViewId,
                   legend: efficiencyLegend,
                   videoSources,
+                  videoStreamsByWorkspaceId,
+                  videoStreamsLoading,
                   displayNames: workspaceDisplayNames,
                   hasFlowBuffers,
                   className: "h-full",
@@ -61565,7 +62593,11 @@ async function getManufacturingInsights(userQuestion, lineId, shiftId, companyId
   );
 }
 function createStreamProxyHandler(config) {
-  const cloudFrontDomain = config?.cloudFrontDomain || "https://d1eiob0chi5jw.cloudfront.net";
+  const baseUrl = config?.baseUrl || config?.cloudFrontDomain || "https://d1eiob0chi5jw.cloudfront.net";
+  const forwardAuth = config?.forwardAuth ?? false;
+  const noCacheManifest = config?.noCacheManifest ?? false;
+  const staticAuthToken = config?.staticAuthToken;
+  const debugAuth = config?.debugAuth ?? false;
   return async function handler(req, res) {
     if (req.method !== "GET") {
       return res.status(405).json({ error: "Method not allowed" });
@@ -61575,15 +62607,28 @@ function createStreamProxyHandler(config) {
       return res.status(400).json({ error: "Missing path parameter" });
     }
     const fullPath = path.join("/");
-    const targetUrl = `${cloudFrontDomain}/${fullPath}`;
+    const targetUrl = `${baseUrl}/${fullPath}`;
     try {
       console.log(`[HLS Stream Proxy] Streaming: ${targetUrl}`);
+      const resolvedAuthHeader = (() => {
+        if (forwardAuth && req.headers.authorization) {
+          return req.headers.authorization;
+        }
+        if (staticAuthToken) {
+          return staticAuthToken.startsWith("Bearer ") ? staticAuthToken : `Bearer ${staticAuthToken}`;
+        }
+        return void 0;
+      })();
+      if (debugAuth) {
+        console.log("[HLS Stream Proxy] Auth header present:", Boolean(resolvedAuthHeader));
+      }
       const response = await fetch(targetUrl, {
         method: "GET",
         headers: {
           "User-Agent": "NextJS-HLS-Stream-Proxy",
           // Pass through range headers for partial content requests
-          ...req.headers.range && { "Range": req.headers.range }
+          ...req.headers.range && { "Range": req.headers.range },
+          ...resolvedAuthHeader ? { "Authorization": resolvedAuthHeader } : {}
         }
       });
       if (!response.ok) {
@@ -61604,6 +62649,10 @@ function createStreamProxyHandler(config) {
       }
       if (fullPath.endsWith(".m3u8")) {
         res.setHeader("Content-Type", "application/vnd.apple.mpegurl");
+        if (noCacheManifest) {
+          res.setHeader("Cache-Control", "no-store, must-revalidate");
+          res.setHeader("Pragma", "no-cache");
+        }
       } else if (fullPath.endsWith(".ts")) {
         res.setHeader("Content-Type", "video/mp2t");
       }
@@ -61657,4 +62706,4 @@ var streamProxyConfig = {
   }
 };
 
-export { ACTION_NAMES, AIAgentView_default as AIAgentView, AcceptInvite, AcceptInviteView_default as AcceptInviteView, AdvancedFilterDialog, AdvancedFilterPanel, AudioService, AuthCallback, AuthCallbackView_default as AuthCallbackView, AuthProvider, AuthService, AuthenticatedBottleneckClipsView, AuthenticatedFactoryView, AuthenticatedHelpView, AuthenticatedHomeView, AuthenticatedShiftsView, AuthenticatedTargetsView, AuthenticatedTicketsView, AuthenticatedWorkspaceHealthView, AxelNotificationPopup, AxelOrb, BackButton, BackButtonMinimal, BarChart, BaseHistoryCalendar, BottleneckClipsModal, BottleneckClipsView_default as BottleneckClipsView, BottlenecksContent, BreakNotificationPopup, CachePrefetchStatus, Card2 as Card, CardContent2 as CardContent, CardDescription2 as CardDescription, CardFooter2 as CardFooter, CardHeader2 as CardHeader, CardTitle2 as CardTitle, ChangeRoleDialog, ClipFilterProvider, CompactWorkspaceHealthCard, ConfirmRemoveUserDialog, CongratulationsOverlay, CroppedHlsVideoPlayer, CroppedVideoPlayer, CycleTimeChart, CycleTimeOverTimeChart, DEFAULT_ANALYTICS_CONFIG, DEFAULT_AUTH_CONFIG, DEFAULT_CONFIG, DEFAULT_DATABASE_CONFIG, DEFAULT_DATE_TIME_CONFIG, DEFAULT_ENDPOINTS_CONFIG, DEFAULT_ENTITY_CONFIG, DEFAULT_HOME_VIEW_CONFIG, DEFAULT_MAP_VIEW_CONFIG, DEFAULT_SHIFT_CONFIG, DEFAULT_SHIFT_DATA, DEFAULT_THEME_CONFIG, DEFAULT_VIDEO_CONFIG, DEFAULT_WORKSPACE_CONFIG, DEFAULT_WORKSPACE_POSITIONS, DashboardHeader, DashboardLayout, DashboardOverridesProvider, DashboardProvider, DateDisplay_default as DateDisplay, DateTimeDisplay, DebugAuth, DebugAuthView_default as DebugAuthView, DetailedHealthStatus, DiagnosisVideoModal, EmptyStateMessage, EncouragementOverlay, FactoryAssignmentDropdown, FactoryView_default as FactoryView, FileManagerFilters, FilterDialogTrigger, FirstTimeLoginDebug, FirstTimeLoginHandler, GaugeChart, GridComponentsPlaceholder, HamburgerButton, Header, HealthDateShiftSelector, HealthStatusGrid, HealthStatusIndicator, HelpView_default as HelpView, HlsVideoPlayer, HomeView_default as HomeView, HourlyOutputChart2 as HourlyOutputChart, ISTTimer_default as ISTTimer, ImprovementCenterView_default as ImprovementCenterView, InlineEditableText, InteractiveOnboardingTour, InvitationService, InvitationsTable, InviteUserDialog, KPICard, KPIDetailView_default as KPIDetailView, KPIGrid, KPIHeader, KPISection, KPIsOverviewView_default as KPIsOverviewView, LINE_1_UUID, LINE_2_UUID, LargeOutputProgressChart, LeaderboardDetailView_default as LeaderboardDetailView, Legend6 as Legend, LineAssignmentDropdown, LineChart, LineHistoryCalendar, LineMonthlyHistory, LineMonthlyPdfGenerator, LinePdfExportButton, LinePdfGenerator, LineWhatsAppShareButton, LinesService, LiveTimer, LoadingInline, LoadingOverlay_default as LoadingOverlay, LoadingPage_default as LoadingPage, LoadingSkeleton, LoadingState, LoginPage, LoginView_default as LoginView, Logo, MainLayout, MapGridView, MetricCard_default as MetricCard, MinimalOnboardingPopup, MobileMenuProvider, NewClipsNotification, NoWorkspaceData, OnboardingDemo, OnboardingTour, OptifyeAgentClient, OptifyeLogoLoader_default as OptifyeLogoLoader, OutputProgressChart, PageHeader, PieChart4 as PieChart, PlayPauseIndicator, PrefetchConfigurationError, PrefetchError, PrefetchEvents, PrefetchStatus, PrefetchTimeoutError, ProfileView_default as ProfileView, RegistryProvider, RoleBadge, S3ClipsSupabaseService as S3ClipsService, S3Service, SKUManagementView, SOPComplianceChart, SSEChatClient, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SessionTracker, SessionTrackingContext, SessionTrackingProvider, SettingsPopup, ShiftDisplay_default as ShiftDisplay, ShiftsView_default as ShiftsView, SideNavBar, SignupWithInvitation, SilentErrorBoundary, SimpleOnboardingPopup, SingleVideoStream_default as SingleVideoStream, Skeleton, SubscriptionManager, SubscriptionManagerProvider, SupabaseProvider, SupervisorDropdown_default as SupervisorDropdown, SupervisorManagementView_default as SupervisorManagementView, SupervisorService, TargetWorkspaceGrid, TargetsView_default as TargetsView, TeamManagementView_default as TeamManagementView, TeamUsagePdfGenerator, ThreadSidebar, TicketHistory_default as TicketHistory, TicketHistoryService, TicketsView_default as TicketsView, TimeDisplay_default as TimeDisplay, TimePickerDropdown, Timer_default as Timer, TimezoneProvider, TimezoneService, UserManagementService, UserManagementTable, UserService, UserUsageDetailModal, UserUsageStats, VideoCard, VideoGridView, VideoPlayer, VideoPreloader, WORKSPACE_POSITIONS, WhatsAppShareButton, WorkspaceCard, WorkspaceDetailView_default as WorkspaceDetailView, WorkspaceDisplayNameExample, WorkspaceGrid, WorkspaceGridItem, WorkspaceHealthCard, WorkspaceHealthView_default as WorkspaceHealthView, WorkspaceHistoryCalendar, WorkspaceMetricCards, WorkspaceMetricCardsImpl, WorkspaceMonthlyDataFetcher, WorkspaceMonthlyHistory, WorkspaceMonthlyPdfGenerator, WorkspacePdfExportButton, WorkspacePdfGenerator, WorkspaceWhatsAppShareButton, actionService, aggregateKPIsFromLineMetricsRows, apiUtils, areAllLinesOnSameShift, authCoreService, authOTPService, authRateLimitService, buildDateKey, buildKPIsFromLineMetricsRow, checkRateLimit2 as checkRateLimit, clearAllRateLimits2 as clearAllRateLimits, clearRateLimit2 as clearRateLimit, clearS3VideoCache, clearS3VideoFromCache, clearWorkspaceDisplayNamesCache, cn, createDefaultKPIs, createInvitationService, createLinesService, createSessionTracker, createStreamProxyHandler, createSupabaseClient, createSupervisorService, createThrottledReload, createUserManagementService, createUserService, dashboardService, deleteThread, fetchIdleTimeReasons, filterDataByDateKeyRange, forceRefreshWorkspaceDisplayNames, formatDateInZone, formatDateKeyForDisplay, formatDateTimeInZone, formatDuration, formatISTDate, formatIdleTime, formatRangeLabel, formatReasonLabel, formatRelativeTime, formatTimeInZone, fromUrlFriendlyName, getAllLineDisplayNames, getAllThreadMessages, getAllWorkspaceDisplayNamesAsync, getAllWorkspaceDisplayNamesSnapshot, getAnonClient, getAvailableShiftIds, getBrowserName, getCameraNumber, getCompanyMetricsTableName, getConfigurableShortWorkspaceDisplayName, getConfigurableWorkspaceDisplayName, getConfiguredLineIds, getCoreSessionRecordingProperties, getCoreSessionReplayUrl, getCurrentShift, getCurrentShiftForLine, getCurrentTimeInZone, getDashboardHeaderTimeInZone, getDateKeyFromDate, getDaysDifferenceInZone, getDefaultCameraStreamUrl, getDefaultLineId, getDefaultTabForWorkspace, getLineDisplayName, getManufacturingInsights, getMetricsTablePrefix, getMonthKeyBounds, getMonthWeekRanges, getNextUpdateInterval, getOperationalDate, getReasonColor, getS3SignedUrl, getS3VideoSrc, getShiftData, getShiftNameById, getShiftWorkDurationSeconds, getShortShiftName, getShortWorkspaceDisplayName, getShortWorkspaceDisplayNameAsync, getStoredWorkspaceMappings, getSubscriptionManager, getThreadMessages, getUniformShiftGroup, getUserThreads, getUserThreadsPaginated, getWorkspaceDisplayName, getWorkspaceDisplayNameAsync, getWorkspaceDisplayNamesMap, getWorkspaceFromUrl, getWorkspaceNavigationParams, groupLinesByShift, hasAnyShiftData, identifyCoreUser, initializeCoreMixpanel, isFullMonthRange, isLegacyConfiguration, isPrefetchError, isSafari, isTransitionPeriod, isUrlPermanentlyFailed, isValidFactoryViewConfiguration, isValidLineInfoPayload, isValidPrefetchParams, isValidPrefetchStatus, isValidWorkspaceDetailedMetricsPayload, isValidWorkspaceMetricsPayload, isWorkspaceDisplayNamesLoaded, isWorkspaceDisplayNamesLoading, linesService, mergeWithDefaultConfig, migrateLegacyConfiguration, normalizeDateKeyRange, optifyeAgentClient, parseDateKeyToDate, parseS3Uri, preInitializeWorkspaceDisplayNames, preloadS3Video, preloadS3VideoUrl, preloadS3VideosUrl, preloadVideoUrl, preloadVideosUrl, qualityService, realtimeService, refreshWorkspaceDisplayNames, resetCoreMixpanel, resetFailedUrl, resetSubscriptionManager, s3VideoPreloader, shuffleArray, simulateApiDelay, skuService, startCoreSessionRecording, stopCoreSessionRecording, storeWorkspaceMapping, streamProxyConfig, subscribeWorkspaceDisplayNames, throttledReloadDashboard, toUrlFriendlyName, trackCoreEvent, trackCorePageView, transformToChartData, updateThreadTitle, upsertWorkspaceDisplayNameInCache, useAccessControl, useActiveBreaks, useActiveLineId, useAllWorkspaceMetrics, useAnalyticsConfig, useAppTimezone, useAudioService, useAuth, useAuthConfig, useAxelNotifications, useCanSaveTargets, useClipFilter, useClipTypes, useClipTypesWithCounts, useCompanyUsersUsage, useComponentOverride, useCustomConfig, useDashboardConfig, useDashboardMetrics, useDatabaseConfig, useDateFormatter, useDateTimeConfig, useDynamicShiftConfig, useEndpointsConfig, useEntityConfig, useFactoryOverviewMetrics, useFeatureFlags, useFormatNumber, useHasLineAccess, useHideMobileHeader, useHistoricWorkspaceMetrics, useHlsStream, useHlsStreamWithCropping, useHookOverride, useHourEndTimer, useHourlyTargetAchievements, useHourlyTargetMisses, useIdleTimeClipClassifications, useIdleTimeReasons, useLeaderboardMetrics, useLineDetailedMetrics, useLineKPIs, useLineMetrics, useLineShiftConfig, useLineSupervisor, useLineWorkspaceMetrics, useLines, useMessages, useMetrics, useMobileMenu, useMultiLineShiftConfigs, useNavigation, useOverrides, usePageOverride, usePrefetchClipCounts, useRealtimeLineMetrics, useRegistry, useSKUs, useSessionKeepAlive, useSessionTracking, useSessionTrackingContext, useShiftConfig, useShifts, useSubscriptionManager, useSubscriptionManagerSafe, useSupabase, useSupabaseClient, useSupervisorsByLineIds, useTargets, useTeamManagementPermissions, useTheme, useThemeConfig, useThreads, useTicketHistory, useTimezoneContext, useUserLineAccess, useUserUsage, useVideoConfig, useWorkspaceConfig, useWorkspaceDetailedMetrics, useWorkspaceDisplayName, useWorkspaceDisplayNames, useWorkspaceDisplayNamesMap, useWorkspaceHealthById, useWorkspaceHealthStatus, useWorkspaceMetrics, useWorkspaceNavigation, useWorkspaceOperators, useWorkspaceUptimeTimeline, userService, videoPrefetchManager, videoPreloader, whatsappService, withAccessControl, withAuth, withRegistry, withTimezone, workspaceHealthService, workspaceService };
+export { ACTION_NAMES, AIAgentView_default as AIAgentView, AcceptInvite, AcceptInviteView_default as AcceptInviteView, AdvancedFilterDialog, AdvancedFilterPanel, AudioService, AuthCallback, AuthCallbackView_default as AuthCallbackView, AuthProvider, AuthService, AuthenticatedBottleneckClipsView, AuthenticatedFactoryView, AuthenticatedHelpView, AuthenticatedHomeView, AuthenticatedShiftsView, AuthenticatedTargetsView, AuthenticatedTicketsView, AuthenticatedWorkspaceHealthView, AxelNotificationPopup, AxelOrb, BackButton, BackButtonMinimal, BarChart, BaseHistoryCalendar, BottleneckClipsModal, BottleneckClipsView_default as BottleneckClipsView, BottlenecksContent, BreakNotificationPopup, CachePrefetchStatus, Card2 as Card, CardContent2 as CardContent, CardDescription2 as CardDescription, CardFooter2 as CardFooter, CardHeader2 as CardHeader, CardTitle2 as CardTitle, ChangeRoleDialog, ClipFilterProvider, CompactWorkspaceHealthCard, ConfirmRemoveUserDialog, CongratulationsOverlay, CroppedHlsVideoPlayer, CroppedVideoPlayer, CycleTimeChart, CycleTimeOverTimeChart, DEFAULT_ANALYTICS_CONFIG, DEFAULT_AUTH_CONFIG, DEFAULT_CONFIG, DEFAULT_DATABASE_CONFIG, DEFAULT_DATE_TIME_CONFIG, DEFAULT_ENDPOINTS_CONFIG, DEFAULT_ENTITY_CONFIG, DEFAULT_HOME_VIEW_CONFIG, DEFAULT_MAP_VIEW_CONFIG, DEFAULT_SHIFT_CONFIG, DEFAULT_SHIFT_DATA, DEFAULT_THEME_CONFIG, DEFAULT_VIDEO_CONFIG, DEFAULT_WORKSPACE_CONFIG, DEFAULT_WORKSPACE_POSITIONS, DashboardHeader, DashboardLayout, DashboardOverridesProvider, DashboardProvider, DateDisplay_default as DateDisplay, DateTimeDisplay, DebugAuth, DebugAuthView_default as DebugAuthView, DetailedHealthStatus, DiagnosisVideoModal, EmptyStateMessage, EncouragementOverlay, FactoryAssignmentDropdown, FactoryView_default as FactoryView, FileManagerFilters, FilterDialogTrigger, FirstTimeLoginDebug, FirstTimeLoginHandler, GaugeChart, GridComponentsPlaceholder, HamburgerButton, Header, HealthDateShiftSelector, HealthStatusGrid, HealthStatusIndicator, HelpView_default as HelpView, HlsVideoPlayer, HomeView_default as HomeView, HourlyOutputChart2 as HourlyOutputChart, ISTTimer_default as ISTTimer, ImprovementCenterView_default as ImprovementCenterView, InlineEditableText, InteractiveOnboardingTour, InvitationService, InvitationsTable, InviteUserDialog, KPICard, KPIDetailView_default as KPIDetailView, KPIGrid, KPIHeader, KPISection, KPIsOverviewView_default as KPIsOverviewView, LINE_1_UUID, LINE_2_UUID, LargeOutputProgressChart, LeaderboardDetailView_default as LeaderboardDetailView, Legend6 as Legend, LineAssignmentDropdown, LineChart, LineHistoryCalendar, LineMonthlyHistory, LineMonthlyPdfGenerator, LinePdfExportButton, LinePdfGenerator, LineWhatsAppShareButton, LinesService, LiveTimer, LoadingInline, LoadingOverlay_default as LoadingOverlay, LoadingPage_default as LoadingPage, LoadingSkeleton, LoadingState, LoginPage, LoginView_default as LoginView, Logo, MainLayout, MapGridView, MetricCard_default as MetricCard, MinimalOnboardingPopup, MobileMenuProvider, NewClipsNotification, NoWorkspaceData, OnboardingDemo, OnboardingTour, OptifyeAgentClient, OptifyeLogoLoader_default as OptifyeLogoLoader, OutputProgressChart, PageHeader, PieChart4 as PieChart, PlayPauseIndicator, PrefetchConfigurationError, PrefetchError, PrefetchEvents, PrefetchStatus, PrefetchTimeoutError, ProfileView_default as ProfileView, RegistryProvider, RoleBadge, S3ClipsSupabaseService as S3ClipsService, S3Service, SKUManagementView, SOPComplianceChart, SSEChatClient, Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SessionTracker, SessionTrackingContext, SessionTrackingProvider, SettingsPopup, ShiftDisplay_default as ShiftDisplay, ShiftsView_default as ShiftsView, SideNavBar, SignupWithInvitation, SilentErrorBoundary, SimpleOnboardingPopup, SingleVideoStream_default as SingleVideoStream, Skeleton, SubscriptionManager, SubscriptionManagerProvider, SupabaseProvider, SupervisorDropdown_default as SupervisorDropdown, SupervisorManagementView_default as SupervisorManagementView, SupervisorService, TargetWorkspaceGrid, TargetsView_default as TargetsView, TeamManagementView_default as TeamManagementView, TeamUsagePdfGenerator, ThreadSidebar, TicketHistory_default as TicketHistory, TicketHistoryService, TicketsView_default as TicketsView, TimeDisplay_default as TimeDisplay, TimePickerDropdown, Timer_default as Timer, TimezoneProvider, TimezoneService, UserManagementService, UserManagementTable, UserService, UserUsageDetailModal, UserUsageStats, VideoCard, VideoGridView, VideoPlayer, VideoPreloader, WORKSPACE_POSITIONS, WhatsAppShareButton, WorkspaceCard, WorkspaceDetailView_default as WorkspaceDetailView, WorkspaceDisplayNameExample, WorkspaceGrid, WorkspaceGridItem, WorkspaceHealthCard, WorkspaceHealthView_default as WorkspaceHealthView, WorkspaceHistoryCalendar, WorkspaceMetricCards, WorkspaceMetricCardsImpl, WorkspaceMonthlyDataFetcher, WorkspaceMonthlyHistory, WorkspaceMonthlyPdfGenerator, WorkspacePdfExportButton, WorkspacePdfGenerator, WorkspaceWhatsAppShareButton, actionService, aggregateKPIsFromLineMetricsRows, apiUtils, areAllLinesOnSameShift, authCoreService, authOTPService, authRateLimitService, buildDateKey, buildKPIsFromLineMetricsRow, checkRateLimit2 as checkRateLimit, clearAllRateLimits2 as clearAllRateLimits, clearRateLimit2 as clearRateLimit, clearS3VideoCache, clearS3VideoFromCache, clearWorkspaceDisplayNamesCache, cn, createDefaultKPIs, createInvitationService, createLinesService, createSessionTracker, createStreamProxyHandler, createSupabaseClient, createSupervisorService, createThrottledReload, createUserManagementService, createUserService, dashboardService, deleteThread, fetchIdleTimeReasons, filterDataByDateKeyRange, forceRefreshWorkspaceDisplayNames, formatDateInZone, formatDateKeyForDisplay, formatDateTimeInZone, formatDuration, formatISTDate, formatIdleTime, formatRangeLabel, formatReasonLabel, formatRelativeTime, formatTimeInZone, fromUrlFriendlyName, getAllLineDisplayNames, getAllThreadMessages, getAllWorkspaceDisplayNamesAsync, getAllWorkspaceDisplayNamesSnapshot, getAnonClient, getAvailableShiftIds, getBrowserName, getCameraNumber, getCompanyMetricsTableName, getConfigurableShortWorkspaceDisplayName, getConfigurableWorkspaceDisplayName, getConfiguredLineIds, getCoreSessionRecordingProperties, getCoreSessionReplayUrl, getCurrentShift, getCurrentShiftForLine, getCurrentTimeInZone, getDashboardHeaderTimeInZone, getDateKeyFromDate, getDaysDifferenceInZone, getDefaultCameraStreamUrl, getDefaultLineId, getDefaultTabForWorkspace, getLineDisplayName, getManufacturingInsights, getMetricsTablePrefix, getMonthKeyBounds, getMonthWeekRanges, getNextUpdateInterval, getOperationalDate, getReasonColor, getS3SignedUrl, getS3VideoSrc, getShiftData, getShiftNameById, getShiftWorkDurationSeconds, getShortShiftName, getShortWorkspaceDisplayName, getShortWorkspaceDisplayNameAsync, getStoredWorkspaceMappings, getSubscriptionManager, getThreadMessages, getUniformShiftGroup, getUserThreads, getUserThreadsPaginated, getWorkspaceDisplayName, getWorkspaceDisplayNameAsync, getWorkspaceDisplayNamesMap, getWorkspaceFromUrl, getWorkspaceNavigationParams, groupLinesByShift, hasAnyShiftData, identifyCoreUser, initializeCoreMixpanel, isFullMonthRange, isLegacyConfiguration, isPrefetchError, isSafari, isTransitionPeriod, isUrlPermanentlyFailed, isValidFactoryViewConfiguration, isValidLineInfoPayload, isValidPrefetchParams, isValidPrefetchStatus, isValidWorkspaceDetailedMetricsPayload, isValidWorkspaceMetricsPayload, isWorkspaceDisplayNamesLoaded, isWorkspaceDisplayNamesLoading, linesService, mergeWithDefaultConfig, migrateLegacyConfiguration, normalizeDateKeyRange, optifyeAgentClient, parseDateKeyToDate, parseS3Uri, preInitializeWorkspaceDisplayNames, preloadS3Video, preloadS3VideoUrl, preloadS3VideosUrl, preloadVideoUrl, preloadVideosUrl, qualityService, realtimeService, refreshWorkspaceDisplayNames, resetCoreMixpanel, resetFailedUrl, resetSubscriptionManager, s3VideoPreloader, shuffleArray, simulateApiDelay, skuService, startCoreSessionRecording, stopCoreSessionRecording, storeWorkspaceMapping, streamProxyConfig, subscribeWorkspaceDisplayNames, throttledReloadDashboard, toUrlFriendlyName, trackCoreEvent, trackCorePageView, transformToChartData, updateThreadTitle, upsertWorkspaceDisplayNameInCache, useAccessControl, useActiveBreaks, useActiveLineId, useAllWorkspaceMetrics, useAnalyticsConfig, useAppTimezone, useAudioService, useAuth, useAuthConfig, useAxelNotifications, useCanSaveTargets, useClipFilter, useClipTypes, useClipTypesWithCounts, useCompanyUsersUsage, useComponentOverride, useCustomConfig, useDashboardConfig, useDashboardMetrics, useDatabaseConfig, useDateFormatter, useDateTimeConfig, useDynamicShiftConfig, useEndpointsConfig, useEntityConfig, useFactoryOverviewMetrics, useFeatureFlags, useFormatNumber, useHasLineAccess, useHideMobileHeader, useHistoricWorkspaceMetrics, useHlsStream, useHlsStreamWithCropping, useHookOverride, useHourEndTimer, useHourlyTargetAchievements, useHourlyTargetMisses, useIdleTimeClipClassifications, useIdleTimeReasons, useLeaderboardMetrics, useLineDetailedMetrics, useLineKPIs, useLineMetrics, useLineShiftConfig, useLineSupervisor, useLineWorkspaceMetrics, useLines, useMessages, useMetrics, useMobileMenu, useMultiLineShiftConfigs, useNavigation, useOptionalSupabase, useOverrides, usePageOverride, usePrefetchClipCounts, useRealtimeLineMetrics, useRegistry, useSKUs, useSessionKeepAlive, useSessionTracking, useSessionTrackingContext, useShiftConfig, useShifts, useSubscriptionManager, useSubscriptionManagerSafe, useSupabase, useSupabaseClient, useSupervisorsByLineIds, useTargets, useTeamManagementPermissions, useTheme, useThemeConfig, useThreads, useTicketHistory, useTimezoneContext, useUserLineAccess, useUserUsage, useVideoConfig, useWorkspaceConfig, useWorkspaceDetailedMetrics, useWorkspaceDisplayName, useWorkspaceDisplayNames, useWorkspaceDisplayNamesMap, useWorkspaceHealthById, useWorkspaceHealthStatus, useWorkspaceMetrics, useWorkspaceNavigation, useWorkspaceOperators, useWorkspaceUptimeTimeline, useWorkspaceVideoStreams, userService, videoPrefetchManager, videoPreloader, whatsappService, withAccessControl, withAuth, withRegistry, withTimezone, workspaceHealthService, workspaceService };