@optifye/dashboard-core 6.6.6 → 6.6.7

package/dist/index.js

@@ -3598,329 +3598,10 @@ var useAudioService = () => {
 };
 
 // src/lib/utils/dateShiftUtils.ts
-function isValidDateFormat(date) {
-  return /^\d{4}-\d{2}-\d{2}$/.test(date);
-}
 function isValidShiftId(shiftId) {
   const id3 = typeof shiftId === "string" ? parseInt(shiftId, 10) : shiftId;
   return id3 === 0 || id3 === 1;
 }
-
-// src/lib/api/s3-clips-parser.ts
-function parseS3Uri(s3Uri, sopCategories) {
-  const path = new URL(s3Uri).pathname;
-  const parts = path.split("/").filter((p) => p);
-  if (s3Uri.includes("missed_qchecks")) {
-    console.warn(`Skipping missed_qchecks URI in parseS3Uri: ${s3Uri}`);
-    return null;
-  }
-  if (parts.length < 8) {
-    console.warn(`Invalid S3 path structure: ${s3Uri} - Too few parts: ${parts.length}, expected at least 8`);
-    return null;
-  }
-  try {
-    const datePart = parts[2];
-    const shiftPart = parts[3];
-    const violationType = parts[4];
-    let folderName = "";
-    let timestamp = "";
-    for (let i = 5; i < parts.length; i++) {
-      const part = parts[i];
-      if (part && part.includes("_") && /\d{8}_\d{6}/.test(part)) {
-        folderName = part;
-        const timeMatch = folderName.match(/_(\d{8})_(\d{6})_/);
-        if (timeMatch) {
-          timestamp = `${timeMatch[2].substring(0, 2)}:${timeMatch[2].substring(2, 4)}:${timeMatch[2].substring(4, 6)}`;
-          break;
-        }
-      }
-    }
-    if (!timestamp) {
-      console.warn(`Couldn't extract timestamp from any part: ${parts.join("/")}`);
-      timestamp = "00:00:00";
-    }
-    let severity = "low";
-    let type = "bottleneck";
-    let description = "Analysis Clip";
-    const normalizedViolationType = violationType.toLowerCase().trim();
-    if (sopCategories && sopCategories.length > 0) {
-      const matchedCategory = sopCategories.find((category) => {
-        const categoryId = category.id.toLowerCase();
-        const s3FolderName = (category.s3FolderName || category.id).toLowerCase();
-        return categoryId === normalizedViolationType || s3FolderName === normalizedViolationType || // Also check for partial matches for flexibility
-        normalizedViolationType.includes(categoryId) || normalizedViolationType.includes(s3FolderName);
-      });
-      if (matchedCategory) {
-        type = matchedCategory.id;
-        description = matchedCategory.description || matchedCategory.label;
-        if (matchedCategory.color.includes("red")) {
-          severity = "high";
-        } else if (matchedCategory.color.includes("yellow") || matchedCategory.color.includes("orange")) {
-          severity = "medium";
-        } else {
-          severity = "low";
-        }
-        console.log(`Matched SOP category: ${matchedCategory.id} for violation type: ${violationType}`);
-        return { timestamp, severity, description, type, originalUri: s3Uri };
-      }
-    }
-    switch (normalizedViolationType) {
-      case "idle_time":
-      case "idle":
-      case "low_value":
-      case "low value":
-      case "low_value_moment":
-      case "low_value_moments":
-      case "low value moment":
-      case "low value moments":
-        type = "low_value";
-        severity = "low";
-        description = "Idle Time Detected";
-        break;
-      case "sop_deviation":
-        type = "missing_quality_check";
-        severity = "high";
-        description = "SOP Deviations";
-        break;
-      case "long_cycle_time":
-        severity = "high";
-        type = "long_cycle_time";
-        description = "Long Cycle Time Detected";
-        break;
-      case "best_cycle_time":
-        type = "best_cycle_time";
-        severity = "low";
-        description = "Best Cycle Time Performance";
-        break;
-      case "worst_cycle_time":
-        type = "worst_cycle_time";
-        severity = "high";
-        description = "Worst Cycle Time Performance";
-        break;
-      case "cycle_completion":
-      case "completed_cycles":
-      case "completed_cycle":
-        type = "cycle_completion";
-        severity = "low";
-        description = "Cycle Completion";
-        break;
-      case "running_cycle":
-      case "active_cycle":
-      case "production_cycle":
-        type = "running_cycle";
-        severity = "low";
-        description = "Active Production Cycle";
-        break;
-      case "setup_state":
-      case "machine_setup":
-      case "line_setup":
-        type = "setup_state";
-        severity = "medium";
-        description = "Machine Setup Activity";
-        break;
-      case "medium_bottleneck":
-        severity = "medium";
-        description = "Medium Bottleneck Identified";
-        break;
-      case "minor_bottleneck":
-      case "mild_bottleneck":
-        severity = "low";
-        description = "Minor Bottleneck Identified";
-        break;
-      default:
-        if (normalizedViolationType.includes("sop") && normalizedViolationType.includes("deviation")) {
-          type = "missing_quality_check";
-          severity = "high";
-          description = "SOP Deviations";
-        } else if (normalizedViolationType.includes("worst") && normalizedViolationType.includes("cycle")) {
-          type = "worst_cycle_time";
-          severity = "high";
-          description = "Worst Cycle Time Performance";
-        } else if (normalizedViolationType.includes("best") && normalizedViolationType.includes("cycle")) {
-          type = "best_cycle_time";
-          severity = "low";
-          description = "Best Cycle Time Performance";
-        } else if (normalizedViolationType.includes("long") && normalizedViolationType.includes("cycle")) {
-          type = "long_cycle_time";
-          severity = "high";
-          description = "Long Cycle Time Detected";
-        } else if (normalizedViolationType.includes("cycle") && (normalizedViolationType.includes("completion") || normalizedViolationType.includes("complete"))) {
-          type = "cycle_completion";
-          severity = "low";
-          description = "Cycle Completion";
-        } else if (normalizedViolationType.includes("running") && normalizedViolationType.includes("cycle")) {
-          type = "running_cycle";
-          severity = "low";
-          description = "Active Production Cycle";
-        } else if (normalizedViolationType.includes("setup") || normalizedViolationType.includes("machine") && normalizedViolationType.includes("setup")) {
-          type = "setup_state";
-          severity = "medium";
-          description = "Machine Setup Activity";
-        } else {
-          description = `Clip type: ${violationType.replace(/_/g, " ")}`;
-          console.log(`Detected unknown violation type: ${violationType} in URI: ${s3Uri}`);
-        }
-        break;
-    }
-    return { timestamp, severity, description, type, originalUri: s3Uri };
-  } catch (error) {
-    console.error(`Error parsing S3 URI: ${s3Uri}`, error);
-    return null;
-  }
-}
-function shuffleArray(array) {
-  const shuffled = [...array];
-  for (let i = shuffled.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
-  }
-  return shuffled;
-}
-var SmartVideoCache = class extends events.EventEmitter {
-  constructor() {
-    super();
-    this.metrics = {
-      hits: 0,
-      misses: 0,
-      evictions: 0,
-      totalSize: 0,
-      entryCount: 0,
-      hitRate: 0
-    };
-    this.setMaxListeners(50);
-  }
-  /**
-   * DISABLED - Always returns null
-   */
-  async getSummary(key) {
-    this.metrics.misses++;
-    this.updateHitRate();
-    return null;
-  }
-  /**
-   * DISABLED - Does nothing
-   */
-  async setSummary(key, summary) {
-  }
-  /**
-   * DISABLED - Always returns null
-   */
-  async getVideos(key) {
-    this.metrics.misses++;
-    this.updateHitRate();
-    return null;
-  }
-  /**
-   * DISABLED - Does nothing
-   */
-  async setVideos(key, videos) {
-  }
-  /**
-   * DISABLED - Always returns null
-   */
-  async getClipCounts(key) {
-    console.log("[SmartVideoCache] DISABLED - Returning null for clip counts");
-    this.metrics.misses++;
-    this.updateHitRate();
-    return null;
-  }
-  /**
-   * DISABLED - Does nothing
-   */
-  async setClipCounts(key, clipCountsWithIndex, ttlMinutes) {
-    console.log("[SmartVideoCache] DISABLED - Not caching clip counts");
-  }
-  /**
-   * DISABLED - Does nothing
-   */
-  setPrefetchStatus(key, status) {
-  }
-  /**
-   * DISABLED - Always returns NONE
-   */
-  getPrefetchStatus(key) {
-    return "none" /* NONE */;
-  }
-  /**
-   * DISABLED - Always returns false
-   */
-  isPrefetchReady(key) {
-    return false;
-  }
-  /**
-   * DISABLED - Returns empty cleanup function
-   */
-  subscribeToPrefetchStatus(key, callback) {
-    return () => {
-    };
-  }
-  /**
-   * DISABLED - Always returns null
-   */
-  getSignedUrl(s3Uri) {
-    this.metrics.misses++;
-    this.updateHitRate();
-    return null;
-  }
-  /**
-   * DISABLED - Does nothing
-   */
-  setSignedUrl(s3Uri, url, ttlSeconds = 3600) {
-  }
-  /**
-   * DISABLED - Always returns empty array
-   */
-  async getVideosByWorkspace(workspaceId) {
-    return [];
-  }
-  /**
-   * DISABLED - Does nothing
-   */
-  async warmup(entries) {
-  }
-  /**
-   * Get cache statistics (mostly zeros since cache is disabled)
-   */
-  getStats() {
-    return {
-      ...this.metrics,
-      summaryStats: { hits: 0, misses: this.metrics.misses, evictions: 0, totalSize: 0 },
-      videoStats: { hits: 0, misses: this.metrics.misses, evictions: 0, totalSize: 0 },
-      clipCountsStats: { hits: 0, misses: this.metrics.misses, evictions: 0, totalSize: 0 },
-      urlCacheSize: 0
-    };
-  }
-  /**
-   * DISABLED - Does nothing
-   */
-  clear(type) {
-    this.removeAllListeners();
-  }
-  /**
-   * Update hit rate metric
-   */
-  updateHitRate() {
-    const total = this.metrics.hits + this.metrics.misses;
-    this.metrics.hitRate = total > 0 ? this.metrics.hits / total : 0;
-  }
-  /**
-   * Export cache state for debugging (returns empty state)
-   */
-  exportState() {
-    return {
-      summaries: [],
-      videos: [],
-      urls: [],
-      metrics: this.getStats()
-    };
-  }
-};
-var smartVideoCache = new SmartVideoCache();
-if (typeof window !== "undefined") {
-  window.addEventListener("beforeunload", () => {
-    console.log("[SmartVideoCache] Cache disabled - no cleanup needed");
-  });
-}
 var getSupabaseClient = () => {
   const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
   const key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
@@ -3933,616 +3614,6 @@ var getAuthToken = async () => {
   try {
     const supabase = getSupabaseClient();
     const { data: { session } } = await supabase.auth.getSession();
-    return session?.access_token || null;
-  } catch (error) {
-    console.error("[S3ClipsAPIClient] Error getting auth token:", error);
-    return null;
-  }
-};
-var S3ClipsAPIClient = class {
-  constructor(sopCategories) {
-    this.baseUrl = "/api/clips";
-    this.requestCache = /* @__PURE__ */ new Map();
-    this.sopCategories = sopCategories;
-    console.log("[S3ClipsAPIClient] \u2705 Initialized - Using secure API routes (no direct S3 access)");
-  }
-  /**
-   * Fetch with authentication and error handling
-   */
-  async fetchWithAuth(endpoint, body) {
-    const token = await getAuthToken();
-    if (!token) {
-      throw new Error("Authentication required");
-    }
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Authorization": `Bearer ${token}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: "Request failed" }));
-      throw new Error(error.error || `API error: ${response.status}`);
-    }
-    return response.json();
-  }
-  /**
-   * Deduplicate requests to prevent multiple API calls
-   */
-  async deduplicate(key, factory) {
-    if (this.requestCache.has(key)) {
-      console.log(`[S3ClipsAPIClient] Deduplicating request: ${key}`);
-      return this.requestCache.get(key);
-    }
-    const promise = factory().finally(() => {
-      this.requestCache.delete(key);
-    });
-    this.requestCache.set(key, promise);
-    return promise;
-  }
-  /**
-   * List S3 clips
-   */
-  async listS3Clips(params) {
-    const cacheKey = `list:${JSON.stringify(params)}`;
-    return this.deduplicate(cacheKey, async () => {
-      const response = await this.fetchWithAuth(this.baseUrl, {
-        action: "list",
-        workspaceId: params.workspaceId,
-        date: params.date,
-        shift: params.shiftId,
-        maxKeys: params.maxKeys
-      });
-      return response.clips.map((clip) => clip.originalUri);
-    });
-  }
-  /**
-   * Get clip counts
-   */
-  async getClipCounts(workspaceId, date, shiftId) {
-    const cacheKey = `counts:${workspaceId}:${date}:${shiftId}`;
-    return this.deduplicate(cacheKey, async () => {
-      const response = await this.fetchWithAuth(this.baseUrl, {
-        action: "count",
-        workspaceId,
-        date,
-        shift: shiftId.toString()
-      });
-      return response.counts;
-    });
-  }
-  /**
-   * Get clip counts with index (for compatibility)
-   */
-  async getClipCountsWithIndex(workspaceId, date, shiftId) {
-    const counts = await this.getClipCounts(workspaceId, date, shiftId.toString());
-    const videoIndex = {
-      byCategory: /* @__PURE__ */ new Map(),
-      allVideos: [],
-      counts,
-      workspaceId,
-      date,
-      shiftId: shiftId.toString(),
-      lastUpdated: /* @__PURE__ */ new Date()
-    };
-    return { counts, videoIndex };
-  }
-  /**
-   * Get metadata for a video
-   */
-  async getMetadata(playlistUri) {
-    const cacheKey = `metadata:${playlistUri}`;
-    return this.deduplicate(cacheKey, async () => {
-      const response = await this.fetchWithAuth(this.baseUrl, {
-        action: "metadata",
-        playlistUri
-      });
-      return response.metadata;
-    });
-  }
-  /**
-   * Get metadata cycle time
-   */
-  async getMetadataCycleTime(playlistUri) {
-    const metadata = await this.getMetadata(playlistUri);
-    return metadata?.cycle_time_seconds || null;
-  }
-  /**
-   * Get first clip for category
-   */
-  async getFirstClipForCategory(workspaceId, date, shiftId, category) {
-    const cacheKey = `first:${workspaceId}:${date}:${shiftId}:${category}`;
-    return this.deduplicate(cacheKey, async () => {
-      const response = await this.fetchWithAuth(this.baseUrl, {
-        action: "first",
-        workspaceId,
-        date,
-        shift: shiftId.toString(),
-        category,
-        sopCategories: this.sopCategories
-      });
-      return response.video;
-    });
-  }
-  /**
-   * Get clip by index
-   */
-  async getClipByIndex(workspaceId, date, shiftId, category, index, includeCycleTime = true, includeMetadata = false) {
-    const cacheKey = `by-index:${workspaceId}:${date}:${shiftId}:${category}:${index}`;
-    return this.deduplicate(cacheKey, async () => {
-      const response = await this.fetchWithAuth(this.baseUrl, {
-        action: "by-index",
-        workspaceId,
-        date,
-        shift: shiftId.toString(),
-        category,
-        index,
-        sopCategories: this.sopCategories
-      });
-      const video = response.video;
-      if (video && includeMetadata && video.originalUri) {
-        try {
-          const metadata = await this.getMetadata(video.originalUri);
-          if (metadata) {
-            video.cycle_time_seconds = metadata.cycle_time_seconds;
-            video.creation_timestamp = metadata.creation_timestamp;
-          }
-        } catch (error) {
-          console.warn("[S3ClipsAPIClient] Failed to fetch metadata:", error);
-        }
-      }
-      return video;
-    });
-  }
-  /**
-   * Get videos page with pagination
-   */
-  async getVideosPage(workspaceId, date, shiftId, category, pageSize = 5, startAfter) {
-    const cacheKey = `page:${workspaceId}:${date}:${shiftId}:${category}:${pageSize}:${startAfter || "first"}`;
-    return this.deduplicate(cacheKey, async () => {
-      const response = await this.fetchWithAuth(this.baseUrl, {
-        action: "page",
-        workspaceId,
-        date,
-        shift: shiftId.toString(),
-        category,
-        pageSize,
-        startAfter,
-        sopCategories: this.sopCategories
-      });
-      return {
-        videos: response.videos,
-        nextToken: response.nextToken,
-        hasMore: response.hasMore
-      };
-    });
-  }
-  /**
-   * Batch fetch multiple videos in parallel
-   */
-  async batchFetchVideos(workspaceId, date, shiftId, requests) {
-    const batchKey = `batch:${workspaceId}:${date}:${shiftId}:${requests.length}`;
-    return this.deduplicate(batchKey, async () => {
-      const response = await this.fetchWithAuth("/api/clips/batch", {
-        workspaceId,
-        date,
-        shift: shiftId.toString(),
-        requests,
-        sopCategories: this.sopCategories
-      });
-      console.log(`[S3ClipsAPIClient] Batch fetched ${response.videos.length} videos in ${response.performance.duration}ms`);
-      return response.videos;
-    });
-  }
-  /**
-   * Convert S3 URI to CloudFront URL
-   * In the API client, URLs are already signed from the server
-   */
-  s3UriToCloudfront(s3Uri) {
-    return s3Uri;
-  }
-  /**
-   * Clean up resources
-   */
-  dispose() {
-    this.requestCache.clear();
-  }
-  /**
-   * Get service statistics
-   */
-  getStats() {
-    return {
-      requestCache: {
-        pendingCount: this.requestCache.size,
-        maxSize: 1e3
-      }
-    };
-  }
-};
-
-// src/lib/api/s3-clips-secure.ts
-var S3ClipsService = class {
-  constructor(config) {
-    // Flags for compatibility
-    this.isIndexBuilding = false;
-    this.isPrefetching = false;
-    this.currentMetadataFetches = 0;
-    this.MAX_CONCURRENT_METADATA = 3;
-    this.config = config;
-    if (!config.s3Config) {
-      throw new Error("S3 configuration is required");
-    }
-    const sopCategories = config.s3Config.sopCategories?.default;
-    this.apiClient = new S3ClipsAPIClient(sopCategories);
-    const processing = config.s3Config.processing || {};
-    this.defaultLimitPerCategory = processing.defaultLimitPerCategory || 30;
-    this.maxLimitPerCategory = processing.maxLimitPerCategory || 1e3;
-    this.concurrencyLimit = processing.concurrencyLimit || 10;
-    this.maxInitialFetch = processing.maxInitialFetch || 60;
-    console.log("[S3ClipsService] \u2705 Initialized with secure API client - AWS credentials are now server-side only!");
-  }
-  /**
-   * Lists S3 clips using API
-   */
-  async listS3Clips(params) {
-    const { workspaceId, date, shiftId } = params;
-    if (!isValidShiftId(shiftId)) {
-      console.error(`[S3ClipsService] Invalid shift ID: ${shiftId}`);
-      return [];
-    }
-    console.log(`[S3ClipsService] Listing clips via API for workspace: ${workspaceId}`);
-    try {
-      return await this.apiClient.listS3Clips(params);
-    } catch (error) {
-      console.error("[S3ClipsService] Error listing clips:", error);
-      return [];
-    }
-  }
-  /**
-   * Get metadata cycle time
-   */
-  async getMetadataCycleTime(playlistUri) {
-    try {
-      return await this.apiClient.getMetadataCycleTime(playlistUri);
-    } catch (error) {
-      console.error("[S3ClipsService] Error fetching metadata cycle time:", error);
-      return null;
-    }
-  }
-  /**
-   * Control prefetch mode
-   */
-  setPrefetchMode(enabled) {
-    this.isPrefetching = enabled;
-    console.log(`[S3ClipsService] Prefetch mode ${enabled ? "enabled" : "disabled"}`);
-  }
-  /**
-   * Get full metadata
-   */
-  async getFullMetadata(playlistUri) {
-    if (this.isIndexBuilding || this.isPrefetching) {
-      console.warn("[S3ClipsService] Skipping metadata - operation in progress");
-      return null;
-    }
-    if (this.currentMetadataFetches >= this.MAX_CONCURRENT_METADATA) {
-      console.warn("[S3ClipsService] Skipping metadata - max concurrent fetches reached");
-      return null;
-    }
-    this.currentMetadataFetches++;
-    try {
-      return await this.apiClient.getMetadata(playlistUri);
-    } catch (error) {
-      console.error("[S3ClipsService] Error fetching metadata:", error);
-      return null;
-    } finally {
-      this.currentMetadataFetches--;
-    }
-  }
-  /**
-   * Convert S3 URI to CloudFront URL
-   * URLs from API are already signed
-   */
-  s3UriToCloudfront(s3Uri) {
-    if (s3Uri.startsWith("http")) {
-      return s3Uri;
-    }
-    console.warn("[S3ClipsService] Unexpected S3 URI in secure mode:", s3Uri);
-    return s3Uri;
-  }
-  /**
-   * Get SOP categories for workspace
-   */
-  getSOPCategories(workspaceId) {
-    const sopConfig = this.config.s3Config?.sopCategories;
-    if (!sopConfig) return void 0;
-    if (sopConfig.workspaceOverrides && sopConfig.workspaceOverrides[workspaceId]) {
-      return sopConfig.workspaceOverrides[workspaceId];
-    }
-    return sopConfig.default;
-  }
-  async getClipCounts(workspaceId, date, shiftId, buildIndex) {
-    if (!isValidShiftId(shiftId)) {
-      console.error(`[S3ClipsService] Invalid shift ID: ${shiftId}`);
-      return buildIndex ? { counts: {}, videoIndex: this.createEmptyVideoIndex(workspaceId, date, shiftId.toString()) } : {};
-    }
-    try {
-      if (buildIndex) {
-        const result = await this.apiClient.getClipCountsWithIndex(workspaceId, date, shiftId);
-        const cacheKey = `clip-counts:${workspaceId}:${date}:${shiftId}`;
-        await smartVideoCache.setClipCounts(cacheKey, result);
-        return result;
-      } else {
-        const counts = await this.apiClient.getClipCounts(workspaceId, date, shiftId);
-        return counts;
-      }
-    } catch (error) {
-      console.error("[S3ClipsService] Error fetching clip counts:", error);
-      return buildIndex ? { counts: {}, videoIndex: this.createEmptyVideoIndex(workspaceId, date, shiftId.toString()) } : {};
-    }
-  }
-  async getClipCountsCacheFirst(workspaceId, date, shiftId, buildIndex) {
-    const cacheKey = `clip-counts:${workspaceId}:${date}:${shiftId}`;
-    const cachedResult = await smartVideoCache.getClipCounts(cacheKey);
-    if (cachedResult) {
-      console.log("[S3ClipsService] Using cached clip counts");
-      return buildIndex ? cachedResult : cachedResult.counts;
-    }
-    console.log("[S3ClipsService] Cache miss - fetching from API");
-    return buildIndex ? this.getClipCounts(workspaceId, date, shiftId, true) : this.getClipCounts(workspaceId, date, shiftId);
-  }
-  /**
-   * Get first clip for category
-   */
-  async getFirstClipForCategory(workspaceId, date, shiftId, category) {
-    if (!isValidShiftId(shiftId)) {
-      console.error(`[S3ClipsService] Invalid shift ID: ${shiftId}`);
-      return null;
-    }
-    try {
-      return await this.apiClient.getFirstClipForCategory(workspaceId, date, shiftId, category);
-    } catch (error) {
-      console.error("[S3ClipsService] Error fetching first clip:", error);
-      return null;
-    }
-  }
-  /**
-   * Get video from index (for compatibility)
-   */
-  async getVideoFromIndex(videoIndex, category, index, includeCycleTime = true, includeMetadata = true) {
-    const { workspaceId, date, shiftId } = videoIndex;
-    return this.getClipByIndex(
-      workspaceId,
-      date,
-      shiftId,
-      category,
-      index,
-      includeCycleTime,
-      includeMetadata
-    );
-  }
-  /**
-   * Get clip by index
-   */
-  async getClipByIndex(workspaceId, date, shiftId, category, index, includeCycleTime = true, includeMetadata = false) {
-    try {
-      return await this.apiClient.getClipByIndex(
-        workspaceId,
-        date,
-        shiftId,
-        category,
-        index,
-        includeCycleTime,
-        includeMetadata
-      );
-    } catch (error) {
-      console.error("[S3ClipsService] Error fetching clip by index:", error);
-      return null;
-    }
-  }
-  /**
-   * Process full video (for compatibility)
-   */
-  async processFullVideo(uri, index, workspaceId, date, shiftId, includeCycleTime, includeMetadata = false) {
-    const sopCategories = this.getSOPCategories(workspaceId);
-    const parsedInfo = parseS3Uri(uri, sopCategories);
-    if (!parsedInfo) {
-      console.warn(`Skipping URI due to parsing failure: ${uri}`);
-      return null;
-    }
-    const video = {
-      id: `${workspaceId}-${date}-${shiftId}-${index}`,
-      src: uri,
-      // Already signed from API
-      ...parsedInfo,
-      originalUri: uri
-    };
-    if (includeMetadata) {
-      const metadata = await this.getFullMetadata(uri);
-      if (metadata) {
-        video.cycle_time_seconds = metadata.original_task_metadata?.cycle_time;
-        video.creation_timestamp = metadata.upload_timestamp || metadata.original_task_metadata?.timestamp || metadata.creation_timestamp;
-      }
-    }
-    return video;
-  }
-  /**
-   * Fetch clips (main method for compatibility)
-   */
-  async fetchClips(params) {
-    const {
-      workspaceId,
-      date: inputDate,
-      shift,
-      category,
-      limit,
-      offset = 0,
-      mode
-    } = params;
-    if (!workspaceId) {
-      throw new Error("Valid Workspace ID is required");
-    }
-    const date = inputDate || getOperationalDate(
-      this.config.dateTimeConfig?.defaultTimezone || "Asia/Kolkata",
-      /* @__PURE__ */ new Date(),
-      this.config.shiftConfig?.dayShift?.startTime || "06:00"
-    );
-    if (!isValidDateFormat(date)) {
-      throw new Error("Invalid date format. Use YYYY-MM-DD.");
-    }
-    let shiftId;
-    if (shift !== void 0) {
-      if (!isValidShiftId(shift)) {
-        throw new Error("Invalid shift value. Must be 0 (day) or 1 (night).");
-      }
-      shiftId = parseInt(shift, 10);
-    } else {
-      const { shiftId: currentShiftId } = getCurrentShift(
-        this.config.dateTimeConfig?.defaultTimezone || "Asia/Kolkata",
-        this.config.shiftConfig
-      );
-      shiftId = currentShiftId;
-    }
-    console.log(`[S3ClipsService] Fetching clips for workspace ${workspaceId}`);
-    if (mode === "summary") {
-      const counts = await this.getClipCounts(workspaceId, date, shiftId.toString());
-      return { counts, samples: {} };
-    }
-    const effectiveLimit = limit || this.defaultLimitPerCategory;
-    const result = await this.getVideosPage(
-      workspaceId,
-      date,
-      shiftId,
-      category || "all",
-      effectiveLimit
-    );
-    return result.videos;
-  }
-  /**
-   * Batch fetch multiple videos in parallel
-   */
-  async batchFetchVideos(workspaceId, date, shiftId, requests) {
-    try {
-      const results = await this.apiClient.batchFetchVideos(
-        workspaceId,
-        date,
-        shiftId,
-        requests
-      );
-      return results.map((r2) => r2.video).filter((v) => v !== null);
-    } catch (error) {
-      console.error("[S3ClipsService] Error batch fetching videos:", error);
-      return [];
-    }
-  }
-  /**
-   * Get videos page using pagination API
-   */
-  async getVideosPage(workspaceId, date, shiftId, category, pageSize = 5, startAfter) {
-    try {
-      return await this.apiClient.getVideosPage(
-        workspaceId,
-        date,
-        shiftId,
-        category,
-        pageSize,
-        startAfter
-      );
-    } catch (error) {
-      console.error("[S3ClipsService] Error fetching videos page:", error);
-      return { videos: [], hasMore: false };
-    }
-  }
-  /**
-   * Create empty video index for compatibility
-   */
-  createEmptyVideoIndex(workspaceId, date, shiftId) {
-    return {
-      byCategory: /* @__PURE__ */ new Map(),
-      allVideos: [],
-      counts: {},
-      workspaceId,
-      date,
-      shiftId,
-      lastUpdated: /* @__PURE__ */ new Date(),
-      _debugId: `empty_${Date.now()}`
-    };
-  }
-  /**
-   * Get clip by ID
-   */
-  async getClipById(clipId, sopCategories) {
-    console.log(`[S3ClipsService] Getting clip by ID: ${clipId} (Note: This is a fallback implementation)`);
-    try {
-      const parts = clipId.split("-");
-      if (parts.length >= 5) {
-        const workspaceId = parts[0];
-        const date = parts[1];
-        const shift = parts[2];
-        const category = parts[3];
-        const index = parseInt(parts[4], 10);
-        if (!isNaN(index)) {
-          return await this.getClipByIndex(workspaceId, date, shift, category, index, true, false);
-        }
-      }
-      console.warn(`[S3ClipsService] Could not parse clipId: ${clipId}`);
-      return null;
-    } catch (error) {
-      console.error("[S3ClipsService] Error getting clip by ID:", error);
-      return null;
-    }
-  }
-  /**
-   * Get neighboring clips
-   */
-  async getNeighboringClips(workspaceId, date, shiftId, category, currentClipId, sopCategories) {
-    console.log(`[S3ClipsService] Getting neighboring clips for ID: ${currentClipId} (Note: This is a fallback implementation)`);
-    try {
-      const parts = currentClipId.split("-");
-      if (parts.length >= 5) {
-        const index = parseInt(parts[4], 10);
-        if (!isNaN(index)) {
-          const [previous, next] = await Promise.all([
-            index > 0 ? this.getClipByIndex(workspaceId, date, shiftId, category, index - 1, true, false) : null,
-            this.getClipByIndex(workspaceId, date, shiftId, category, index + 1, true, false)
-          ]);
-          return { previous, next };
-        }
-      }
-      console.warn(`[S3ClipsService] Could not parse currentClipId: ${currentClipId}`);
-      return { previous: null, next: null };
-    } catch (error) {
-      console.error("[S3ClipsService] Error getting neighboring clips:", error);
-      return { previous: null, next: null };
-    }
-  }
-  /**
-   * Cleanup
-   */
-  dispose() {
-    console.log("[S3ClipsService] Disposing service");
-    this.apiClient.dispose();
-  }
-  /**
-   * Get statistics
-   */
-  getStats() {
-    return this.apiClient.getStats();
-  }
-};
-var getSupabaseClient2 = () => {
-  const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
-  const key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
-  if (!url || !key) {
-    throw new Error("Supabase configuration missing");
-  }
-  return supabaseJs.createClient(url, key);
-};
-var getAuthToken2 = async () => {
-  try {
-    const supabase = getSupabaseClient2();
-    const { data: { session } } = await supabase.auth.getSession();
     console.log("[S3ClipsSupabase] Auth session exists:", !!session, "has token:", !!session?.access_token);
     return session?.access_token || null;
   } catch (error) {
@@ -4573,7 +3644,7 @@ var S3ClipsSupabaseService = class {
    * Fetch with authentication and error handling
    */
   async fetchWithAuth(endpoint, body) {
-    const token = await getAuthToken2();
+    const token = await getAuthToken();
     if (!token) {
       throw new Error("Authentication required");
     }
@@ -5036,7 +4107,8 @@ var S3ClipsSupabaseService = class {
     return descriptions[clipType] || "Analysis Clip";
   }
 };
-var S3ClipsService2 = S3ClipsSupabaseService ;
+
+// src/lib/services/videoPrefetchManager.ts
 var VideoPrefetchManager = class extends events.EventEmitter {
   constructor() {
     super();
@@ -5050,7 +4122,7 @@ var VideoPrefetchManager = class extends events.EventEmitter {
   getS3Service(dashboardConfig) {
     const configKey = JSON.stringify(dashboardConfig.s3Config);
     if (!this.s3Services.has(configKey)) {
-      this.s3Services.set(configKey, new S3ClipsService2(dashboardConfig));
+      this.s3Services.set(configKey, new S3ClipsSupabaseService(dashboardConfig));
     }
     return this.s3Services.get(configKey);
   }
@@ -22835,32 +21907,10 @@ var VideoGridView = React20__namespace.default.memo(({
       observerRef.current?.disconnect();
     };
   }, [filteredWorkspaces]);
-  const prefetchCacheRef = React20.useRef({});
+  React20.useRef({});
   const handleWorkspaceClick = React20.useCallback((workspace) => {
     const workspaceId = workspace.workspace_uuid || workspace.workspace_name;
-    if (dashboardConfig?.s3Config && workspaceId) {
-      const operationalDate = getOperationalDate(dashboardConfig.dateTimeConfig?.defaultTimezone);
-      const fullKey = `${workspaceId}-${operationalDate}-all-all-meta-1000--`;
-      if (!prefetchCacheRef.current[fullKey]?.status) {
-        const clipsService = new S3ClipsService(dashboardConfig);
-        const fullPromise = clipsService.fetchClips({
-          workspaceId,
-          date: operationalDate,
-          mode: "full",
-          includeCycleTime: true,
-          includeMetadata: true,
-          limit: 1e3
-        });
-        prefetchCacheRef.current[fullKey] = { status: "pending", promise: fullPromise };
-        fullPromise.then((data) => {
-          prefetchCacheRef.current[fullKey] = { status: "resolved", data };
-          console.log(`Prefetched full clips data for workspace ${workspaceId}`);
-        }).catch((error) => {
-          prefetchCacheRef.current[fullKey] = { status: "rejected", error };
-          console.warn(`Failed to prefetch full clips for workspace ${workspaceId}:`, error);
-        });
-      }
-    }
+    console.log(`[VideoGridView] Prefetching disabled for workspace ${workspaceId}`);
     trackCoreEvent("Workspace Detail Clicked", {
       workspace_name: workspace.workspace_name,
       workspace_id: workspaceId,
@@ -28917,7 +27967,7 @@ var NewClipsNotification = ({
     }
   );
 };
-var getSupabaseClient3 = () => {
+var getSupabaseClient2 = () => {
   const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
   const key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY;
   if (!url || !key) {
@@ -28925,9 +27975,9 @@ var getSupabaseClient3 = () => {
   }
   return supabaseJs.createClient(url, key);
 };
-var getAuthToken3 = async () => {
+var getAuthToken2 = async () => {
   try {
-    const supabase = getSupabaseClient3();
+    const supabase = getSupabaseClient2();
     const { data: { session } } = await supabase.auth.getSession();
     return session?.access_token || null;
   } catch (error) {
@@ -28948,7 +27998,7 @@ function useWorkspaceCrop(workspaceId) {
       setIsLoading(true);
       setError(null);
       try {
-        const token = await getAuthToken3();
+        const token = await getAuthToken2();
         if (!token) {
           throw new Error("Authentication required");
         }
@@ -29101,7 +28151,7 @@ var FileManagerFilters = ({
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "Authorization": `Bearer ${await getAuthToken4()}`
+          "Authorization": `Bearer ${await getAuthToken3()}`
         },
         body: JSON.stringify({
           action: "clip-metadata",
@@ -29134,10 +28184,10 @@ var FileManagerFilters = ({
       });
     }
   }, [workspaceId, date, shift]);
-  const getAuthToken4 = async () => {
+  const getAuthToken3 = async () => {
     try {
-      const { createClient: createClient5 } = await import('@supabase/supabase-js');
-      const supabase = createClient5(
+      const { createClient: createClient4 } = await import('@supabase/supabase-js');
+      const supabase = createClient4(
         process.env.NEXT_PUBLIC_SUPABASE_URL || "",
         process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || ""
       );
@@ -29160,7 +28210,7 @@ var FileManagerFilters = ({
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "Authorization": `Bearer ${await getAuthToken4()}`
+          "Authorization": `Bearer ${await getAuthToken3()}`
         },
         body: JSON.stringify({
           action: "percentile-clips",
@@ -29903,8 +28953,6 @@ function useClipsRealtimeUpdates({
     hasNewClips: newClipsNotification !== null && newClipsNotification.count > 0
   };
 }
-var USE_SUPABASE_CLIPS2 = true;
-var S3ClipsService3 = S3ClipsSupabaseService ;
 var BottlenecksContent = ({
   workspaceId,
   workspaceName,
@@ -29962,8 +29010,8 @@ var BottlenecksContent = ({
     workspaceId,
     date: date || getOperationalDate(),
     shiftId: effectiveShift,
-    enabled: USE_SUPABASE_CLIPS2,
-    // Only enable for Supabase implementation
+    enabled: true,
+    // Supabase implementation
     onNewClips: (notification) => {
       console.log(`[BottlenecksContent] New clips detected:`, notification);
       if (notification.clips.length > 0) {
@@ -29988,7 +29036,7 @@ var BottlenecksContent = ({
       console.warn("S3 configuration not found in dashboard config");
       return null;
     }
-    return new S3ClipsService3(dashboardConfig);
+    return new S3ClipsSupabaseService(dashboardConfig);
   }, [dashboardConfig]);
   const {
     clipTypes,
@@ -30009,8 +29057,7 @@ var BottlenecksContent = ({
     dynamicCounts,
     workspaceId,
     date: date || getOperationalDate(),
-    shift: shift || "0",
-    USE_SUPABASE_CLIPS: USE_SUPABASE_CLIPS2
+    shift: shift || "0"
   });
   React20.useEffect(() => {
     if (clipTypes.length > 0 && !initialFilter) {
@@ -30118,12 +29165,8 @@ var BottlenecksContent = ({
             operationalDate,
             shiftStr,
             targetCategory,
-            0,
+            0
             // First video (index 0)
-            true,
-            // includeCycleTime
-            true
-            // includeMetadata
           );
           if (firstVideo && isMountedRef.current) {
             console.log(`[BottlenecksContent] Successfully loaded first video via index`);
@@ -30267,8 +29310,8 @@ var BottlenecksContent = ({
       if (isPercentileCategory(categoryId)) {
         console.log(`[BottlenecksContent] Loading percentile category: ${categoryId}`);
         const percentileType = categoryId === "fast-cycles" ? "fast-cycles" : categoryId === "slow-cycles" ? "slow-cycles" : "idle-times";
-        const { createClient: createClient5 } = await import('@supabase/supabase-js');
-        const supabase = createClient5(
+        const { createClient: createClient4 } = await import('@supabase/supabase-js');
+        const supabase = createClient4(
           process.env.NEXT_PUBLIC_SUPABASE_URL || "",
           process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || ""
         );
@@ -30340,9 +29383,7 @@ var BottlenecksContent = ({
         operationalDate,
         shiftStr,
         categoryId,
-        clipIndex,
-        true,
-        true
+        clipIndex
       );
       if (video?.id) {
         await loadAndPlayClipById(video.id, categoryId);
@@ -44506,6 +43547,177 @@ var streamProxyConfig = {
   }
 };
 
+// src/lib/api/s3-clips-parser.ts
+function parseS3Uri(s3Uri, sopCategories) {
+  const path = new URL(s3Uri).pathname;
+  const parts = path.split("/").filter((p) => p);
+  if (s3Uri.includes("missed_qchecks")) {
+    console.warn(`Skipping missed_qchecks URI in parseS3Uri: ${s3Uri}`);
+    return null;
+  }
+  if (parts.length < 8) {
+    console.warn(`Invalid S3 path structure: ${s3Uri} - Too few parts: ${parts.length}, expected at least 8`);
+    return null;
+  }
+  try {
+    const datePart = parts[2];
+    const shiftPart = parts[3];
+    const violationType = parts[4];
+    let folderName = "";
+    let timestamp = "";
+    for (let i = 5; i < parts.length; i++) {
+      const part = parts[i];
+      if (part && part.includes("_") && /\d{8}_\d{6}/.test(part)) {
+        folderName = part;
+        const timeMatch = folderName.match(/_(\d{8})_(\d{6})_/);
+        if (timeMatch) {
+          timestamp = `${timeMatch[2].substring(0, 2)}:${timeMatch[2].substring(2, 4)}:${timeMatch[2].substring(4, 6)}`;
+          break;
+        }
+      }
+    }
+    if (!timestamp) {
+      console.warn(`Couldn't extract timestamp from any part: ${parts.join("/")}`);
+      timestamp = "00:00:00";
+    }
+    let severity = "low";
+    let type = "bottleneck";
+    let description = "Analysis Clip";
+    const normalizedViolationType = violationType.toLowerCase().trim();
+    if (sopCategories && sopCategories.length > 0) {
+      const matchedCategory = sopCategories.find((category) => {
+        const categoryId = category.id.toLowerCase();
+        const s3FolderName = (category.s3FolderName || category.id).toLowerCase();
+        return categoryId === normalizedViolationType || s3FolderName === normalizedViolationType || // Also check for partial matches for flexibility
+        normalizedViolationType.includes(categoryId) || normalizedViolationType.includes(s3FolderName);
+      });
+      if (matchedCategory) {
+        type = matchedCategory.id;
+        description = matchedCategory.description || matchedCategory.label;
+        if (matchedCategory.color.includes("red")) {
+          severity = "high";
+        } else if (matchedCategory.color.includes("yellow") || matchedCategory.color.includes("orange")) {
+          severity = "medium";
+        } else {
+          severity = "low";
+        }
+        console.log(`Matched SOP category: ${matchedCategory.id} for violation type: ${violationType}`);
+        return { timestamp, severity, description, type, originalUri: s3Uri };
+      }
+    }
+    switch (normalizedViolationType) {
+      case "idle_time":
+      case "idle":
+      case "low_value":
+      case "low value":
+      case "low_value_moment":
+      case "low_value_moments":
+      case "low value moment":
+      case "low value moments":
+        type = "low_value";
+        severity = "low";
+        description = "Idle Time Detected";
+        break;
+      case "sop_deviation":
+        type = "missing_quality_check";
+        severity = "high";
+        description = "SOP Deviations";
+        break;
+      case "long_cycle_time":
+        severity = "high";
+        type = "long_cycle_time";
+        description = "Long Cycle Time Detected";
+        break;
+      case "best_cycle_time":
+        type = "best_cycle_time";
+        severity = "low";
+        description = "Best Cycle Time Performance";
+        break;
+      case "worst_cycle_time":
+        type = "worst_cycle_time";
+        severity = "high";
+        description = "Worst Cycle Time Performance";
+        break;
+      case "cycle_completion":
+      case "completed_cycles":
+      case "completed_cycle":
+        type = "cycle_completion";
+        severity = "low";
+        description = "Cycle Completion";
+        break;
+      case "running_cycle":
+      case "active_cycle":
+      case "production_cycle":
+        type = "running_cycle";
+        severity = "low";
+        description = "Active Production Cycle";
+        break;
+      case "setup_state":
+      case "machine_setup":
+      case "line_setup":
+        type = "setup_state";
+        severity = "medium";
+        description = "Machine Setup Activity";
+        break;
+      case "medium_bottleneck":
+        severity = "medium";
+        description = "Medium Bottleneck Identified";
+        break;
+      case "minor_bottleneck":
+      case "mild_bottleneck":
+        severity = "low";
+        description = "Minor Bottleneck Identified";
+        break;
+      default:
+        if (normalizedViolationType.includes("sop") && normalizedViolationType.includes("deviation")) {
+          type = "missing_quality_check";
+          severity = "high";
+          description = "SOP Deviations";
+        } else if (normalizedViolationType.includes("worst") && normalizedViolationType.includes("cycle")) {
+          type = "worst_cycle_time";
+          severity = "high";
+          description = "Worst Cycle Time Performance";
+        } else if (normalizedViolationType.includes("best") && normalizedViolationType.includes("cycle")) {
+          type = "best_cycle_time";
+          severity = "low";
+          description = "Best Cycle Time Performance";
+        } else if (normalizedViolationType.includes("long") && normalizedViolationType.includes("cycle")) {
+          type = "long_cycle_time";
+          severity = "high";
+          description = "Long Cycle Time Detected";
+        } else if (normalizedViolationType.includes("cycle") && (normalizedViolationType.includes("completion") || normalizedViolationType.includes("complete"))) {
+          type = "cycle_completion";
+          severity = "low";
+          description = "Cycle Completion";
+        } else if (normalizedViolationType.includes("running") && normalizedViolationType.includes("cycle")) {
+          type = "running_cycle";
+          severity = "low";
+          description = "Active Production Cycle";
+        } else if (normalizedViolationType.includes("setup") || normalizedViolationType.includes("machine") && normalizedViolationType.includes("setup")) {
+          type = "setup_state";
+          severity = "medium";
+          description = "Machine Setup Activity";
+        } else {
+          description = `Clip type: ${violationType.replace(/_/g, " ")}`;
+          console.log(`Detected unknown violation type: ${violationType} in URI: ${s3Uri}`);
+        }
+        break;
+    }
+    return { timestamp, severity, description, type, originalUri: s3Uri };
+  } catch (error) {
+    console.error(`Error parsing S3 URI: ${s3Uri}`, error);
+    return null;
+  }
+}
+function shuffleArray(array) {
+  const shuffled = [...array];
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+  }
+  return shuffled;
+}
+
 exports.ACTION_NAMES = ACTION_NAMES;
 exports.AIAgentView = AIAgentView_default;
 exports.AdvancedFilterDialog = AdvancedFilterDialog;
@@ -44625,7 +43837,7 @@ exports.PrefetchStatus = PrefetchStatus;
 exports.PrefetchTimeoutError = PrefetchTimeoutError;
 exports.ProfileView = ProfileView_default;
 exports.RegistryProvider = RegistryProvider;
-exports.S3ClipsService = S3ClipsService;
+exports.S3ClipsService = S3ClipsSupabaseService;
 exports.S3Service = S3Service;
 exports.SKUManagementView = SKUManagementView;
 exports.SOPComplianceChart = SOPComplianceChart;