@meframe/core 0.0.1

package/dist/stages/load/ResourceLoader.js

@@ -0,0 +1,184 @@
+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";
+class ResourceLoader {
+  orchestrator;
+  model;
+  taskManager;
+  streamFactory;
+  eventHandlers;
+  eventBus;
+  onStateChange;
+  byteRangeResolver;
+  constructor(options) {
+    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.byteRangeResolver = new WindowByteRangeResolver();
+    if (options?.orchestrator) {
+      this.bind(options.orchestrator);
+    }
+  }
+  /**
+   * Bind to Orchestrator event system
+   */
+  bind(orchestrator) {
+    this.unbind();
+    this.orchestrator = orchestrator;
+    this.eventHandlers = new EventHandlers(
+      orchestrator,
+      (resource, priority) => this.enqueueLoad(resource, priority),
+      (resourceId) => this.cancel(resourceId),
+      (model) => this.handleModelSet(model)
+    );
+  }
+  /**
+   * Unbind from Orchestrator
+   */
+  unbind() {
+    this.eventHandlers?.dispose();
+    this.eventHandlers = void 0;
+    this.orchestrator = void 0;
+  }
+  handleModelSet(model) {
+    this.model = model;
+  }
+  enqueueLoad(resource, priority = "normal", range) {
+    if (this.taskManager.hasActiveTask(resource.id)) {
+      return;
+    }
+    if (resource.type === "json" || resource.type === "text") {
+      this.loadNonStreamingResource(resource);
+      return;
+    }
+    const task = this.taskManager.enqueue(resource, priority);
+    if (task && range) {
+      task.range = range;
+    }
+    this.processQueue();
+  }
+  processQueue() {
+    while (this.taskManager.canProcess) {
+      const task = this.taskManager.getNextTask();
+      if (!task) break;
+      this.startLoad(task);
+    }
+  }
+  async startLoad(task) {
+    this.taskManager.activateTask(task);
+    try {
+      this.updateResourceState(task.resourceId, "loading");
+      task.controller = new AbortController();
+      const stream = await this.streamFactory.createRegularStream(task);
+      if (!stream) {
+        throw new Error(`Failed to create stream for ${task.resourceId}`);
+      }
+      task.stream = stream;
+      if (task.resource.type === "video" || task.resource.type === "audio") {
+        await this.transferToDemuxWorker(task);
+      }
+      this.updateResourceState(task.resourceId, "ready");
+    } catch (error) {
+      task.error = error;
+      this.updateResourceState(task.resourceId, "error");
+    } finally {
+      this.taskManager.completeTask(task.resourceId);
+      this.processQueue();
+    }
+  }
+  async loadNonStreamingResource(resource) {
+    try {
+      this.updateResourceState(resource.id, "loading");
+      const response = await fetch(resource.uri);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      this.updateResourceState(resource.id, "ready");
+    } catch {
+      this.updateResourceState(resource.id, "error");
+    }
+  }
+  async transferToDemuxWorker(task) {
+    if (!task.stream || !this.orchestrator) return;
+    const workerType = task.resource.type === "video" ? "videoDemux" : "audioDemux";
+    const demuxWorker = await this.orchestrator.workers.get(workerType, task.resourceId, {
+      lazy: true
+    });
+    const clipIds = this.model?.getClipIdsByResourceId?.(task.resourceId) || [];
+    const clipId = clipIds[0];
+    await demuxWorker.sendStream(task.stream, {
+      resourceId: task.resourceId,
+      clipId,
+      ...task.metadata,
+      ...task.range && { range: task.range }
+    });
+  }
+  updateResourceState(resourceId, state) {
+    const resource = this.model?.resources.get(resourceId);
+    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.onStateChange?.(resourceId, state);
+  }
+  async fetch(resourceId, options) {
+    if (!resourceId) {
+      return;
+    }
+    const resource = this.model?.resources.get(resourceId);
+    if (!resource) {
+      console.warn(`Resource ${resourceId} not found in model`);
+      return;
+    }
+    this.enqueueLoad(resource, options?.priority || "normal", options?.range);
+  }
+  cancel(resourceId) {
+    this.taskManager.cancelTask(resourceId);
+    this.processQueue();
+  }
+  pause(resourceId) {
+    const task = this.taskManager.getActiveTask(resourceId);
+    if (task) {
+      task.controller?.abort();
+    }
+  }
+  async resume(resourceId, options) {
+    const resource = this.model?.getResource(resourceId);
+    if (!resource) {
+      throw new Error(`Resource ${resourceId} not found`);
+    }
+    const pausedTask = this.taskManager.getActiveTask(resourceId);
+    if (pausedTask?.pausedAt !== void 0) {
+      this.enqueueLoad(resource, options?.priority || "normal");
+    } else {
+      await this.fetch(resourceId, options);
+    }
+  }
+  get activeTasks() {
+    return this.taskManager.activeTasks;
+  }
+  get taskQueue() {
+    return this.taskManager.taskQueue;
+  }
+  dispose() {
+    this.taskManager.clear();
+    this.byteRangeResolver.dispose();
+    this.unbind();
+  }
+}
+export {
+  ResourceLoader
+};
+//# sourceMappingURL=ResourceLoader.js.map

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

