@meframe/core 0.0.29 → 0.0.30

package/dist/stages/load/ResourceLoader.js

@@ -1,9 +1,10 @@
+import { hasResourceId } from "../../model/types.js";
 import { TaskManager } from "./TaskManager.js";
 import { StreamFactory } from "./StreamFactory.js";
-import { EventHandlers } from "./EventHandlers.js";
 import { MeframeEvent } from "../../event/events.js";
 import { WindowByteRangeResolver } from "./WindowByteRangeResolver.js";
 import { createImageBitmapFromBlob } from "../../utils/image-utils.js";
+import { MP4IndexParser } from "../demux/MP4IndexParser.js";
 class ResourceConflictError extends Error {
   constructor(message) {
     super(message);
@@ -11,51 +12,89 @@ class ResourceConflictError extends Error {
   }
 }
 class ResourceLoader {
-  orchestrator;
+  cacheManager;
+  workerPool;
   model;
   taskManager;
   streamFactory;
-  eventHandlers;
   eventBus;
   onStateChange;
   byteRangeResolver;
   blobCache = /* @__PURE__ */ new Map();
   pendingTransfers = /* @__PURE__ */ new Map();
+  parsingIndexes = /* @__PURE__ */ new Set();
+  // Track in-progress index parsing
+  // Preloading state
+  isPreloadingEnabled = true;
+  preloadQueue = [];
+  activePreloads = /* @__PURE__ */ new Set();
+  // TODO: make this configurable
+  IDLE_PRELOAD_CONCURRENCY = 2;
   constructor(options) {
-    const maxConcurrent = options?.config?.maxConcurrent ?? 4;
+    const maxConcurrent = options.config?.maxConcurrent ?? 4;
     this.taskManager = new TaskManager(maxConcurrent);
-    this.streamFactory = new StreamFactory(options?.onProgress, options?.config);
-    this.eventBus = options?.eventBus;
-    this.onStateChange = options?.onStateChange;
+    this.streamFactory = new StreamFactory(options.onProgress, options.config);
+    this.eventBus = options.eventBus;
+    this.onStateChange = options.onStateChange;
     this.byteRangeResolver = new WindowByteRangeResolver();
-    if (options?.orchestrator) {
-      this.bind(options.orchestrator);
+    this.cacheManager = options.cacheManager;
+    this.workerPool = options.workerPool;
+  }
+  async setModel(model) {
+    this.model = model;
+    const mainTrack = model.tracks.find((track) => track.id === (model.mainTrackId || "main"));
+    if (mainTrack?.clips?.[0] && hasResourceId(mainTrack.clips[0])) {
+      await this.fetch(mainTrack.clips[0].resourceId, {
+        priority: "high",
+        clipId: mainTrack.clips[0].id,
+        trackId: mainTrack.id
+      });
     }
+    this.startPreloading();
   }
-  /**
-   * Bind to Orchestrator event system
-   */
-  bind(orchestrator) {
-    this.unbind();
-    this.orchestrator = orchestrator;
-    this.eventHandlers = new EventHandlers(
-      orchestrator,
-      (resourceId) => this.cancel(resourceId),
-      (model) => this.handleModelSet(model)
-    );
+  setPreloadingEnabled(enabled) {
+    this.isPreloadingEnabled = enabled;
+    if (enabled) {
+      this.startPreloading();
+    } else {
+      this.preloadQueue = [];
+    }
   }
-  /**
-   * Unbind from Orchestrator
-   */
-  unbind() {
-    this.eventHandlers?.dispose();
-    this.eventHandlers = void 0;
-    this.orchestrator = void 0;
+  startPreloading() {
+    if (!this.model || !this.isPreloadingEnabled) return;
+    const mainTrack = this.model.tracks.find(
+      (track) => track.id === (this.model?.mainTrackId || "main")
+    );
+    if (!mainTrack) return;
+    const newQueue = [];
+    for (const clip of mainTrack.clips) {
+      if (!hasResourceId(clip)) continue;
+      const resource = this.model.getResource(clip.resourceId);
+      if (!resource) continue;
+      if (!resource || resource.state === "ready" || resource.state === "loading" || resource.state === "error") {
+        continue;
+      }
+      if (this.activePreloads.has(resource.id) || this.taskManager.hasActiveTask(resource.id)) {
+        continue;
+      }
+      newQueue.push(resource.id);
+    }
+    this.preloadQueue = newQueue;
+    this.processPreloadQueue();
   }
-  handleModelSet(model) {
-    this.model = model;
+  processPreloadQueue() {
+    if (!this.isPreloadingEnabled || this.preloadQueue.length === 0) return;
+    while (this.activePreloads.size < this.IDLE_PRELOAD_CONCURRENCY && this.preloadQueue.length > 0) {
+      const resourceId = this.preloadQueue.shift();
+      if (!resourceId) break;
+      this.activePreloads.add(resourceId);
+      this.fetch(resourceId, { priority: "low" }).finally(() => {
+        this.activePreloads.delete(resourceId);
+        this.processPreloadQueue();
+      });
+    }
   }
-  enqueueLoad(resource, priority = "normal", sessionId, trackId, isMainTrack = false) {
+  enqueueLoad(resource, priority = "normal", sessionId, clipId, trackId, isMainTrack = false) {
     if (this.taskManager.hasActiveTask(resource.id)) {
       if (priority === "high") ;
       else if (isMainTrack) {
@@ -75,7 +114,7 @@ class ResourceLoader {
         }
       }
     }
-    this.taskManager.enqueue(resource, priority, sessionId, trackId);
+    this.taskManager.enqueue(resource, priority, sessionId, clipId, trackId);
     this.processQueue();
   }
   registerPendingTransfer(resourceId, sessionId) {
@@ -99,12 +138,25 @@ class ResourceLoader {
    */
   async startLoad(task) {
     this.taskManager.activateTask(task);
+    let loadError;
     try {
       this.updateResourceState(task.resourceId, "loading");
       task.controller = new AbortController();
       if (task.resource.type === "image") {
         await this.loadImageBitmap(task);
-      } else if (task.resource.type === "video" || task.resource.type === "audio") {
+      } else if (task.resource.type === "video") {
+        const cached = await this.cacheManager.hasResourceInCache(task.resourceId);
+        if (cached) {
+          await this.ensureIndexParsed(task.resourceId);
+          if (task.sessionId) {
+            const stream = await this.createOPFSReadStream(task.resourceId);
+            task.stream = stream;
+            await this.transferToDemuxWorker(task);
+          }
+        } else {
+          await this.loadWithOPFSCache(task);
+        }
+      } else if (task.resource.type === "audio") {
         const stream = await this.streamFactory.createRegularStream(task);
         if (!stream) {
           throw new Error(`Failed to create stream for ${task.resourceId}`);
@@ -117,12 +169,136 @@ class ResourceLoader {
       this.updateResourceState(task.resourceId, "ready");
     } catch (error) {
       task.error = error;
+      loadError = error;
       this.updateResourceState(task.resourceId, "error");
     } finally {
-      this.taskManager.completeTask(task.resourceId);
+      this.taskManager.completeTask(task.resourceId, loadError);
       this.processQueue();
     }
   }
+  /**
+   * Ensure MP4 index is parsed for a cached resource
+   */
+  async ensureIndexParsed(resourceId) {
+    if (this.cacheManager.mp4IndexCache.has(resourceId)) {
+      return;
+    }
+    if (this.parsingIndexes.has(resourceId)) {
+      while (this.parsingIndexes.has(resourceId)) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      }
+      return;
+    }
+    this.parsingIndexes.add(resourceId);
+    try {
+      const stream = await this.createOPFSReadStream(resourceId);
+      const parseTask = {
+        resourceId,
+        resource: { id: resourceId, type: "video", uri: "" },
+        bytesLoaded: 0,
+        totalBytes: 0,
+        startTime: Date.now(),
+        priority: "normal"
+      };
+      await this.parseIndexFromStream(parseTask, stream);
+    } finally {
+      this.parsingIndexes.delete(resourceId);
+    }
+  }
+  /**
+   * Create ReadableStream from OPFS file
+   * Reuses OPFSManager's underlying file access
+   */
+  async createOPFSReadStream(resourceId) {
+    const opfsManager = this.cacheManager.resourceCache.opfsManager;
+    const projectId = this.cacheManager.resourceCache.projectId;
+    const dir = await opfsManager.getProjectDir(projectId, "resource");
+    const fileName = `${resourceId}.mp4`;
+    const fileHandle = await dir.getFileHandle(fileName);
+    const file = await fileHandle.getFile();
+    return file.stream();
+  }
+  /**
+   * Load resource and cache to OPFS + parse moov + extract first frame
+   *
+   * Strategy: Parallel tee() approach for fast first frame
+   * - One stream writes to OPFS (background)
+   * - Another stream parses moov and extracts first GOP
+   * - First frame is decoded and cached immediately
+   */
+  async loadWithOPFSCache(task) {
+    const stream = await this.streamFactory.createRegularStream(task);
+    if (!stream) {
+      throw new Error(`Failed to create stream for ${task.resourceId}`);
+    }
+    let opfsStream;
+    let parseStream;
+    let workerStream;
+    if (task.sessionId) {
+      const [branch1, branch2] = stream.tee();
+      const [branch2a, branch2b] = branch2.tee();
+      opfsStream = branch1;
+      parseStream = branch2a;
+      workerStream = branch2b;
+    } else {
+      const [s1, s2] = stream.tee();
+      opfsStream = s1;
+      parseStream = s2;
+    }
+    const promises = [
+      this.writeToOPFS(task.resourceId, opfsStream),
+      this.parseIndexFromStream(task, parseStream)
+    ];
+    if (workerStream && task.sessionId) {
+      const workerTask = { ...task, stream: workerStream };
+      promises.push(this.transferToDemuxWorker(workerTask));
+    }
+    await Promise.all(promises);
+  }
+  /**
+   * Write resource stream to OPFS
+   */
+  async writeToOPFS(resourceId, stream) {
+    await this.cacheManager.resourceCache.writeResource(resourceId, stream);
+  }
+  /**
+   * Parse moov from stream and cache index + audio samples + decode first frame
+   */
+  async parseIndexFromStream(task, stream) {
+    const { resourceId, clipId } = task;
+    try {
+      const parser = new MP4IndexParser();
+      const result = await parser.parseFromStream(stream, {
+        onFirstFrameReady: async (index, chunks) => {
+          index.resourceId = resourceId;
+          this.cacheManager.mp4IndexCache.set(resourceId, index);
+          if (clipId) {
+            this.eventBus?.emit(MeframeEvent.ResourceFirstFrameReady, {
+              resourceId,
+              clipId,
+              index,
+              chunks
+            });
+          }
+        }
+      });
+      result.index.resourceId = resourceId;
+      if (!this.cacheManager.mp4IndexCache.has(resourceId)) {
+        this.cacheManager.mp4IndexCache.set(resourceId, result.index);
+      }
+      if (result.audioSamples && result.audioMetadata) {
+        this.cacheManager.audioSampleCache.set(
+          resourceId,
+          result.audioSamples,
+          result.audioMetadata
+        );
+      } else {
+      }
+    } catch (error) {
+      console.error(`[ResourceLoader] Failed to parse MP4 index for ${resourceId}:`, error);
+      throw error;
+    }
+  }
   /**
    * Load text-based resources (json, text)
    * Just download the content - state management is handled by startLoad()
@@ -131,8 +307,13 @@ class ResourceLoader {
     await this.fetchBlob(task.resource.uri, task.controller.signal);
   }
   /**
-   * Load image resource: fetch blob → create ImageBitmap → transfer to worker
+   * Load image resource: fetch blob → create ImageBitmap → cache in CacheManager
    * Note: Images don't need streaming (typically < 5MB)
+   *
+   * Strategy for window cache architecture:
+   * - Store ImageBitmap in CacheManager.imageBitmapCache (main thread accessible)
+   * - OnDemandComposeSession retrieves from cache for composition
+   * - No longer transfer to Worker (composition is in main thread)
    */
   async loadImageBitmap(task) {
     let blob = this.blobCache.get(task.resourceId);
@@ -141,14 +322,7 @@ class ResourceLoader {
       this.blobCache.set(task.resourceId, blob);
     }
     const imageBitmap = await createImageBitmapFromBlob(blob);
-    await this.transferImageToWorker(task, imageBitmap);
-    const pending = this.pendingTransfers.get(task.resourceId);
-    if (pending && pending.length > 0) {
-      for (const sessionId of pending) {
-        await this.transferCachedImage(task.resourceId, sessionId);
-      }
-      this.pendingTransfers.delete(task.resourceId);
-    }
+    this.cacheManager.imageBitmapCache.set(task.resourceId, imageBitmap);
   }
   /**
    * Fetch resource as blob (for images, json, etc.)
@@ -162,25 +336,27 @@ class ResourceLoader {
   }
   /**
    * Transfer ImageBitmap to VideoComposeWorker
+   * Legacy: Not used in window cache architecture (images accessed via CacheManager)
    */
-  async transferImageToWorker(task, imageBitmap) {
-    if (!this.orchestrator) return;
-    if (!task.sessionId) {
-      throw new Error(
-        `[ResourceLoader] sessionId required for resource ${task.resourceId}. In Clip-based architecture, use fetch(resourceId, { sessionId })`
-      );
-    }
-    const composeWorker = await this.orchestrator.workers.get("videoCompose", task.sessionId);
-    await composeWorker?.send?.(
-      "receive_image",
-      {
-        resourceId: task.resourceId,
-        sessionId: task.sessionId,
-        imageBitmap
-      },
-      { transfer: [imageBitmap] }
-    );
-  }
+  // private async transferImageToWorker(task: LoadTask, imageBitmap: ImageBitmap): Promise<void> {
+  //   if (!this.orchestrator) return;
+  //   if (!task.sessionId) {
+  //     throw new Error(
+  //       `[ResourceLoader] sessionId required for resource ${task.resourceId}. ` +
+  //         `In Clip-based architecture, use fetch(resourceId, { sessionId })`
+  //     );
+  //   }
+  //   const composeWorker = await this.orchestrator.workers.get('videoCompose', task.sessionId);
+  //   await composeWorker?.send?.(
+  //     'receive_image',
+  //     {
+  //       resourceId: task.resourceId,
+  //       sessionId: task.sessionId,
+  //       imageBitmap,
+  //     },
+  //     { transfer: [imageBitmap] }
+  //   );
+  // }
   /**
    * Transfer cached image to a session
    * Creates new ImageBitmap from cached Blob and transfers to worker
@@ -189,8 +365,7 @@ class ResourceLoader {
     const blob = this.blobCache.get(resourceId);
     if (!blob || !sessionId) return;
     const imageBitmap = await createImageBitmapFromBlob(blob);
-    if (!this.orchestrator) return;
-    const composeWorker = await this.orchestrator.workers.get("videoCompose", sessionId);
+    const composeWorker = await this.workerPool.get("videoCompose", sessionId);
     await composeWorker?.send?.(
       "receive_image",
       {
@@ -201,15 +376,18 @@ class ResourceLoader {
       { transfer: [imageBitmap] }
     );
   }
+  /**
+   * Transfer stream to demux worker (for audio files)
+   */
   async transferToDemuxWorker(task) {
-    if (!task.stream || !this.orchestrator) return;
+    if (!task.stream) return;
     if (!task.sessionId) {
       throw new Error(
         `[ResourceLoader] sessionId required for resource ${task.resourceId}. In Clip-based architecture, use fetch(resourceId, { sessionId })`
       );
     }
     const workerType = task.resource.type === "video" ? "videoDemux" : "audioDemux";
-    const demuxWorker = await this.orchestrator.workers.get(workerType, task.sessionId);
+    const demuxWorker = await this.workerPool.get(workerType, task.sessionId);
     if (demuxWorker) {
       await demuxWorker.sendStream(task.stream, {
         sessionId: task.sessionId,
@@ -226,14 +404,12 @@ class ResourceLoader {
     if (resource) {
       const oldState = resource.state;
       resource.state = state;
-      if (this.orchestrator) {
-        this.eventBus?.emit(MeframeEvent.ResourceStageChange, {
-          type: MeframeEvent.ResourceStageChange,
-          resourceId,
-          oldState,
-          newState: state
-        });
-      }
+      this.eventBus?.emit(MeframeEvent.ResourceStageChange, {
+        type: MeframeEvent.ResourceStageChange,
+        resourceId,
+        oldState,
+        newState: state
+      });
     }
     this.onStateChange?.(resourceId, state);
   }
@@ -246,13 +422,54 @@ class ResourceLoader {
       console.warn(`Resource ${resourceId} not found in model`);
       return;
     }
-    this.enqueueLoad(
-      resource,
-      options?.priority || "normal",
-      options?.sessionId,
-      options?.trackId,
-      options?.isMainTrack ?? false
-    );
+    const transferResourceToWorker = async (rId, sId, type) => {
+      if (type === "video") {
+        const stream = await this.createOPFSReadStream(rId);
+        const task = {
+          resourceId: rId,
+          sessionId: sId,
+          resource: this.model?.resources.get(rId),
+          stream,
+          bytesLoaded: 0,
+          totalBytes: 0,
+          startTime: Date.now(),
+          priority: "normal"
+        };
+        await this.transferToDemuxWorker(task);
+      } else if (type === "image") {
+        await this.transferCachedImage(rId, sId);
+      }
+    };
+    if (resource.state === "ready") {
+      if (options?.sessionId) {
+        await transferResourceToWorker(resourceId, options.sessionId, resource.type);
+      }
+      return;
+    }
+    let taskPromise = this.taskManager.getTaskPromise(resourceId);
+    let isCoveredByTask = false;
+    if (taskPromise) {
+      const activeTask = this.taskManager.activeTasks.get(resourceId) || this.taskManager.taskQueue.find((t) => t.resourceId === resourceId);
+      if (activeTask && activeTask.sessionId === options?.sessionId) {
+        isCoveredByTask = true;
+      }
+    } else {
+      this.enqueueLoad(
+        resource,
+        options?.priority || "normal",
+        options?.sessionId,
+        options?.clipId,
+        options?.trackId,
+        options?.isMainTrack ?? false
+      );
+      taskPromise = this.taskManager.getTaskPromise(resourceId);
+      isCoveredByTask = true;
+    }
+    await taskPromise;
+    const updatedResource = this.model?.resources.get(resourceId);
+    if (!isCoveredByTask && updatedResource?.state === "ready" && options?.sessionId) {
+      await transferResourceToWorker(resourceId, options.sessionId, resource.type);
+    }
   }
   cancel(resourceId) {
     this.taskManager.cancelTask(resourceId);
@@ -281,6 +498,7 @@ class ResourceLoader {
         resource,
         options?.priority || "normal",
         options?.sessionId,
+        options?.clipId,
         options?.trackId
       );
     } else {
@@ -298,7 +516,6 @@ class ResourceLoader {
     this.byteRangeResolver.dispose();
     this.blobCache.clear();
     this.pendingTransfers.clear();
-    this.unbind();
   }
 }
 export {

package/dist/stages/load/ResourceLoader.js.map

@@ -1 +1 @@
-{"version":3,"file":"ResourceLoader.js","sources":["../../../src/stages/load/ResourceLoader.ts"],"sourcesContent":["import type { Resource, CompositionModel } from '../../model';\nimport type { Orchestrator, ResourceLoadOptions, LoadTask, ResourceLoaderOptions } from './types';\nimport { TaskManager } from './TaskManager';\nimport { StreamFactory } from './StreamFactory';\nimport { EventHandlers } from './EventHandlers';\nimport { EventPayloadMap, MeframeEvent } from '../../event/events';\nimport { EventBus } from '../../event/EventBus';\nimport { WindowByteRangeResolver } from './WindowByteRangeResolver';\nimport { createImageBitmapFromBlob } from '../../utils/image-utils';\n\nexport class ResourceConflictError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'ResourceConflictError';\n  }\n}\n\nexport class ResourceLoader {\n  private orchestrator?: Orchestrator;\n  private model?: CompositionModel;\n  private taskManager: TaskManager;\n  private streamFactory: StreamFactory;\n  private eventHandlers?: EventHandlers;\n  private eventBus?: EventBus<EventPayloadMap>;\n  private onStateChange?: (resourceId: string, state: Resource['state']) => void;\n  private byteRangeResolver: WindowByteRangeResolver;\n  private blobCache = new Map<string, Blob>();\n  private pendingTransfers = new Map<string, string[]>();\n\n  constructor(options?: ResourceLoaderOptions) {\n    const maxConcurrent = options?.config?.maxConcurrent ?? 4;\n    this.taskManager = new TaskManager(maxConcurrent);\n    this.streamFactory = new StreamFactory(options?.onProgress, options?.config);\n    this.eventBus = options?.eventBus;\n    this.onStateChange = options?.onStateChange;\n    this.byteRangeResolver = new WindowByteRangeResolver();\n\n    if (options?.orchestrator) {\n      this.bind(options.orchestrator);\n    }\n  }\n\n  /**\n   * Bind to Orchestrator event system\n   */\n  bind(orchestrator: Orchestrator): void {\n    this.unbind();\n    this.orchestrator = orchestrator;\n\n    this.eventHandlers = new EventHandlers(\n      orchestrator,\n      (resourceId) => this.cancel(resourceId),\n      (model) => this.handleModelSet(model)\n    );\n  }\n\n  /**\n   * Unbind from Orchestrator\n   */\n  unbind(): void {\n    this.eventHandlers?.dispose();\n    this.eventHandlers = undefined;\n    this.orchestrator = undefined;\n  }\n\n  private handleModelSet(model: CompositionModel): void {\n    this.model = model;\n  }\n\n  private enqueueLoad(\n    resource: Resource,\n    priority: 'high' | 'normal' | 'low' = 'normal',\n    sessionId?: string,\n    trackId?: string,\n    isMainTrack = false\n  ): void {\n    if (this.taskManager.hasActiveTask(resource.id)) {\n      if (priority === 'high') {\n        // Preview channel: high priority can preempt (existing logic preserved)\n      } else if (isMainTrack) {\n        // Main track resource conflict: throw error for PreRenderService to detect\n        throw new ResourceConflictError(\n          `Resource ${resource.id} is being loaded by another session. Preview channel has priority.`\n        );\n      } else {\n        // Attachment resource conflict: check cache\n        if (this.blobCache.has(resource.id)) {\n          // Already cached: immediately create ImageBitmap and transfer\n          void this.transferCachedImage(resource.id, sessionId);\n          return;\n        } else {\n          // Loading in progress: register to pending queue, will transfer after load complete\n          this.registerPendingTransfer(resource.id, sessionId);\n          console.debug(\n            `[ResourceLoader] Attachment resource ${resource.id} loading, registered for pending transfer`\n          );\n          return;\n        }\n      }\n    }\n\n    this.taskManager.enqueue(resource, priority, sessionId, trackId);\n    this.processQueue();\n  }\n\n  private registerPendingTransfer(resourceId: string, sessionId?: string): void {\n    if (!sessionId) return;\n\n    const pending = this.pendingTransfers.get(resourceId) || [];\n    if (!pending.includes(sessionId)) {\n      pending.push(sessionId);\n      this.pendingTransfers.set(resourceId, pending);\n    }\n  }\n\n  private processQueue(): void {\n    while (this.taskManager.canProcess) {\n      const task = this.taskManager.getNextTask();\n      if (!task) break;\n      this.startLoad(task);\n    }\n  }\n\n  /**\n   * Start loading a resource\n   * Handles state management (loading → ready/error) for all resource types\n   */\n  private async startLoad(task: LoadTask): Promise<void> {\n    this.taskManager.activateTask(task);\n    try {\n      this.updateResourceState(task.resourceId, 'loading');\n      task.controller = new AbortController();\n\n      // Route to different handlers based on resource type\n      // Note: Each handler only deals with data, state is managed here\n      if (task.resource.type === 'image') {\n        await this.loadImageBitmap(task);\n      } else if (task.resource.type === 'video' || task.resource.type === 'audio') {\n        const stream = await this.streamFactory.createRegularStream(task);\n        if (!stream) {\n          throw new Error(`Failed to create stream for ${task.resourceId}`);\n        }\n        task.stream = stream;\n        await this.transferToDemuxWorker(task);\n      } else if (task.resource.type === 'json' || task.resource.type === 'text') {\n        await this.loadTextResource(task);\n      }\n\n      // Unified state update for all resource types\n      this.updateResourceState(task.resourceId, 'ready');\n    } catch (error) {\n      task.error = error as Error;\n      this.updateResourceState(task.resourceId, 'error');\n    } finally {\n      this.taskManager.completeTask(task.resourceId);\n      this.processQueue();\n    }\n  }\n\n  /**\n   * Load text-based resources (json, text)\n   * Just download the content - state management is handled by startLoad()\n   */\n  private async loadTextResource(task: LoadTask): Promise<void> {\n    await this.fetchBlob(task.resource.uri, task.controller!.signal);\n    // For json/text, just verify we can download it\n    // Future: could parse and validate json here if needed\n  }\n\n  /**\n   * Load image resource: fetch blob → create ImageBitmap → transfer to worker\n   * Note: Images don't need streaming (typically < 5MB)\n   */\n  private async loadImageBitmap(task: LoadTask): Promise<void> {\n    // Check cache\n    let blob = this.blobCache.get(task.resourceId);\n\n    if (!blob) {\n      // Not cached: download and cache\n      blob = await this.fetchBlob(task.resource.uri, task.controller!.signal);\n      this.blobCache.set(task.resourceId, blob);\n    }\n\n    // Create ImageBitmap from Blob (with special handling for SVG)\n    const imageBitmap = await createImageBitmapFromBlob(blob);\n\n    await this.transferImageToWorker(task, imageBitmap);\n\n    // Process pending transfer queue\n    const pending = this.pendingTransfers.get(task.resourceId);\n    if (pending && pending.length > 0) {\n      for (const sessionId of pending) {\n        await this.transferCachedImage(task.resourceId, sessionId);\n      }\n      this.pendingTransfers.delete(task.resourceId);\n    }\n  }\n\n  /**\n   * Fetch resource as blob (for images, json, etc.)\n   */\n  private async fetchBlob(uri: string, signal: AbortSignal): Promise<Blob> {\n    const response = await fetch(uri, { signal });\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    return response.blob();\n  }\n\n  /**\n   * Transfer ImageBitmap to VideoComposeWorker\n   */\n  private async transferImageToWorker(task: LoadTask, imageBitmap: ImageBitmap): Promise<void> {\n    if (!this.orchestrator) return;\n\n    if (!task.sessionId) {\n      throw new Error(\n        `[ResourceLoader] sessionId required for resource ${task.resourceId}. ` +\n          `In Clip-based architecture, use fetch(resourceId, { sessionId })`\n      );\n    }\n\n    const composeWorker = await this.orchestrator.workers.get('videoCompose', task.sessionId);\n    await composeWorker?.send?.(\n      'receive_image',\n      {\n        resourceId: task.resourceId,\n        sessionId: task.sessionId,\n        imageBitmap,\n      },\n      { transfer: [imageBitmap] }\n    );\n  }\n\n  /**\n   * Transfer cached image to a session\n   * Creates new ImageBitmap from cached Blob and transfers to worker\n   */\n  private async transferCachedImage(resourceId: string, sessionId?: string): Promise<void> {\n    const blob = this.blobCache.get(resourceId);\n    if (!blob || !sessionId) return;\n\n    // Create new ImageBitmap from cached Blob (with SVG support)\n    const imageBitmap = await createImageBitmapFromBlob(blob);\n\n    // Transfer to Worker\n    if (!this.orchestrator) return;\n\n    const composeWorker = await this.orchestrator.workers.get('videoCompose', sessionId);\n\n    await composeWorker?.send?.(\n      'receive_image',\n      {\n        resourceId,\n        sessionId,\n        imageBitmap,\n      },\n      { transfer: [imageBitmap] }\n    );\n  }\n\n  private async transferToDemuxWorker(task: LoadTask): Promise<void> {\n    if (!task.stream || !this.orchestrator) return;\n\n    if (!task.sessionId) {\n      throw new Error(\n        `[ResourceLoader] sessionId required for resource ${task.resourceId}. ` +\n          `In Clip-based architecture, use fetch(resourceId, { sessionId })`\n      );\n    }\n\n    const workerType = task.resource.type === 'video' ? 'videoDemux' : 'audioDemux';\n    const demuxWorker = await this.orchestrator.workers.get(workerType, task.sessionId);\n    if (demuxWorker) {\n      await demuxWorker.sendStream(task.stream, {\n        sessionId: task.sessionId,\n        ...task.metadata,\n        ...(task.range && { range: task.range }),\n        ...(task.trackId && { trackId: task.trackId }),\n      });\n    } else {\n      // maybe the demux worker is terminated\n      task.stream.cancel();\n    }\n  }\n\n  private updateResourceState(resourceId: string, state: Resource['state']): void {\n    const resource = this.model?.resources.get(resourceId);\n    if (resource) {\n      const oldState = resource.state;\n      resource.state = state;\n      if (this.orchestrator) {\n        this.eventBus?.emit(MeframeEvent.ResourceStageChange, {\n          type: MeframeEvent.ResourceStageChange,\n          resourceId,\n          oldState,\n          newState: state,\n        });\n      }\n    }\n\n    this.onStateChange?.(resourceId, state);\n  }\n\n  async fetch(resourceId?: string, options?: ResourceLoadOptions): Promise<void> {\n    if (!resourceId) {\n      return;\n    }\n\n    const resource = this.model?.resources.get(resourceId);\n    if (!resource) {\n      console.warn(`Resource ${resourceId} not found in model`);\n      return;\n    }\n\n    this.enqueueLoad(\n      resource,\n      options?.priority || 'normal',\n      options?.sessionId,\n      options?.trackId,\n      options?.isMainTrack ?? false\n    );\n  }\n\n  cancel(resourceId: string): void {\n    this.taskManager.cancelTask(resourceId);\n    this.processQueue();\n  }\n\n  /**\n   * Check if a resource is currently being loaded\n   */\n  isResourceLoading(resourceId: string): boolean {\n    return this.taskManager.hasActiveTask(resourceId);\n  }\n\n  pause(resourceId: string): void {\n    const task = this.taskManager.getActiveTask(resourceId);\n    if (task) {\n      task.controller?.abort();\n    }\n  }\n\n  async resume(resourceId: string, options?: ResourceLoadOptions): Promise<void> {\n    const resource = this.model?.getResource(resourceId);\n    if (!resource) {\n      throw new Error(`Resource ${resourceId} not found`);\n    }\n\n    const pausedTask = this.taskManager.getActiveTask(resourceId);\n\n    if (pausedTask?.pausedAt !== undefined) {\n      this.enqueueLoad(\n        resource,\n        options?.priority || 'normal',\n        options?.sessionId,\n        options?.trackId\n      );\n    } else {\n      await this.fetch(resourceId, options);\n    }\n  }\n\n  get activeTasks(): Map<string, LoadTask> {\n    return this.taskManager.activeTasks;\n  }\n\n  get taskQueue(): LoadTask[] {\n    return this.taskManager.taskQueue;\n  }\n\n  dispose(): void {\n    this.taskManager.clear();\n    this.byteRangeResolver.dispose();\n    this.blobCache.clear();\n    this.pendingTransfers.clear();\n    this.unbind();\n  }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"ResourceLoader.js","sources":["../../../src/stages/load/ResourceLoader.ts"],"sourcesContent":["import { type Resource, type CompositionModel, hasResourceId } from '../../model';\nimport type { ResourceLoadOptions, LoadTask, ResourceLoaderOptions } from './types';\nimport { TaskManager } from './TaskManager';\nimport { StreamFactory } from './StreamFactory';\nimport { EventPayloadMap, MeframeEvent } from '../../event/events';\nimport { EventBus } from '../../event/EventBus';\nimport { WindowByteRangeResolver } from './WindowByteRangeResolver';\nimport { createImageBitmapFromBlob } from '../../utils/image-utils';\nimport { MP4IndexParser, type MP4ParseResult } from '../demux/MP4IndexParser';\nimport type { CacheManager } from '../../cache/CacheManager';\nimport type { WorkerPool } from '../../worker/WorkerPool';\n\nexport class ResourceConflictError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = 'ResourceConflictError';\n  }\n}\n\nexport class ResourceLoader {\n  private cacheManager: CacheManager;\n  private workerPool: WorkerPool;\n  private model?: CompositionModel;\n  private taskManager: TaskManager;\n  private streamFactory: StreamFactory;\n  private eventBus?: EventBus<EventPayloadMap>;\n  private onStateChange?: (resourceId: string, state: Resource['state']) => void;\n  private byteRangeResolver: WindowByteRangeResolver;\n  private blobCache = new Map<string, Blob>();\n  private pendingTransfers = new Map<string, string[]>();\n  private parsingIndexes = new Set<string>(); // Track in-progress index parsing\n\n  // Preloading state\n  private isPreloadingEnabled = true;\n  private preloadQueue: string[] = [];\n  private activePreloads = new Set<string>();\n  // TODO: make this configurable\n  private readonly IDLE_PRELOAD_CONCURRENCY = 2;\n\n  constructor(options: ResourceLoaderOptions) {\n    const maxConcurrent = options.config?.maxConcurrent ?? 4;\n    this.taskManager = new TaskManager(maxConcurrent);\n    this.streamFactory = new StreamFactory(options.onProgress, options.config);\n    this.eventBus = options.eventBus;\n    this.onStateChange = options.onStateChange;\n    this.byteRangeResolver = new WindowByteRangeResolver();\n    this.cacheManager = options.cacheManager;\n    this.workerPool = options.workerPool;\n  }\n\n  async setModel(model: CompositionModel): Promise<void> {\n    this.model = model;\n    const mainTrack = model.tracks.find((track) => track.id === (model.mainTrackId || 'main'));\n    if (mainTrack?.clips?.[0] && hasResourceId(mainTrack.clips[0])) {\n      await this.fetch(mainTrack.clips[0].resourceId, {\n        priority: 'high',\n        clipId: mainTrack.clips[0].id,\n        trackId: mainTrack.id,\n      });\n    }\n    this.startPreloading();\n  }\n\n  setPreloadingEnabled(enabled: boolean): void {\n    this.isPreloadingEnabled = enabled;\n    if (enabled) {\n      this.startPreloading();\n    } else {\n      // Clear queue if disabled, but let active preloads finish (they are low priority)\n      this.preloadQueue = [];\n    }\n  }\n\n  startPreloading(): void {\n    if (!this.model || !this.isPreloadingEnabled) return;\n\n    const mainTrack = this.model.tracks.find(\n      (track) => track.id === (this.model?.mainTrackId || 'main')\n    );\n    if (!mainTrack) return;\n    const newQueue: string[] = [];\n    for (const clip of mainTrack.clips) {\n      if (!hasResourceId(clip)) continue;\n      const resource = this.model.getResource(clip.resourceId);\n      if (!resource) continue;\n\n      // Skip if already ready, loading, or error\n      if (\n        !resource ||\n        resource.state === 'ready' ||\n        resource.state === 'loading' ||\n        resource.state === 'error'\n      ) {\n        continue;\n      }\n\n      // Also skip if currently in activePreloads or activeTasks\n      if (this.activePreloads.has(resource.id) || this.taskManager.hasActiveTask(resource.id)) {\n        continue;\n      }\n\n      newQueue.push(resource.id);\n    }\n\n    this.preloadQueue = newQueue;\n    this.processPreloadQueue();\n  }\n\n  private processPreloadQueue(): void {\n    if (!this.isPreloadingEnabled || this.preloadQueue.length === 0) return;\n\n    while (\n      this.activePreloads.size < this.IDLE_PRELOAD_CONCURRENCY &&\n      this.preloadQueue.length > 0\n    ) {\n      const resourceId = this.preloadQueue.shift();\n      if (!resourceId) break;\n\n      this.activePreloads.add(resourceId);\n\n      // Use low priority for preloading\n      this.fetch(resourceId, { priority: 'low' }).finally(() => {\n        this.activePreloads.delete(resourceId);\n        // Continue processing queue\n        this.processPreloadQueue();\n      });\n    }\n  }\n\n  private enqueueLoad(\n    resource: Resource,\n    priority: 'high' | 'normal' | 'low' = 'normal',\n    sessionId?: string,\n    clipId?: string,\n    trackId?: string,\n    isMainTrack = false\n  ): void {\n    if (this.taskManager.hasActiveTask(resource.id)) {\n      if (priority === 'high') {\n        // Preview channel: high priority can preempt (existing logic preserved)\n      } else if (isMainTrack) {\n        // Main track resource conflict: throw error for PreRenderService to detect\n        throw new ResourceConflictError(\n          `Resource ${resource.id} is being loaded by another session. Preview channel has priority.`\n        );\n      } else {\n        // Attachment resource conflict: check cache\n        if (this.blobCache.has(resource.id)) {\n          // Already cached: immediately create ImageBitmap and transfer\n          void this.transferCachedImage(resource.id, sessionId);\n          return;\n        } else {\n          // Loading in progress: register to pending queue, will transfer after load complete\n          this.registerPendingTransfer(resource.id, sessionId);\n          console.debug(\n            `[ResourceLoader] Attachment resource ${resource.id} loading, registered for pending transfer`\n          );\n          return;\n        }\n      }\n    }\n\n    this.taskManager.enqueue(resource, priority, sessionId, clipId, trackId);\n    this.processQueue();\n  }\n\n  private registerPendingTransfer(resourceId: string, sessionId?: string): void {\n    if (!sessionId) return;\n\n    const pending = this.pendingTransfers.get(resourceId) || [];\n    if (!pending.includes(sessionId)) {\n      pending.push(sessionId);\n      this.pendingTransfers.set(resourceId, pending);\n    }\n  }\n\n  private processQueue(): void {\n    while (this.taskManager.canProcess) {\n      const task = this.taskManager.getNextTask();\n      if (!task) break;\n      this.startLoad(task);\n    }\n  }\n\n  /**\n   * Start loading a resource\n   * Handles state management (loading → ready/error) for all resource types\n   */\n  private async startLoad(task: LoadTask): Promise<void> {\n    this.taskManager.activateTask(task);\n    let loadError: Error | undefined;\n\n    try {\n      this.updateResourceState(task.resourceId, 'loading');\n      task.controller = new AbortController();\n\n      // Route to different handlers based on resource type\n      if (task.resource.type === 'image') {\n        await this.loadImageBitmap(task);\n      } else if (task.resource.type === 'video') {\n        // Video: OPFS cache + MP4 index parsing (for window cache architecture)\n        const cached = await this.cacheManager.hasResourceInCache(task.resourceId);\n        if (cached) {\n          // Resource already in OPFS - ensure index is parsed\n          await this.ensureIndexParsed(task.resourceId);\n\n          // If sessionId is present (Worker Pipeline active), transfer OPFS stream to worker\n          if (task.sessionId) {\n            const stream = await this.createOPFSReadStream(task.resourceId);\n            task.stream = stream;\n            await this.transferToDemuxWorker(task);\n          }\n        } else {\n          // Not cached - download and cache to OPFS\n          await this.loadWithOPFSCache(task);\n        }\n      } else if (task.resource.type === 'audio') {\n        // Audio (MP3/WAV): Traditional pipeline (demux worker)\n        // No OPFS cache or index parsing needed\n        const stream = await this.streamFactory.createRegularStream(task);\n        if (!stream) {\n          throw new Error(`Failed to create stream for ${task.resourceId}`);\n        }\n        task.stream = stream;\n        await this.transferToDemuxWorker(task);\n      } else if (task.resource.type === 'json' || task.resource.type === 'text') {\n        await this.loadTextResource(task);\n      }\n\n      // Unified state update for all resource types\n      this.updateResourceState(task.resourceId, 'ready');\n    } catch (error) {\n      task.error = error as Error;\n      loadError = error as Error;\n      this.updateResourceState(task.resourceId, 'error');\n    } finally {\n      this.taskManager.completeTask(task.resourceId, loadError);\n      this.processQueue();\n    }\n  }\n\n  /**\n   * Ensure MP4 index is parsed for a cached resource\n   */\n  async ensureIndexParsed(resourceId: string): Promise<void> {\n    // Check if index already exists\n    if (this.cacheManager.mp4IndexCache.has(resourceId)) {\n      return;\n    }\n\n    // Check if already parsing (avoid duplicate parsing for same resource)\n    if (this.parsingIndexes.has(resourceId)) {\n      // Wait for the in-progress parsing to complete\n      while (this.parsingIndexes.has(resourceId)) {\n        await new Promise((resolve) => setTimeout(resolve, 50));\n      }\n      return;\n    }\n\n    // Mark as parsing\n    this.parsingIndexes.add(resourceId);\n\n    try {\n      // Parse from OPFS file\n      const stream = await this.createOPFSReadStream(resourceId);\n      // Create minimal task for parsing (no clipId since this is a background index parse)\n      const parseTask: LoadTask = {\n        resourceId,\n        resource: { id: resourceId, type: 'video', uri: '' },\n        bytesLoaded: 0,\n        totalBytes: 0,\n        startTime: Date.now(),\n        priority: 'normal',\n      };\n      await this.parseIndexFromStream(parseTask, stream);\n    } finally {\n      // Remove from parsing set\n      this.parsingIndexes.delete(resourceId);\n    }\n  }\n\n  /**\n   * Create ReadableStream from OPFS file\n   * Reuses OPFSManager's underlying file access\n   */\n  private async createOPFSReadStream(resourceId: string): Promise<ReadableStream<Uint8Array>> {\n    const opfsManager = this.cacheManager.resourceCache.opfsManager;\n    const projectId = this.cacheManager.resourceCache.projectId;\n\n    // Get file handle from OPFS\n    const dir = await opfsManager.getProjectDir(projectId, 'resource');\n    const fileName = `${resourceId}.mp4`;\n    const fileHandle = await dir.getFileHandle(fileName);\n    const file = await fileHandle.getFile();\n\n    // Return native stream\n    return file.stream();\n  }\n\n  /**\n   * Load resource and cache to OPFS + parse moov + extract first frame\n   *\n   * Strategy: Parallel tee() approach for fast first frame\n   * - One stream writes to OPFS (background)\n   * - Another stream parses moov and extracts first GOP\n   * - First frame is decoded and cached immediately\n   */\n  private async loadWithOPFSCache(task: LoadTask): Promise<void> {\n    const stream = await this.streamFactory.createRegularStream(task);\n    if (!stream) {\n      throw new Error(`Failed to create stream for ${task.resourceId}`);\n    }\n\n    // Prepare streams: 1 for OPFS, 1 for parsing, optional 1 for Worker\n    let opfsStream: ReadableStream<Uint8Array>;\n    let parseStream: ReadableStream<Uint8Array>;\n    let workerStream: ReadableStream<Uint8Array> | undefined;\n\n    if (task.sessionId) {\n      // If worker needs it, split into 3 ways\n      const [branch1, branch2] = stream.tee();\n      const [branch2a, branch2b] = branch2.tee();\n\n      opfsStream = branch1;\n      parseStream = branch2a;\n      workerStream = branch2b;\n    } else {\n      // Just 2 ways\n      const [s1, s2] = stream.tee();\n      opfsStream = s1;\n      parseStream = s2;\n    }\n\n    const promises: Promise<void>[] = [\n      this.writeToOPFS(task.resourceId, opfsStream),\n      this.parseIndexFromStream(task, parseStream),\n    ];\n\n    if (workerStream && task.sessionId) {\n      // Assign stream to task so transferToDemuxWorker uses it\n      // Note: we need to clone the task or modify it carefully, but here it's safe\n      // We create a temp task object or just modify current (since stream is consumed)\n      // Actually transferToDemuxWorker uses task.stream.\n      // We can't modify task.stream in place easily if type is readonly-ish, but it's not.\n      const workerTask = { ...task, stream: workerStream };\n      promises.push(this.transferToDemuxWorker(workerTask));\n    }\n\n    // Parallel execution\n    await Promise.all(promises);\n  }\n\n  /**\n   * Write resource stream to OPFS\n   */\n  private async writeToOPFS(resourceId: string, stream: ReadableStream<Uint8Array>): Promise<void> {\n    await this.cacheManager.resourceCache.writeResource(resourceId, stream);\n  }\n\n  /**\n   * Parse moov from stream and cache index + audio samples + decode first frame\n   */\n  private async parseIndexFromStream(\n    task: LoadTask,\n    stream: ReadableStream<Uint8Array>\n  ): Promise<void> {\n    const { resourceId, clipId } = task;\n\n    try {\n      const parser = new MP4IndexParser();\n\n      const result: MP4ParseResult = await parser.parseFromStream(stream, {\n        onFirstFrameReady: async (index, chunks) => {\n          // Set resourceId on index\n          index.resourceId = resourceId;\n\n          // Cache index immediately\n          this.cacheManager.mp4IndexCache.set(resourceId, index);\n\n          // Emit event with chunks for Orchestrator to handle\n          // Only if clipId is provided (indicates this is a preview/cover request)\n          if (clipId) {\n            this.eventBus?.emit(MeframeEvent.ResourceFirstFrameReady, {\n              resourceId,\n              clipId,\n              index,\n              chunks,\n            });\n          }\n        },\n      });\n\n      result.index.resourceId = resourceId;\n\n      // Cache index (if not already cached by onFirstFrameReady)\n      if (!this.cacheManager.mp4IndexCache.has(resourceId)) {\n        this.cacheManager.mp4IndexCache.set(resourceId, result.index);\n      }\n\n      // Cache audio samples if present\n      if (result.audioSamples && result.audioMetadata) {\n        this.cacheManager.audioSampleCache.set(\n          resourceId,\n          result.audioSamples,\n          result.audioMetadata\n        );\n      } else {\n        // Ensure cache knows this resource has NO audio\n        // This prevents GlobalAudioSession from waiting for it\n        // AudioSampleCache should ideally support storing \"empty\" state or we just rely on has() returning false\n        // But has() returning false triggers fetch.\n        // We need a way to say \"fetched, but no audio\".\n        // Currently AudioSampleCache.set requires samples.\n        // We might need to update AudioSampleCache to support explicit \"no audio\" record\n        // Or we rely on MP4Index having audio track info.\n      }\n    } catch (error) {\n      console.error(`[ResourceLoader] Failed to parse MP4 index for ${resourceId}:`, error);\n      // Rethrow error to ensure resource is marked as failed\n      // In the new architecture (Window Cache + AudioSampleCache), index parsing is critical.\n      throw error;\n    }\n  }\n\n  /**\n   * Load text-based resources (json, text)\n   * Just download the content - state management is handled by startLoad()\n   */\n  private async loadTextResource(task: LoadTask): Promise<void> {\n    await this.fetchBlob(task.resource.uri, task.controller!.signal);\n    // For json/text, just verify we can download it\n    // Future: could parse and validate json here if needed\n  }\n\n  /**\n   * Load image resource: fetch blob → create ImageBitmap → cache in CacheManager\n   * Note: Images don't need streaming (typically < 5MB)\n   *\n   * Strategy for window cache architecture:\n   * - Store ImageBitmap in CacheManager.imageBitmapCache (main thread accessible)\n   * - OnDemandComposeSession retrieves from cache for composition\n   * - No longer transfer to Worker (composition is in main thread)\n   */\n  private async loadImageBitmap(task: LoadTask): Promise<void> {\n    // Check cache\n    let blob = this.blobCache.get(task.resourceId);\n\n    if (!blob) {\n      // Not cached: download and cache\n      blob = await this.fetchBlob(task.resource.uri, task.controller!.signal);\n      this.blobCache.set(task.resourceId, blob);\n    }\n\n    // Create ImageBitmap from Blob (with special handling for SVG)\n    const imageBitmap = await createImageBitmapFromBlob(blob);\n\n    // Store in CacheManager for main-thread access (OnDemandComposeSession)\n    this.cacheManager.imageBitmapCache.set(task.resourceId, imageBitmap);\n\n    // Legacy: Transfer to Worker if sessionId is provided (for old pipeline compatibility)\n    // if (task.sessionId) {\n    //   await this.transferImageToWorker(task, imageBitmap);\n\n    //   // Process pending transfer queue\n    //   const pending = this.pendingTransfers.get(task.resourceId);\n    //   if (pending && pending.length > 0) {\n    //     for (const sessionId of pending) {\n    //       await this.transferCachedImage(task.resourceId, sessionId);\n    //     }\n    //     this.pendingTransfers.delete(task.resourceId);\n    //   }\n    // }\n  }\n\n  /**\n   * Fetch resource as blob (for images, json, etc.)\n   */\n  private async fetchBlob(uri: string, signal: AbortSignal): Promise<Blob> {\n    const response = await fetch(uri, { signal });\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    return response.blob();\n  }\n\n  /**\n   * Transfer ImageBitmap to VideoComposeWorker\n   * Legacy: Not used in window cache architecture (images accessed via CacheManager)\n   */\n  // private async transferImageToWorker(task: LoadTask, imageBitmap: ImageBitmap): Promise<void> {\n  //   if (!this.orchestrator) return;\n\n  //   if (!task.sessionId) {\n  //     throw new Error(\n  //       `[ResourceLoader] sessionId required for resource ${task.resourceId}. ` +\n  //         `In Clip-based architecture, use fetch(resourceId, { sessionId })`\n  //     );\n  //   }\n\n  //   const composeWorker = await this.orchestrator.workers.get('videoCompose', task.sessionId);\n  //   await composeWorker?.send?.(\n  //     'receive_image',\n  //     {\n  //       resourceId: task.resourceId,\n  //       sessionId: task.sessionId,\n  //       imageBitmap,\n  //     },\n  //     { transfer: [imageBitmap] }\n  //   );\n  // }\n\n  /**\n   * Transfer cached image to a session\n   * Creates new ImageBitmap from cached Blob and transfers to worker\n   */\n  private async transferCachedImage(resourceId: string, sessionId?: string): Promise<void> {\n    const blob = this.blobCache.get(resourceId);\n    if (!blob || !sessionId) return;\n\n    // Create new ImageBitmap from cached Blob (with SVG support)\n    const imageBitmap = await createImageBitmapFromBlob(blob);\n\n    // Transfer to Worker\n    const composeWorker = await this.workerPool.get('videoCompose', sessionId);\n\n    await composeWorker?.send?.(\n      'receive_image',\n      {\n        resourceId,\n        sessionId,\n        imageBitmap,\n      },\n      { transfer: [imageBitmap] }\n    );\n  }\n\n  /**\n   * Transfer stream to demux worker (for audio files)\n   */\n  private async transferToDemuxWorker(task: LoadTask): Promise<void> {\n    if (!task.stream) return;\n\n    if (!task.sessionId) {\n      throw new Error(\n        `[ResourceLoader] sessionId required for resource ${task.resourceId}. ` +\n          `In Clip-based architecture, use fetch(resourceId, { sessionId })`\n      );\n    }\n\n    const workerType = task.resource.type === 'video' ? 'videoDemux' : 'audioDemux';\n    const demuxWorker = await this.workerPool.get(workerType, task.sessionId);\n    if (demuxWorker) {\n      await demuxWorker.sendStream(task.stream, {\n        sessionId: task.sessionId,\n        ...task.metadata,\n        ...(task.range && { range: task.range }),\n        ...(task.trackId && { trackId: task.trackId }),\n      });\n    } else {\n      // Demux worker not ready - cancel stream\n      task.stream.cancel();\n    }\n  }\n\n  private updateResourceState(resourceId: string, state: Resource['state']): void {\n    const resource = this.model?.resources.get(resourceId);\n    if (resource) {\n      const oldState = resource.state;\n      resource.state = state;\n      this.eventBus?.emit(MeframeEvent.ResourceStageChange, {\n        type: MeframeEvent.ResourceStageChange,\n        resourceId,\n        oldState,\n        newState: state,\n      });\n    }\n\n    this.onStateChange?.(resourceId, state);\n  }\n\n  async fetch(resourceId?: string, options?: ResourceLoadOptions): Promise<void> {\n    if (!resourceId) {\n      return;\n    }\n\n    const resource = this.model?.resources.get(resourceId);\n    if (!resource) {\n      console.warn(`Resource ${resourceId} not found in model`);\n      return;\n    }\n\n    const transferResourceToWorker = async (\n      rId: string,\n      sId: string,\n      type: string\n    ): Promise<void> => {\n      if (type === 'video') {\n        const stream = await this.createOPFSReadStream(rId);\n        // Mock a task to reuse transfer logic\n        const task: LoadTask = {\n          resourceId: rId,\n          sessionId: sId,\n          resource: this.model?.resources.get(rId)!,\n          stream,\n          bytesLoaded: 0,\n          totalBytes: 0,\n          startTime: Date.now(),\n          priority: 'normal',\n        };\n        await this.transferToDemuxWorker(task);\n      } else if (type === 'image') {\n        await this.transferCachedImage(rId, sId);\n      }\n    };\n\n    // If resource is already ready, check if we need to transfer stream (Worker Pipeline)\n    if (resource.state === 'ready') {\n      if (options?.sessionId) {\n        await transferResourceToWorker(resourceId, options.sessionId, resource.type);\n      }\n      return;\n    }\n\n    // Check if task already exists\n    let taskPromise = this.taskManager.getTaskPromise(resourceId);\n    let isCoveredByTask = false;\n\n    if (taskPromise) {\n      // Check if existing task covers this session\n      // Use activeTasks map + taskQueue search instead of getTaskFromQueue\n      const activeTask =\n        this.taskManager.activeTasks.get(resourceId) ||\n        this.taskManager.taskQueue.find((t) => t.resourceId === resourceId);\n\n      if (activeTask && activeTask.sessionId === options?.sessionId) {\n        isCoveredByTask = true;\n      }\n    } else {\n      // No task, we create it.\n      // enqueue() will create the task with promise\n      this.enqueueLoad(\n        resource,\n        options?.priority || 'normal',\n        options?.sessionId,\n        options?.clipId,\n        options?.trackId,\n        options?.isMainTrack ?? false\n      );\n      // Get the newly created promise\n      taskPromise = this.taskManager.getTaskPromise(resourceId);\n      isCoveredByTask = true;\n    }\n\n    // Wait for task to complete\n    await taskPromise;\n\n    // If we weren't the primary session for the task, transfer now from cache/OPFS\n    // We must re-check resource.state here because it might have failed\n    const updatedResource = this.model?.resources.get(resourceId);\n    if (!isCoveredByTask && updatedResource?.state === 'ready' && options?.sessionId) {\n      await transferResourceToWorker(resourceId, options.sessionId, resource.type);\n    }\n  }\n\n  cancel(resourceId: string): void {\n    this.taskManager.cancelTask(resourceId);\n    this.processQueue();\n  }\n\n  /**\n   * Check if a resource is currently being loaded\n   */\n  isResourceLoading(resourceId: string): boolean {\n    return this.taskManager.hasActiveTask(resourceId);\n  }\n\n  pause(resourceId: string): void {\n    const task = this.taskManager.getActiveTask(resourceId);\n    if (task) {\n      task.controller?.abort();\n    }\n  }\n\n  async resume(resourceId: string, options?: ResourceLoadOptions): Promise<void> {\n    const resource = this.model?.getResource(resourceId);\n    if (!resource) {\n      throw new Error(`Resource ${resourceId} not found`);\n    }\n\n    const pausedTask = this.taskManager.getActiveTask(resourceId);\n\n    if (pausedTask?.pausedAt !== undefined) {\n      this.enqueueLoad(\n        resource,\n        options?.priority || 'normal',\n        options?.sessionId,\n        options?.clipId,\n        options?.trackId\n      );\n    } else {\n      await this.fetch(resourceId, options);\n    }\n  }\n\n  get activeTasks(): Map<string, LoadTask> {\n    return this.taskManager.activeTasks;\n  }\n\n  get taskQueue(): LoadTask[] {\n    return this.taskManager.taskQueue;\n  }\n\n  dispose(): void {\n    this.taskManager.clear();\n    this.byteRangeResolver.dispose();\n    this.blobCache.clear();\n    this.pendingTransfers.clear();\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/stages/load/TaskManager.d.ts

@@ -14,10 +14,14 @@ export declare class TaskManager {
      * Check if a resource is already being loaded
      */
     hasActiveTask(resourceId: string): boolean;
+    /**
+     * Get task promise (task must already exist)
+     */
+    getTaskPromise(resourceId: string): Promise<void> | undefined;
     /**
      * Create and enqueue a new task
      */
-    enqueue(resource: Resource, priority?: 'high' | 'normal' | 'low', sessionId?: string, trackId?: string): LoadTask;
+    enqueue(resource: Resource, priority?: 'high' | 'normal' | 'low', sessionId?: string, clipId?: string, trackId?: string): LoadTask;
     /**
      * Get next task from queue if under concurrent limit
      */
@@ -29,7 +33,7 @@ export declare class TaskManager {
     /**
      * Mark task as completed
      */
-    completeTask(resourceId: string): void;
+    completeTask(resourceId: string, error?: Error): void;
     /**
      * Cancel a task
      */