@optifye/dashboard-core 6.3.4 → 6.4.0

package/dist/index.js

@@ -424,11 +424,11 @@ var actionService = {
 };
 function createMemoizedFunction(fn, getCacheKey) {
   const cache = /* @__PURE__ */ new Map();
-  const CACHE_DURATION3 = 5 * 60 * 1e3;
+  const CACHE_DURATION = 5 * 60 * 1e3;
   return (...args) => {
     const key = getCacheKey(...args);
     const cached = cache.get(key);
-    if (cached && Date.now() - cached.timestamp < CACHE_DURATION3) {
+    if (cached && Date.now() - cached.timestamp < CACHE_DURATION) {
       return cached.result;
     }
     const result = fn(...args);
@@ -2479,199 +2479,6 @@ async function deleteThread(threadId) {
   if (error) throw error;
 }
 
-// src/lib/services/cacheService.ts
-var CacheService = class {
-  constructor() {
-    this.memoryCache = /* @__PURE__ */ new Map();
-    this.DEFAULT_DURATION = 5 * 60 * 1e3;
-  }
-  // 5 minutes
-  /**
-   * Generate a cache key from multiple parts
-   */
-  generateKey(...parts) {
-    return parts.filter((p) => p !== void 0 && p !== null).join(":");
-  }
-  /**
-   * Get item from cache
-   */
-  get(key, options) {
-    const storage = options?.storage || "memory";
-    try {
-      let cacheItem = null;
-      if (storage === "memory") {
-        cacheItem = this.memoryCache.get(key) || null;
-      } else if (storage === "localStorage" || storage === "sessionStorage") {
-        const stored = window[storage].getItem(key);
-        if (stored) {
-          cacheItem = JSON.parse(stored);
-        }
-      }
-      if (!cacheItem) {
-        return null;
-      }
-      if (Date.now() > cacheItem.expiresAt) {
-        this.delete(key, options);
-        return null;
-      }
-      return cacheItem.data;
-    } catch (error) {
-      console.error(`Error getting cache item ${key}:`, error);
-      return null;
-    }
-  }
-  /**
-   * Set item in cache
-   */
-  set(key, data, options) {
-    const storage = options?.storage || "memory";
-    const duration = options?.duration || this.DEFAULT_DURATION;
-    const cacheItem = {
-      data,
-      timestamp: Date.now(),
-      expiresAt: Date.now() + duration
-    };
-    try {
-      if (storage === "memory") {
-        this.memoryCache.set(key, cacheItem);
-        if (this.memoryCache.size > 100) {
-          const firstKey = this.memoryCache.keys().next().value;
-          if (firstKey) {
-            this.memoryCache.delete(firstKey);
-          }
-        }
-      } else if (storage === "localStorage" || storage === "sessionStorage") {
-        window[storage].setItem(key, JSON.stringify(cacheItem));
-      }
-    } catch (error) {
-      console.error(`Error setting cache item ${key}:`, error);
-    }
-  }
-  /**
-   * Delete item from cache
-   */
-  delete(key, options) {
-    const storage = options?.storage || "memory";
-    try {
-      if (storage === "memory") {
-        this.memoryCache.delete(key);
-      } else if (storage === "localStorage" || storage === "sessionStorage") {
-        window[storage].removeItem(key);
-      }
-    } catch (error) {
-      console.error(`Error deleting cache item ${key}:`, error);
-    }
-  }
-  /**
-   * Clear all items from cache
-   */
-  clear(options) {
-    const storage = options?.storage || "memory";
-    try {
-      if (storage === "memory") {
-        this.memoryCache.clear();
-      } else if (storage === "localStorage" || storage === "sessionStorage") {
-        const keys = Object.keys(window[storage]);
-        keys.forEach((key) => {
-          try {
-            const item = window[storage].getItem(key);
-            if (item) {
-              const parsed = JSON.parse(item);
-              if (parsed.timestamp && parsed.expiresAt && parsed.data !== void 0) {
-                window[storage].removeItem(key);
-              }
-            }
-          } catch {
-          }
-        });
-      }
-    } catch (error) {
-      console.error("Error clearing cache:", error);
-    }
-  }
-  /**
-   * Get or set item in cache with a factory function
-   */
-  async getOrSet(key, factory, options) {
-    const cached = this.get(key, options);
-    if (cached !== null) {
-      return cached;
-    }
-    const data = await factory();
-    this.set(key, data, options);
-    return data;
-  }
-  /**
-   * Invalidate cache entries matching a pattern
-   */
-  invalidatePattern(pattern, options) {
-    const storage = options?.storage || "memory";
-    const regex = typeof pattern === "string" ? new RegExp(pattern) : pattern;
-    try {
-      if (storage === "memory") {
-        const keysToDelete = [];
-        this.memoryCache.forEach((_, key) => {
-          if (regex.test(key)) {
-            keysToDelete.push(key);
-          }
-        });
-        keysToDelete.forEach((key) => this.memoryCache.delete(key));
-      } else if (storage === "localStorage" || storage === "sessionStorage") {
-        const keys = Object.keys(window[storage]);
-        keys.forEach((key) => {
-          if (regex.test(key)) {
-            window[storage].removeItem(key);
-          }
-        });
-      }
-    } catch (error) {
-      console.error("Error invalidating cache pattern:", error);
-    }
-  }
-  /**
-   * Clean up expired items
-   */
-  cleanup(options) {
-    const storage = options?.storage || "memory";
-    const now2 = Date.now();
-    try {
-      if (storage === "memory") {
-        const keysToDelete = [];
-        this.memoryCache.forEach((item, key) => {
-          if (now2 > item.expiresAt) {
-            keysToDelete.push(key);
-          }
-        });
-        keysToDelete.forEach((key) => this.memoryCache.delete(key));
-      } else if (storage === "localStorage" || storage === "sessionStorage") {
-        const keys = Object.keys(window[storage]);
-        keys.forEach((key) => {
-          try {
-            const item = window[storage].getItem(key);
-            if (item) {
-              const parsed = JSON.parse(item);
-              if (parsed.expiresAt && now2 > parsed.expiresAt) {
-                window[storage].removeItem(key);
-              }
-            }
-          } catch {
-          }
-        });
-      }
-    } catch (error) {
-      console.error("Error cleaning up cache:", error);
-    }
-  }
-};
-var cacheService = new CacheService();
-if (typeof window !== "undefined") {
-  setInterval(() => {
-    cacheService.cleanup({ storage: "localStorage" });
-    cacheService.cleanup({ storage: "sessionStorage" });
-    cacheService.cleanup({ storage: "memory" });
-  }, 60 * 1e3);
-}
-
 // src/lib/services/subscriptionManager.ts
 var SubscriptionManager = class {
   constructor(supabase) {
@@ -4000,6 +3807,13 @@ var S3ClipsService = class {
   constructor(config) {
     // Request deduplication cache
     this.requestCache = new RequestDeduplicationCache();
+    // Flag to prevent metadata fetching during index building
+    this.isIndexBuilding = false;
+    // Flag to prevent metadata fetching during entire prefetch operation
+    this.isPrefetching = false;
+    // Global safeguard: limit concurrent metadata fetches to prevent flooding
+    this.currentMetadataFetches = 0;
+    this.MAX_CONCURRENT_METADATA = 3;
     this.config = config;
     if (!config.s3Config) {
       throw new Error("S3 configuration is required");
@@ -4147,16 +3961,36 @@ var S3ClipsService = class {
       return null;
     }
   }
+  /**
+   * Control prefetch mode to prevent metadata fetching during background operations
+   */
+  setPrefetchMode(enabled) {
+    this.isPrefetching = enabled;
+    console.log(`[S3ClipsService] Prefetch mode ${enabled ? "enabled" : "disabled"} - metadata fetching ${enabled ? "blocked" : "allowed"}`);
+  }
   /**
    * Fetches full metadata including timestamps with deduplication
    */
   async getFullMetadata(playlistUri) {
-    const deduplicationKey = `full-metadata:${playlistUri}`;
-    return this.requestCache.deduplicate(
-      deduplicationKey,
-      () => this.executeGetFullMetadata(playlistUri),
-      "FullMetadata"
-    );
+    if (this.isIndexBuilding || this.isPrefetching) {
+      console.warn(`[S3ClipsService] Skipping metadata fetch - building: ${this.isIndexBuilding}, prefetching: ${this.isPrefetching}`);
+      return null;
+    }
+    if (this.currentMetadataFetches >= this.MAX_CONCURRENT_METADATA) {
+      console.warn(`[S3ClipsService] Skipping metadata - max concurrent fetches (${this.MAX_CONCURRENT_METADATA}) reached`);
+      return null;
+    }
+    this.currentMetadataFetches++;
+    try {
+      const deduplicationKey = `full-metadata:${playlistUri}`;
+      return await this.requestCache.deduplicate(
+        deduplicationKey,
+        () => this.executeGetFullMetadata(playlistUri),
+        "FullMetadata"
+      );
+    } finally {
+      this.currentMetadataFetches--;
+    }
   }
   /**
    * Internal implementation of full metadata fetching
@@ -4217,141 +4051,152 @@ var S3ClipsService = class {
    * Internal implementation of clip counts fetching
    */
   async executeGetClipCounts(workspaceId, date, shiftId, buildIndex) {
-    const basePrefix = `sop_violations/${workspaceId}/${date}/${shiftId}/`;
-    const counts = { total: 0 };
-    const categoryFolders = [
-      "idle_time",
-      "low_value",
-      "sop_deviation",
-      "missing_quality_check",
-      "best_cycle_time",
-      "worst_cycle_time",
-      "long_cycle_time",
-      "cycle_completion",
-      "bottleneck"
-    ];
-    console.log(`[S3ClipsService] ${buildIndex ? "Building video index and counting" : "Fast counting"} clips for ${workspaceId} on ${date}, shift ${shiftId}`);
-    const startTime = performance.now();
-    const videoIndex = buildIndex ? {
-      byCategory: /* @__PURE__ */ new Map(),
-      allVideos: [],
-      counts: {},
-      workspaceId,
-      date,
-      shiftId: shiftId.toString(),
-      lastUpdated: /* @__PURE__ */ new Date(),
-      _debugId: `vid_${Date.now()}_${Math.random().toString(36).substring(7)}`
-    } : null;
-    const countPromises = categoryFolders.map(async (category) => {
-      const categoryPrefix = `${basePrefix}${category}/videos/`;
-      const categoryVideos = [];
-      try {
-        if (buildIndex) {
-          const command = new clientS3.ListObjectsV2Command({
-            Bucket: this.config.s3Config.bucketName,
-            Prefix: categoryPrefix,
-            MaxKeys: 1e3
-          });
-          let continuationToken;
-          do {
-            if (continuationToken) {
-              command.input.ContinuationToken = continuationToken;
-            }
-            const response = await this.s3Client.send(command);
-            if (response.Contents) {
-              for (const obj of response.Contents) {
-                if (obj.Key && obj.Key.endsWith("playlist.m3u8")) {
-                  if (obj.Key.includes("missed_qchecks")) {
-                    continue;
-                  }
-                  const s3Uri = `s3://${this.config.s3Config.bucketName}/${obj.Key}`;
-                  const sopCategories = this.getSOPCategories(workspaceId);
-                  const parsedInfo = parseS3Uri(s3Uri, sopCategories);
-                  const belongsToCategory = parsedInfo && (parsedInfo.type === category || // Handle specific mismatches between folder names and parsed types
-                  category === "cycle_completion" && parsedInfo.type === "cycle_completion" || category === "sop_deviation" && parsedInfo.type === "missing_quality_check" || category === "missing_quality_check" && parsedInfo.type === "missing_quality_check" || category === "idle_time" && parsedInfo.type === "low_value" || category === "low_value" && parsedInfo.type === "low_value");
-                  if (belongsToCategory) {
-                    const videoEntry = {
-                      uri: s3Uri,
-                      category: parsedInfo.type,
-                      // Use the parsed type, not the folder name
-                      timestamp: parsedInfo.timestamp,
-                      videoId: `${workspaceId}-${parsedInfo.timestamp}`,
-                      workspaceId,
-                      date,
-                      shiftId: shiftId.toString()
-                    };
-                    categoryVideos.push(videoEntry);
+    if (buildIndex) {
+      this.isIndexBuilding = true;
+      console.log(`[S3ClipsService] Starting index building - metadata fetching disabled`);
+    }
+    try {
+      const basePrefix = `sop_violations/${workspaceId}/${date}/${shiftId}/`;
+      const counts = { total: 0 };
+      const categoryFolders = [
+        "idle_time",
+        "low_value",
+        "sop_deviation",
+        "missing_quality_check",
+        "best_cycle_time",
+        "worst_cycle_time",
+        "long_cycle_time",
+        "cycle_completion",
+        "bottleneck"
+      ];
+      console.log(`[S3ClipsService] ${buildIndex ? "Building video index and counting" : "Fast counting"} clips for ${workspaceId} on ${date}, shift ${shiftId}`);
+      const startTime = performance.now();
+      const videoIndex = buildIndex ? {
+        byCategory: /* @__PURE__ */ new Map(),
+        allVideos: [],
+        counts: {},
+        workspaceId,
+        date,
+        shiftId: shiftId.toString(),
+        lastUpdated: /* @__PURE__ */ new Date(),
+        _debugId: `vid_${Date.now()}_${Math.random().toString(36).substring(7)}`
+      } : null;
+      const countPromises = categoryFolders.map(async (category) => {
+        const categoryPrefix = `${basePrefix}${category}/videos/`;
+        const categoryVideos = [];
+        try {
+          if (buildIndex) {
+            const command = new clientS3.ListObjectsV2Command({
+              Bucket: this.config.s3Config.bucketName,
+              Prefix: categoryPrefix,
+              MaxKeys: 1e3
+            });
+            let continuationToken;
+            do {
+              if (continuationToken) {
+                command.input.ContinuationToken = continuationToken;
+              }
+              const response = await this.s3Client.send(command);
+              if (response.Contents) {
+                for (const obj of response.Contents) {
+                  if (obj.Key && obj.Key.endsWith("playlist.m3u8")) {
+                    if (obj.Key.includes("missed_qchecks")) {
+                      continue;
+                    }
+                    const s3Uri = `s3://${this.config.s3Config.bucketName}/${obj.Key}`;
+                    const sopCategories = this.getSOPCategories(workspaceId);
+                    const parsedInfo = parseS3Uri(s3Uri, sopCategories);
+                    const belongsToCategory = parsedInfo && (parsedInfo.type === category || // Handle specific mismatches between folder names and parsed types
+                    category === "cycle_completion" && parsedInfo.type === "cycle_completion" || category === "sop_deviation" && parsedInfo.type === "missing_quality_check" || category === "missing_quality_check" && parsedInfo.type === "missing_quality_check" || category === "idle_time" && parsedInfo.type === "low_value" || category === "low_value" && parsedInfo.type === "low_value");
+                    if (belongsToCategory) {
+                      const videoEntry = {
+                        uri: s3Uri,
+                        category: parsedInfo.type,
+                        // Use the parsed type, not the folder name
+                        timestamp: parsedInfo.timestamp,
+                        videoId: `${workspaceId}-${parsedInfo.timestamp}`,
+                        workspaceId,
+                        date,
+                        shiftId: shiftId.toString()
+                      };
+                      categoryVideos.push(videoEntry);
+                    }
                   }
                 }
               }
+              continuationToken = response.NextContinuationToken;
+            } while (continuationToken);
+            categoryVideos.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+            if (categoryVideos.length > 0) {
+              console.log(`[S3ClipsService] Found ${categoryVideos.length} videos for category '${category}' (parsed types: ${[...new Set(categoryVideos.map((v) => v.category))].join(", ")})`);
             }
-            continuationToken = response.NextContinuationToken;
-          } while (continuationToken);
-          categoryVideos.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-          if (categoryVideos.length > 0) {
-            console.log(`[S3ClipsService] Found ${categoryVideos.length} videos for category '${category}' (parsed types: ${[...new Set(categoryVideos.map((v) => v.category))].join(", ")})`);
+            return { category, count: categoryVideos.length, videos: categoryVideos };
+          } else {
+            const command = new clientS3.ListObjectsV2Command({
+              Bucket: this.config.s3Config.bucketName,
+              Prefix: categoryPrefix,
+              Delimiter: "/",
+              MaxKeys: 1e3
+            });
+            let folderCount = 0;
+            let continuationToken;
+            do {
+              if (continuationToken) {
+                command.input.ContinuationToken = continuationToken;
+              }
+              const response = await this.s3Client.send(command);
+              if (response.CommonPrefixes) {
+                folderCount += response.CommonPrefixes.length;
+              }
+              continuationToken = response.NextContinuationToken;
+            } while (continuationToken);
+            return { category, count: folderCount, videos: [] };
           }
-          return { category, count: categoryVideos.length, videos: categoryVideos };
-        } else {
-          const command = new clientS3.ListObjectsV2Command({
-            Bucket: this.config.s3Config.bucketName,
-            Prefix: categoryPrefix,
-            Delimiter: "/",
-            MaxKeys: 1e3
-          });
-          let folderCount = 0;
-          let continuationToken;
-          do {
-            if (continuationToken) {
-              command.input.ContinuationToken = continuationToken;
-            }
-            const response = await this.s3Client.send(command);
-            if (response.CommonPrefixes) {
-              folderCount += response.CommonPrefixes.length;
+        } catch (error) {
+          console.error(`Error ${buildIndex ? "building index for" : "counting folders for"} category ${category}:`, error);
+          return { category, count: 0, videos: [] };
+        }
+      });
+      const results = await Promise.all(countPromises);
+      for (const { category, count, videos } of results) {
+        counts[category] = count;
+        counts.total += count;
+        if (buildIndex && videoIndex && videos) {
+          if (videos.length > 0) {
+            const parsedType = videos[0].category;
+            videoIndex.byCategory.set(parsedType, videos);
+            console.log(`[S3ClipsService] Indexed ${videos.length} videos under parsed type '${parsedType}'`);
+            if (category !== parsedType) {
+              videoIndex.byCategory.set(category, videos);
+              console.log(`[S3ClipsService] Created alias: S3 folder '${category}' -> parsed type '${parsedType}' (${videos.length} videos)`);
             }
-            continuationToken = response.NextContinuationToken;
-          } while (continuationToken);
-          return { category, count: folderCount, videos: [] };
+          }
+          videoIndex.allVideos.push(...videos);
         }
-      } catch (error) {
-        console.error(`Error ${buildIndex ? "building index for" : "counting folders for"} category ${category}:`, error);
-        return { category, count: 0, videos: [] };
       }
-    });
-    const results = await Promise.all(countPromises);
-    for (const { category, count, videos } of results) {
-      counts[category] = count;
-      counts.total += count;
-      if (buildIndex && videoIndex && videos) {
-        if (videos.length > 0) {
-          const parsedType = videos[0].category;
-          videoIndex.byCategory.set(parsedType, videos);
-          console.log(`[S3ClipsService] Indexed ${videos.length} videos under parsed type '${parsedType}'`);
-          if (category !== parsedType) {
-            videoIndex.byCategory.set(category, videos);
-            console.log(`[S3ClipsService] Created alias: S3 folder '${category}' -> parsed type '${parsedType}' (${videos.length} videos)`);
-          }
+      if (buildIndex && videoIndex) {
+        videoIndex.allVideos.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+        videoIndex.counts = { ...counts };
+      }
+      const elapsed = performance.now() - startTime;
+      console.log(`[S3ClipsService] ${buildIndex ? "Video index and counts" : "Clip counts"} completed in ${elapsed.toFixed(2)}ms - Total: ${counts.total}`);
+      if (buildIndex && videoIndex) {
+        console.log(`[S3ClipsService] Final video index summary:`);
+        console.log(`  - VideoIndex ID: ${videoIndex._debugId}`);
+        console.log(`  - Total videos in allVideos: ${videoIndex.allVideos.length}`);
+        console.log(`  - Categories in byCategory Map: ${Array.from(videoIndex.byCategory.keys()).join(", ")}`);
+        for (const [cat, vids] of videoIndex.byCategory.entries()) {
+          console.log(`    - '${cat}': ${vids.length} videos`);
         }
-        videoIndex.allVideos.push(...videos);
+        return { counts, videoIndex };
       }
-    }
-    if (buildIndex && videoIndex) {
-      videoIndex.allVideos.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-      videoIndex.counts = { ...counts };
-    }
-    const elapsed = performance.now() - startTime;
-    console.log(`[S3ClipsService] ${buildIndex ? "Video index and counts" : "Clip counts"} completed in ${elapsed.toFixed(2)}ms - Total: ${counts.total}`);
-    if (buildIndex && videoIndex) {
-      console.log(`[S3ClipsService] Final video index summary:`);
-      console.log(`  - VideoIndex ID: ${videoIndex._debugId}`);
-      console.log(`  - Total videos in allVideos: ${videoIndex.allVideos.length}`);
-      console.log(`  - Categories in byCategory Map: ${Array.from(videoIndex.byCategory.keys()).join(", ")}`);
-      for (const [cat, vids] of videoIndex.byCategory.entries()) {
-        console.log(`    - '${cat}': ${vids.length} videos`);
+      return counts;
+    } finally {
+      if (buildIndex) {
+        this.isIndexBuilding = false;
+        console.log(`[S3ClipsService] Index building complete - metadata fetching re-enabled`);
       }
-      return { counts, videoIndex };
     }
-    return counts;
   }
   async getClipCountsCacheFirst(workspaceId, date, shiftId, buildIndex) {
     const cacheKey = `clip-counts:${workspaceId}:${date}:${shiftId}`;
@@ -4445,18 +4290,18 @@ var S3ClipsService = class {
    * Get a specific clip by index for a category with deduplication
    * @deprecated Use getVideoFromIndex with a pre-built VideoIndex for better performance
    */
-  async getClipByIndex(workspaceId, date, shiftId, category, index) {
-    const deduplicationKey = `clip-by-index:${workspaceId}:${date}:${shiftId}:${category}:${index}`;
+  async getClipByIndex(workspaceId, date, shiftId, category, index, includeCycleTime = true, includeMetadata = false) {
+    const deduplicationKey = `clip-by-index:${workspaceId}:${date}:${shiftId}:${category}:${index}:${includeCycleTime}:${includeMetadata}`;
     return this.requestCache.deduplicate(
       deduplicationKey,
-      () => this.executeGetClipByIndex(workspaceId, date, shiftId, category, index),
+      () => this.executeGetClipByIndex(workspaceId, date, shiftId, category, index, includeCycleTime, includeMetadata),
       "ClipByIndex"
     );
   }
   /**
    * Internal implementation of clip by index fetching
    */
-  async executeGetClipByIndex(workspaceId, date, shiftId, category, index) {
+  async executeGetClipByIndex(workspaceId, date, shiftId, category, index, includeCycleTime = true, includeMetadata = false) {
     const categoryPrefix = `sop_violations/${workspaceId}/${date}/${shiftId}/${category}/videos/`;
     try {
       const command = new clientS3.ListObjectsV2Command({
@@ -4494,10 +4339,8 @@ var S3ClipsService = class {
           workspaceId,
           date,
           shiftId.toString(),
-          true,
-          // includeCycleTime
-          true
-          // includeMetadata
+          includeCycleTime,
+          includeMetadata
         );
       }
     } catch (error) {
@@ -4568,7 +4411,7 @@ var S3ClipsService = class {
     }
     let cycleTimeSeconds = null;
     let creationTimestamp = void 0;
-    if (includeMetadata || includeCycleTime && (parsedInfo.type === "bottleneck" && parsedInfo.description.toLowerCase().includes("cycle time") || parsedInfo.type === "best_cycle_time" || parsedInfo.type === "worst_cycle_time" || parsedInfo.type === "cycle_completion")) {
+    if (includeMetadata) {
       const metadata = await this.getFullMetadata(uri);
       if (metadata) {
         if (metadata.original_task_metadata?.cycle_time) {
@@ -4576,6 +4419,8 @@ var S3ClipsService = class {
         }
         creationTimestamp = metadata.upload_timestamp || metadata.original_task_metadata?.timestamp || metadata.creation_timestamp || metadata[""];
       }
+    } else if (includeCycleTime && (parsedInfo.type === "bottleneck" && parsedInfo.description.toLowerCase().includes("cycle time") || parsedInfo.type === "best_cycle_time" || parsedInfo.type === "worst_cycle_time" || parsedInfo.type === "cycle_completion")) {
+      cycleTimeSeconds = null;
     }
     const cloudfrontPlaylistUrl = this.s3UriToCloudfront(uri);
     const { type: videoType, timestamp: videoTimestamp } = parsedInfo;
@@ -4647,7 +4492,8 @@ var S3ClipsService = class {
         date,
         shiftId.toString(),
         includeCycleTime || false,
-        includeMetadata || (!!timestampStart || !!timestampEnd)
+        includeMetadata || false
+        // Never fetch metadata for timestamp filtering to prevent flooding
       );
     });
     const videoResults = await Promise.all(videoPromises);
@@ -4718,6 +4564,7 @@ var VideoPrefetchManager = class extends events.EventEmitter {
   }
   /**
    * Get or create S3 service instance for dashboard config
+   * Public method to allow sharing the same S3Service instance across components
    */
   getS3Service(dashboardConfig) {
     const configKey = JSON.stringify(dashboardConfig.s3Config);
@@ -4787,75 +4634,80 @@ var VideoPrefetchManager = class extends events.EventEmitter {
    * Perform the actual prefetch work
    */
   async performPrefetchWork(key, params, s3Service, buildIndex) {
-    const cacheKey = `clip-counts:${params.workspaceId}:${params.date}:${params.shift}`;
-    const cachedResult = await smartVideoCache.getClipCounts(cacheKey);
-    if (cachedResult) {
-      console.log(`[VideoPrefetchManager] Found cached data for ${key}`);
-      this.updateRequestStatus(key, "fully_indexed" /* FULLY_INDEXED */, cachedResult);
-      return cachedResult;
-    }
-    if (buildIndex) {
-      const countsOnly = await s3Service.getClipCounts(
+    s3Service.setPrefetchMode(true);
+    try {
+      const cacheKey = `clip-counts:${params.workspaceId}:${params.date}:${params.shift}`;
+      const cachedResult = await smartVideoCache.getClipCounts(cacheKey);
+      if (cachedResult) {
+        console.log(`[VideoPrefetchManager] Found cached data for ${key}`);
+        this.updateRequestStatus(key, "fully_indexed" /* FULLY_INDEXED */, cachedResult);
+        return cachedResult;
+      }
+      if (buildIndex) {
+        const countsOnly = await s3Service.getClipCounts(
+          params.workspaceId,
+          params.date,
+          params.shift
+        );
+        if (typeof countsOnly === "object" && countsOnly !== null) {
+          const renderReadyData = {
+            counts: countsOnly,
+            videoIndex: {
+              byCategory: /* @__PURE__ */ new Map(),
+              allVideos: [],
+              counts: countsOnly,
+              workspaceId: params.workspaceId,
+              date: params.date,
+              shiftId: params.shift,
+              lastUpdated: /* @__PURE__ */ new Date(),
+              _debugId: `vid_RENDER_READY_${Date.now()}_${Math.random().toString(36).substring(7)}`
+            }
+          };
+          this.updateRequestStatus(key, "render_ready" /* RENDER_READY */, renderReadyData);
+          console.log(`[VideoPrefetchManager] Render ready, building full index for ${key}`);
+        }
+      }
+      const fullResult = await s3Service.getClipCountsCacheFirst(
         params.workspaceId,
         params.date,
-        params.shift
+        params.shift,
+        true
       );
-      if (typeof countsOnly === "object" && countsOnly !== null) {
-        const renderReadyData = {
-          counts: countsOnly,
+      if (fullResult && typeof fullResult === "object" && "videoIndex" in fullResult) {
+        const clipCountsWithIndex = fullResult;
+        if (clipCountsWithIndex.videoIndex.allVideos.length > 0) {
+          console.log(`[VideoPrefetchManager] Video index properly populated with ${clipCountsWithIndex.videoIndex.allVideos.length} videos`);
+        } else {
+          console.warn(`[VideoPrefetchManager] Video index is empty, but counts available:`, clipCountsWithIndex.counts);
+        }
+        await smartVideoCache.setClipCounts(cacheKey, clipCountsWithIndex, 5 * 60);
+        this.updateRequestStatus(key, "fully_indexed" /* FULLY_INDEXED */, clipCountsWithIndex);
+        console.log(`[VideoPrefetchManager] Fully indexed: ${key} (${clipCountsWithIndex.videoIndex.allVideos.length} videos)`);
+        return clipCountsWithIndex;
+      } else if (fullResult && typeof fullResult === "object") {
+        console.log(`[VideoPrefetchManager] Received counts only, building fallback data structure`);
+        const countsResult = fullResult;
+        const fallbackData = {
+          counts: countsResult,
           videoIndex: {
             byCategory: /* @__PURE__ */ new Map(),
             allVideos: [],
-            counts: countsOnly,
+            counts: countsResult,
             workspaceId: params.workspaceId,
             date: params.date,
             shiftId: params.shift,
             lastUpdated: /* @__PURE__ */ new Date(),
-            _debugId: `vid_RENDER_READY_${Date.now()}_${Math.random().toString(36).substring(7)}`
+            _debugId: `vid_FALLBACK_${Date.now()}_${Math.random().toString(36).substring(7)}`
           }
         };
-        this.updateRequestStatus(key, "render_ready" /* RENDER_READY */, renderReadyData);
-        console.log(`[VideoPrefetchManager] Render ready, building full index for ${key}`);
-      }
-    }
-    const fullResult = await s3Service.getClipCountsCacheFirst(
-      params.workspaceId,
-      params.date,
-      params.shift,
-      true
-    );
-    if (fullResult && typeof fullResult === "object" && "videoIndex" in fullResult) {
-      const clipCountsWithIndex = fullResult;
-      if (clipCountsWithIndex.videoIndex.allVideos.length > 0) {
-        console.log(`[VideoPrefetchManager] Video index properly populated with ${clipCountsWithIndex.videoIndex.allVideos.length} videos`);
+        this.updateRequestStatus(key, "render_ready" /* RENDER_READY */, fallbackData);
+        return fallbackData;
       } else {
-        console.warn(`[VideoPrefetchManager] Video index is empty, but counts available:`, clipCountsWithIndex.counts);
-      }
-      await smartVideoCache.setClipCounts(cacheKey, clipCountsWithIndex, 5 * 60);
-      this.updateRequestStatus(key, "fully_indexed" /* FULLY_INDEXED */, clipCountsWithIndex);
-      console.log(`[VideoPrefetchManager] Fully indexed: ${key} (${clipCountsWithIndex.videoIndex.allVideos.length} videos)`);
-      return clipCountsWithIndex;
-    } else if (fullResult && typeof fullResult === "object") {
-      console.log(`[VideoPrefetchManager] Received counts only, building fallback data structure`);
-      const countsResult = fullResult;
-      const fallbackData = {
-        counts: countsResult,
-        videoIndex: {
-          byCategory: /* @__PURE__ */ new Map(),
-          allVideos: [],
-          counts: countsResult,
-          workspaceId: params.workspaceId,
-          date: params.date,
-          shiftId: params.shift,
-          lastUpdated: /* @__PURE__ */ new Date(),
-          _debugId: `vid_FALLBACK_${Date.now()}_${Math.random().toString(36).substring(7)}`
-        }
-      };
-      this.updateRequestStatus(key, "render_ready" /* RENDER_READY */, fallbackData);
-      return fallbackData;
-    } else {
-      console.error(`[VideoPrefetchManager] Received null/undefined result from S3 service`);
-      throw new Error("Failed to fetch clip counts from S3 service");
+        console.error(`[VideoPrefetchManager] Received null/undefined result from S3 service`);
+        throw new Error("Failed to fetch clip counts from S3 service");
+      }
+    } finally {
+      s3Service.setPrefetchMode(false);
     }
   }
   /**
@@ -5118,9 +4970,13 @@ var AuthProvider = ({ children }) => {
   const [loading, setLoading] = React19.useState(true);
   const [error, setError] = React19.useState(null);
   const router$1 = router.useRouter();
-  const userProfileTable = authConfig?.userProfileTable;
-  const roleColumn = authConfig?.roleColumn || "role";
+  authConfig?.userProfileTable;
+  authConfig?.roleColumn || "role";
   const fetchUserDetails = React19.useCallback(async (supabaseUser) => {
+    console.log("[fetchUserDetails] Called for user:", supabaseUser.id, {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      stackTrace: new Error().stack?.split("\n").slice(1, 4).join(" -> ")
+    });
     if (!supabaseUser) return null;
     const basicUser = {
       id: supabaseUser.id,
@@ -5129,42 +4985,34 @@ var AuthProvider = ({ children }) => {
     if (!supabase) return basicUser;
     try {
       const timeoutPromise = new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("Profile fetch timeout")), 5e3)
+        (_, reject) => setTimeout(() => {
+          console.log("[fetchUserDetails] Timeout triggered after 2 seconds");
+          reject(new Error("Profile fetch timeout"));
+        }, 2e3)
       );
       const rolePromise = supabase.from("user_roles").select("role_level").eq("user_id", supabaseUser.id).single();
-      let profilePromise = null;
-      if (userProfileTable) {
-        profilePromise = supabase.from(userProfileTable).select(roleColumn).eq("id", supabaseUser.id).single();
-      }
-      const [roleResult, profileResult] = await Promise.race([
-        Promise.all([
-          rolePromise,
-          profilePromise || Promise.resolve(null)
-        ]),
-        timeoutPromise.then(() => {
-          throw new Error("Timeout");
-        })
+      const roleResult = await Promise.race([
+        rolePromise,
+        timeoutPromise
+        // Fixed: removed .then() which was causing the bug
       ]);
       let roleLevel = void 0;
       if (roleResult && !roleResult.error && roleResult.data) {
         roleLevel = roleResult.data.role_level;
-      } else if (roleResult?.error) {
+      } else if (roleResult?.error && roleResult.error.code !== "PGRST116") {
         console.log("Error fetching role_level:", roleResult.error.message);
       }
-      let roleValue = void 0;
-      if (profileResult && !profileResult.error && profileResult.data) {
-        roleValue = profileResult.data[roleColumn];
-      }
       return {
         ...basicUser,
-        role: roleValue,
         role_level: roleLevel
       };
     } catch (err) {
-      console.error("Error fetching user details:", err);
+      if (err instanceof Error && err.message.includes("timeout")) {
+        console.warn("Auth fetch timeout - using basic user info");
+      }
       return basicUser;
     }
-  }, [supabase, userProfileTable, roleColumn]);
+  }, [supabase]);
   React19.useEffect(() => {
     if (!supabase) return;
     let mounted = true;
@@ -5175,6 +5023,7 @@ var AuthProvider = ({ children }) => {
       }
     }, 1e4);
     const initializeAuth = async () => {
+      const startTime = performance.now();
       try {
         const { data: { session: initialSession }, error: sessionError } = await supabase.auth.getSession();
         if (!mounted) return;
@@ -5217,12 +5066,38 @@ var AuthProvider = ({ children }) => {
         if (mounted) {
           setLoading(false);
           clearTimeout(safetyTimeout);
+          const duration = performance.now() - startTime;
+          if (duration > 3e3) {
+            console.warn(`[Auth] Initialization took ${duration.toFixed(0)}ms - consider optimization`);
+          } else if (process.env.NODE_ENV === "development") {
+            console.log(`[Auth] Initialized in ${duration.toFixed(0)}ms`);
+          }
         }
       }
     };
     initializeAuth();
-    const { data: { subscription } } = supabase.auth.onAuthStateChange(async (_event, currentSession) => {
+    const { data: { subscription } } = supabase.auth.onAuthStateChange(async (event, currentSession) => {
       if (!mounted) return;
+      console.log("[AuthContext] Auth event fired:", {
+        event,
+        sessionId: currentSession?.user?.id,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        currentPath: typeof window !== "undefined" ? window.location.pathname : "unknown"
+      });
+      if (event === "TOKEN_REFRESHED") {
+        if (session?.user?.id === currentSession?.user?.id && session?.user?.email === currentSession?.user?.email) {
+          console.log("[AuthContext] Skipping TOKEN_REFRESHED - session unchanged");
+          return;
+        }
+      }
+      if (event !== "TOKEN_REFRESHED" && currentSession?.user) {
+        console.log("[AuthContext] Non-TOKEN_REFRESHED event will trigger fetchUserDetails:", event);
+      }
+      const sessionChanged = session?.user?.id !== currentSession?.user?.id || session?.user?.email !== currentSession?.user?.email;
+      if (!sessionChanged && user) {
+        console.log("[AuthContext] Session and user unchanged, skipping update");
+        return;
+      }
       setSession(currentSession);
       setUser(null);
       setLoading(false);
@@ -5597,7 +5472,6 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
   const [error, setError] = React19.useState(null);
   const updateQueueRef = React19.useRef(false);
   const isFetchingRef = React19.useRef(false);
-  const timeoutRef = React19.useRef(null);
   const channelRef = React19.useRef(null);
   const schema = databaseConfig.schema ?? "public";
   const companyId = entityConfig.companyId || "";
@@ -5606,7 +5480,7 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
   const defaultTimezone = dateTimeConfig.defaultTimezone;
   const workspaceMetricsBaseTable = databaseConfig.tables?.workspaces ?? "workspace_metrics";
   const workspaceActionsTable = databaseConfig.tables?.actions ?? "workspace_actions";
-  const fetchMetrics = React19.useCallback(async (skipCache = false) => {
+  const fetchMetrics = React19.useCallback(async () => {
     if (!workspaceId || isFetchingRef.current) return;
     try {
       isFetchingRef.current = true;
@@ -5615,28 +5489,6 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
       const queryShiftId = shiftId !== void 0 ? shiftId : currentShift.shiftId;
       console.log("[useWorkspaceDetailedMetrics] Using shift ID:", queryShiftId, "from input shift:", shiftId);
       console.log("[useWorkspaceDetailedMetrics] Using date:", queryDate, "from input date:", date);
-      const cacheKey = cacheService.generateKey(
-        "workspace-detailed-metrics",
-        workspaceId,
-        queryDate,
-        queryShiftId,
-        companyId
-      );
-      if (!skipCache) {
-        const cachedData = cacheService.get(cacheKey, {
-          storage: "memory",
-          duration: 5 * 60 * 1e3
-          // 5 minutes
-        });
-        if (cachedData) {
-          console.log("[useWorkspaceDetailedMetrics] Using cached data for:", cacheKey);
-          setMetrics(cachedData);
-          setIsLoading(false);
-          updateQueueRef.current = false;
-          isFetchingRef.current = false;
-          return;
-        }
-      }
       console.log(`[useWorkspaceDetailedMetrics] Querying ${metricsTable} for workspace: ${workspaceId}, date: ${queryDate}, shift: ${queryShiftId}`);
       const { data, error: fetchError } = await supabase.from(metricsTable).select("*").eq("workspace_id", workspaceId).eq("date", queryDate).eq("shift_id", queryShiftId).maybeSingle();
       if (fetchError) throw fetchError;
@@ -5739,18 +5591,6 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
           setIsLoading(false);
           updateQueueRef.current = false;
           isFetchingRef.current = false;
-          const fallbackCacheKey = cacheService.generateKey(
-            "workspace-detailed-metrics",
-            workspaceId,
-            recentData.date,
-            recentData.shift_id,
-            companyId
-          );
-          cacheService.set(fallbackCacheKey, transformedData2, {
-            storage: "memory",
-            duration: 2 * 60 * 1e3
-            // 2 minutes for fallback data
-          });
           return;
         } else {
           console.warn("[useWorkspaceDetailedMetrics] No data found for workspace:", workspaceId, "at all");
@@ -5864,11 +5704,6 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
         ...data.sop_check !== void 0 && { sop_check: data.sop_check }
       };
       setMetrics(transformedData);
-      cacheService.set(cacheKey, transformedData, {
-        storage: "memory",
-        duration: 5 * 60 * 1e3
-        // 5 minutes
-      });
     } catch (err) {
       console.error("Error fetching workspace metrics:", err);
       setError({ message: err.message, code: err.code });
@@ -5881,12 +5716,7 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
   const queueUpdate = React19.useCallback(() => {
     if (!workspaceId || updateQueueRef.current) return;
     updateQueueRef.current = true;
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-    }
-    timeoutRef.current = setTimeout(() => {
-      fetchMetrics();
-    }, 500);
+    fetchMetrics();
   }, [fetchMetrics, workspaceId]);
   const setupSubscription = React19.useCallback(() => {
     if (!workspaceId) return;
@@ -5903,7 +5733,7 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
       },
       async (payload) => {
         console.log(`Received ${metricsTablePrefix} update:`, payload);
-        await fetchMetrics(true);
+        await fetchMetrics();
       }
     ).subscribe((status) => {
       console.log(`Workspace detailed metrics subscription status:`, status);
@@ -5937,14 +5767,6 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
           matches: payloadData?.date === operationalDate && payloadData?.shift_id === queryShiftId
         });
         if (payloadData?.date === operationalDate && payloadData?.shift_id === queryShiftId) {
-          const cacheKey = cacheService.generateKey(
-            "workspace-detailed-metrics",
-            workspaceId,
-            operationalDate,
-            queryShiftId,
-            companyId
-          );
-          cacheService.delete(cacheKey, { storage: "memory" });
           queueUpdate();
         }
       }
@@ -5970,14 +5792,6 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
           matches: payloadData?.date === operationalDate && payloadData?.shift_id === queryShiftId
         });
         if (payloadData?.date === operationalDate && payloadData?.shift_id === queryShiftId) {
-          const cacheKey = cacheService.generateKey(
-            "workspace-detailed-metrics",
-            workspaceId,
-            operationalDate,
-            queryShiftId,
-            companyId
-          );
-          cacheService.delete(cacheKey, { storage: "memory" });
           queueUpdate();
         }
       }
@@ -6003,14 +5817,6 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
           matches: payloadData?.date === operationalDate && payloadData?.shift_id === queryShiftId
         });
         if (payloadData?.date === operationalDate && payloadData?.shift_id === queryShiftId) {
-          const cacheKey = cacheService.generateKey(
-            "workspace-detailed-metrics",
-            workspaceId,
-            operationalDate,
-            queryShiftId,
-            companyId
-          );
-          cacheService.delete(cacheKey, { storage: "memory" });
           queueUpdate();
         }
       }
@@ -6021,9 +5827,6 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
     fetchMetrics();
     setupSubscription();
     return () => {
-      if (timeoutRef.current) {
-        clearTimeout(timeoutRef.current);
-      }
       channels.forEach((channel) => {
         console.log("Cleaning up channel subscription");
         supabase.removeChannel(channel);
@@ -6037,7 +5840,7 @@ var useWorkspaceDetailedMetrics = (workspaceId, date, shiftId) => {
     metrics: metrics2,
     isLoading,
     error,
-    refetch: () => fetchMetrics(true)
+    refetch: () => fetchMetrics()
     // Force refresh without cache
   };
 };
@@ -6482,33 +6285,6 @@ var useLeaderboardMetrics = (lineId, topCount = 10) => {
     refetch: fetchLeaderboardData
   };
 };
-var CACHE_KEY_PREFIX = "dashboard_metrics_cache_";
-var CACHE_DURATION = 5 * 60 * 1e3;
-var getCache = (lineId) => {
-  if (typeof window === "undefined") return null;
-  try {
-    const cached = localStorage.getItem(`${CACHE_KEY_PREFIX}${lineId}`);
-    if (!cached) return null;
-    const parsedCache = JSON.parse(cached);
-    if (!parsedCache.lastUpdated || Date.now() - parsedCache.lastUpdated > CACHE_DURATION) {
-      localStorage.removeItem(`${CACHE_KEY_PREFIX}${lineId}`);
-      return null;
-    }
-    return parsedCache;
-  } catch {
-    return null;
-  }
-};
-var setCache = (lineId, metrics2) => {
-  if (typeof window === "undefined") return;
-  try {
-    localStorage.setItem(`${CACHE_KEY_PREFIX}${lineId}`, JSON.stringify({
-      ...metrics2,
-      lastUpdated: Date.now()
-    }));
-  } catch {
-  }
-};
 var useDashboardMetrics = ({ onLineMetricsUpdate, lineId }) => {
   const { supabaseUrl, supabaseKey } = useDashboardConfig();
   const entityConfig = useEntityConfig();
@@ -6519,22 +6295,20 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId }) => {
   const configuredLineMetricsTable = databaseConfig?.tables?.lineMetrics ?? "line_metrics";
   const schema = databaseConfig?.schema ?? "public";
   const supabase = useSupabase();
-  const [metrics2, setMetrics] = React19.useState(() => getCache(lineId) || { workspaceMetrics: [], lineMetrics: [] });
-  const [isLoading, setIsLoading] = React19.useState(() => !getCache(lineId));
+  const [metrics2, setMetrics] = React19.useState({ workspaceMetrics: [], lineMetrics: [] });
+  const [isLoading, setIsLoading] = React19.useState(true);
   const [error, setError] = React19.useState(null);
   const lineIdRef = React19.useRef(lineId);
   const isFetchingRef = React19.useRef(false);
   const updateQueueRef = React19.useRef(false);
-  const timeoutRef = React19.useRef(null);
   const companySpecificMetricsTable = React19.useMemo(
     () => getCompanyMetricsTableName(entityConfig.companyId, "performance_metrics"),
     [entityConfig.companyId]
   );
   React19.useEffect(() => {
     lineIdRef.current = lineId;
-    const cachedData = getCache(lineId);
-    setMetrics(cachedData || { workspaceMetrics: [], lineMetrics: [] });
-    setIsLoading(!cachedData);
+    setMetrics({ workspaceMetrics: [], lineMetrics: [] });
+    setIsLoading(true);
   }, [lineId]);
   const fetchAllMetrics = React19.useCallback(async () => {
     const currentLineIdToUse = lineIdRef.current;
@@ -6546,9 +6320,7 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId }) => {
       return;
     }
     isFetchingRef.current = true;
-    if (!getCache(currentLineIdToUse)) {
-      setIsLoading(true);
-    }
+    setIsLoading(true);
     setError(null);
     try {
       const currentShiftDetails = getCurrentShift(defaultTimezone, shiftConfig);
@@ -6573,7 +6345,6 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId }) => {
           lineMetrics: []
         };
         setMetrics(newMetricsState2);
-        setCache(currentLineIdToUse, newMetricsState2);
         return;
       }
       let workspaceQuery = supabase.from(companySpecificMetricsTable).select("company_id,line_id,shift_id,date,workspace_id,workspace_name,total_output,avg_pph,performance_score,avg_cycle_time,trend_score,ideal_output,efficiency,total_day_output").eq("date", operationalDate).eq("shift_id", currentShiftDetails.shiftId).in("workspace_id", enabledWorkspaceIds);
@@ -6625,7 +6396,6 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId }) => {
         lineMetrics: lineData || []
       };
       setMetrics(newMetricsState);
-      setCache(currentLineIdToUse, newMetricsState);
     } catch (err) {
       setError({ message: err.message, code: err.code || "FETCH_ERROR" });
     } finally {
@@ -6651,12 +6421,7 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId }) => {
       return;
     }
     updateQueueRef.current = true;
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-    }
-    timeoutRef.current = setTimeout(() => {
-      fetchAllMetrics();
-    }, 500);
+    fetchAllMetrics();
   }, [fetchAllMetrics, supabase]);
   React19.useEffect(() => {
     if (lineId && supabase) {
@@ -6701,9 +6466,6 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId }) => {
       onLineMetricsUpdate?.();
     });
     return () => {
-      if (timeoutRef.current) {
-        clearTimeout(timeoutRef.current);
-      }
       channels.forEach((channel) => {
         supabase?.removeChannel(channel).catch((err) => console.error("[useDashboardMetrics] Error removing channel:", err.message));
       });
@@ -6732,30 +6494,6 @@ var useDashboardMetrics = ({ onLineMetricsUpdate, lineId }) => {
     refetch: fetchAllMetrics
   };
 };
-var CACHE_KEY_PREFIX2 = "line_kpis_cache_";
-var CACHE_DURATION2 = 5 * 60 * 1e3;
-var getCache2 = (lineId) => {
-  if (typeof window === "undefined") return null;
-  try {
-    const cached = localStorage.getItem(`${CACHE_KEY_PREFIX2}${lineId}`);
-    if (!cached) return null;
-    const parsedCache = JSON.parse(cached);
-    if (!parsedCache.timestamp || Date.now() - parsedCache.timestamp > CACHE_DURATION2) {
-      localStorage.removeItem(`${CACHE_KEY_PREFIX2}${lineId}`);
-      return null;
-    }
-    return parsedCache.data;
-  } catch (error) {
-    return null;
-  }
-};
-var setCache2 = (lineId, data) => {
-  if (typeof window === "undefined") return;
-  try {
-    localStorage.setItem(`${CACHE_KEY_PREFIX2}${lineId}`, JSON.stringify({ data, timestamp: Date.now() }));
-  } catch (error) {
-  }
-};
 var useLineKPIs = ({ lineId }) => {
   useDashboardConfig();
   const entityConfig = useEntityConfig();
@@ -6767,13 +6505,12 @@ var useLineKPIs = ({ lineId }) => {
   const dashboardServiceInstance = React19.useMemo(() => {
     return dashboardService;
   }, []);
-  const [kpis, setKPIs] = React19.useState(() => getCache2(lineId));
-  const [isLoading, setIsLoading] = React19.useState(!getCache2(lineId));
+  const [kpis, setKPIs] = React19.useState(null);
+  const [isLoading, setIsLoading] = React19.useState(true);
   const [error, setError] = React19.useState(null);
   const lineIdRef = React19.useRef(lineId);
   const isFetchingRef = React19.useRef(false);
   const updateQueueRef = React19.useRef(false);
-  const timeoutRef = React19.useRef(null);
   const defaultTimezone = dateTimeConfig.defaultTimezone;
   const schema = databaseConfig.schema ?? "public";
   const lineMetricsTable = databaseConfig.tables?.lineMetrics ?? "line_metrics";
@@ -6804,7 +6541,6 @@ var useLineKPIs = ({ lineId }) => {
       if (lineInfo) {
         const newKPIs = dashboardServiceInstance.calculateKPIs(lineInfo);
         setKPIs(newKPIs);
-        setCache2(currentLineId, newKPIs);
       } else {
         setKPIs(null);
       }
@@ -6821,12 +6557,7 @@ var useLineKPIs = ({ lineId }) => {
   const queueUpdate = React19.useCallback(() => {
     if (updateQueueRef.current) return;
     updateQueueRef.current = true;
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-    }
-    timeoutRef.current = setTimeout(() => {
-      fetchKPIs();
-    }, 500);
+    fetchKPIs();
   }, [fetchKPIs]);
   React19.useEffect(() => {
     const currentLineId = lineIdRef.current;
@@ -6884,9 +6615,6 @@ var useLineKPIs = ({ lineId }) => {
       activeChannels.push(csChannel);
     }
     return () => {
-      if (timeoutRef.current) {
-        clearTimeout(timeoutRef.current);
-      }
       activeChannels.forEach((ch) => supabase.removeChannel(ch).catch((err) => console.error("[useLineKPIs] Error removing KPI channel:", err)));
     };
   }, [supabase, lineId, fetchKPIs, queueUpdate, dashboardServiceInstance, entityConfig, schema, lineMetricsTable, companySpecificMetricsTable, defaultTimezone, shiftConfig, kpis, isFactoryView]);
@@ -6915,7 +6643,6 @@ var useRealtimeLineMetrics = ({
   const [initialized, setInitialized] = React19.useState(false);
   const lineIdRef = React19.useRef(null);
   const updateQueueRef = React19.useRef(false);
-  const timeoutRef = React19.useRef(null);
   const isFetchingRef = React19.useRef(false);
   const channelsRef = React19.useRef([]);
   const currentShift = React19.useMemo(() => getCurrentShift(dateTimeConfig.defaultTimezone || "Asia/Kolkata", shiftConfig), [dateTimeConfig.defaultTimezone, shiftConfig]);
@@ -7128,12 +6855,7 @@ var useRealtimeLineMetrics = ({
   const queueUpdate = React19.useCallback(() => {
     if (updateQueueRef.current) return;
     updateQueueRef.current = true;
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-    }
-    timeoutRef.current = setTimeout(() => {
-      fetchData();
-    }, 500);
+    fetchData();
   }, [fetchData]);
   const setupSubscriptions = React19.useCallback(() => {
     if (channelsRef.current.length > 0) {
@@ -7211,9 +6933,6 @@ var useRealtimeLineMetrics = ({
     }
     setupSubscriptions();
     return () => {
-      if (timeoutRef.current) {
-        clearTimeout(timeoutRef.current);
-      }
       if (channelsRef.current.length > 0) {
         channelsRef.current.forEach((channel) => {
           if (process.env.NODE_ENV === "development") {
@@ -7299,16 +7018,12 @@ var useTargets = (options) => {
 };
 var DEFAULT_SHIFTS_TABLE_NAME = "shift_configurations";
 var useShifts = () => {
-  const { supabaseUrl, supabaseKey } = useDashboardConfig();
   const { companyId } = useEntityConfig();
   const { tables } = useDatabaseConfig();
+  const supabase = useSupabase();
   const [shifts, setShifts] = React19.useState([]);
   const [isLoading, setIsLoading] = React19.useState(true);
   const [error, setError] = React19.useState(null);
-  const supabase = React19.useMemo(() => {
-    if (!supabaseUrl || !supabaseKey) return null;
-    return supabaseJs.createClient(supabaseUrl, supabaseKey);
-  }, [supabaseUrl, supabaseKey]);
   const shiftsTable = tables?.shiftConfigurations || DEFAULT_SHIFTS_TABLE_NAME;
   const fetchData = React19.useCallback(async () => {
     if (!supabase) {
@@ -8007,6 +7722,7 @@ var runtimeWorkspaceDisplayNames = {};
 var isInitialized = false;
 var isInitializing = false;
 var initializedWithLineIds = [];
+var initializationPromise = null;
 function getCurrentLineIds() {
   try {
     const config = _getDashboardConfigInstance();
@@ -8027,52 +7743,79 @@ function getCurrentLineIds() {
 }
 async function initializeWorkspaceDisplayNames(explicitLineId) {
   console.log("\u{1F504} initializeWorkspaceDisplayNames called", { isInitialized, isInitializing, explicitLineId });
-  if (isInitialized || isInitializing) return;
-  isInitializing = true;
-  try {
-    console.log("\u{1F504} Starting Supabase workspace display names initialization...");
-    let targetLineIds = [];
-    if (explicitLineId) {
-      targetLineIds = [explicitLineId];
-    } else {
-      targetLineIds = getCurrentLineIds();
+  if (isInitialized) return;
+  if (initializationPromise) {
+    console.log("\u{1F504} Already initializing, waiting for existing initialization...");
+    await initializationPromise;
+    return;
+  }
+  initializationPromise = (async () => {
+    isInitializing = true;
+    try {
+      console.log("\u{1F504} Starting Supabase workspace display names initialization...");
+      let targetLineIds = [];
+      if (explicitLineId) {
+        targetLineIds = [explicitLineId];
+      } else {
+        targetLineIds = getCurrentLineIds();
+      }
+      console.log("\u{1F504} Target line IDs for workspace filtering:", targetLineIds);
+      runtimeWorkspaceDisplayNames = {};
+      if (targetLineIds.length > 0) {
+        for (const lineId of targetLineIds) {
+          console.log(`\u{1F504} Fetching workspaces for line: ${lineId}`);
+          const lineDisplayNamesMap = await workspaceService.getWorkspaceDisplayNames(void 0, lineId);
+          runtimeWorkspaceDisplayNames[lineId] = {};
+          lineDisplayNamesMap.forEach((displayName, workspaceId) => {
+            runtimeWorkspaceDisplayNames[lineId][workspaceId] = displayName;
+          });
+          console.log(`\u2705 Stored ${lineDisplayNamesMap.size} workspaces for line ${lineId}`);
+        }
+      } else {
+        console.warn("\u26A0\uFE0F No line IDs found, fetching all workspaces (less efficient)");
+        const allWorkspacesMap = await workspaceService.getWorkspaceDisplayNames();
+        runtimeWorkspaceDisplayNames["global"] = {};
+        allWorkspacesMap.forEach((displayName, workspaceId) => {
+          runtimeWorkspaceDisplayNames["global"][workspaceId] = displayName;
+        });
+      }
+      isInitialized = true;
+      initializedWithLineIds = targetLineIds;
+      console.log("\u2705 Workspace display names initialized from Supabase:", runtimeWorkspaceDisplayNames);
+      console.log("\u2705 Initialized with line IDs:", initializedWithLineIds);
+    } catch (error) {
+      console.error("\u274C Failed to initialize workspace display names from Supabase:", error);
+    } finally {
+      isInitializing = false;
+      initializationPromise = null;
     }
-    console.log("\u{1F504} Target line IDs for workspace filtering:", targetLineIds);
-    runtimeWorkspaceDisplayNames = {};
-    if (targetLineIds.length > 0) {
-      for (const lineId of targetLineIds) {
-        console.log(`\u{1F504} Fetching workspaces for line: ${lineId}`);
+  })();
+  await initializationPromise;
+}
+var preInitializeWorkspaceDisplayNames = async (lineId) => {
+  console.log("\u{1F504} preInitializeWorkspaceDisplayNames called for lineId:", lineId);
+  if (isInitialized) {
+    console.log("\u{1F504} Already initialized");
+    if (lineId && !runtimeWorkspaceDisplayNames[lineId]) {
+      console.log(`\u{1F504} Line ${lineId} not in cache, fetching...`);
+      try {
         const lineDisplayNamesMap = await workspaceService.getWorkspaceDisplayNames(void 0, lineId);
         runtimeWorkspaceDisplayNames[lineId] = {};
         lineDisplayNamesMap.forEach((displayName, workspaceId) => {
           runtimeWorkspaceDisplayNames[lineId][workspaceId] = displayName;
         });
-        console.log(`\u2705 Stored ${lineDisplayNamesMap.size} workspaces for line ${lineId}`);
+        console.log(`\u2705 Added ${lineDisplayNamesMap.size} workspaces for line ${lineId}`);
+      } catch (error) {
+        console.error(`\u274C Failed to fetch workspaces for line ${lineId}:`, error);
       }
-    } else {
-      console.warn("\u26A0\uFE0F No line IDs found, fetching all workspaces (less efficient)");
-      const allWorkspacesMap = await workspaceService.getWorkspaceDisplayNames();
-      runtimeWorkspaceDisplayNames["global"] = {};
-      allWorkspacesMap.forEach((displayName, workspaceId) => {
-        runtimeWorkspaceDisplayNames["global"][workspaceId] = displayName;
-      });
     }
-    isInitialized = true;
-    initializedWithLineIds = targetLineIds;
-    console.log("\u2705 Workspace display names initialized from Supabase:", runtimeWorkspaceDisplayNames);
-    console.log("\u2705 Initialized with line IDs:", initializedWithLineIds);
-  } catch (error) {
-    console.error("\u274C Failed to initialize workspace display names from Supabase:", error);
-  } finally {
-    isInitializing = false;
+    return;
   }
-}
-var preInitializeWorkspaceDisplayNames = async (lineId) => {
-  console.log("\u{1F504} preInitializeWorkspaceDisplayNames called for lineId:", lineId);
-  if (isInitialized || isInitializing) {
-    console.log("\u{1F504} Already initialized or initializing");
+  if (initializationPromise) {
+    console.log("\u{1F504} Already initializing, waiting for completion...");
+    await initializationPromise;
     if (lineId && !runtimeWorkspaceDisplayNames[lineId]) {
-      console.log(`\u{1F504} Line ${lineId} not in cache, fetching...`);
+      console.log(`\u{1F504} Line ${lineId} not in cache after init, fetching...`);
       try {
         const lineDisplayNamesMap = await workspaceService.getWorkspaceDisplayNames(void 0, lineId);
         runtimeWorkspaceDisplayNames[lineId] = {};
@@ -8090,7 +7833,12 @@ var preInitializeWorkspaceDisplayNames = async (lineId) => {
 };
 var forceRefreshWorkspaceDisplayNames = async (lineId) => {
   console.log("\u{1F504} forceRefreshWorkspaceDisplayNames called for lineId:", lineId);
+  if (initializationPromise) {
+    console.log("\u{1F504} Waiting for existing initialization to complete before refresh...");
+    await initializationPromise;
+  }
   clearWorkspaceDisplayNamesCache();
+  initializationPromise = null;
   await initializeWorkspaceDisplayNames(lineId);
 };
 console.log("\u{1F504} Module loaded, will initialize lazily when first function is called");
@@ -8238,6 +7986,7 @@ var clearWorkspaceDisplayNamesCache = () => {
   isInitialized = false;
   isInitializing = false;
   initializedWithLineIds = [];
+  initializationPromise = null;
 };
 
 // src/lib/hooks/useWorkspaceDisplayNames.ts
@@ -8501,32 +8250,12 @@ var useAllWorkspaceMetrics = (options) => {
     return `${metricsTablePrefix}_${companyId.replace(/-/g, "_")}`;
   }, [entityConfig.companyId]);
   const schema = databaseConfig.schema ?? "public";
-  const fetchWorkspaceMetrics = React19.useCallback(async (skipCache = false) => {
+  const fetchWorkspaceMetrics = React19.useCallback(async () => {
     if (!initialized) {
       setLoading(true);
     }
     setError(null);
     try {
-      const cacheKey = cacheService.generateKey(
-        "all-workspace-metrics",
-        entityConfig.companyId,
-        queryDate,
-        queryShiftId
-      );
-      if (!skipCache && !loading) {
-        const cachedData = cacheService.get(cacheKey, {
-          storage: "memory",
-          duration: 5 * 60 * 1e3
-          // 5 minutes
-        });
-        if (cachedData) {
-          console.log("[useAllWorkspaceMetrics] Using cached data for:", cacheKey);
-          setWorkspaces(cachedData);
-          setInitialized(true);
-          setLoading(false);
-          return;
-        }
-      }
       console.log("Fetching all workspace metrics with params:", {
         queryDate,
         queryShiftId,
@@ -8576,11 +8305,6 @@ var useAllWorkspaceMetrics = (options) => {
       }));
       setWorkspaces(transformedData);
       setInitialized(true);
-      cacheService.set(cacheKey, transformedData, {
-        storage: "memory",
-        duration: 5 * 60 * 1e3
-        // 5 minutes
-      });
     } catch (err) {
       console.error("Error fetching all workspace metrics:", err);
       setError({ message: err.message, code: err.code || "FETCH_ERROR" });
@@ -8605,14 +8329,7 @@ var useAllWorkspaceMetrics = (options) => {
         },
         async (payload) => {
           console.log("All workspace metrics update received:", payload);
-          const cacheKey = cacheService.generateKey(
-            "all-workspace-metrics",
-            entityConfig.companyId,
-            queryDate,
-            queryShiftId
-          );
-          cacheService.delete(cacheKey, { storage: "memory" });
-          await fetchWorkspaceMetrics(true);
+          await fetchWorkspaceMetrics();
         }
       ).subscribe();
       return channel2;
@@ -8627,7 +8344,7 @@ var useAllWorkspaceMetrics = (options) => {
   React19.useEffect(() => {
     setInitialized(false);
   }, [queryDate, queryShiftId]);
-  const refreshWorkspaces = React19.useCallback(() => fetchWorkspaceMetrics(true), [fetchWorkspaceMetrics]);
+  const refreshWorkspaces = React19.useCallback(() => fetchWorkspaceMetrics(), [fetchWorkspaceMetrics]);
   return React19.useMemo(
     () => ({ workspaces, loading, error, refreshWorkspaces }),
     [workspaces, loading, error, refreshWorkspaces]
@@ -19910,11 +19627,13 @@ var withAuth = (WrappedComponent2, options) => {
     requireAuth: true,
     ...options
   };
-  return function WithAuthComponent(props) {
+  const WithAuthComponent = React19__namespace.memo(function WithAuthComponent2(props) {
     const { session, loading } = useAuth();
     const router$1 = router.useRouter();
     React19__namespace.useEffect(() => {
-      console.log("withAuth state:", { loading, hasSession: !!session, requireAuth: defaultOptions.requireAuth });
+      if (process.env.NODE_ENV === "development" && process.env.DEBUG_AUTH === "true") {
+        console.log("withAuth state:", { loading, hasSession: !!session, requireAuth: defaultOptions.requireAuth });
+      }
     }, [session, loading]);
     React19__namespace.useEffect(() => {
       if (!loading && defaultOptions.requireAuth && !session) {
@@ -19929,7 +19648,9 @@ var withAuth = (WrappedComponent2, options) => {
       return null;
     }
     return /* @__PURE__ */ jsxRuntime.jsx(WrappedComponent2, { ...props });
-  };
+  });
+  WithAuthComponent.displayName = `withAuth(${WrappedComponent2.displayName || WrappedComponent2.name || "Component"})`;
+  return WithAuthComponent;
 };
 var LoginPage = ({
   onRateLimitCheck,
@@ -26517,7 +26238,7 @@ var BottlenecksContent = ({
   const [duration, setDuration] = React19.useState(0);
   const [currentIndex, setCurrentIndex] = React19.useState(0);
   const [activeFilter, setActiveFilter] = React19.useState(initialFilter);
-  const previousFilterRef = React19.useRef(initialFilter);
+  const previousFilterRef = React19.useRef("");
   const [allVideos, setAllVideos] = React19.useState([]);
   const [isLoading, setIsLoading] = React19.useState(true);
   const [isCategoryLoading, setIsCategoryLoading] = React19.useState(false);
@@ -26567,7 +26288,7 @@ var BottlenecksContent = ({
       console.warn("S3 configuration not found in dashboard config");
       return null;
     }
-    return new S3ClipsService(dashboardConfig);
+    return videoPrefetchManager.getS3Service(dashboardConfig);
   }, [dashboardConfig]);
   const {
     data: prefetchData,
@@ -26635,6 +26356,85 @@ var BottlenecksContent = ({
   }, [workspaceId, date, s3ClipsService, shift, dashboardConfig, updateClipCounts, updateVideoIndex]);
   const loadingCategoryRef = React19.useRef(null);
   const videoRetryCountRef = React19.useRef(0);
+  const loadingVideosRef = React19.useRef(/* @__PURE__ */ new Set());
+  const loadedVideosMapRef = React19.useRef(/* @__PURE__ */ new Map());
+  const ensureVideosLoaded = React19.useCallback(async (centerIndex) => {
+    if (!s3ClipsService || !workspaceId || !isMountedRef.current) return;
+    const currentFilter = activeFilterRef.current;
+    const currentVideoIndex = videoIndexRef.current;
+    let effectiveFilter = currentFilter;
+    if (sopCategories && sopCategories.length > 0) {
+      const category = sopCategories.find((cat) => cat.id === currentFilter);
+      if (category && category.s3FolderName) {
+        effectiveFilter = category.s3FolderName;
+      }
+    }
+    const cacheKey = `${effectiveFilter}:${date}:${shift}`;
+    if (!loadedVideosMapRef.current.has(cacheKey)) {
+      loadedVideosMapRef.current.set(cacheKey, /* @__PURE__ */ new Set());
+    }
+    const loadedIndices = loadedVideosMapRef.current.get(cacheKey);
+    const indicesToLoad = [];
+    const rangeBefore = 1;
+    const rangeAfter = 3;
+    for (let i = Math.max(0, centerIndex - rangeBefore); i <= Math.min(clipCounts[effectiveFilter] - 1, centerIndex + rangeAfter); i++) {
+      if (!loadedIndices.has(i) && !loadingVideosRef.current.has(i)) {
+        indicesToLoad.push(i);
+      }
+    }
+    if (indicesToLoad.length === 0) return;
+    console.log(`[ensureVideosLoaded] Preloading ${indicesToLoad.length} videos around index ${centerIndex}: [${indicesToLoad.join(", ")}]`);
+    indicesToLoad.forEach((idx) => loadingVideosRef.current.add(idx));
+    const loadPromises = indicesToLoad.map(async (index) => {
+      try {
+        let video = null;
+        if (currentVideoIndex && currentVideoIndex.byCategory && currentVideoIndex.allVideos.length > 0) {
+          video = await s3ClipsService.getVideoFromIndex(
+            currentVideoIndex,
+            effectiveFilter,
+            index,
+            true,
+            // includeCycleTime - OK for preloading
+            false
+            // includeMetadata - NO metadata during bulk preloading to prevent flooding
+          );
+        }
+        if (!video) {
+          const operationalDate = date || getOperationalDate();
+          const shiftStr = shift?.toString() || "0";
+          video = await s3ClipsService.getClipByIndex(
+            workspaceId,
+            operationalDate,
+            shiftStr,
+            effectiveFilter,
+            index,
+            true,
+            // includeCycleTime - OK for preloading
+            false
+            // includeMetadata - NO metadata during bulk preloading to prevent flooding
+          );
+        }
+        if (video && isMountedRef.current) {
+          setAllVideos((prev) => {
+            const exists = prev.some((v) => v.id === video.id);
+            if (!exists) {
+              return [...prev, video];
+            }
+            return prev;
+          });
+          loadedIndices.add(index);
+          preloadVideoUrl(video.src);
+        }
+      } catch (error2) {
+        console.warn(`[ensureVideosLoaded] Failed to load video at index ${index}:`, error2);
+      } finally {
+        loadingVideosRef.current.delete(index);
+      }
+    });
+    Promise.all(loadPromises).catch((err) => {
+      console.warn("[ensureVideosLoaded] Some videos failed to preload:", err);
+    });
+  }, [s3ClipsService, workspaceId, clipCounts, sopCategories, date, shift]);
   const loadFirstVideoForCategory = React19.useCallback(async (category) => {
     if (!workspaceId || !s3ClipsService || !isMountedRef.current) return;
     const targetCategory = category || activeFilterRef.current;
@@ -26671,8 +26471,16 @@ var BottlenecksContent = ({
         );
         if (firstVideo) {
           console.log(`[BottlenecksContent] Successfully loaded first video via direct S3 method`);
-          setAllVideos([firstVideo]);
+          setAllVideos((prev) => {
+            const exists = prev.some((v) => v.id === firstVideo.id);
+            if (!exists) {
+              return [...prev, firstVideo];
+            }
+            return prev;
+          });
           preloadVideoUrl(firstVideo.src);
+          setIsLoading(false);
+          setHasInitialLoad(true);
           loadingCategoryRef.current = null;
           setIsCategoryLoading(false);
           return;
@@ -26695,7 +26503,13 @@ var BottlenecksContent = ({
           );
           if (firstVideo && isMountedRef.current) {
             console.log(`[BottlenecksContent] Successfully loaded first video via video index`);
-            setAllVideos([firstVideo]);
+            setAllVideos((prev) => {
+              const exists = prev.some((v) => v.id === firstVideo.id);
+              if (!exists) {
+                return [...prev, firstVideo];
+              }
+              return prev;
+            });
             preloadVideoUrl(firstVideo.src);
             setIsCategoryLoading(false);
             return;
@@ -26720,15 +26534,17 @@ var BottlenecksContent = ({
     }
   }, [workspaceId, date, s3ClipsService, clipCounts, videoIndex, shift, updateClipCounts, updateVideoIndex]);
   React19.useEffect(() => {
-    if (s3ClipsService) {
+    if (s3ClipsService && !prefetchData) {
       fetchClipCounts();
     }
-  }, [workspaceId, date, shift, s3ClipsService, fetchClipCounts, updateClipCounts, updateVideoIndex]);
+  }, [workspaceId, date, shift, s3ClipsService, fetchClipCounts, updateClipCounts, updateVideoIndex, prefetchData]);
   React19.useEffect(() => {
     if (prefetchData) {
       console.log(`[BottlenecksContent] Received prefetch update - status: ${prefetchStatus}, videos: ${prefetchData.videoIndex.allVideos.length}, ID: ${prefetchData.videoIndex._debugId || "NO_ID"}`);
       updateClipCounts(prefetchData.counts);
-      updateVideoIndex(prefetchData.videoIndex);
+      if (prefetchData.videoIndex.allVideos.length > 0) {
+        updateVideoIndex(prefetchData.videoIndex);
+      }
       if (!hasInitialLoad && prefetchData.videoIndex.allVideos.length > 0) {
         setIsLoading(false);
         setHasInitialLoad(true);
@@ -26736,10 +26552,45 @@ var BottlenecksContent = ({
     }
   }, [prefetchData, prefetchStatus, updateClipCounts, updateVideoIndex, hasInitialLoad]);
   React19.useEffect(() => {
-    if (s3ClipsService && videoIndex && clipCounts[activeFilter] > 0) {
-      loadFirstVideoForCategory(activeFilter);
+    if (s3ClipsService && clipCounts[activeFilter] > 0) {
+      const hasVideosForCurrentFilter = allVideos.some((video) => {
+        if (sopCategories && sopCategories.length > 0) {
+          const selectedCategory = sopCategories.find((cat) => cat.id === activeFilter);
+          if (selectedCategory) {
+            return video.type === selectedCategory.id;
+          }
+        }
+        if (activeFilter === "all") return true;
+        if (activeFilter === "low_value") {
+          return video.type === "low_value";
+        }
+        if (activeFilter === "idle_time") {
+          return video.type === "idle_time";
+        }
+        if (activeFilter === "sop_deviations") {
+          return video.type === "missing_quality_check";
+        }
+        if (activeFilter === "best_cycle_time") {
+          return video.type === "best_cycle_time";
+        }
+        if (activeFilter === "worst_cycle_time") {
+          return video.type === "worst_cycle_time";
+        }
+        if (activeFilter === "cycle_completion") {
+          return video.type === "cycle_completion";
+        }
+        if (activeFilter === "long_cycle_time") {
+          return video.type === "long_cycle_time";
+        }
+        return video.type === "bottleneck" && video.severity === activeFilter;
+      });
+      if (!hasVideosForCurrentFilter) {
+        loadFirstVideoForCategory(activeFilter);
+      } else {
+        setIsCategoryLoading(false);
+      }
     }
-  }, [activeFilter, s3ClipsService, videoIndex, clipCounts, loadFirstVideoForCategory]);
+  }, [activeFilter, s3ClipsService, videoIndex, clipCounts, loadFirstVideoForCategory, allVideos, sopCategories]);
   React19.useEffect(() => {
     if (previousFilterRef.current !== activeFilter) {
       console.log(`Filter changed from ${previousFilterRef.current} to ${activeFilter} - resetting to first video`);
@@ -26808,26 +26659,25 @@ var BottlenecksContent = ({
       return new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime();
     });
   }, [activeFilter, allVideos, sopCategories]);
-  React19.useEffect(() => {
-    if (filteredVideos.length === 0) return;
-    const upcoming = [];
-    if (currentIndex + 1 < filteredVideos.length && filteredVideos[currentIndex + 1]) {
-      upcoming.push(filteredVideos[currentIndex + 1].src);
-    }
-    if (currentIndex - 1 >= 0 && currentIndex - 1 < filteredVideos.length && filteredVideos[currentIndex - 1]) {
-      upcoming.push(filteredVideos[currentIndex - 1].src);
-    }
-    if (upcoming.length > 0) {
-      preloadVideosUrl(upcoming);
-    }
-  }, [currentIndex, filteredVideos]);
   React19.useEffect(() => {
     if (isNavigating && currentIndex < filteredVideos.length) {
       setIsNavigating(false);
       setError(null);
       videoRetryCountRef.current = 0;
+      ensureVideosLoaded(currentIndex);
     }
   }, [isNavigating, currentIndex, filteredVideos.length]);
+  React19.useEffect(() => {
+    if (!isPlaying || !isMountedRef.current) return;
+    const preloadInterval = setInterval(() => {
+      if (isMountedRef.current) {
+        const currentIdx = currentIndexRef.current;
+        console.log(`[Background Preloader] Ensuring videos loaded around index ${currentIdx}`);
+        ensureVideosLoaded(currentIdx);
+      }
+    }, 2e3);
+    return () => clearInterval(preloadInterval);
+  }, [isPlaying]);
   const handleNext = React19.useCallback(async () => {
     if (!isMountedRef.current) return;
     const currentIdx = currentIndexRef.current;
@@ -26848,6 +26698,7 @@ var BottlenecksContent = ({
       }
       if (nextIndex < filteredVideos.length) {
         setIsNavigating(false);
+        ensureVideosLoaded(nextIndex);
         return;
       }
       if (isMountedRef.current) {
@@ -26865,8 +26716,8 @@ var BottlenecksContent = ({
             nextIndex,
             true,
             // includeCycleTime
-            true
-            // includeMetadata
+            false
+            // includeMetadata - DON'T fetch metadata during navigation to prevent flooding!
           );
         } else {
           console.warn(`[BottlenecksContent] Video index not ready for navigation: ID: ${currentVideoIndex?._debugId || "NO_ID"}, byCategory exists = ${!!currentVideoIndex?.byCategory}, allVideos = ${currentVideoIndex?.allVideos?.length || 0}`);
@@ -26879,7 +26730,11 @@ var BottlenecksContent = ({
             operationalDate,
             shiftStr,
             effectiveFilter,
-            nextIndex
+            nextIndex,
+            true,
+            // includeCycleTime - needed for main video display
+            false
+            // includeMetadata - DON'T fetch metadata during navigation to prevent flooding!
           );
         }
         if (video && isMountedRef.current) {
@@ -26892,26 +26747,7 @@ var BottlenecksContent = ({
             return prev;
           });
           preloadVideoUrl(video.src);
-          if (nextIndex + 1 < clipCounts[effectiveFilter]) {
-            setTimeout(() => {
-              const videoIndexForPreload = videoIndexRef.current;
-              if (videoIndexForPreload && s3ClipsService && isMountedRef.current) {
-                s3ClipsService.getVideoFromIndex(videoIndexForPreload, effectiveFilter, nextIndex + 1, true, true).then((nextVideo) => {
-                  if (nextVideo && isMountedRef.current) {
-                    setAllVideos((prev) => {
-                      if (!prev.some((v) => v.id === nextVideo.id)) {
-                        const newVideos = [...prev, nextVideo];
-                        return newVideos;
-                      }
-                      return prev;
-                    });
-                    preloadVideoUrl(nextVideo.src);
-                  }
-                }).catch(() => {
-                });
-              }
-            }, 100);
-          }
+          ensureVideosLoaded(nextIndex);
         }
       } catch (error2) {
         console.error("Error loading next video:", error2);
@@ -26933,15 +26769,43 @@ var BottlenecksContent = ({
       if (prevIndex < filteredVideos.length) {
         setCurrentIndex(prevIndex);
         setError(null);
+        ensureVideosLoaded(prevIndex);
       }
     }
   }, [filteredVideos.length]);
+  const currentVideo = React19.useMemo(() => {
+    if (!filteredVideos || filteredVideos.length === 0 || currentIndex >= filteredVideos.length) {
+      return null;
+    }
+    return filteredVideos[currentIndex];
+  }, [filteredVideos, currentIndex]);
   const handleVideoReady = React19.useCallback((player) => {
     console.log("Video.js player ready");
   }, []);
-  const handleVideoPlay = React19.useCallback((player) => {
+  const handleVideoPlay = React19.useCallback(async (player) => {
     setIsPlaying(true);
-  }, []);
+    const currentIdx = currentIndexRef.current;
+    ensureVideosLoaded(currentIdx);
+    if (currentVideo && !currentVideo.creation_timestamp && s3ClipsService) {
+      try {
+        const originalUri = currentVideo.originalUri || currentVideo.src;
+        if (originalUri && originalUri.includes("s3://")) {
+          const metadata = await s3ClipsService.getFullMetadata(originalUri);
+          if (metadata && isMountedRef.current) {
+            setAllVideos((prev) => prev.map(
+              (v) => v.id === currentVideo.id ? {
+                ...v,
+                creation_timestamp: metadata.upload_timestamp || metadata.original_task_metadata?.timestamp || metadata.creation_timestamp,
+                cycle_time_seconds: metadata.original_task_metadata?.cycle_time || v.cycle_time_seconds
+              } : v
+            ));
+          }
+        }
+      } catch (error2) {
+        console.warn("[BottlenecksContent] Failed to load metadata for current video:", error2);
+      }
+    }
+  }, [currentVideo, s3ClipsService]);
   const handleVideoPause = React19.useCallback((player) => {
     setIsPlaying(false);
   }, []);
@@ -26968,13 +26832,6 @@ var BottlenecksContent = ({
       fetchInProgressRef.current.clear();
       setIsCategoryLoading(false);
       setIsNavigating(false);
-      if (s3ClipsService) {
-        try {
-          s3ClipsService.dispose();
-        } catch (error2) {
-          console.warn("[BottlenecksContent] Error disposing S3 service:", error2);
-        }
-      }
     };
   }, [s3ClipsService]);
   React19.useEffect(() => {
@@ -27015,12 +26872,6 @@ var BottlenecksContent = ({
     counts.bottlenecks = counts.bottleneck || counts.bottlenecks || 0;
     return counts;
   }, [clipCounts]);
-  const currentVideo = React19.useMemo(() => {
-    if (!filteredVideos || filteredVideos.length === 0 || currentIndex >= filteredVideos.length) {
-      return null;
-    }
-    return filteredVideos[currentIndex];
-  }, [filteredVideos, currentIndex]);
   const getClipTypeLabel = (video) => {
     if (!video) return "";
     switch (video.type) {
@@ -27255,8 +27106,8 @@ var BottlenecksContent = ({
       ] }),
       /* Priority 1: Show loading if initial load hasn't completed yet */
       isLoading && !hasInitialLoad ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4 h-[calc(100%-4rem)]", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative h-full", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative w-full h-full overflow-hidden rounded-md shadow-inner bg-gray-900 flex items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(OptifyeLogoLoader_default, { size: "md", message: "Loading clips..." }) }) }) }) : (
-        /* Priority 2: Show loading if category is loading (prevents "no matching clips" flash) */
-        isCategoryLoading ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4 h-[calc(100%-4rem)]", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative h-full", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative w-full h-full overflow-hidden rounded-md shadow-inner bg-gray-900 flex items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(OptifyeLogoLoader_default, { size: "md", message: "Loading videos..." }) }) }) }) : (
+        /* Priority 2: Show loading if category is loading BUT only if no video is available */
+        isCategoryLoading && (!filteredVideos.length || !currentVideo) ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4 h-[calc(100%-4rem)]", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative h-full", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative w-full h-full overflow-hidden rounded-md shadow-inner bg-gray-900 flex items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(OptifyeLogoLoader_default, { size: "md", message: "Loading videos..." }) }) }) }) : (
           /* Priority 3: Show loading if navigating and current video not available */
           isNavigating || currentIndex >= filteredVideos.length && currentIndex < clipCounts[activeFilter] ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "p-4 h-[calc(100%-4rem)]", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative h-full", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative w-full h-full overflow-hidden rounded-md shadow-inner bg-gray-900 flex items-center justify-center", children: /* @__PURE__ */ jsxRuntime.jsx(OptifyeLogoLoader_default, { size: "md", message: "Loading video..." }) }) }) }) : (
             /* Priority 4: Show video if we have filtered videos and current video */
@@ -32054,9 +31905,25 @@ function withWorkspaceDisplayNames(Component3, options = {}) {
   return function WithWorkspaceDisplayNamesWrapper(props) {
     const [isInitialized2, setIsInitialized] = React19.useState(false);
     const [error, setError] = React19.useState(null);
+    const [lastInitKey, setLastInitKey] = React19.useState("");
+    const lineIdsKey = React19.useMemo(() => {
+      if (!props.lineIds) return "";
+      if (Array.isArray(props.lineIds)) {
+        return props.lineIds.sort().join(",");
+      }
+      const values = Object.values(props.lineIds).filter(Boolean);
+      return values.sort().join(",");
+    }, [props.lineIds]);
+    const initKey = React19.useMemo(() => {
+      return `${lineIdsKey}-${props.selectedLineId || ""}-${props.factoryViewId || ""}-${initializeFor}`;
+    }, [lineIdsKey, props.selectedLineId, props.factoryViewId]);
     React19.useEffect(() => {
-      setIsInitialized(false);
-      setError(null);
+      if (initKey === lastInitKey && isInitialized2) {
+        return;
+      }
+      if (initKey !== lastInitKey) {
+        setError(null);
+      }
       const initializeDisplayNames = async () => {
         try {
           const { lineIds, selectedLineId, factoryViewId } = props;
@@ -32082,20 +31949,17 @@ function withWorkspaceDisplayNames(Component3, options = {}) {
             await preInitializeWorkspaceDisplayNames();
           }
           setIsInitialized(true);
+          setLastInitKey(initKey);
         } catch (err) {
           console.error("Failed to initialize workspace display names:", err);
           setError(err);
           setIsInitialized(true);
+          setLastInitKey(initKey);
         }
       };
       initializeDisplayNames();
-    }, [
-      Array.isArray(props.lineIds) ? props.lineIds.join(",") : JSON.stringify(props.lineIds),
-      props.selectedLineId,
-      props.factoryViewId,
-      initializeFor
-    ]);
-    if (!isInitialized2 && showLoading) {
+    }, [initKey]);
+    if (!isInitialized2 && showLoading && lastInitKey === "") {
       return /* @__PURE__ */ jsxRuntime.jsx(LoadingPage, { message: loadingMessage });
     }
     if (error && showLoading) {
@@ -34166,7 +34030,15 @@ var ShiftsView = ({
   className = ""
 }) => {
   const supabase = useSupabase();
-  const auth = useAuth();
+  React19.useEffect(() => {
+    console.log("[ShiftsView] Component mounted/re-rendered", {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      lineIds: lineIds.length
+    });
+    return () => {
+      console.log("[ShiftsView] Component unmounting");
+    };
+  }, []);
   const [lineConfigs, setLineConfigs] = React19.useState(
     () => lineIds.map((id3) => ({
       id: id3,
@@ -34264,7 +34136,7 @@ var ShiftsView = ({
       }
     };
     fetchShiftConfigs();
-  }, [supabase, lineIds, showToast]);
+  }, [lineIds, showToast]);
   React19.useCallback((lineId) => {
     setLineConfigs((prev) => {
       const typedPrev = prev;
@@ -34457,7 +34329,6 @@ var ShiftsView = ({
     }));
   }, []);
   const handleSaveShifts = React19.useCallback(async (lineId) => {
-    if (!auth.user?.id && false) ;
     setLineConfigs((prev) => prev.map(
       (config) => config.id === lineId ? { ...config, isSaving: true, saveSuccess: false } : config
     ));
@@ -34504,7 +34375,7 @@ var ShiftsView = ({
         (config) => config.id === lineId ? { ...config, isSaving: false, saveSuccess: false } : config
       ));
     }
-  }, [auth.user?.id, lineConfigs, supabase, showToast]);
+  }, [lineConfigs, supabase, showToast]);
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: `min-h-screen bg-slate-50 ${className}`, children: [
     /* @__PURE__ */ jsxRuntime.jsx("div", { className: "sticky top-0 z-10 bg-white border-b border-gray-200/80 shadow-sm", children: /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-4 sm:px-8 py-4", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center relative", children: [
       /* @__PURE__ */ jsxRuntime.jsxs(
@@ -34612,6 +34483,7 @@ var ShiftsView = ({
     ] })
   ] });
 };
+var AuthenticatedShiftsView = withAuth(React19__namespace.default.memo(ShiftsView));
 var ShiftsView_default = ShiftsView;
 
 // src/lib/constants/actions.ts
@@ -35399,6 +35271,7 @@ var TargetsViewUI = ({
   isLoading,
   lineWorkspaces,
   lineNames,
+  dropdownStates,
   savingLines,
   saveSuccess,
   selectedShift,
@@ -35484,13 +35357,13 @@ var TargetsViewUI = ({
                   {
                     onClick: () => onToggleLineDropdown(lineId),
                     className: "flex items-center gap-3 text-lg font-medium transition-colors duration-200 \n                          focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500 rounded-lg \n                          hover:bg-blue-50 px-3 py-2 group",
-                    "aria-expanded": line.isOpen,
+                    "aria-expanded": dropdownStates[lineId],
                     "aria-controls": `line-${lineId}-content`,
                     children: [
                       /* @__PURE__ */ jsxRuntime.jsx(
                         lucideReact.ChevronDown,
                         {
-                          className: `w-5 h-5 text-blue-500 transform transition-transform duration-200 ${line.isOpen ? "rotate-180" : ""}`
+                          className: `w-5 h-5 text-blue-500 transform transition-transform duration-200 ${dropdownStates[lineId] ? "rotate-180" : ""}`
                         }
                       ),
                       /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2.5", children: [
@@ -35537,7 +35410,7 @@ var TargetsViewUI = ({
                 )
               ] })
             ] }) }),
-            line.isOpen && /* @__PURE__ */ jsxRuntime.jsxs("div", { id: `line-${lineId}-content`, className: "border-t border-gray-200", children: [
+            dropdownStates[lineId] && /* @__PURE__ */ jsxRuntime.jsxs("div", { id: `line-${lineId}-content`, className: "border-t border-gray-200", children: [
               skuEnabled && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-6 py-4 border-b border-gray-200 bg-gray-50/50", children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-4", children: [
                 /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: `sku-${lineId}`, className: "text-sm font-medium text-gray-700", children: "Select SKU:" }),
                 /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex-1 max-w-md", children: /* @__PURE__ */ jsxRuntime.jsx(
@@ -35574,68 +35447,71 @@ var TargetsViewUI = ({
                   /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs text-gray-400", children: "pieces per day" })
                 ] })
               ] }) }),
-              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "divide-y divide-gray-100", children: line.workspaces.map((workspace) => /* @__PURE__ */ jsxRuntime.jsx(
-                "div",
-                {
-                  className: "px-6 py-4 hover:bg-gray-50 transition-all duration-200",
-                  children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid grid-cols-12 gap-6 items-center", children: [
-                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "col-span-2", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-medium text-gray-900", children: formatWorkspaceName(workspace.name, lineId) }) }),
-                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "col-span-2", children: /* @__PURE__ */ jsxRuntime.jsxs(
-                      "select",
-                      {
-                        value: workspace.actionType,
-                        onChange: (e) => {
-                          const newActionType = e.target.value;
-                          onActionTypeChange(lineId, workspace.id, newActionType);
-                        },
-                        className: "w-full p-2 border border-gray-300 rounded-md shadow-sm focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm",
-                        "aria-label": `Action type for ${formatWorkspaceName(workspace.name, lineId)}`,
-                        children: [
-                          /* @__PURE__ */ jsxRuntime.jsx("option", { value: "assembly", className: "py-2", children: "Assembly" }),
-                          /* @__PURE__ */ jsxRuntime.jsx("option", { value: "packaging", className: "py-2", children: "Packaging" })
-                        ]
-                      }
-                    ) }),
-                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "col-span-3", children: /* @__PURE__ */ jsxRuntime.jsx(
-                      "input",
-                      {
-                        type: "number",
-                        value: workspace.targetCycleTime === 0 ? "" : workspace.targetCycleTime,
-                        onChange: (e) => onUpdateWorkspaceTarget(lineId, workspace.id, "targetCycleTime", Number(e.target.value) || ""),
-                        className: "block w-full rounded-lg border border-gray-300 bg-white px-3 py-2 text-sm\n                                  shadow-sm focus:border-blue-500 focus:ring-blue-500 \n                                  transition-all duration-200 hover:border-gray-400",
-                        min: "0",
-                        step: "0.01",
-                        placeholder: "Enter cycle time"
-                      }
-                    ) }),
-                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "col-span-3", children: /* @__PURE__ */ jsxRuntime.jsx(
-                      "input",
-                      {
-                        type: "number",
-                        value: workspace.targetPPH === 0 ? "" : workspace.targetPPH,
-                        onChange: (e) => onUpdateWorkspaceTarget(lineId, workspace.id, "targetPPH", Number(e.target.value) || ""),
-                        className: "block w-full rounded-lg border border-gray-300 bg-white px-3 py-2 text-sm\n                                  shadow-sm focus:border-blue-500 focus:ring-blue-500 \n                                  transition-all duration-200 hover:border-gray-400 \n                                  placeholder:text-gray-400",
-                        min: "0",
-                        step: "0.1",
-                        placeholder: "Enter PPH"
-                      }
-                    ) }),
-                    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "col-span-2", children: /* @__PURE__ */ jsxRuntime.jsx(
-                      "input",
-                      {
-                        type: "number",
-                        value: workspace.targetDayOutput === 0 ? "" : workspace.targetDayOutput,
-                        onChange: (e) => onUpdateWorkspaceTarget(lineId, workspace.id, "targetDayOutput", Number(e.target.value) || ""),
-                        className: "block w-full rounded-lg border border-gray-300 bg-white px-3 py-2 text-sm\n                                  shadow-sm focus:border-blue-500 focus:ring-blue-500 \n                                  transition-all duration-200 hover:border-gray-400 \n                                  placeholder:text-gray-400",
-                        min: "0",
-                        step: "1",
-                        placeholder: "Enter day output"
-                      }
-                    ) })
-                  ] })
-                },
-                workspace.id
-              )) })
+              /* @__PURE__ */ jsxRuntime.jsx("div", { className: "divide-y divide-gray-100", children: line.workspaces.map((workspace) => {
+                const formattedName = formatWorkspaceName(workspace.name, lineId);
+                return /* @__PURE__ */ jsxRuntime.jsx(
+                  "div",
+                  {
+                    className: "px-6 py-4 hover:bg-gray-50 transition-all duration-200",
+                    children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "grid grid-cols-12 gap-6 items-center", children: [
+                      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "col-span-2", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "font-medium text-gray-900", children: formattedName }) }),
+                      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "col-span-2", children: /* @__PURE__ */ jsxRuntime.jsxs(
+                        "select",
+                        {
+                          value: workspace.actionType,
+                          onChange: (e) => {
+                            const newActionType = e.target.value;
+                            onActionTypeChange(lineId, workspace.id, newActionType);
+                          },
+                          className: "w-full p-2 border border-gray-300 rounded-md shadow-sm focus:ring-indigo-500 focus:border-indigo-500 sm:text-sm",
+                          "aria-label": `Action type for ${formattedName}`,
+                          children: [
+                            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "assembly", className: "py-2", children: "Assembly" }),
+                            /* @__PURE__ */ jsxRuntime.jsx("option", { value: "packaging", className: "py-2", children: "Packaging" })
+                          ]
+                        }
+                      ) }),
+                      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "col-span-3", children: /* @__PURE__ */ jsxRuntime.jsx(
+                        "input",
+                        {
+                          type: "number",
+                          value: workspace.targetCycleTime === 0 ? "" : workspace.targetCycleTime,
+                          onChange: (e) => onUpdateWorkspaceTarget(lineId, workspace.id, "targetCycleTime", Number(e.target.value) || ""),
+                          className: "block w-full rounded-lg border border-gray-300 bg-white px-3 py-2 text-sm\n                                  shadow-sm focus:border-blue-500 focus:ring-blue-500 \n                                  transition-all duration-200 hover:border-gray-400",
+                          min: "0",
+                          step: "0.01",
+                          placeholder: "Enter cycle time"
+                        }
+                      ) }),
+                      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "col-span-3", children: /* @__PURE__ */ jsxRuntime.jsx(
+                        "input",
+                        {
+                          type: "number",
+                          value: workspace.targetPPH === 0 ? "" : workspace.targetPPH,
+                          onChange: (e) => onUpdateWorkspaceTarget(lineId, workspace.id, "targetPPH", Number(e.target.value) || ""),
+                          className: "block w-full rounded-lg border border-gray-300 bg-white px-3 py-2 text-sm\n                                  shadow-sm focus:border-blue-500 focus:ring-blue-500 \n                                  transition-all duration-200 hover:border-gray-400 \n                                  placeholder:text-gray-400",
+                          min: "0",
+                          step: "0.1",
+                          placeholder: "Enter PPH"
+                        }
+                      ) }),
+                      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "col-span-2", children: /* @__PURE__ */ jsxRuntime.jsx(
+                        "input",
+                        {
+                          type: "number",
+                          value: workspace.targetDayOutput === 0 ? "" : workspace.targetDayOutput,
+                          onChange: (e) => onUpdateWorkspaceTarget(lineId, workspace.id, "targetDayOutput", Number(e.target.value) || ""),
+                          className: "block w-full rounded-lg border border-gray-300 bg-white px-3 py-2 text-sm\n                                  shadow-sm focus:border-blue-500 focus:ring-blue-500 \n                                  transition-all duration-200 hover:border-gray-400 \n                                  placeholder:text-gray-400",
+                          min: "0",
+                          step: "1",
+                          placeholder: "Enter day output"
+                        }
+                      ) })
+                    ] })
+                  },
+                  workspace.id
+                );
+              }) })
             ] })
           ]
         },