@@ -0,0 +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';\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\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      (resource, priority) => this.enqueueLoad(resource, priority),\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    range?: { start: number; end: number }\n  ): void {\n    if (this.taskManager.hasActiveTask(resource.id)) {\n      return;\n    }\n\n    if (resource.type === 'json' || resource.type === 'text') {\n      this.loadNonStreamingResource(resource);\n      return;\n    }\n\n    const task = this.taskManager.enqueue(resource, priority);\n    if (task && range) {\n      task.range = range;\n    }\n    this.processQueue();\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  private async startLoad(task: LoadTask): Promise<void> {\n    this.taskManager.activateTask(task);\n\n    try {\n      this.updateResourceState(task.resourceId, 'loading');\n      task.controller = new AbortController();\n\n      // const metadata = await this.streamFactory.fetchMetadata(\n      //   task.resource.uri,\n      //   task.controller.signal\n      // );\n\n      // if (metadata) {\n      //   task.metadata = metadata;\n      //   task.totalBytes = metadata.contentLength;\n      // }\n\n      // let stream =\n      //   metadata?.acceptRanges && task.pausedAt !== undefined\n      //     ? this.streamFactory.createResumableStream(task)\n      //     : await this.streamFactory.createRegularStream(task);\n\n      const stream = await this.streamFactory.createRegularStream(task);\n\n      if (!stream) {\n        throw new Error(`Failed to create stream for ${task.resourceId}`);\n      }\n\n      task.stream = stream;\n\n      if (task.resource.type === 'video' || task.resource.type === 'audio') {\n        await this.transferToDemuxWorker(task);\n      }\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  private async loadNonStreamingResource(resource: Resource): Promise<void> {\n    try {\n      this.updateResourceState(resource.id, 'loading');\n      const response = await fetch(resource.uri);\n      if (!response.ok) {\n        throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n      }\n      this.updateResourceState(resource.id, 'ready');\n    } catch {\n      this.updateResourceState(resource.id, 'error');\n    }\n  }\n\n  private async transferToDemuxWorker(task: LoadTask): Promise<void> {\n    if (!task.stream || !this.orchestrator) return;\n\n    const workerType = task.resource.type === 'video' ? 'videoDemux' : 'audioDemux';\n    // use lazy mode to avoid initializing worker when not needed\n    const demuxWorker = await this.orchestrator.workers.get(workerType, task.resourceId, {\n      lazy: true,\n    });\n\n    const clipIds = this.model?.getClipIdsByResourceId?.(task.resourceId) || [];\n    const clipId = clipIds[0];\n\n    await demuxWorker.sendStream(task.stream, {\n      resourceId: task.resourceId,\n      clipId,\n      ...task.metadata,\n      ...(task.range && { range: task.range }),\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(resource, options?.priority || 'normal', options?.range);\n  }\n\n  cancel(resourceId: string): void {\n    this.taskManager.cancelTask(resourceId);\n    this.processQueue();\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(resource, options?.priority || 'normal');\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.unbind();\n  }\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,42 @@
+import { LoadTask, LoadProgress, StreamMetadata, LoaderConfig } from './types';
+
+/**
+ * Factory for creating various types of streams with backpressure configuration
+ */
+export declare class StreamFactory {
+    private onProgress?;
+    private static readonly DEFAULT_HIGH_WATER_MARK;
+    private static readonly DEFAULT_CHUNK_SIZE;
+    private static readonly DEFAULT_RETRY_COUNT;
+    private static readonly DEFAULT_RETRY_DELAY;
+    private readonly highWaterMark;
+    private readonly chunkSize;
+    private readonly retryCount;
+    private readonly retryDelay;
+    constructor(onProgress?: ((progress: LoadProgress) => void) | undefined, config?: LoaderConfig);
+    /**
+     * Fetch metadata for a resource
+     */
+    fetchMetadata(url: string, signal: AbortSignal): Promise<StreamMetadata | null>;
+    /**
+     * Create a regular (non-resumable) stream
+     */
+    createRegularStream(task: LoadTask): Promise<ReadableStream<Uint8Array> | null>;
+    /**
+     * Create a resumable stream with Range support
+     */
+    createResumableStream(task: LoadTask): ReadableStream<Uint8Array>;
+    /**
+     * Wrap stream with progress tracking
+     */
+    wrapWithProgress(stream: ReadableStream<Uint8Array>, task: LoadTask): ReadableStream<Uint8Array>;
+    /**
+     * Fetch with retry logic
+     */
+    private fetchWithRetry;
+    /**
+     * Report progress
+     */
+    private reportProgress;
+}
+//# sourceMappingURL=StreamFactory.d.ts.map

package/dist/stages/load/StreamFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamFactory.d.ts","sourceRoot":"","sources":["../../../src/stages/load/StreamFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEpF;;GAEG;AACH,qBAAa,aAAa;IAatB,OAAO,CAAC,UAAU,CAAC;IAXrB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,uBAAuB,CAAe;IAC9D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,kBAAkB,CAAe;IACzD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAK;IAChD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,mBAAmB,CAAO;IAElD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAG1B,UAAU,CAAC,GAAE,CAAC,QAAQ,EAAE,YAAY,KAAK,IAAI,aAAA,EACrD,MAAM,CAAC,EAAE,YAAY;IASvB;;OAEG;IACG,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IAwBrF;;OAEG;IACG,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IAuBrF;;OAEG;IACH,qBAAqB,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC;IA8DjE;;OAEG;IACH,gBAAgB,CAAC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,CAAC;IAmChG;;OAEG;YACW,cAAc;IAkC5B;;OAEG;IACH,OAAO,CAAC,cAAc;CAkBvB"}

package/dist/stages/load/StreamFactory.js

@@ -0,0 +1,201 @@
+class StreamFactory {
+  constructor(onProgress, config) {
+    this.onProgress = onProgress;
+    this.highWaterMark = config?.highWaterMark ?? StreamFactory.DEFAULT_HIGH_WATER_MARK;
+    this.chunkSize = config?.chunkSize ?? StreamFactory.DEFAULT_CHUNK_SIZE;
+    this.retryCount = config?.retryCount ?? StreamFactory.DEFAULT_RETRY_COUNT;
+    this.retryDelay = config?.retryDelay ?? StreamFactory.DEFAULT_RETRY_DELAY;
+  }
+  // Default values as fallback
+  static DEFAULT_HIGH_WATER_MARK = 1024 * 1024;
+  // 1MB
+  static DEFAULT_CHUNK_SIZE = 1024 * 1024;
+  // 1MB
+  static DEFAULT_RETRY_COUNT = 3;
+  static DEFAULT_RETRY_DELAY = 500;
+  // ms
+  highWaterMark;
+  chunkSize;
+  retryCount;
+  retryDelay;
+  /**
+   * Fetch metadata for a resource
+   */
+  async fetchMetadata(url, signal) {
+    try {
+      const response = await fetch(url, {
+        method: "HEAD",
+        signal
+      });
+      if (!response.ok) {
+        return null;
+      }
+      return {
+        url,
+        contentLength: Number(response.headers.get("content-length") || 0),
+        acceptRanges: response.headers.get("accept-ranges") === "bytes",
+        contentType: response.headers.get("content-type") || void 0,
+        lastModified: response.headers.get("last-modified") || void 0,
+        etag: response.headers.get("etag") || void 0
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Create a regular (non-resumable) stream
+   */
+  async createRegularStream(task) {
+    const response = await this.fetchWithRetry(task.resource.uri, {
+      method: "GET",
+      // Explicitly specify GET (vs HEAD)
+      signal: task.controller.signal
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    if (!response.body) {
+      console.warn(
+        `[StreamFactory] Response body is null for ${task.resource.uri}, possibly cached HEAD response`
+      );
+      return null;
+    }
+    task.totalBytes = Number(response.headers.get("content-length") || 0);
+    return this.wrapWithProgress(response.body, task);
+  }
+  /**
+   * Create a resumable stream with Range support
+   */
+  createResumableStream(task) {
+    let bytesReceived = task.pausedAt || 0;
+    const totalSize = task.metadata?.contentLength || 0;
+    return new ReadableStream(
+      {
+        pull: async (controller) => {
+          if (controller.desiredSize !== null && controller.desiredSize <= 0) {
+            return;
+          }
+          if (bytesReceived >= totalSize) {
+            controller.close();
+            return;
+          }
+          const end = Math.min(bytesReceived + this.chunkSize - 1, totalSize - 1);
+          try {
+            const response = await fetch(task.resource.uri, {
+              method: "GET",
+              signal: task.controller.signal,
+              headers: { Range: `bytes=${bytesReceived}-${end}` }
+              // Use default cache for Range requests
+            });
+            if (!response.ok && response.status !== 206) {
+              throw new Error(`Range request failed: ${response.status}`);
+            }
+            if (!response.body) {
+              throw new Error(`Response body is null in Range request for ${task.resource.uri}`);
+            }
+            const chunk = await response.arrayBuffer();
+            const uint8Array = new Uint8Array(chunk);
+            controller.enqueue(uint8Array);
+            bytesReceived += chunk.byteLength;
+            task.bytesLoaded = bytesReceived;
+            this.reportProgress(task, bytesReceived, totalSize);
+          } catch (error) {
+            if (error.name === "AbortError") {
+              task.pausedAt = bytesReceived;
+            }
+            controller.error(error);
+          }
+        },
+        cancel: () => {
+          task.pausedAt = bytesReceived;
+        }
+      },
+      {
+        highWaterMark: this.highWaterMark,
+        size: (chunk) => chunk.byteLength
+      }
+    );
+  }
+  /**
+   * Wrap stream with progress tracking
+   */
+  wrapWithProgress(stream, task) {
+    const reader = stream.getReader();
+    let bytesReceived = 0;
+    return new ReadableStream(
+      {
+        pull: async (controller) => {
+          while (true) {
+            try {
+              const { done, value } = await reader.read();
+              if (done) {
+                controller.close();
+                break;
+              }
+              bytesReceived += value.byteLength;
+              task.bytesLoaded = bytesReceived;
+              this.reportProgress(task, bytesReceived, task.totalBytes);
+              controller.enqueue(value);
+            } catch (error) {
+              controller.error(error);
+              break;
+            }
+          }
+        },
+        cancel: () => reader.cancel()
+      },
+      {
+        highWaterMark: this.highWaterMark,
+        size: (chunk) => chunk.byteLength
+      }
+    );
+  }
+  /**
+   * Fetch with retry logic
+   */
+  async fetchWithRetry(url, init) {
+    let lastError = null;
+    for (let i = 0; i <= this.retryCount; i++) {
+      try {
+        const response = await fetch(url, init);
+        if (response.ok || response.status === 206) {
+          return response;
+        }
+        if (response.status >= 400 && response.status < 500) {
+          return response;
+        }
+        lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+      } catch (error) {
+        lastError = error;
+        if (error.name === "AbortError") {
+          throw error;
+        }
+      }
+      if (i < this.retryCount) {
+        await new Promise((resolve) => setTimeout(resolve, this.retryDelay * Math.pow(2, i)));
+      }
+    }
+    throw lastError || new Error("Failed to fetch after retries");
+  }
+  /**
+   * Report progress
+   */
+  reportProgress(task, bytesLoaded, totalBytes) {
+    if (!this.onProgress || !task.resource.id) return;
+    const elapsedSeconds = (Date.now() - task.startTime) / 1e3;
+    const speed = bytesLoaded / elapsedSeconds;
+    const progress = {
+      resourceId: task.resource.id,
+      bytesLoaded,
+      totalBytes,
+      percentage: totalBytes > 0 ? bytesLoaded / totalBytes * 100 : 0,
+      speed,
+      estimatedTimeRemaining: speed > 0 && totalBytes > 0 ? (totalBytes - bytesLoaded) / speed * 1e3 : 0
+    };
+    this.onProgress(progress);
+  }
+}
+export {
+  StreamFactory
+};
+//# sourceMappingURL=StreamFactory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StreamFactory.js","sources":["../../../src/stages/load/StreamFactory.ts"],"sourcesContent":["import type { LoadTask, LoadProgress, StreamMetadata, LoaderConfig } from './types';\n\n/**\n * Factory for creating various types of streams with backpressure configuration\n */\nexport class StreamFactory {\n  // Default values as fallback\n  private static readonly DEFAULT_HIGH_WATER_MARK = 1024 * 1024; // 1MB\n  private static readonly DEFAULT_CHUNK_SIZE = 1024 * 1024; // 1MB\n  private static readonly DEFAULT_RETRY_COUNT = 3;\n  private static readonly DEFAULT_RETRY_DELAY = 500; // ms\n\n  private readonly highWaterMark: number;\n  private readonly chunkSize: number;\n  private readonly retryCount: number;\n  private readonly retryDelay: number;\n\n  constructor(\n    private onProgress?: (progress: LoadProgress) => void,\n    config?: LoaderConfig\n  ) {\n    // Use provided config with local defaults as fallback\n    this.highWaterMark = config?.highWaterMark ?? StreamFactory.DEFAULT_HIGH_WATER_MARK;\n    this.chunkSize = config?.chunkSize ?? StreamFactory.DEFAULT_CHUNK_SIZE;\n    this.retryCount = config?.retryCount ?? StreamFactory.DEFAULT_RETRY_COUNT;\n    this.retryDelay = config?.retryDelay ?? StreamFactory.DEFAULT_RETRY_DELAY;\n  }\n\n  /**\n   * Fetch metadata for a resource\n   */\n  async fetchMetadata(url: string, signal: AbortSignal): Promise<StreamMetadata | null> {\n    try {\n      const response = await fetch(url, {\n        method: 'HEAD',\n        signal,\n      });\n\n      if (!response.ok) {\n        return null;\n      }\n\n      return {\n        url,\n        contentLength: Number(response.headers.get('content-length') || 0),\n        acceptRanges: response.headers.get('accept-ranges') === 'bytes',\n        contentType: response.headers.get('content-type') || undefined,\n        lastModified: response.headers.get('last-modified') || undefined,\n        etag: response.headers.get('etag') || undefined,\n      };\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Create a regular (non-resumable) stream\n   */\n  async createRegularStream(task: LoadTask): Promise<ReadableStream<Uint8Array> | null> {\n    const response = await this.fetchWithRetry(task.resource.uri, {\n      method: 'GET', // Explicitly specify GET (vs HEAD)\n      signal: task.controller!.signal,\n    });\n\n    if (!response.ok) {\n      throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n    }\n\n    // Return null if body is empty (e.g., from cached HEAD response)\n    // ResourceLoader should retry with forceFresh in this case\n    if (!response.body) {\n      console.warn(\n        `[StreamFactory] Response body is null for ${task.resource.uri}, possibly cached HEAD response`\n      );\n      return null;\n    }\n\n    task.totalBytes = Number(response.headers.get('content-length') || 0);\n    return this.wrapWithProgress(response.body, task);\n  }\n\n  /**\n   * Create a resumable stream with Range support\n   */\n  createResumableStream(task: LoadTask): ReadableStream<Uint8Array> {\n    let bytesReceived = task.pausedAt || 0;\n    const totalSize = task.metadata?.contentLength || 0;\n\n    return new ReadableStream<Uint8Array>(\n      {\n        pull: async (controller) => {\n          // Backpressure: wait for downstream to consume\n          if (controller.desiredSize !== null && controller.desiredSize <= 0) {\n            return;\n          }\n\n          if (bytesReceived >= totalSize) {\n            controller.close();\n            return;\n          }\n\n          const end = Math.min(bytesReceived + this.chunkSize - 1, totalSize - 1);\n\n          try {\n            const response = await fetch(task.resource.uri, {\n              method: 'GET',\n              signal: task.controller!.signal,\n              headers: { Range: `bytes=${bytesReceived}-${end}` },\n              // Use default cache for Range requests\n            });\n\n            if (!response.ok && response.status !== 206) {\n              throw new Error(`Range request failed: ${response.status}`);\n            }\n\n            if (!response.body) {\n              throw new Error(`Response body is null in Range request for ${task.resource.uri}`);\n            }\n\n            const chunk = await response.arrayBuffer();\n            const uint8Array = new Uint8Array(chunk);\n\n            controller.enqueue(uint8Array);\n            bytesReceived += chunk.byteLength;\n            task.bytesLoaded = bytesReceived;\n\n            this.reportProgress(task, bytesReceived, totalSize);\n          } catch (error: any) {\n            if (error.name === 'AbortError') {\n              task.pausedAt = bytesReceived;\n            }\n            controller.error(error);\n          }\n        },\n\n        cancel: () => {\n          task.pausedAt = bytesReceived;\n        },\n      },\n      {\n        highWaterMark: this.highWaterMark,\n        size: (chunk) => chunk.byteLength,\n      }\n    );\n  }\n\n  /**\n   * Wrap stream with progress tracking\n   */\n  wrapWithProgress(stream: ReadableStream<Uint8Array>, task: LoadTask): ReadableStream<Uint8Array> {\n    const reader = stream.getReader();\n    let bytesReceived = 0;\n\n    return new ReadableStream<Uint8Array>(\n      {\n        pull: async (controller) => {\n          while (true) {\n            try {\n              const { done, value } = await reader.read();\n              if (done) {\n                controller.close();\n                break;\n              }\n\n              bytesReceived += value.byteLength;\n              task.bytesLoaded = bytesReceived;\n              this.reportProgress(task, bytesReceived, task.totalBytes);\n              controller.enqueue(value);\n            } catch (error) {\n              controller.error(error);\n              break;\n            }\n          }\n        },\n\n        cancel: () => reader.cancel(),\n      },\n      {\n        highWaterMark: this.highWaterMark,\n        size: (chunk) => chunk.byteLength,\n      }\n    );\n  }\n\n  /**\n   * Fetch with retry logic\n   */\n  private async fetchWithRetry(url: string, init: RequestInit): Promise<Response> {\n    let lastError: Error | null = null;\n\n    for (let i = 0; i <= this.retryCount; i++) {\n      try {\n        const response = await fetch(url, init);\n        if (response.ok || response.status === 206) {\n          return response;\n        }\n\n        // Don't retry on client errors (4xx)\n        if (response.status >= 400 && response.status < 500) {\n          return response;\n        }\n\n        lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);\n      } catch (error: any) {\n        lastError = error;\n\n        // Don't retry on abort\n        if (error.name === 'AbortError') {\n          throw error;\n        }\n      }\n\n      // Exponential backoff\n      if (i < this.retryCount) {\n        await new Promise((resolve) => setTimeout(resolve, this.retryDelay * Math.pow(2, i)));\n      }\n    }\n\n    throw lastError || new Error('Failed to fetch after retries');\n  }\n\n  /**\n   * Report progress\n   */\n  private reportProgress(task: LoadTask, bytesLoaded: number, totalBytes: number): void {\n    if (!this.onProgress || !task.resource.id) return;\n\n    const elapsedSeconds = (Date.now() - task.startTime) / 1000;\n    const speed = bytesLoaded / elapsedSeconds;\n\n    const progress: LoadProgress = {\n      resourceId: task.resource.id,\n      bytesLoaded,\n      totalBytes,\n      percentage: totalBytes > 0 ? (bytesLoaded / totalBytes) * 100 : 0,\n      speed,\n      estimatedTimeRemaining:\n        speed > 0 && totalBytes > 0 ? ((totalBytes - bytesLoaded) / speed) * 1000 : 0,\n    };\n\n    this.onProgress(progress);\n  }\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,50 @@
+import { LoadTask } from './types';
+import { Resource } from '../../model';
+
+/**
+ * Manages resource loading tasks and queue
+ */
+export declare class TaskManager {
+    activeTasks: Map<string, LoadTask>;
+    taskQueue: LoadTask[];
+    private concurrentCount;
+    private maxConcurrent;
+    constructor(maxConcurrent?: number);
+    /**
+     * Check if a resource is already being loaded
+     */
+    hasActiveTask(resourceId: string): boolean;
+    /**
+     * Create and enqueue a new task
+     */
+    enqueue(resource: Resource, priority?: 'high' | 'normal' | 'low'): LoadTask;
+    /**
+     * Get next task from queue if under concurrent limit
+     */
+    getNextTask(): LoadTask | null;
+    /**
+     * Mark task as active
+     */
+    activateTask(task: LoadTask): void;
+    /**
+     * Mark task as completed
+     */
+    completeTask(resourceId: string): void;
+    /**
+     * Cancel a task
+     */
+    cancelTask(resourceId: string): boolean;
+    /**
+     * Find an active task
+     */
+    getActiveTask(resourceId: string): LoadTask | undefined;
+    /**
+     * Check if can process more tasks
+     */
+    get canProcess(): boolean;
+    /**
+     * Clear all tasks
+     */
+    clear(): void;
+}
+//# sourceMappingURL=TaskManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TaskManager.d.ts","sourceRoot":"","sources":["../../../src/stages/load/TaskManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;GAEG;AACH,qBAAa,WAAW;IACtB,WAAW,wBAA+B;IAC1C,SAAS,EAAE,QAAQ,EAAE,CAAM;IAC3B,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,aAAa,CAAS;gBAElB,aAAa,GAAE,MAAU;IAIrC;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAI1C;;OAEG;IACH,OAAO,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,GAAE,MAAM,GAAG,QAAQ,GAAG,KAAgB,GAAG,QAAQ;IAoBrF;;OAEG;IACH,WAAW,IAAI,QAAQ,GAAG,IAAI;IAQ9B;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAKlC;;OAEG;IACH,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAOtC;;OAEG;IACH,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAkBvC;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS;IAIvD;;OAEG;IACH,IAAI,UAAU,IAAI,OAAO,CAExB;IAED;;OAEG;IACH,KAAK,IAAI,IAAI;CAUd"}

package/dist/stages/load/TaskManager.js

@@ -0,0 +1,103 @@
+class TaskManager {
+  activeTasks = /* @__PURE__ */ new Map();
+  taskQueue = [];
+  concurrentCount = 0;
+  maxConcurrent;
+  constructor(maxConcurrent = 4) {
+    this.maxConcurrent = maxConcurrent;
+  }
+  /**
+   * Check if a resource is already being loaded
+   */
+  hasActiveTask(resourceId) {
+    return this.activeTasks.has(resourceId);
+  }
+  /**
+   * Create and enqueue a new task
+   */
+  enqueue(resource, priority = "normal") {
+    const task = {
+      resourceId: resource.id,
+      resource,
+      bytesLoaded: 0,
+      totalBytes: 0,
+      startTime: Date.now(),
+      priority
+    };
+    if (priority === "high") {
+      this.taskQueue.unshift(task);
+    } else {
+      this.taskQueue.push(task);
+    }
+    return task;
+  }
+  /**
+   * Get next task from queue if under concurrent limit
+   */
+  getNextTask() {
+    if (this.taskQueue.length === 0 || this.concurrentCount >= this.maxConcurrent) {
+      return null;
+    }
+    return this.taskQueue.shift() || null;
+  }
+  /**
+   * Mark task as active
+   */
+  activateTask(task) {
+    this.activeTasks.set(task.resourceId, task);
+    this.concurrentCount++;
+  }
+  /**
+   * Mark task as completed
+   */
+  completeTask(resourceId) {
+    if (this.activeTasks.has(resourceId)) {
+      this.activeTasks.delete(resourceId);
+      this.concurrentCount--;
+    }
+  }
+  /**
+   * Cancel a task
+   */
+  cancelTask(resourceId) {
+    const task = this.activeTasks.get(resourceId);
+    if (task) {
+      task.controller?.abort();
+      this.completeTask(resourceId);
+      return true;
+    }
+    const index = this.taskQueue.findIndex((t) => t.resourceId === resourceId);
+    if (index >= 0) {
+      this.taskQueue.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Find an active task
+   */
+  getActiveTask(resourceId) {
+    return this.activeTasks.get(resourceId);
+  }
+  /**
+   * Check if can process more tasks
+   */
+  get canProcess() {
+    return this.concurrentCount < this.maxConcurrent;
+  }
+  /**
+   * Clear all tasks
+   */
+  clear() {
+    for (const task of this.activeTasks.values()) {
+      task.controller?.abort();
+    }
+    this.activeTasks.clear();
+    this.taskQueue = [];
+    this.concurrentCount = 0;
+  }
+}
+export {
+  TaskManager
+};
+//# sourceMappingURL=TaskManager.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TaskManager.js","sources":["../../../src/stages/load/TaskManager.ts"],"sourcesContent":["import type { LoadTask } from './types';\nimport type { Resource } from '../../model';\n\n/**\n * Manages resource loading tasks and queue\n */\nexport class TaskManager {\n  activeTasks = new Map<string, LoadTask>();\n  taskQueue: LoadTask[] = [];\n  private concurrentCount = 0;\n  private maxConcurrent: number;\n\n  constructor(maxConcurrent: number = 4) {\n    this.maxConcurrent = maxConcurrent;\n  }\n\n  /**\n   * Check if a resource is already being loaded\n   */\n  hasActiveTask(resourceId: string): boolean {\n    return this.activeTasks.has(resourceId);\n  }\n\n  /**\n   * Create and enqueue a new task\n   */\n  enqueue(resource: Resource, priority: 'high' | 'normal' | 'low' = 'normal'): LoadTask {\n    const task: LoadTask = {\n      resourceId: resource.id,\n      resource,\n      bytesLoaded: 0,\n      totalBytes: 0,\n      startTime: Date.now(),\n      priority,\n    };\n\n    // Add to queue based on priority\n    if (priority === 'high') {\n      this.taskQueue.unshift(task);\n    } else {\n      this.taskQueue.push(task);\n    }\n\n    return task;\n  }\n\n  /**\n   * Get next task from queue if under concurrent limit\n   */\n  getNextTask(): LoadTask | null {\n    if (this.taskQueue.length === 0 || this.concurrentCount >= this.maxConcurrent) {\n      return null;\n    }\n\n    return this.taskQueue.shift() || null;\n  }\n\n  /**\n   * Mark task as active\n   */\n  activateTask(task: LoadTask): void {\n    this.activeTasks.set(task.resourceId, task);\n    this.concurrentCount++;\n  }\n\n  /**\n   * Mark task as completed\n   */\n  completeTask(resourceId: string): void {\n    if (this.activeTasks.has(resourceId)) {\n      this.activeTasks.delete(resourceId);\n      this.concurrentCount--;\n    }\n  }\n\n  /**\n   * Cancel a task\n   */\n  cancelTask(resourceId: string): boolean {\n    const task = this.activeTasks.get(resourceId);\n    if (task) {\n      task.controller?.abort();\n      this.completeTask(resourceId);\n      return true;\n    }\n\n    // Also remove from queue\n    const index = this.taskQueue.findIndex((t) => t.resourceId === resourceId);\n    if (index >= 0) {\n      this.taskQueue.splice(index, 1);\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Find an active task\n   */\n  getActiveTask(resourceId: string): LoadTask | undefined {\n    return this.activeTasks.get(resourceId);\n  }\n\n  /**\n   * Check if can process more tasks\n   */\n  get canProcess(): boolean {\n    return this.concurrentCount < this.maxConcurrent;\n  }\n\n  /**\n   * Clear all tasks\n   */\n  clear(): void {\n    // Cancel all active tasks\n    for (const task of this.activeTasks.values()) {\n      task.controller?.abort();\n    }\n\n    this.activeTasks.clear();\n    this.taskQueue = [];\n    this.concurrentCount = 0;\n  }\n}\n"],"names":[],"mappings":"AAMO,MAAM,YAAY;AAAA,EACvB,kCAAkB,IAAA;AAAA,EAClB,YAAwB,CAAA;AAAA,EAChB,kBAAkB;AAAA,EAClB;AAAA,EAER,YAAY,gBAAwB,GAAG;AACrC,SAAK,gBAAgB;AAAA,EACvB;AAAA;AAAA;AAAA;AAAA,EAKA,cAAc,YAA6B;AACzC,WAAO,KAAK,YAAY,IAAI,UAAU;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA,EAKA,QAAQ,UAAoB,WAAsC,UAAoB;AACpF,UAAM,OAAiB;AAAA,MACrB,YAAY,SAAS;AAAA,MACrB;AAAA,MACA,aAAa;AAAA,MACb,YAAY;AAAA,MACZ,WAAW,KAAK,IAAA;AAAA,MAChB;AAAA,IAAA;AAIF,QAAI,aAAa,QAAQ;AACvB,WAAK,UAAU,QAAQ,IAAI;AAAA,IAC7B,OAAO;AACL,WAAK,UAAU,KAAK,IAAI;AAAA,IAC1B;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,cAA+B;AAC7B,QAAI,KAAK,UAAU,WAAW,KAAK,KAAK,mBAAmB,KAAK,eAAe;AAC7E,aAAO;AAAA,IACT;AAEA,WAAO,KAAK,UAAU,MAAA,KAAW;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA,EAKA,aAAa,MAAsB;AACjC,SAAK,YAAY,IAAI,KAAK,YAAY,IAAI;AAC1C,SAAK;AAAA,EACP;AAAA;AAAA;AAAA;AAAA,EAKA,aAAa,YAA0B;AACrC,QAAI,KAAK,YAAY,IAAI,UAAU,GAAG;AACpC,WAAK,YAAY,OAAO,UAAU;AAClC,WAAK;AAAA,IACP;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,WAAW,YAA6B;AACtC,UAAM,OAAO,KAAK,YAAY,IAAI,UAAU;AAC5C,QAAI,MAAM;AACR,WAAK,YAAY,MAAA;AACjB,WAAK,aAAa,UAAU;AAC5B,aAAO;AAAA,IACT;AAGA,UAAM,QAAQ,KAAK,UAAU,UAAU,CAAC,MAAM,EAAE,eAAe,UAAU;AACzE,QAAI,SAAS,GAAG;AACd,WAAK,UAAU,OAAO,OAAO,CAAC;AAC9B,aAAO;AAAA,IACT;AAEA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,cAAc,YAA0C;AACtD,WAAO,KAAK,YAAY,IAAI,UAAU;AAAA,EACxC;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,aAAsB;AACxB,WAAO,KAAK,kBAAkB,KAAK;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA,EAKA,QAAc;AAEZ,eAAW,QAAQ,KAAK,YAAY,OAAA,GAAU;AAC5C,WAAK,YAAY,MAAA;AAAA,IACnB;AAEA,SAAK,YAAY,MAAA;AACjB,SAAK,YAAY,CAAA;AACjB,SAAK,kBAAkB;AAAA,EACzB;AACF;"}