@@ -35668,7 +35544,6 @@ var TargetsView = ({
     return lineIds.reduce((acc, lineId) => ({
       ...acc,
       [lineId]: {
-        isOpen: getStoredLineState2(lineId),
         productId: "",
         shiftStartTime: "08:00",
         shiftEndTime: "19:00",
@@ -35681,6 +35556,12 @@ var TargetsView = ({
       }
     }), {});
   }, [lineIds]);
+  const [dropdownStates, setDropdownStates] = React19.useState(() => {
+    return lineIds.reduce((acc, lineId) => ({
+      ...acc,
+      [lineId]: getStoredLineState2(lineId)
+    }), {});
+  });
   const [allShiftsData, setAllShiftsData] = React19.useState({
     0: initialLineWorkspaces,
     // Day shift
@@ -35698,6 +35579,8 @@ var TargetsView = ({
   const [isBulkConfigureOpen, setIsBulkConfigureOpen] = React19.useState(false);
   const [selectedWorkspaces, setSelectedWorkspaces] = React19.useState([]);
   const [selectedShift, setSelectedShift] = React19.useState(0);
+  const [dbValues, setDbValues] = React19.useState({ 0: {}, 1: {} });
+  const [userEditedFields, setUserEditedFields] = React19.useState(/* @__PURE__ */ new Set());
   const lineWorkspaces = allShiftsData[selectedShift] || initialLineWorkspaces;
   const setLineWorkspaces = React19.useCallback((updater) => {
     setAllShiftsData((prev) => ({
@@ -35706,18 +35589,123 @@ var TargetsView = ({
     }));
   }, [selectedShift]);
   const supabase = useSupabase();
-  const auth = useAuth();
-  userId || auth?.user?.id;
+  const effectiveUserId = userId || "6bf6f271-1e55-4a95-9b89-1c3820b58739";
   const dashboardConfig = useDashboardConfig();
   const { skus, isLoading: skusLoading } = useSKUs(companyId);
   const skuEnabled = dashboardConfig?.skuConfig?.enabled || false;
+  const loadOperatingHours = React19.useCallback(async (lineId, shiftId) => {
+    try {
+      if (!supabase) return null;
+      const { data, error } = await supabase.from("line_operating_hours").select("start_time, end_time, breaks").eq("line_id", lineId).eq("shift_id", shiftId).maybeSingle();
+      if (error) {
+        if (error.code === "PGRST116") {
+          console.log(`No operating hours found for line ${lineId}, shift ${shiftId}`);
+          return {
+            startTime: "08:00",
+            // Default values
+            endTime: "19:00",
+            breaks: []
+          };
+        } else {
+          console.error("Error fetching operating hours:", error);
+          return null;
+        }
+      }
+      let breaks = [];
+      if (data?.breaks) {
+        if (Array.isArray(data.breaks)) {
+          breaks = data.breaks.map((breakItem) => {
+            const startTime = breakItem.start || breakItem.startTime || "00:00";
+            const endTime = breakItem.end || breakItem.endTime || "00:00";
+            const calculateDuration = (start, end) => {
+              const [startHour, startMinute] = start.split(":").map(Number);
+              const [endHour, endMinute] = end.split(":").map(Number);
+              let startMinutes = startHour * 60 + startMinute;
+              let endMinutes = endHour * 60 + endMinute;
+              if (endMinutes < startMinutes) {
+                endMinutes += 24 * 60;
+              }
+              return endMinutes - startMinutes;
+            };
+            return {
+              startTime,
+              endTime,
+              duration: breakItem.duration || calculateDuration(startTime, endTime)
+            };
+          });
+        } else if (typeof data.breaks === "object" && data.breaks.breaks) {
+          breaks = data.breaks.breaks.map((breakItem) => {
+            const startTime = breakItem.start || breakItem.startTime || "00:00";
+            const endTime = breakItem.end || breakItem.endTime || "00:00";
+            const calculateDuration = (start, end) => {
+              const [startHour, startMinute] = start.split(":").map(Number);
+              const [endHour, endMinute] = end.split(":").map(Number);
+              let startMinutes = startHour * 60 + startMinute;
+              let endMinutes = endHour * 60 + endMinute;
+              if (endMinutes < startMinutes) {
+                endMinutes += 24 * 60;
+              }
+              return endMinutes - startMinutes;
+            };
+            return {
+              startTime,
+              endTime,
+              duration: breakItem.duration || calculateDuration(startTime, endTime)
+            };
+          });
+        } else if (typeof data.breaks === "string") {
+          try {
+            const parsedBreaks = JSON.parse(data.breaks);
+            if (Array.isArray(parsedBreaks)) {
+              breaks = parsedBreaks.map((breakItem) => ({
+                startTime: breakItem.start || breakItem.startTime || "00:00",
+                endTime: breakItem.end || breakItem.endTime || "00:00",
+                duration: breakItem.duration || 0
+              }));
+            } else if (parsedBreaks.breaks && Array.isArray(parsedBreaks.breaks)) {
+              breaks = parsedBreaks.breaks.map((breakItem) => ({
+                startTime: breakItem.start || breakItem.startTime || "00:00",
+                endTime: breakItem.end || breakItem.endTime || "00:00",
+                duration: breakItem.duration || 0
+              }));
+            }
+          } catch (e) {
+            console.error("Error parsing breaks data:", e);
+          }
+        }
+      }
+      return {
+        startTime: data?.start_time || "08:00",
+        endTime: data?.end_time || "19:00",
+        breaks
+      };
+    } catch (e) {
+      console.error("Exception when loading operating hours:", e);
+      return {
+        startTime: "08:00",
+        endTime: "19:00",
+        breaks: []
+      };
+    }
+  }, [supabase]);
+  React19.useEffect(() => {
+    console.log("[TargetsView] Component mounted/re-rendered", {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      lineIds: lineIds.length,
+      effectiveUserId
+    });
+    return () => {
+      console.log("[TargetsView] Component unmounting");
+    };
+  }, []);
   React19.useEffect(() => {
     let timeoutId;
     let retryCount = 0;
     const MAX_RETRIES2 = 2;
     const LOADING_TIMEOUT = 15e3;
     const fetchInitialData = async () => {
-      if (!supabase || lineIds.length === 0) return;
+      if (lineIds.length === 0) return;
+      console.log("[TargetsView] Starting fetchInitialData");
       setIsLoading(true);
       timeoutId = setTimeout(() => {
         console.error("Loading timeout reached");
@@ -35781,10 +35769,32 @@ var TargetsView = ({
             const actionThresholds = await workspaceService.getActionThresholds(
               lineId,
               currentDate,
-              selectedShift
+              0
+              // Always use day shift for initial load
             );
+            const operatingHoursData = await loadOperatingHours(lineId, 0);
+            if (operatingHoursData) {
+              updatedLineWorkspaces[lineId].shiftStartTime = operatingHoursData.startTime;
+              updatedLineWorkspaces[lineId].shiftEndTime = operatingHoursData.endTime;
+              updatedLineWorkspaces[lineId].breaks = operatingHoursData.breaks;
+              updatedLineWorkspaces[lineId].shiftHours = calculateShiftHours2(
+                operatingHoursData.startTime,
+                operatingHoursData.endTime,
+                operatingHoursData.breaks
+              );
+            }
             const mappedWorkspaces = enabledWorkspaces.map((ws) => {
               const threshold = actionThresholds.find((t) => t.workspace_id === ws.id);
+              if (!dbValues[0][lineId]) {
+                dbValues[0][lineId] = {};
+              }
+              if (threshold) {
+                dbValues[0][lineId][ws.id] = {
+                  targetPPH: threshold.pph_threshold,
+                  targetCycleTime: threshold.ideal_cycle_time,
+                  targetDayOutput: threshold.total_day_output
+                };
+              }
               return {
                 id: ws.id,
                 name: ws.workspace_id,
@@ -35825,90 +35835,7 @@ var TargetsView = ({
     return () => {
       clearTimeout(timeoutId);
     };
-  }, [supabase, lineIds, companyId]);
-  React19.useCallback(async (shiftId) => {
-    try {
-      if (!supabase) return;
-      const currentDate = getOperationalDate();
-      const updatedLineWorkspaces = { ...lineWorkspaces };
-      let hasUpdates = false;
-      for (const lineId of lineIds) {
-        const lineState = lineWorkspaces[lineId];
-        if (!lineState || !lineState.factoryId) {
-          console.warn(`Skipping line thresholds for ${lineId} as factoryId is not yet available.`);
-          continue;
-        }
-        const currentFactoryId = lineState.factoryId;
-        try {
-          const { data: lineThresholdsRows, error: thresholdError } = await supabase.from("line_thresholds").select("product_code").eq("line_id", lineId).eq("date", currentDate).eq("shift_id", selectedShift).eq("factory_id", currentFactoryId);
-          if (thresholdError) {
-            console.error(`Error fetching line threshold for line ${lineId}, factory ${currentFactoryId}:`, thresholdError);
-            continue;
-          }
-          let determinedProductId = updatedLineWorkspaces[lineId]?.productId || "";
-          if (lineThresholdsRows && lineThresholdsRows.length > 0) {
-            if (lineThresholdsRows.length > 1) {
-              console.warn(
-                `Multiple line_thresholds records found for line ${lineId}, factory ${currentFactoryId}, date ${currentDate}, shift ${selectedShift}. Using product_code from the first record. Rows:`,
-                lineThresholdsRows
-              );
-            }
-            determinedProductId = lineThresholdsRows[0].product_code;
-          } else {
-            console.log(
-              `No line_thresholds record found for line ${lineId}, factory ${currentFactoryId}, date ${currentDate}, shift ${selectedShift}. Using existing/default product ID.`
-            );
-          }
-          const { data: operatingHours, error: hoursError } = await supabase.from("line_operating_hours").select("start_time, end_time, breaks").eq("line_id", lineId).eq("shift_id", selectedShift).maybeSingle();
-          if (hoursError) {
-            console.error(`Error fetching operating hours for line ${lineId}:`, hoursError);
-            continue;
-          }
-          const startTime = operatingHours?.start_time || updatedLineWorkspaces[lineId]?.shiftStartTime || "08:00";
-          const endTime = operatingHours?.end_time || updatedLineWorkspaces[lineId]?.shiftEndTime || "19:00";
-          let breaks = [];
-          if (operatingHours?.breaks) {
-            if (Array.isArray(operatingHours.breaks)) {
-              breaks = operatingHours.breaks.map((breakItem) => ({
-                startTime: breakItem.start || breakItem.startTime || "00:00",
-                endTime: breakItem.end || breakItem.endTime || "00:00",
-                duration: breakItem.duration || calculateShiftHours2(breakItem.start || breakItem.startTime || "00:00", breakItem.end || breakItem.endTime || "00:00", []) * 60
-              }));
-            } else if (typeof operatingHours.breaks === "object" && operatingHours.breaks.breaks) {
-              breaks = operatingHours.breaks.breaks.map((breakItem) => ({
-                startTime: breakItem.start || breakItem.startTime || "00:00",
-                endTime: breakItem.end || breakItem.endTime || "00:00",
-                duration: breakItem.duration || calculateShiftHours2(breakItem.start || breakItem.startTime || "00:00", breakItem.end || breakItem.endTime || "00:00", []) * 60
-              }));
-            }
-          }
-          const shiftHours = calculateShiftHours2(startTime, endTime, breaks);
-          const currentLineStateFromLoop = updatedLineWorkspaces[lineId];
-          if (determinedProductId !== currentLineStateFromLoop?.productId || startTime !== currentLineStateFromLoop?.shiftStartTime || endTime !== currentLineStateFromLoop?.shiftEndTime || shiftHours !== currentLineStateFromLoop?.shiftHours || JSON.stringify(breaks) !== JSON.stringify(currentLineStateFromLoop?.breaks)) {
-            updatedLineWorkspaces[lineId] = {
-              ...currentLineStateFromLoop || {},
-              factoryId: currentFactoryId,
-              // Ensure factoryId is preserved
-              productId: determinedProductId,
-              shiftStartTime: startTime,
-              shiftEndTime: endTime,
-              breaks,
-              shiftHours: Number(shiftHours),
-              workspaces: currentLineStateFromLoop?.workspaces || []
-            };
-            hasUpdates = true;
-          }
-        } catch (lineError) {
-          console.error(`Error processing line ${lineId}:`, lineError);
-        }
-      }
-      if (hasUpdates) {
-        setLineWorkspaces(updatedLineWorkspaces);
-      }
-    } catch (error) {
-      console.error("Error in fetchLineThresholds outer try-catch:", error);
-    }
-  }, [selectedShift, supabase, lineIds, lineWorkspaces, allShiftsData]);
+  }, [lineIds, companyId, loadOperatingHours]);
   const fetchAllShiftsData = React19.useCallback(async (currentWorkspaces) => {
     if (!supabase) return;
     const currentDate = getOperationalDate();
@@ -35918,32 +35845,25 @@ var TargetsView = ({
       1: JSON.parse(JSON.stringify(currentWorkspaces))
       // Deep clone for night shift
     };
+    const newDbValues = { 0: {}, 1: {} };
     for (const shiftId of [0, 1]) {
       for (const lineId of lineIds) {
         try {
-          const { data: operatingHours, error: hoursError } = await supabase.from("line_operating_hours").select("start_time, end_time, breaks").eq("line_id", lineId).eq("shift_id", shiftId).maybeSingle();
-          if (hoursError) {
-            console.error(`Error fetching operating hours for line ${lineId}, shift ${shiftId}:`, hoursError);
+          const operatingHoursData = await loadOperatingHours(lineId, shiftId);
+          if (!operatingHoursData) {
+            console.warn(`No operating hours for line ${lineId}, shift ${shiftId} - using defaults`);
             continue;
           }
-          let breaks = [];
-          if (operatingHours?.breaks) {
-            if (Array.isArray(operatingHours.breaks)) {
-              breaks = operatingHours.breaks.map((breakItem) => ({
-                startTime: breakItem.start || breakItem.startTime || "00:00",
-                endTime: breakItem.end || breakItem.endTime || "00:00",
-                duration: breakItem.duration || calculateShiftHours2(breakItem.start || breakItem.startTime || "00:00", breakItem.end || breakItem.endTime || "00:00", []) * 60
-              }));
-            }
-          }
-          const startTime = operatingHours?.start_time || "08:00";
-          const endTime = operatingHours?.end_time || "19:00";
+          const { startTime, endTime, breaks } = operatingHoursData;
           const shiftHours = calculateShiftHours2(startTime, endTime, breaks);
           const actionThresholds = await workspaceService.getActionThresholds(
             lineId,
             currentDate,
             shiftId
           );
+          if (!newDbValues[shiftId][lineId]) {
+            newDbValues[shiftId][lineId] = {};
+          }
           const existingLine = newAllShiftsData[shiftId][lineId];
           if (existingLine) {
             newAllShiftsData[shiftId][lineId] = {
@@ -35955,6 +35875,11 @@ var TargetsView = ({
               workspaces: existingLine.workspaces.map((ws) => {
                 const threshold = actionThresholds.find((t) => t.workspace_id === ws.id);
                 if (threshold) {
+                  newDbValues[shiftId][lineId][ws.id] = {
+                    targetPPH: threshold.pph_threshold,
+                    targetCycleTime: threshold.ideal_cycle_time,
+                    targetDayOutput: threshold.total_day_output
+                  };
                   return {
                     ...ws,
                     targetPPH: threshold.pph_threshold,
@@ -35972,114 +35897,17 @@ var TargetsView = ({
       }
     }
     setAllShiftsData(newAllShiftsData);
-  }, [supabase, lineIds]);
-  const loadOperatingHours = React19.useCallback(async (lineId, shiftId) => {
-    try {
-      if (!supabase) return null;
-      const { data, error } = await supabase.from("line_operating_hours").select("start_time, end_time, breaks").eq("line_id", lineId).eq("shift_id", shiftId).maybeSingle();
-      if (error) {
-        if (error.code === "PGRST116") {
-          console.log(`No operating hours found for line ${lineId}, shift ${shiftId}`);
-          return {
-            startTime: "08:00",
-            // Default values
-            endTime: "19:00",
-            breaks: []
-          };
-        } else {
-          console.error("Error fetching operating hours:", error);
-          return null;
-        }
-      }
-      let breaks = [];
-      if (data?.breaks) {
-        if (Array.isArray(data.breaks)) {
-          breaks = data.breaks.map((breakItem) => {
-            const startTime = breakItem.start || breakItem.startTime || "00:00";
-            const endTime = breakItem.end || breakItem.endTime || "00:00";
-            const calculateDuration = (start, end) => {
-              const [startHour, startMinute] = start.split(":").map(Number);
-              const [endHour, endMinute] = end.split(":").map(Number);
-              let startMinutes = startHour * 60 + startMinute;
-              let endMinutes = endHour * 60 + endMinute;
-              if (endMinutes < startMinutes) {
-                endMinutes += 24 * 60;
-              }
-              return endMinutes - startMinutes;
-            };
-            return {
-              startTime,
-              endTime,
-              duration: breakItem.duration || calculateDuration(startTime, endTime)
-            };
-          });
-        } else if (typeof data.breaks === "object" && data.breaks.breaks) {
-          breaks = data.breaks.breaks.map((breakItem) => {
-            const startTime = breakItem.start || breakItem.startTime || "00:00";
-            const endTime = breakItem.end || breakItem.endTime || "00:00";
-            const calculateDuration = (start, end) => {
-              const [startHour, startMinute] = start.split(":").map(Number);
-              const [endHour, endMinute] = end.split(":").map(Number);
-              let startMinutes = startHour * 60 + startMinute;
-              let endMinutes = endHour * 60 + endMinute;
-              if (endMinutes < startMinutes) {
-                endMinutes += 24 * 60;
-              }
-              return endMinutes - startMinutes;
-            };
-            return {
-              startTime,
-              endTime,
-              duration: breakItem.duration || calculateDuration(startTime, endTime)
-            };
-          });
-        } else if (typeof data.breaks === "string") {
-          try {
-            const parsedBreaks = JSON.parse(data.breaks);
-            if (Array.isArray(parsedBreaks)) {
-              breaks = parsedBreaks.map((breakItem) => ({
-                startTime: breakItem.start || breakItem.startTime || "00:00",
-                endTime: breakItem.end || breakItem.endTime || "00:00",
-                duration: breakItem.duration || 0
-              }));
-            } else if (parsedBreaks.breaks && Array.isArray(parsedBreaks.breaks)) {
-              breaks = parsedBreaks.breaks.map((breakItem) => ({
-                startTime: breakItem.start || breakItem.startTime || "00:00",
-                endTime: breakItem.end || breakItem.endTime || "00:00",
-                duration: breakItem.duration || 0
-              }));
-            }
-          } catch (e) {
-            console.error("Error parsing breaks data:", e);
-          }
-        }
-      }
-      return {
-        startTime: data?.start_time || "08:00",
-        endTime: data?.end_time || "19:00",
-        breaks
-      };
-    } catch (e) {
-      console.error("Exception when loading operating hours:", e);
-      return {
-        startTime: "08:00",
-        endTime: "19:00",
-        breaks: []
-      };
-    }
-  }, [supabase]);
+    setDbValues(newDbValues);
+  }, [supabase, lineIds, loadOperatingHours]);
   const toggleLineDropdown = React19.useCallback((lineId) => {
-    setLineWorkspaces((prev) => {
-      const newIsOpen = !prev[lineId].isOpen;
+    setDropdownStates((prev) => {
+      const newIsOpen = !prev[lineId];
       if (typeof window !== "undefined") {
         localStorage.setItem(`line_${lineId}_open`, JSON.stringify(newIsOpen));
       }
       return {
         ...prev,
-        [lineId]: {
-          ...prev[lineId],
-          isOpen: newIsOpen
-        }
+        [lineId]: newIsOpen
       };
     });
   }, []);
@@ -36128,6 +35956,8 @@ var TargetsView = ({
     }
   };
   const updateWorkspaceTarget = (lineId, workspaceId, field, value) => {
+    const fieldKey = `${lineId}-${workspaceId}-${field}`;
+    setUserEditedFields((prev) => new Set(prev).add(fieldKey));
     setLineWorkspaces((prev) => {
       const shiftHours = prev[lineId].shiftHours;
       return {
@@ -36152,11 +35982,7 @@ var TargetsView = ({
             } else if (field === "targetDayOutput") {
               updates.targetDayOutput = value;
               if (value !== "") {
-                const breaks = prev[lineId].breaks;
-                const totalBreakMinutes = breaks.reduce((total, b) => total + b.duration, 0);
-                const totalBreakHours = totalBreakMinutes / 60;
-                const realWorkHours = shiftHours - totalBreakHours;
-                const calculatedPPH = Math.round(value / realWorkHours);
+                const calculatedPPH = Math.round(value / shiftHours);
                 updates.targetPPH = calculatedPPH;
               } else {
                 updates.targetPPH = "";
@@ -36171,62 +35997,35 @@ var TargetsView = ({
   };
   const handleShiftChange = (shiftId) => {
     setSelectedShift(shiftId);
-    const loadShiftHours = async () => {
-      const updatedLineWorkspaces = { ...allShiftsData[shiftId] };
-      let hasUpdates = false;
-      for (const lineId of lineIds) {
-        try {
-          const operatingHours = await loadOperatingHours(lineId, shiftId);
-          if (!operatingHours) continue;
-          const shiftHours = calculateShiftHours2(
-            operatingHours.startTime,
-            operatingHours.endTime,
-            operatingHours.breaks
-          );
-          updatedLineWorkspaces[lineId] = {
-            ...updatedLineWorkspaces[lineId],
-            shiftStartTime: operatingHours.startTime,
-            shiftEndTime: operatingHours.endTime,
-            breaks: operatingHours.breaks,
-            shiftHours: Number(shiftHours),
-            workspaces: updatedLineWorkspaces[lineId].workspaces.map((ws) => {
-              let updatedPPH = ws.targetPPH;
-              if (ws.targetCycleTime !== "") {
-                const idealPPH = calculatePPH(
-                  ws.targetCycleTime,
-                  operatingHours.breaks,
-                  Number(shiftHours)
-                );
-                const shouldUpdatePPH = typeof ws.targetPPH === "string" ? ws.targetPPH === "" : ws.targetPPH === 0 || !ws.targetPPH;
-                if (shouldUpdatePPH) {
-                  updatedPPH = idealPPH;
+    setUserEditedFields(/* @__PURE__ */ new Set());
+    if (dbValues[shiftId] && Object.keys(dbValues[shiftId]).length > 0) {
+      setAllShiftsData((prev) => {
+        const updatedShiftData = { ...prev[shiftId] };
+        for (const lineId of Object.keys(updatedShiftData)) {
+          if (dbValues[shiftId][lineId]) {
+            updatedShiftData[lineId] = {
+              ...updatedShiftData[lineId],
+              workspaces: updatedShiftData[lineId].workspaces.map((ws) => {
+                const dbValue = dbValues[shiftId][lineId][ws.id];
+                if (dbValue) {
+                  return {
+                    ...ws,
+                    targetPPH: dbValue.targetPPH,
+                    targetCycleTime: dbValue.targetCycleTime,
+                    targetDayOutput: dbValue.targetDayOutput
+                  };
                 }
-              }
-              const updatedDayOutput = calculateDayOutput(
-                updatedPPH,
-                Number(shiftHours),
-                operatingHours.breaks
-              );
-              return {
-                ...ws,
-                targetPPH: updatedPPH,
-                targetDayOutput: updatedDayOutput
-              };
-            })
-          };
-          hasUpdates = true;
-        } catch (e) {
-          console.error(`Exception when loading shift hours for line ${lineId}:`, e);
+                return ws;
+              })
+            };
+          }
         }
-      }
-      if (hasUpdates) {
-        setAllShiftsData((prev) => ({
+        return {
           ...prev,
-          [shiftId]: updatedLineWorkspaces
-        }));
-      }
-    };
-    loadShiftHours();
+          [shiftId]: updatedShiftData
+        };
+      });
+    }
   };
   const handleActionTypeChange = React19.useCallback((lineId, workspaceId, newActionType) => {
     if (!actionIds) return;
@@ -36316,6 +36115,31 @@ var TargetsView = ({
         throw lineUpsertError;
       }
       console.log(`[handleSaveLine] Successfully upserted line_thresholds for ${lineId}`);
+      setDbValues((prev) => ({
+        ...prev,
+        [selectedShift]: {
+          ...prev[selectedShift],
+          [lineId]: lineDataToSave.workspaces.reduce((acc, ws) => ({
+            ...acc,
+            [ws.id]: {
+              targetPPH: ws.targetPPH,
+              targetCycleTime: ws.targetCycleTime,
+              targetDayOutput: ws.targetDayOutput
+            }
+          }), {})
+        }
+      }));
+      console.log(`[handleSaveLine] Updated dbValues for line ${lineId}, shift ${selectedShift}`);
+      setUserEditedFields((prev) => {
+        const newSet = new Set(prev);
+        lineDataToSave.workspaces.forEach((ws) => {
+          newSet.delete(`${lineId}-${ws.id}-targetPPH`);
+          newSet.delete(`${lineId}-${ws.id}-targetCycleTime`);
+          newSet.delete(`${lineId}-${ws.id}-targetDayOutput`);
+        });
+        return newSet;
+      });
+      console.log(`[handleSaveLine] Cleared user edited fields for line ${lineId}`);
       setSaveSuccess((prev) => ({ ...prev, [lineId]: true }));
       sonner.toast.success(`${lineNames[lineId] || lineId} targets saved successfully`);
       if (onSaveChanges) onSaveChanges(lineId);
@@ -36329,7 +36153,7 @@ var TargetsView = ({
       setSavingLines((prev) => ({ ...prev, [lineId]: false }));
       console.log(`[handleSaveLine] Set savingLines to false for ${lineId} in finally block`);
     }
-  }, [supabase, lineWorkspaces, selectedShift, lineNames, onSaveChanges]);
+  }, [supabase, lineWorkspaces, selectedShift, lineNames, onSaveChanges, skuEnabled, dashboardConfig]);
   const handleBulkConfigure = async (updates) => {
     if (!actionIds) return;
     if (updates.productId !== void 0) {
@@ -36377,6 +36201,7 @@ var TargetsView = ({
       isLoading: isLoading || skusLoading,
       lineWorkspaces,
       lineNames,
+      dropdownStates,
       savingLines,
       saveSuccess,
       selectedShift,
@@ -36401,7 +36226,7 @@ var TargetsView = ({
 };
 var TargetsViewWithDisplayNames = withAllWorkspaceDisplayNames(TargetsView);
 var TargetsView_default = TargetsViewWithDisplayNames;
-var AuthenticatedTargetsView = withAuth(TargetsViewWithDisplayNames);
+var AuthenticatedTargetsView = withAuth(React19__namespace.default.memo(TargetsViewWithDisplayNames));
 
 // src/views/workspace-detail-view.utils.ts
 var formatISTDate2 = (date = /* @__PURE__ */ new Date(), options) => {
@@ -37881,6 +37706,7 @@ exports.AuthProvider = AuthProvider;
 exports.AuthenticatedFactoryView = AuthenticatedFactoryView;
 exports.AuthenticatedHelpView = AuthenticatedHelpView;
 exports.AuthenticatedHomeView = AuthenticatedHomeView;
+exports.AuthenticatedShiftsView = AuthenticatedShiftsView;
 exports.AuthenticatedTargetsView = AuthenticatedTargetsView;
 exports.BarChart = BarChart;
 exports.BaseHistoryCalendar = BaseHistoryCalendar;
@@ -38020,7 +37846,6 @@ exports.apiUtils = apiUtils;
 exports.authCoreService = authCoreService;
 exports.authOTPService = authOTPService;
 exports.authRateLimitService = authRateLimitService;
-exports.cacheService = cacheService;
 exports.checkRateLimit = checkRateLimit2;
 exports.clearAllRateLimits = clearAllRateLimits2;
 exports.clearRateLimit = clearRateLimit2;