@editframe/elements 0.37.3-beta → 0.38.0

package/dist/transcoding/types/index.d.ts

@@ -40,7 +40,7 @@ interface MediaEngine {
     id?: RenditionId;
     trackId: number | undefined;
     src: string;
-  }, signal?: AbortSignal) => Promise<ArrayBuffer>;
+  }, signal: AbortSignal) => Promise<ArrayBuffer>;
   computeSegmentId: (desiredSeekTimeMs: number, rendition: MediaRendition) => number | undefined;
   /**
    * Get the video rendition if available, otherwise return undefined.

package/dist/transcoding/utils/UrlGenerator.js

@@ -15,10 +15,17 @@ var UrlGenerator = class {
 	generateSegmentUrl(segmentId, renditionId, metadata) {
 		const audioRendition = metadata.audioRendition;
 		const videoRendition = metadata.videoRendition;
-		const rendition = audioRendition ?? videoRendition;
+		let rendition;
+		if (renditionId === "audio") rendition = audioRendition;
+		else rendition = videoRendition;
 		if (!rendition) {
-			console.error("Rendition not found", metadata);
-			throw new Error(`Rendition ${renditionId} not found`);
+			console.error("Rendition not found", {
+				renditionId,
+				hasAudio: !!audioRendition,
+				hasVideo: !!videoRendition,
+				metadata
+			});
+			throw new Error(`Rendition ${renditionId} not found (hasAudio=${!!audioRendition}, hasVideo=${!!videoRendition})`);
 		}
 		return (segmentId === "init" ? metadata.templates.initSegment : metadata.templates.mediaSegment).replace("{rendition}", renditionId).replace("{segmentId}", segmentId.toString()).replace("{src}", metadata.src).replace("{trackId}", rendition.trackId?.toString() ?? "");
 	}

package/dist/transcoding/utils/UrlGenerator.js.map

@@ -1 +1 @@
-{"version":3,"file":"UrlGenerator.js","names":["baseUrl: () => string"],"sources":["../../../src/transcoding/utils/UrlGenerator.ts"],"sourcesContent":["/**\n * URL generation utilities for transcoding endpoints\n */\n\nimport type { RenditionId } from \"../types/index.js\";\nimport type { MediaEngine } from \"../types/index.ts\";\n\nexport class UrlGenerator {\n  constructor(private baseUrl: () => string) {}\n\n  /**\n   * Get the base URL for constructing absolute URLs\n   */\n  getBaseUrl(): string {\n    return this.baseUrl();\n  }\n\n  /**\n   * Generate video segment URL\n   */\n  generateSegmentUrl(\n    segmentId: \"init\" | number,\n    renditionId: RenditionId,\n    metadata: MediaEngine,\n  ): string {\n    const audioRendition = metadata.audioRendition;\n    const videoRendition = metadata.videoRendition;\n    const rendition = audioRendition ?? videoRendition;\n    if (!rendition) {\n      console.error(\"Rendition not found\", metadata);\n      throw new Error(`Rendition ${renditionId} not found`);\n    }\n\n    const template =\n      segmentId === \"init\"\n        ? metadata.templates.initSegment\n        : metadata.templates.mediaSegment;\n    return template\n      .replace(\"{rendition}\", renditionId)\n      .replace(\"{segmentId}\", segmentId.toString())\n      .replace(\"{src}\", metadata.src)\n      .replace(\"{trackId}\", rendition.trackId?.toString() ?? \"\");\n  }\n\n  /**\n   * Generate init segment URL\n   */\n  generateInitSegmentUrl(mediaUrl: string, rendition: string): string {\n    return `${this.baseUrl()}/api/v1/transcode/${rendition}/init.mp4?url=${encodeURIComponent(mediaUrl)}`;\n  }\n\n  /**\n   * Generate manifest URL\n   */\n  generateManifestUrl(mediaUrl: string): string {\n    return `${this.baseUrl()}/api/v1/transcode/manifest.json?url=${encodeURIComponent(mediaUrl)}`;\n  }\n\n  /**\n   * Generate track fragment index URL using production API format\n   * @deprecated Use MD5-based URL generation in AssetMediaEngine.fetch() instead\n   */\n  generateTrackFragmentIndexUrl(mediaUrl: string): string {\n    // Normalize the path: remove leading slash and any double slashes\n    let normalizedSrc = mediaUrl.startsWith(\"/\")\n      ? mediaUrl.slice(1)\n      : mediaUrl;\n    // Remove any remaining leading slashes (handles cases like \"//assets/video.mp4\")\n    normalizedSrc = normalizedSrc.replace(/^\\/+/, \"\");\n    // Legacy format - kept for backward compatibility but should not be used\n    return `@ef-track-fragment-index/${normalizedSrc}`;\n  }\n\n  /**\n   * Generate quality presets URL\n   */\n  generatePresetsUrl(): string {\n    return `${this.baseUrl()}/api/v1/transcode/presets`;\n  }\n}\n"],"mappings":";AAOA,IAAa,eAAb,MAA0B;CACxB,YAAY,AAAQA,SAAuB;EAAvB;;;;;CAKpB,aAAqB;AACnB,SAAO,KAAK,SAAS;;;;;CAMvB,mBACE,WACA,aACA,UACQ;EACR,MAAM,iBAAiB,SAAS;EAChC,MAAM,iBAAiB,SAAS;EAChC,MAAM,YAAY,kBAAkB;AACpC,MAAI,CAAC,WAAW;AACd,WAAQ,MAAM,uBAAuB,SAAS;AAC9C,SAAM,IAAI,MAAM,aAAa,YAAY,YAAY;;AAOvD,UAHE,cAAc,SACV,SAAS,UAAU,cACnB,SAAS,UAAU,cAEtB,QAAQ,eAAe,YAAY,CACnC,QAAQ,eAAe,UAAU,UAAU,CAAC,CAC5C,QAAQ,SAAS,SAAS,IAAI,CAC9B,QAAQ,aAAa,UAAU,SAAS,UAAU,IAAI,GAAG;;;;;CAM9D,uBAAuB,UAAkB,WAA2B;AAClE,SAAO,GAAG,KAAK,SAAS,CAAC,oBAAoB,UAAU,gBAAgB,mBAAmB,SAAS;;;;;CAMrG,oBAAoB,UAA0B;AAC5C,SAAO,GAAG,KAAK,SAAS,CAAC,sCAAsC,mBAAmB,SAAS;;;;;;CAO7F,8BAA8B,UAA0B;EAEtD,IAAI,gBAAgB,SAAS,WAAW,IAAI,GACxC,SAAS,MAAM,EAAE,GACjB;AAEJ,kBAAgB,cAAc,QAAQ,QAAQ,GAAG;AAEjD,SAAO,4BAA4B;;;;;CAMrC,qBAA6B;AAC3B,SAAO,GAAG,KAAK,SAAS,CAAC"}
+{"version":3,"file":"UrlGenerator.js","names":["baseUrl: () => string"],"sources":["../../../src/transcoding/utils/UrlGenerator.ts"],"sourcesContent":["/**\n * URL generation utilities for transcoding endpoints\n */\n\nimport type { RenditionId } from \"../types/index.js\";\nimport type { MediaEngine } from \"../types/index.ts\";\n\nexport class UrlGenerator {\n  constructor(private baseUrl: () => string) {}\n\n  /**\n   * Get the base URL for constructing absolute URLs\n   */\n  getBaseUrl(): string {\n    return this.baseUrl();\n  }\n\n  /**\n   * Generate video segment URL\n   */\n  generateSegmentUrl(\n    segmentId: \"init\" | number,\n    renditionId: RenditionId,\n    metadata: MediaEngine,\n  ): string {\n    // Determine which rendition to use based on renditionId\n    // Audio renditions: \"audio\"\n    // Video renditions: \"high\", \"scrub\", \"low\", \"medium\", etc.\n    const audioRendition = metadata.audioRendition;\n    const videoRendition = metadata.videoRendition;\n\n    let rendition;\n    if (renditionId === \"audio\") {\n      rendition = audioRendition;\n    } else {\n      // For all other rendition IDs (high, scrub, low, medium), use video rendition\n      rendition = videoRendition;\n    }\n\n    if (!rendition) {\n      console.error(\"Rendition not found\", {\n        renditionId,\n        hasAudio: !!audioRendition,\n        hasVideo: !!videoRendition,\n        metadata,\n      });\n      throw new Error(\n        `Rendition ${renditionId} not found (hasAudio=${!!audioRendition}, hasVideo=${!!videoRendition})`,\n      );\n    }\n\n    const template =\n      segmentId === \"init\"\n        ? metadata.templates.initSegment\n        : metadata.templates.mediaSegment;\n    return template\n      .replace(\"{rendition}\", renditionId)\n      .replace(\"{segmentId}\", segmentId.toString())\n      .replace(\"{src}\", metadata.src)\n      .replace(\"{trackId}\", rendition.trackId?.toString() ?? \"\");\n  }\n\n  /**\n   * Generate init segment URL\n   */\n  generateInitSegmentUrl(mediaUrl: string, rendition: string): string {\n    return `${this.baseUrl()}/api/v1/transcode/${rendition}/init.mp4?url=${encodeURIComponent(mediaUrl)}`;\n  }\n\n  /**\n   * Generate manifest URL\n   */\n  generateManifestUrl(mediaUrl: string): string {\n    return `${this.baseUrl()}/api/v1/transcode/manifest.json?url=${encodeURIComponent(mediaUrl)}`;\n  }\n\n  /**\n   * Generate track fragment index URL using production API format\n   * @deprecated Use MD5-based URL generation in AssetMediaEngine.fetch() instead\n   */\n  generateTrackFragmentIndexUrl(mediaUrl: string): string {\n    // Normalize the path: remove leading slash and any double slashes\n    let normalizedSrc = mediaUrl.startsWith(\"/\") ? mediaUrl.slice(1) : mediaUrl;\n    // Remove any remaining leading slashes (handles cases like \"//assets/video.mp4\")\n    normalizedSrc = normalizedSrc.replace(/^\\/+/, \"\");\n    // Legacy format - kept for backward compatibility but should not be used\n    return `@ef-track-fragment-index/${normalizedSrc}`;\n  }\n\n  /**\n   * Generate quality presets URL\n   */\n  generatePresetsUrl(): string {\n    return `${this.baseUrl()}/api/v1/transcode/presets`;\n  }\n}\n"],"mappings":";AAOA,IAAa,eAAb,MAA0B;CACxB,YAAY,AAAQA,SAAuB;EAAvB;;;;;CAKpB,aAAqB;AACnB,SAAO,KAAK,SAAS;;;;;CAMvB,mBACE,WACA,aACA,UACQ;EAIR,MAAM,iBAAiB,SAAS;EAChC,MAAM,iBAAiB,SAAS;EAEhC,IAAI;AACJ,MAAI,gBAAgB,QAClB,aAAY;MAGZ,aAAY;AAGd,MAAI,CAAC,WAAW;AACd,WAAQ,MAAM,uBAAuB;IACnC;IACA,UAAU,CAAC,CAAC;IACZ,UAAU,CAAC,CAAC;IACZ;IACD,CAAC;AACF,SAAM,IAAI,MACR,aAAa,YAAY,uBAAuB,CAAC,CAAC,eAAe,aAAa,CAAC,CAAC,eAAe,GAChG;;AAOH,UAHE,cAAc,SACV,SAAS,UAAU,cACnB,SAAS,UAAU,cAEtB,QAAQ,eAAe,YAAY,CACnC,QAAQ,eAAe,UAAU,UAAU,CAAC,CAC5C,QAAQ,SAAS,SAAS,IAAI,CAC9B,QAAQ,aAAa,UAAU,SAAS,UAAU,IAAI,GAAG;;;;;CAM9D,uBAAuB,UAAkB,WAA2B;AAClE,SAAO,GAAG,KAAK,SAAS,CAAC,oBAAoB,UAAU,gBAAgB,mBAAmB,SAAS;;;;;CAMrG,oBAAoB,UAA0B;AAC5C,SAAO,GAAG,KAAK,SAAS,CAAC,sCAAsC,mBAAmB,SAAS;;;;;;CAO7F,8BAA8B,UAA0B;EAEtD,IAAI,gBAAgB,SAAS,WAAW,IAAI,GAAG,SAAS,MAAM,EAAE,GAAG;AAEnE,kBAAgB,cAAc,QAAQ,QAAQ,GAAG;AAEjD,SAAO,4BAA4B;;;;;CAMrC,qBAA6B;AAC3B,SAAO,GAAG,KAAK,SAAS,CAAC"}

package/dist/utils/LRUCache.js

@@ -76,6 +76,7 @@ var SizeAwareLRUCache = class {
 			this.sizes.delete(key);
 			throw error;
 		});
+		sizeTrackingPromise.catch(() => {});
 		this.cache.set(key, sizeTrackingPromise);
 	}
 	evictIfNecessary() {

package/dist/utils/LRUCache.js.map

@@ -1 +1 @@
-{"version":3,"file":"LRUCache.js","names":[],"sources":["../../src/utils/LRUCache.ts"],"sourcesContent":["/**\n * A simple LRU (Least Recently Used) cache implementation\n */\nexport class LRUCache<K, V> {\n  private cache = new Map<K, V>();\n  private readonly maxSize: number;\n\n  constructor(maxSize: number) {\n    this.maxSize = maxSize;\n  }\n\n  get(key: K): V | undefined {\n    const value = this.cache.get(key);\n    if (value) {\n      // Refresh position by removing and re-adding\n      this.cache.delete(key);\n      this.cache.set(key, value);\n    }\n    return value;\n  }\n\n  set(key: K, value: V): void {\n    if (this.cache.has(key)) {\n      this.cache.delete(key);\n    } else if (this.cache.size >= this.maxSize) {\n      // Remove oldest entry (first item in map)\n      const firstKey = this.cache.keys().next().value;\n      if (firstKey) {\n        this.cache.delete(firstKey);\n      }\n    }\n    this.cache.set(key, value);\n  }\n\n  has(key: K): boolean {\n    return this.cache.has(key);\n  }\n\n  delete(key: K): boolean {\n    return this.cache.delete(key);\n  }\n\n  clear(): void {\n    this.cache.clear();\n  }\n\n  get size(): number {\n    return this.cache.size;\n  }\n}\n\n/**\n * Size-aware LRU cache that tracks memory usage in bytes\n * Evicts entries when total size exceeds the maximum\n */\nexport class SizeAwareLRUCache<K> {\n  private cache = new Map<K, Promise<ArrayBuffer>>();\n  private sizes = new Map<K, number>();\n  private currentSize = 0;\n  private readonly maxSizeBytes: number;\n\n  constructor(maxSizeBytes: number) {\n    this.maxSizeBytes = maxSizeBytes;\n  }\n\n  get(key: K): Promise<ArrayBuffer> | undefined {\n    const value = this.cache.get(key);\n    if (value) {\n      // Refresh position by removing and re-adding\n      const size = this.sizes.get(key) || 0;\n      this.cache.delete(key);\n      this.cache.set(key, value);\n      this.sizes.delete(key);\n      this.sizes.set(key, size);\n    }\n    return value;\n  }\n\n  set(key: K, value: Promise<ArrayBuffer>): void {\n    // If key already exists, remove it first\n    if (this.cache.has(key)) {\n      const oldSize = this.sizes.get(key) || 0;\n      this.currentSize -= oldSize;\n      this.cache.delete(key);\n      this.sizes.delete(key);\n    }\n\n    // Track the size when the promise resolves\n    const sizeTrackingPromise = value\n      .then((buffer) => {\n        const bufferSize = buffer.byteLength;\n        this.sizes.set(key, bufferSize);\n        this.currentSize += bufferSize;\n\n        // Evict oldest entries if we exceed the size limit\n        this.evictIfNecessary();\n\n        return buffer;\n      })\n      .catch((error) => {\n        // If the promise fails, clean up the entry\n        this.cache.delete(key);\n        this.sizes.delete(key);\n        throw error;\n      });\n\n    this.cache.set(key, sizeTrackingPromise);\n  }\n\n  private evictIfNecessary(): void {\n    while (this.currentSize > this.maxSizeBytes && this.cache.size > 0) {\n      // Remove oldest entry (first item in map)\n      const firstKey = this.cache.keys().next().value;\n      if (firstKey) {\n        const size = this.sizes.get(firstKey) || 0;\n        this.currentSize -= size;\n        this.cache.delete(firstKey);\n        this.sizes.delete(firstKey);\n      } else {\n        break;\n      }\n    }\n  }\n\n  has(key: K): boolean {\n    return this.cache.has(key);\n  }\n\n  delete(key: K): boolean {\n    const size = this.sizes.get(key) || 0;\n    this.currentSize -= size;\n    this.sizes.delete(key);\n    return this.cache.delete(key);\n  }\n\n  clear(): void {\n    this.cache.clear();\n    this.sizes.clear();\n    this.currentSize = 0;\n  }\n\n  get size(): number {\n    return this.cache.size;\n  }\n\n  get currentSizeBytes(): number {\n    return this.currentSize;\n  }\n\n  get maxSize(): number {\n    return this.maxSizeBytes;\n  }\n}\n\n/**\n * Red-Black Tree node colors\n */\nenum Color {\n  RED = \"RED\",\n  BLACK = \"BLACK\",\n}\n\n/**\n * Red-Black Tree node for ordered key storage\n */\nclass RBTreeNode<K> {\n  constructor(\n    public key: K,\n    public color: Color = Color.RED,\n    public left: RBTreeNode<K> | null = null,\n    public right: RBTreeNode<K> | null = null,\n    public parent: RBTreeNode<K> | null = null,\n  ) {}\n}\n\n/**\n * Red-Black Tree implementation for O(log n) operations\n * Supports insert, delete, search, range queries, and nearest neighbor\n */\nclass RedBlackTree<K> {\n  private root: RBTreeNode<K> | null = null;\n  private readonly compareFn: (a: K, b: K) => number;\n\n  constructor(compareFn: (a: K, b: K) => number) {\n    this.compareFn = compareFn;\n  }\n\n  insert(key: K): void {\n    const node = new RBTreeNode(key);\n\n    if (!this.root) {\n      this.root = node;\n      node.color = Color.BLACK;\n      return;\n    }\n\n    this.insertNode(node);\n    this.fixInsert(node);\n  }\n\n  delete(key: K): boolean {\n    const node = this.findNode(key);\n    if (!node) return false;\n\n    this.deleteNode(node);\n    return true;\n  }\n\n  find(key: K): K | null {\n    const node = this.findNode(key);\n    return node ? node.key : null;\n  }\n\n  findNearestInRange(center: K, distance: K): K[] {\n    // Calculate the range bounds\n    const start = this.subtractDistance(center, distance);\n    const end = this.addDistance(center, distance);\n\n    // Use existing range search (O(log n + k))\n    return this.findRange(start, end);\n  }\n\n  private subtractDistance(center: K, distance: K): K {\n    if (typeof center === \"number\" && typeof distance === \"number\") {\n      return (center - distance) as K;\n    }\n\n    // For strings, we can't easily subtract distance, so just return center\n    // This means string searches will be exact matches only\n    return center;\n  }\n\n  private addDistance(center: K, distance: K): K {\n    if (typeof center === \"number\" && typeof distance === \"number\") {\n      return (center + distance) as K;\n    }\n\n    // For strings, we can't easily add distance, so just return center\n    // This means string searches will be exact matches only\n    return center;\n  }\n\n  findRange(start: K, end: K): K[] {\n    const result: K[] = [];\n    this.inorderRange(this.root, start, end, result);\n    return result;\n  }\n\n  getAllSorted(): K[] {\n    const result: K[] = [];\n    this.inorder(this.root, result);\n    return result;\n  }\n\n  private findNode(key: K): RBTreeNode<K> | null {\n    let current = this.root;\n\n    while (current) {\n      const cmp = this.compareFn(key, current.key);\n      if (cmp === 0) return current;\n      current = cmp < 0 ? current.left : current.right;\n    }\n\n    return null;\n  }\n\n  private insertNode(node: RBTreeNode<K>): void {\n    let parent = null;\n    let current = this.root;\n\n    while (current) {\n      parent = current;\n      const cmp = this.compareFn(node.key, current.key);\n      current = cmp < 0 ? current.left : current.right;\n    }\n\n    node.parent = parent;\n    if (!parent) {\n      this.root = node;\n    } else {\n      const cmp = this.compareFn(node.key, parent.key);\n      if (cmp < 0) {\n        parent.left = node;\n      } else {\n        parent.right = node;\n      }\n    }\n  }\n\n  private fixInsert(node: RBTreeNode<K>): void {\n    while (node.parent && node.parent.color === Color.RED) {\n      if (node.parent === node.parent.parent?.left) {\n        const uncle = node.parent.parent.right;\n\n        if (uncle?.color === Color.RED) {\n          node.parent.color = Color.BLACK;\n          uncle.color = Color.BLACK;\n          node.parent.parent.color = Color.RED;\n          node = node.parent.parent;\n        } else {\n          if (node === node.parent.right) {\n            node = node.parent;\n            this.rotateLeft(node);\n          }\n\n          if (node.parent) {\n            node.parent.color = Color.BLACK;\n            if (node.parent.parent) {\n              node.parent.parent.color = Color.RED;\n              this.rotateRight(node.parent.parent);\n            }\n          }\n        }\n      } else {\n        const uncle = node.parent.parent?.left;\n\n        if (uncle?.color === Color.RED) {\n          node.parent.color = Color.BLACK;\n          uncle.color = Color.BLACK;\n          if (node.parent.parent) {\n            node.parent.parent.color = Color.RED;\n            node = node.parent.parent;\n          }\n        } else {\n          if (node === node.parent.left) {\n            node = node.parent;\n            this.rotateRight(node);\n          }\n\n          if (node.parent) {\n            node.parent.color = Color.BLACK;\n            if (node.parent.parent) {\n              node.parent.parent.color = Color.RED;\n              this.rotateLeft(node.parent.parent);\n            }\n          }\n        }\n      }\n    }\n\n    if (this.root) {\n      this.root.color = Color.BLACK;\n    }\n  }\n\n  private deleteNode(node: RBTreeNode<K>): void {\n    let y = node;\n    let yOriginalColor = y.color;\n    let x: RBTreeNode<K> | null;\n\n    if (!node.left) {\n      x = node.right;\n      this.transplant(node, node.right);\n    } else if (!node.right) {\n      x = node.left;\n      this.transplant(node, node.left);\n    } else {\n      y = this.minimum(node.right);\n      yOriginalColor = y.color;\n      x = y.right;\n\n      if (y.parent === node) {\n        if (x) x.parent = y;\n      } else {\n        this.transplant(y, y.right);\n        y.right = node.right;\n        if (y.right) y.right.parent = y;\n      }\n\n      this.transplant(node, y);\n      y.left = node.left;\n      if (y.left) y.left.parent = y;\n      y.color = node.color;\n    }\n\n    if (yOriginalColor === Color.BLACK && x) {\n      this.fixDelete(x);\n    }\n  }\n\n  private fixDelete(node: RBTreeNode<K>): void {\n    while (node !== this.root && node.color === Color.BLACK) {\n      if (node === node.parent?.left) {\n        let sibling = node.parent.right;\n\n        if (sibling?.color === Color.RED) {\n          sibling.color = Color.BLACK;\n          node.parent.color = Color.RED;\n          this.rotateLeft(node.parent);\n          sibling = node.parent.right;\n        }\n\n        if (\n          sibling?.left?.color !== Color.RED &&\n          sibling?.right?.color !== Color.RED\n        ) {\n          if (sibling) {\n            sibling.color = Color.RED;\n          }\n          node = node.parent;\n        } else {\n          if (sibling?.right?.color !== Color.RED) {\n            if (sibling.left) sibling.left.color = Color.BLACK;\n            sibling.color = Color.RED;\n            this.rotateRight(sibling);\n            sibling = node.parent.right;\n          }\n\n          if (sibling) {\n            sibling.color = node.parent.color;\n            node.parent.color = Color.BLACK;\n            if (sibling.right) sibling.right.color = Color.BLACK;\n            this.rotateLeft(node.parent);\n          }\n          if (!this.root) {\n            throw new Error(\"Root is null\");\n          }\n          node = this.root;\n        }\n      } else {\n        let sibling = node.parent?.left;\n\n        if (sibling?.color === Color.RED) {\n          sibling.color = Color.BLACK;\n          if (node.parent) node.parent.color = Color.RED;\n          if (node.parent) this.rotateRight(node.parent);\n          sibling = node.parent?.left;\n        }\n\n        if (\n          sibling?.right?.color !== Color.RED &&\n          sibling?.left?.color !== Color.RED\n        ) {\n          if (sibling) {\n            sibling.color = Color.RED;\n          }\n          if (node.parent === null) {\n            throw new Error(\"Node parent is null\");\n          }\n          node = node.parent;\n        } else {\n          if (sibling?.left?.color !== Color.RED) {\n            if (sibling.right) sibling.right.color = Color.BLACK;\n            sibling.color = Color.RED;\n            this.rotateLeft(sibling);\n            sibling = node.parent?.left;\n          }\n\n          if (sibling) {\n            sibling.color = node.parent?.color || Color.BLACK;\n            if (node.parent) node.parent.color = Color.BLACK;\n            if (sibling.left) sibling.left.color = Color.BLACK;\n            if (node.parent) this.rotateRight(node.parent);\n          }\n          if (!this.root) {\n            throw new Error(\"Root is null\");\n          }\n          node = this.root;\n        }\n      }\n    }\n\n    node.color = Color.BLACK;\n  }\n\n  private rotateLeft(node: RBTreeNode<K>): void {\n    const rightChild = node.right;\n    if (!rightChild) {\n      throw new Error(\"Right child is null\");\n    }\n    node.right = rightChild.left;\n\n    if (rightChild.left) {\n      rightChild.left.parent = node;\n    }\n\n    rightChild.parent = node.parent;\n\n    if (!node.parent) {\n      this.root = rightChild;\n    } else if (node === node.parent.left) {\n      node.parent.left = rightChild;\n    } else {\n      node.parent.right = rightChild;\n    }\n\n    rightChild.left = node;\n    node.parent = rightChild;\n  }\n\n  private rotateRight(node: RBTreeNode<K>): void {\n    const leftChild = node.left;\n    if (!leftChild) {\n      throw new Error(\"Left child is null\");\n    }\n    node.left = leftChild.right;\n\n    if (leftChild.right) {\n      leftChild.right.parent = node;\n    }\n\n    leftChild.parent = node.parent;\n\n    if (!node.parent) {\n      this.root = leftChild;\n    } else if (node === node.parent.right) {\n      node.parent.right = leftChild;\n    } else {\n      node.parent.left = leftChild;\n    }\n\n    leftChild.right = node;\n    node.parent = leftChild;\n  }\n\n  private transplant(u: RBTreeNode<K>, v: RBTreeNode<K> | null): void {\n    if (!u.parent) {\n      this.root = v;\n    } else if (u === u.parent.left) {\n      u.parent.left = v;\n    } else {\n      u.parent.right = v;\n    }\n\n    if (v) {\n      v.parent = u.parent;\n    }\n  }\n\n  private minimum(node: RBTreeNode<K>): RBTreeNode<K> {\n    while (node.left) {\n      node = node.left;\n    }\n    return node;\n  }\n\n  private inorder(node: RBTreeNode<K> | null, result: K[]): void {\n    if (node) {\n      this.inorder(node.left, result);\n      result.push(node.key);\n      this.inorder(node.right, result);\n    }\n  }\n\n  private inorderRange(\n    node: RBTreeNode<K> | null,\n    start: K,\n    end: K,\n    result: K[],\n  ): void {\n    if (!node) return;\n\n    const startCmp = this.compareFn(node.key, start);\n    const endCmp = this.compareFn(node.key, end);\n\n    if (startCmp > 0) {\n      this.inorderRange(node.left, start, end, result);\n    }\n\n    if (startCmp >= 0 && endCmp <= 0) {\n      result.push(node.key);\n    }\n\n    if (endCmp < 0) {\n      this.inorderRange(node.right, start, end, result);\n    }\n  }\n}\n\n/**\n * LRU cache with binary search capabilities using Red-Black tree\n * All operations are O(log n) for ordered queries and O(1) for LRU operations\n */\nexport class OrderedLRUCache<K extends number | string, V> {\n  private cache = new Map<K, V>();\n  private tree: RedBlackTree<K>;\n  private readonly maxSize: number;\n  private readonly compareFn: (a: K, b: K) => number;\n\n  constructor(maxSize: number, compareFn?: (a: K, b: K) => number) {\n    this.maxSize = maxSize;\n    this.compareFn = compareFn || ((a, b) => (a < b ? -1 : a > b ? 1 : 0));\n    this.tree = new RedBlackTree(this.compareFn);\n  }\n\n  /**\n   * Get value by exact key (O(1))\n   */\n  get(key: K): V | undefined {\n    const value = this.cache.get(key);\n    if (value) {\n      // Refresh position by removing and re-adding\n      this.cache.delete(key);\n      this.cache.set(key, value);\n    }\n    return value;\n  }\n\n  /**\n   * Set key-value pair (O(log n) for tree operations, O(1) for cache)\n   */\n  set(key: K, value: V): void {\n    const isUpdate = this.cache.has(key);\n\n    if (isUpdate) {\n      this.cache.delete(key);\n    } else {\n      if (this.cache.size >= this.maxSize) {\n        // Remove oldest entry (first item in map)\n        const firstKey = this.cache.keys().next().value;\n        if (firstKey) {\n          this.cache.delete(firstKey);\n          this.tree.delete(firstKey);\n        }\n      }\n      // Add to tree index for new keys\n      this.tree.insert(key);\n    }\n\n    this.cache.set(key, value);\n  }\n\n  /**\n   * Find exact key using tree search (O(log n))\n   */\n  findExact(key: K): V | undefined {\n    const foundKey = this.tree.find(key);\n    if (foundKey !== null) {\n      return this.get(key);\n    }\n    return undefined;\n  }\n\n  /**\n   * Find keys within distance of center point (O(log n + k) where k is result count)\n   * Returns empty array if no keys found in range\n   */\n  findNearestInRange(center: K, distance: K): Array<{ key: K; value: V }> {\n    const nearestKeys = this.tree.findNearestInRange(center, distance);\n    const result: Array<{ key: K; value: V }> = [];\n\n    for (const key of nearestKeys) {\n      const value = this.get(key);\n      if (value !== undefined) {\n        result.push({ key, value });\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Find all key-value pairs in range [start, end] (O(log n + k) where k is result count)\n   */\n  findRange(start: K, end: K): Array<{ key: K; value: V }> {\n    const keys = this.tree.findRange(start, end);\n    const result: Array<{ key: K; value: V }> = [];\n\n    for (const key of keys) {\n      const value = this.get(key);\n      if (value !== undefined) {\n        result.push({ key, value });\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Get all keys in sorted order (O(n))\n   */\n  getSortedKeys(): ReadonlyArray<K> {\n    return this.tree.getAllSorted();\n  }\n\n  has(key: K): boolean {\n    return this.cache.has(key);\n  }\n\n  delete(key: K): boolean {\n    const deleted = this.cache.delete(key);\n    if (deleted) {\n      this.tree.delete(key);\n    }\n    return deleted;\n  }\n\n  clear(): void {\n    this.cache.clear();\n    this.tree = new RedBlackTree(this.compareFn);\n  }\n\n  get size(): number {\n    return this.cache.size;\n  }\n}\n"],"mappings":";;;;AAGA,IAAa,WAAb,MAA4B;CAI1B,YAAY,SAAiB;+BAHb,IAAI,KAAW;AAI7B,OAAK,UAAU;;CAGjB,IAAI,KAAuB;EACzB,MAAM,QAAQ,KAAK,MAAM,IAAI,IAAI;AACjC,MAAI,OAAO;AAET,QAAK,MAAM,OAAO,IAAI;AACtB,QAAK,MAAM,IAAI,KAAK,MAAM;;AAE5B,SAAO;;CAGT,IAAI,KAAQ,OAAgB;AAC1B,MAAI,KAAK,MAAM,IAAI,IAAI,CACrB,MAAK,MAAM,OAAO,IAAI;WACb,KAAK,MAAM,QAAQ,KAAK,SAAS;GAE1C,MAAM,WAAW,KAAK,MAAM,MAAM,CAAC,MAAM,CAAC;AAC1C,OAAI,SACF,MAAK,MAAM,OAAO,SAAS;;AAG/B,OAAK,MAAM,IAAI,KAAK,MAAM;;CAG5B,IAAI,KAAiB;AACnB,SAAO,KAAK,MAAM,IAAI,IAAI;;CAG5B,OAAO,KAAiB;AACtB,SAAO,KAAK,MAAM,OAAO,IAAI;;CAG/B,QAAc;AACZ,OAAK,MAAM,OAAO;;CAGpB,IAAI,OAAe;AACjB,SAAO,KAAK,MAAM;;;;;;;AAQtB,IAAa,oBAAb,MAAkC;CAMhC,YAAY,cAAsB;+BALlB,IAAI,KAA8B;+BAClC,IAAI,KAAgB;qBACd;AAIpB,OAAK,eAAe;;CAGtB,IAAI,KAA0C;EAC5C,MAAM,QAAQ,KAAK,MAAM,IAAI,IAAI;AACjC,MAAI,OAAO;GAET,MAAM,OAAO,KAAK,MAAM,IAAI,IAAI,IAAI;AACpC,QAAK,MAAM,OAAO,IAAI;AACtB,QAAK,MAAM,IAAI,KAAK,MAAM;AAC1B,QAAK,MAAM,OAAO,IAAI;AACtB,QAAK,MAAM,IAAI,KAAK,KAAK;;AAE3B,SAAO;;CAGT,IAAI,KAAQ,OAAmC;AAE7C,MAAI,KAAK,MAAM,IAAI,IAAI,EAAE;GACvB,MAAM,UAAU,KAAK,MAAM,IAAI,IAAI,IAAI;AACvC,QAAK,eAAe;AACpB,QAAK,MAAM,OAAO,IAAI;AACtB,QAAK,MAAM,OAAO,IAAI;;EAIxB,MAAM,sBAAsB,MACzB,MAAM,WAAW;GAChB,MAAM,aAAa,OAAO;AAC1B,QAAK,MAAM,IAAI,KAAK,WAAW;AAC/B,QAAK,eAAe;AAGpB,QAAK,kBAAkB;AAEvB,UAAO;IACP,CACD,OAAO,UAAU;AAEhB,QAAK,MAAM,OAAO,IAAI;AACtB,QAAK,MAAM,OAAO,IAAI;AACtB,SAAM;IACN;AAEJ,OAAK,MAAM,IAAI,KAAK,oBAAoB;;CAG1C,AAAQ,mBAAyB;AAC/B,SAAO,KAAK,cAAc,KAAK,gBAAgB,KAAK,MAAM,OAAO,GAAG;GAElE,MAAM,WAAW,KAAK,MAAM,MAAM,CAAC,MAAM,CAAC;AAC1C,OAAI,UAAU;IACZ,MAAM,OAAO,KAAK,MAAM,IAAI,SAAS,IAAI;AACzC,SAAK,eAAe;AACpB,SAAK,MAAM,OAAO,SAAS;AAC3B,SAAK,MAAM,OAAO,SAAS;SAE3B;;;CAKN,IAAI,KAAiB;AACnB,SAAO,KAAK,MAAM,IAAI,IAAI;;CAG5B,OAAO,KAAiB;EACtB,MAAM,OAAO,KAAK,MAAM,IAAI,IAAI,IAAI;AACpC,OAAK,eAAe;AACpB,OAAK,MAAM,OAAO,IAAI;AACtB,SAAO,KAAK,MAAM,OAAO,IAAI;;CAG/B,QAAc;AACZ,OAAK,MAAM,OAAO;AAClB,OAAK,MAAM,OAAO;AAClB,OAAK,cAAc;;CAGrB,IAAI,OAAe;AACjB,SAAO,KAAK,MAAM;;CAGpB,IAAI,mBAA2B;AAC7B,SAAO,KAAK;;CAGd,IAAI,UAAkB;AACpB,SAAO,KAAK"}
+{"version":3,"file":"LRUCache.js","names":[],"sources":["../../src/utils/LRUCache.ts"],"sourcesContent":["/**\n * A simple LRU (Least Recently Used) cache implementation\n */\nexport class LRUCache<K, V> {\n  private cache = new Map<K, V>();\n  private readonly maxSize: number;\n\n  constructor(maxSize: number) {\n    this.maxSize = maxSize;\n  }\n\n  get(key: K): V | undefined {\n    const value = this.cache.get(key);\n    if (value) {\n      // Refresh position by removing and re-adding\n      this.cache.delete(key);\n      this.cache.set(key, value);\n    }\n    return value;\n  }\n\n  set(key: K, value: V): void {\n    if (this.cache.has(key)) {\n      this.cache.delete(key);\n    } else if (this.cache.size >= this.maxSize) {\n      // Remove oldest entry (first item in map)\n      const firstKey = this.cache.keys().next().value;\n      if (firstKey) {\n        this.cache.delete(firstKey);\n      }\n    }\n    this.cache.set(key, value);\n  }\n\n  has(key: K): boolean {\n    return this.cache.has(key);\n  }\n\n  delete(key: K): boolean {\n    return this.cache.delete(key);\n  }\n\n  clear(): void {\n    this.cache.clear();\n  }\n\n  get size(): number {\n    return this.cache.size;\n  }\n}\n\n/**\n * Size-aware LRU cache that tracks memory usage in bytes\n * Evicts entries when total size exceeds the maximum\n */\nexport class SizeAwareLRUCache<K> {\n  private cache = new Map<K, Promise<ArrayBuffer>>();\n  private sizes = new Map<K, number>();\n  private currentSize = 0;\n  private readonly maxSizeBytes: number;\n\n  constructor(maxSizeBytes: number) {\n    this.maxSizeBytes = maxSizeBytes;\n  }\n\n  get(key: K): Promise<ArrayBuffer> | undefined {\n    const value = this.cache.get(key);\n    if (value) {\n      // Refresh position by removing and re-adding\n      const size = this.sizes.get(key) || 0;\n      this.cache.delete(key);\n      this.cache.set(key, value);\n      this.sizes.delete(key);\n      this.sizes.set(key, size);\n    }\n    return value;\n  }\n\n  set(key: K, value: Promise<ArrayBuffer>): void {\n    // If key already exists, remove it first\n    if (this.cache.has(key)) {\n      const oldSize = this.sizes.get(key) || 0;\n      this.currentSize -= oldSize;\n      this.cache.delete(key);\n      this.sizes.delete(key);\n    }\n\n    // Track the size when the promise resolves\n    const sizeTrackingPromise = value\n      .then((buffer) => {\n        const bufferSize = buffer.byteLength;\n        this.sizes.set(key, bufferSize);\n        this.currentSize += bufferSize;\n\n        // Evict oldest entries if we exceed the size limit\n        this.evictIfNecessary();\n\n        return buffer;\n      })\n      .catch((error) => {\n        // If the promise fails, clean up the entry\n        this.cache.delete(key);\n        this.sizes.delete(key);\n        throw error;\n      });\n\n    // Suppress unhandled rejection on the derived promise. This promise sits in\n    // the cache and may reject before any caller retrieves and awaits it.\n    // Zone.js checks for handlers synchronously at rejection time — without this,\n    // the re-thrown error triggers an unhandledrejection event. Callers who later\n    // await the cached promise still see the rejection (this just adds a no-op branch).\n    sizeTrackingPromise.catch(() => {});\n\n    this.cache.set(key, sizeTrackingPromise);\n  }\n\n  private evictIfNecessary(): void {\n    while (this.currentSize > this.maxSizeBytes && this.cache.size > 0) {\n      // Remove oldest entry (first item in map)\n      const firstKey = this.cache.keys().next().value;\n      if (firstKey) {\n        const size = this.sizes.get(firstKey) || 0;\n        this.currentSize -= size;\n        this.cache.delete(firstKey);\n        this.sizes.delete(firstKey);\n      } else {\n        break;\n      }\n    }\n  }\n\n  has(key: K): boolean {\n    return this.cache.has(key);\n  }\n\n  delete(key: K): boolean {\n    const size = this.sizes.get(key) || 0;\n    this.currentSize -= size;\n    this.sizes.delete(key);\n    return this.cache.delete(key);\n  }\n\n  clear(): void {\n    this.cache.clear();\n    this.sizes.clear();\n    this.currentSize = 0;\n  }\n\n  get size(): number {\n    return this.cache.size;\n  }\n\n  get currentSizeBytes(): number {\n    return this.currentSize;\n  }\n\n  get maxSize(): number {\n    return this.maxSizeBytes;\n  }\n}\n\n/**\n * Red-Black Tree node colors\n */\nenum Color {\n  RED = \"RED\",\n  BLACK = \"BLACK\",\n}\n\n/**\n * Red-Black Tree node for ordered key storage\n */\nclass RBTreeNode<K> {\n  constructor(\n    public key: K,\n    public color: Color = Color.RED,\n    public left: RBTreeNode<K> | null = null,\n    public right: RBTreeNode<K> | null = null,\n    public parent: RBTreeNode<K> | null = null,\n  ) {}\n}\n\n/**\n * Red-Black Tree implementation for O(log n) operations\n * Supports insert, delete, search, range queries, and nearest neighbor\n */\nclass RedBlackTree<K> {\n  private root: RBTreeNode<K> | null = null;\n  private readonly compareFn: (a: K, b: K) => number;\n\n  constructor(compareFn: (a: K, b: K) => number) {\n    this.compareFn = compareFn;\n  }\n\n  insert(key: K): void {\n    const node = new RBTreeNode(key);\n\n    if (!this.root) {\n      this.root = node;\n      node.color = Color.BLACK;\n      return;\n    }\n\n    this.insertNode(node);\n    this.fixInsert(node);\n  }\n\n  delete(key: K): boolean {\n    const node = this.findNode(key);\n    if (!node) return false;\n\n    this.deleteNode(node);\n    return true;\n  }\n\n  find(key: K): K | null {\n    const node = this.findNode(key);\n    return node ? node.key : null;\n  }\n\n  findNearestInRange(center: K, distance: K): K[] {\n    // Calculate the range bounds\n    const start = this.subtractDistance(center, distance);\n    const end = this.addDistance(center, distance);\n\n    // Use existing range search (O(log n + k))\n    return this.findRange(start, end);\n  }\n\n  private subtractDistance(center: K, distance: K): K {\n    if (typeof center === \"number\" && typeof distance === \"number\") {\n      return (center - distance) as K;\n    }\n\n    // For strings, we can't easily subtract distance, so just return center\n    // This means string searches will be exact matches only\n    return center;\n  }\n\n  private addDistance(center: K, distance: K): K {\n    if (typeof center === \"number\" && typeof distance === \"number\") {\n      return (center + distance) as K;\n    }\n\n    // For strings, we can't easily add distance, so just return center\n    // This means string searches will be exact matches only\n    return center;\n  }\n\n  findRange(start: K, end: K): K[] {\n    const result: K[] = [];\n    this.inorderRange(this.root, start, end, result);\n    return result;\n  }\n\n  getAllSorted(): K[] {\n    const result: K[] = [];\n    this.inorder(this.root, result);\n    return result;\n  }\n\n  private findNode(key: K): RBTreeNode<K> | null {\n    let current = this.root;\n\n    while (current) {\n      const cmp = this.compareFn(key, current.key);\n      if (cmp === 0) return current;\n      current = cmp < 0 ? current.left : current.right;\n    }\n\n    return null;\n  }\n\n  private insertNode(node: RBTreeNode<K>): void {\n    let parent = null;\n    let current = this.root;\n\n    while (current) {\n      parent = current;\n      const cmp = this.compareFn(node.key, current.key);\n      current = cmp < 0 ? current.left : current.right;\n    }\n\n    node.parent = parent;\n    if (!parent) {\n      this.root = node;\n    } else {\n      const cmp = this.compareFn(node.key, parent.key);\n      if (cmp < 0) {\n        parent.left = node;\n      } else {\n        parent.right = node;\n      }\n    }\n  }\n\n  private fixInsert(node: RBTreeNode<K>): void {\n    while (node.parent && node.parent.color === Color.RED) {\n      if (node.parent === node.parent.parent?.left) {\n        const uncle = node.parent.parent.right;\n\n        if (uncle?.color === Color.RED) {\n          node.parent.color = Color.BLACK;\n          uncle.color = Color.BLACK;\n          node.parent.parent.color = Color.RED;\n          node = node.parent.parent;\n        } else {\n          if (node === node.parent.right) {\n            node = node.parent;\n            this.rotateLeft(node);\n          }\n\n          if (node.parent) {\n            node.parent.color = Color.BLACK;\n            if (node.parent.parent) {\n              node.parent.parent.color = Color.RED;\n              this.rotateRight(node.parent.parent);\n            }\n          }\n        }\n      } else {\n        const uncle = node.parent.parent?.left;\n\n        if (uncle?.color === Color.RED) {\n          node.parent.color = Color.BLACK;\n          uncle.color = Color.BLACK;\n          if (node.parent.parent) {\n            node.parent.parent.color = Color.RED;\n            node = node.parent.parent;\n          }\n        } else {\n          if (node === node.parent.left) {\n            node = node.parent;\n            this.rotateRight(node);\n          }\n\n          if (node.parent) {\n            node.parent.color = Color.BLACK;\n            if (node.parent.parent) {\n              node.parent.parent.color = Color.RED;\n              this.rotateLeft(node.parent.parent);\n            }\n          }\n        }\n      }\n    }\n\n    if (this.root) {\n      this.root.color = Color.BLACK;\n    }\n  }\n\n  private deleteNode(node: RBTreeNode<K>): void {\n    let y = node;\n    let yOriginalColor = y.color;\n    let x: RBTreeNode<K> | null;\n\n    if (!node.left) {\n      x = node.right;\n      this.transplant(node, node.right);\n    } else if (!node.right) {\n      x = node.left;\n      this.transplant(node, node.left);\n    } else {\n      y = this.minimum(node.right);\n      yOriginalColor = y.color;\n      x = y.right;\n\n      if (y.parent === node) {\n        if (x) x.parent = y;\n      } else {\n        this.transplant(y, y.right);\n        y.right = node.right;\n        if (y.right) y.right.parent = y;\n      }\n\n      this.transplant(node, y);\n      y.left = node.left;\n      if (y.left) y.left.parent = y;\n      y.color = node.color;\n    }\n\n    if (yOriginalColor === Color.BLACK && x) {\n      this.fixDelete(x);\n    }\n  }\n\n  private fixDelete(node: RBTreeNode<K>): void {\n    while (node !== this.root && node.color === Color.BLACK) {\n      if (node === node.parent?.left) {\n        let sibling = node.parent.right;\n\n        if (sibling?.color === Color.RED) {\n          sibling.color = Color.BLACK;\n          node.parent.color = Color.RED;\n          this.rotateLeft(node.parent);\n          sibling = node.parent.right;\n        }\n\n        if (\n          sibling?.left?.color !== Color.RED &&\n          sibling?.right?.color !== Color.RED\n        ) {\n          if (sibling) {\n            sibling.color = Color.RED;\n          }\n          node = node.parent;\n        } else {\n          if (sibling?.right?.color !== Color.RED) {\n            if (sibling.left) sibling.left.color = Color.BLACK;\n            sibling.color = Color.RED;\n            this.rotateRight(sibling);\n            sibling = node.parent.right;\n          }\n\n          if (sibling) {\n            sibling.color = node.parent.color;\n            node.parent.color = Color.BLACK;\n            if (sibling.right) sibling.right.color = Color.BLACK;\n            this.rotateLeft(node.parent);\n          }\n          if (!this.root) {\n            throw new Error(\"Root is null\");\n          }\n          node = this.root;\n        }\n      } else {\n        let sibling = node.parent?.left;\n\n        if (sibling?.color === Color.RED) {\n          sibling.color = Color.BLACK;\n          if (node.parent) node.parent.color = Color.RED;\n          if (node.parent) this.rotateRight(node.parent);\n          sibling = node.parent?.left;\n        }\n\n        if (\n          sibling?.right?.color !== Color.RED &&\n          sibling?.left?.color !== Color.RED\n        ) {\n          if (sibling) {\n            sibling.color = Color.RED;\n          }\n          if (node.parent === null) {\n            throw new Error(\"Node parent is null\");\n          }\n          node = node.parent;\n        } else {\n          if (sibling?.left?.color !== Color.RED) {\n            if (sibling.right) sibling.right.color = Color.BLACK;\n            sibling.color = Color.RED;\n            this.rotateLeft(sibling);\n            sibling = node.parent?.left;\n          }\n\n          if (sibling) {\n            sibling.color = node.parent?.color || Color.BLACK;\n            if (node.parent) node.parent.color = Color.BLACK;\n            if (sibling.left) sibling.left.color = Color.BLACK;\n            if (node.parent) this.rotateRight(node.parent);\n          }\n          if (!this.root) {\n            throw new Error(\"Root is null\");\n          }\n          node = this.root;\n        }\n      }\n    }\n\n    node.color = Color.BLACK;\n  }\n\n  private rotateLeft(node: RBTreeNode<K>): void {\n    const rightChild = node.right;\n    if (!rightChild) {\n      throw new Error(\"Right child is null\");\n    }\n    node.right = rightChild.left;\n\n    if (rightChild.left) {\n      rightChild.left.parent = node;\n    }\n\n    rightChild.parent = node.parent;\n\n    if (!node.parent) {\n      this.root = rightChild;\n    } else if (node === node.parent.left) {\n      node.parent.left = rightChild;\n    } else {\n      node.parent.right = rightChild;\n    }\n\n    rightChild.left = node;\n    node.parent = rightChild;\n  }\n\n  private rotateRight(node: RBTreeNode<K>): void {\n    const leftChild = node.left;\n    if (!leftChild) {\n      throw new Error(\"Left child is null\");\n    }\n    node.left = leftChild.right;\n\n    if (leftChild.right) {\n      leftChild.right.parent = node;\n    }\n\n    leftChild.parent = node.parent;\n\n    if (!node.parent) {\n      this.root = leftChild;\n    } else if (node === node.parent.right) {\n      node.parent.right = leftChild;\n    } else {\n      node.parent.left = leftChild;\n    }\n\n    leftChild.right = node;\n    node.parent = leftChild;\n  }\n\n  private transplant(u: RBTreeNode<K>, v: RBTreeNode<K> | null): void {\n    if (!u.parent) {\n      this.root = v;\n    } else if (u === u.parent.left) {\n      u.parent.left = v;\n    } else {\n      u.parent.right = v;\n    }\n\n    if (v) {\n      v.parent = u.parent;\n    }\n  }\n\n  private minimum(node: RBTreeNode<K>): RBTreeNode<K> {\n    while (node.left) {\n      node = node.left;\n    }\n    return node;\n  }\n\n  private inorder(node: RBTreeNode<K> | null, result: K[]): void {\n    if (node) {\n      this.inorder(node.left, result);\n      result.push(node.key);\n      this.inorder(node.right, result);\n    }\n  }\n\n  private inorderRange(\n    node: RBTreeNode<K> | null,\n    start: K,\n    end: K,\n    result: K[],\n  ): void {\n    if (!node) return;\n\n    const startCmp = this.compareFn(node.key, start);\n    const endCmp = this.compareFn(node.key, end);\n\n    if (startCmp > 0) {\n      this.inorderRange(node.left, start, end, result);\n    }\n\n    if (startCmp >= 0 && endCmp <= 0) {\n      result.push(node.key);\n    }\n\n    if (endCmp < 0) {\n      this.inorderRange(node.right, start, end, result);\n    }\n  }\n}\n\n/**\n * LRU cache with binary search capabilities using Red-Black tree\n * All operations are O(log n) for ordered queries and O(1) for LRU operations\n */\nexport class OrderedLRUCache<K extends number | string, V> {\n  private cache = new Map<K, V>();\n  private tree: RedBlackTree<K>;\n  private readonly maxSize: number;\n  private readonly compareFn: (a: K, b: K) => number;\n\n  constructor(maxSize: number, compareFn?: (a: K, b: K) => number) {\n    this.maxSize = maxSize;\n    this.compareFn = compareFn || ((a, b) => (a < b ? -1 : a > b ? 1 : 0));\n    this.tree = new RedBlackTree(this.compareFn);\n  }\n\n  /**\n   * Get value by exact key (O(1))\n   */\n  get(key: K): V | undefined {\n    const value = this.cache.get(key);\n    if (value) {\n      // Refresh position by removing and re-adding\n      this.cache.delete(key);\n      this.cache.set(key, value);\n    }\n    return value;\n  }\n\n  /**\n   * Set key-value pair (O(log n) for tree operations, O(1) for cache)\n   */\n  set(key: K, value: V): void {\n    const isUpdate = this.cache.has(key);\n\n    if (isUpdate) {\n      this.cache.delete(key);\n    } else {\n      if (this.cache.size >= this.maxSize) {\n        // Remove oldest entry (first item in map)\n        const firstKey = this.cache.keys().next().value;\n        if (firstKey) {\n          this.cache.delete(firstKey);\n          this.tree.delete(firstKey);\n        }\n      }\n      // Add to tree index for new keys\n      this.tree.insert(key);\n    }\n\n    this.cache.set(key, value);\n  }\n\n  /**\n   * Find exact key using tree search (O(log n))\n   */\n  findExact(key: K): V | undefined {\n    const foundKey = this.tree.find(key);\n    if (foundKey !== null) {\n      return this.get(key);\n    }\n    return undefined;\n  }\n\n  /**\n   * Find keys within distance of center point (O(log n + k) where k is result count)\n   * Returns empty array if no keys found in range\n   */\n  findNearestInRange(center: K, distance: K): Array<{ key: K; value: V }> {\n    const nearestKeys = this.tree.findNearestInRange(center, distance);\n    const result: Array<{ key: K; value: V }> = [];\n\n    for (const key of nearestKeys) {\n      const value = this.get(key);\n      if (value !== undefined) {\n        result.push({ key, value });\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Find all key-value pairs in range [start, end] (O(log n + k) where k is result count)\n   */\n  findRange(start: K, end: K): Array<{ key: K; value: V }> {\n    const keys = this.tree.findRange(start, end);\n    const result: Array<{ key: K; value: V }> = [];\n\n    for (const key of keys) {\n      const value = this.get(key);\n      if (value !== undefined) {\n        result.push({ key, value });\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * Get all keys in sorted order (O(n))\n   */\n  getSortedKeys(): ReadonlyArray<K> {\n    return this.tree.getAllSorted();\n  }\n\n  has(key: K): boolean {\n    return this.cache.has(key);\n  }\n\n  delete(key: K): boolean {\n    const deleted = this.cache.delete(key);\n    if (deleted) {\n      this.tree.delete(key);\n    }\n    return deleted;\n  }\n\n  clear(): void {\n    this.cache.clear();\n    this.tree = new RedBlackTree(this.compareFn);\n  }\n\n  get size(): number {\n    return this.cache.size;\n  }\n}\n"],"mappings":";;;;AAGA,IAAa,WAAb,MAA4B;CAI1B,YAAY,SAAiB;+BAHb,IAAI,KAAW;AAI7B,OAAK,UAAU;;CAGjB,IAAI,KAAuB;EACzB,MAAM,QAAQ,KAAK,MAAM,IAAI,IAAI;AACjC,MAAI,OAAO;AAET,QAAK,MAAM,OAAO,IAAI;AACtB,QAAK,MAAM,IAAI,KAAK,MAAM;;AAE5B,SAAO;;CAGT,IAAI,KAAQ,OAAgB;AAC1B,MAAI,KAAK,MAAM,IAAI,IAAI,CACrB,MAAK,MAAM,OAAO,IAAI;WACb,KAAK,MAAM,QAAQ,KAAK,SAAS;GAE1C,MAAM,WAAW,KAAK,MAAM,MAAM,CAAC,MAAM,CAAC;AAC1C,OAAI,SACF,MAAK,MAAM,OAAO,SAAS;;AAG/B,OAAK,MAAM,IAAI,KAAK,MAAM;;CAG5B,IAAI,KAAiB;AACnB,SAAO,KAAK,MAAM,IAAI,IAAI;;CAG5B,OAAO,KAAiB;AACtB,SAAO,KAAK,MAAM,OAAO,IAAI;;CAG/B,QAAc;AACZ,OAAK,MAAM,OAAO;;CAGpB,IAAI,OAAe;AACjB,SAAO,KAAK,MAAM;;;;;;;AAQtB,IAAa,oBAAb,MAAkC;CAMhC,YAAY,cAAsB;+BALlB,IAAI,KAA8B;+BAClC,IAAI,KAAgB;qBACd;AAIpB,OAAK,eAAe;;CAGtB,IAAI,KAA0C;EAC5C,MAAM,QAAQ,KAAK,MAAM,IAAI,IAAI;AACjC,MAAI,OAAO;GAET,MAAM,OAAO,KAAK,MAAM,IAAI,IAAI,IAAI;AACpC,QAAK,MAAM,OAAO,IAAI;AACtB,QAAK,MAAM,IAAI,KAAK,MAAM;AAC1B,QAAK,MAAM,OAAO,IAAI;AACtB,QAAK,MAAM,IAAI,KAAK,KAAK;;AAE3B,SAAO;;CAGT,IAAI,KAAQ,OAAmC;AAE7C,MAAI,KAAK,MAAM,IAAI,IAAI,EAAE;GACvB,MAAM,UAAU,KAAK,MAAM,IAAI,IAAI,IAAI;AACvC,QAAK,eAAe;AACpB,QAAK,MAAM,OAAO,IAAI;AACtB,QAAK,MAAM,OAAO,IAAI;;EAIxB,MAAM,sBAAsB,MACzB,MAAM,WAAW;GAChB,MAAM,aAAa,OAAO;AAC1B,QAAK,MAAM,IAAI,KAAK,WAAW;AAC/B,QAAK,eAAe;AAGpB,QAAK,kBAAkB;AAEvB,UAAO;IACP,CACD,OAAO,UAAU;AAEhB,QAAK,MAAM,OAAO,IAAI;AACtB,QAAK,MAAM,OAAO,IAAI;AACtB,SAAM;IACN;AAOJ,sBAAoB,YAAY,GAAG;AAEnC,OAAK,MAAM,IAAI,KAAK,oBAAoB;;CAG1C,AAAQ,mBAAyB;AAC/B,SAAO,KAAK,cAAc,KAAK,gBAAgB,KAAK,MAAM,OAAO,GAAG;GAElE,MAAM,WAAW,KAAK,MAAM,MAAM,CAAC,MAAM,CAAC;AAC1C,OAAI,UAAU;IACZ,MAAM,OAAO,KAAK,MAAM,IAAI,SAAS,IAAI;AACzC,SAAK,eAAe;AACpB,SAAK,MAAM,OAAO,SAAS;AAC3B,SAAK,MAAM,OAAO,SAAS;SAE3B;;;CAKN,IAAI,KAAiB;AACnB,SAAO,KAAK,MAAM,IAAI,IAAI;;CAG5B,OAAO,KAAiB;EACtB,MAAM,OAAO,KAAK,MAAM,IAAI,IAAI,IAAI;AACpC,OAAK,eAAe;AACpB,OAAK,MAAM,OAAO,IAAI;AACtB,SAAO,KAAK,MAAM,OAAO,IAAI;;CAG/B,QAAc;AACZ,OAAK,MAAM,OAAO;AAClB,OAAK,MAAM,OAAO;AAClB,OAAK,cAAc;;CAGrB,IAAI,OAAe;AACjB,SAAO,KAAK,MAAM;;CAGpB,IAAI,mBAA2B;AAC7B,SAAO,KAAK;;CAGd,IAAI,UAAkB;AACpB,SAAO,KAAK"}

package/dist/utils/frameTime.js

@@ -1,5 +1,27 @@
 //#region src/utils/frameTime.ts
 /**
+* Frame timing utilities for quantizing time values to frame boundaries.
+* These utilities ensure consistent frame-aligned timing across the codebase.
+*/
+/** Default FPS when none is specified */
+const DEFAULT_FPS = 30;
+/**
+* Calculate the duration of a single frame in milliseconds.
+*/
+function calculateFrameIntervalMs(fps) {
+	if (fps <= 0) return 1e3 / DEFAULT_FPS;
+	return 1e3 / fps;
+}
+/**
+* Quantize a time value (in milliseconds) to the nearest frame boundary.
+* This ensures frame markers align perfectly with playhead position.
+*/
+function quantizeToFrameTimeMs(timeMs, fps) {
+	if (!fps || fps <= 0) return timeMs;
+	const frameDurationMs = calculateFrameIntervalMs(fps);
+	return Math.round(timeMs / frameDurationMs) * frameDurationMs;
+}
+/**
 * Quantize a time value (in seconds) to the nearest frame boundary.
 * This ensures time values align with frame boundaries for consistent rendering.
 */
@@ -10,5 +32,5 @@ function quantizeToFrameTimeS(timeSeconds, fps) {
 }
 
 //#endregion
-export { quantizeToFrameTimeS };
+export { quantizeToFrameTimeMs, quantizeToFrameTimeS };
 //# sourceMappingURL=frameTime.js.map

package/dist/utils/frameTime.js.map

@@ -1 +1 @@
-{"version":3,"file":"frameTime.js","names":[],"sources":["../../src/utils/frameTime.ts"],"sourcesContent":["/**\n * Frame timing utilities for quantizing time values to frame boundaries.\n * These utilities ensure consistent frame-aligned timing across the codebase.\n */\n\n/** Default FPS when none is specified */\nexport const DEFAULT_FPS = 30;\n\n/**\n * Calculate the duration of a single frame in milliseconds.\n */\nexport function calculateFrameIntervalMs(fps: number): number {\n  if (fps <= 0) return 1000 / DEFAULT_FPS;\n  return 1000 / fps;\n}\n\n/**\n * Quantize a time value (in milliseconds) to the nearest frame boundary.\n * This ensures frame markers align perfectly with playhead position.\n */\nexport function quantizeToFrameTimeMs(timeMs: number, fps: number): number {\n  if (!fps || fps <= 0) return timeMs;\n  const frameDurationMs = calculateFrameIntervalMs(fps);\n  return Math.round(timeMs / frameDurationMs) * frameDurationMs;\n}\n\n/**\n * Quantize a time value (in seconds) to the nearest frame boundary.\n * This ensures time values align with frame boundaries for consistent rendering.\n */\nexport function quantizeToFrameTimeS(timeSeconds: number, fps: number): number {\n  if (!fps || fps <= 0) return timeSeconds;\n  const frameDurationS = 1 / fps;\n  return Math.round(timeSeconds / frameDurationS) * frameDurationS;\n}\n\n/**\n * Clamp and quantize a seek time to valid range.\n * Prevents \"Sample not found\" errors at video boundaries.\n * \n * @param desiredSeekTimeMs - The desired seek time in milliseconds\n * @param durationMs - The total duration in milliseconds\n * @param fps - Frames per second (defaults to 30)\n * @returns Clamped and quantized time in milliseconds\n */\nexport function clampAndQuantizeSeekTimeMs(\n  desiredSeekTimeMs: number,\n  durationMs: number,\n  fps: number = DEFAULT_FPS,\n): number {\n  if (durationMs <= 0) return 0;\n\n  // Quantize to frame boundaries\n  const quantizedMs = quantizeToFrameTimeMs(desiredSeekTimeMs, fps);\n\n  // Clamp to valid range [0, lastFrameTime]\n  // The last valid frame is at durationMs - frameDurationMs to ensure we don't\n  // seek past the last decodable frame\n  const frameDurationMs = calculateFrameIntervalMs(fps);\n  const maxValidTime = Math.max(0, durationMs - frameDurationMs);\n  return Math.max(0, Math.min(quantizedMs, maxValidTime));\n}\n\n\n\n\n"],"mappings":";;;;;AA8BA,SAAgB,qBAAqB,aAAqB,KAAqB;AAC7E,KAAI,CAAC,OAAO,OAAO,EAAG,QAAO;CAC7B,MAAM,iBAAiB,IAAI;AAC3B,QAAO,KAAK,MAAM,cAAc,eAAe,GAAG"}
+{"version":3,"file":"frameTime.js","names":[],"sources":["../../src/utils/frameTime.ts"],"sourcesContent":["/**\n * Frame timing utilities for quantizing time values to frame boundaries.\n * These utilities ensure consistent frame-aligned timing across the codebase.\n */\n\n/** Default FPS when none is specified */\nexport const DEFAULT_FPS = 30;\n\n/**\n * Calculate the duration of a single frame in milliseconds.\n */\nexport function calculateFrameIntervalMs(fps: number): number {\n  if (fps <= 0) return 1000 / DEFAULT_FPS;\n  return 1000 / fps;\n}\n\n/**\n * Quantize a time value (in milliseconds) to the nearest frame boundary.\n * This ensures frame markers align perfectly with playhead position.\n */\nexport function quantizeToFrameTimeMs(timeMs: number, fps: number): number {\n  if (!fps || fps <= 0) return timeMs;\n  const frameDurationMs = calculateFrameIntervalMs(fps);\n  return Math.round(timeMs / frameDurationMs) * frameDurationMs;\n}\n\n/**\n * Quantize a time value (in seconds) to the nearest frame boundary.\n * This ensures time values align with frame boundaries for consistent rendering.\n */\nexport function quantizeToFrameTimeS(timeSeconds: number, fps: number): number {\n  if (!fps || fps <= 0) return timeSeconds;\n  const frameDurationS = 1 / fps;\n  return Math.round(timeSeconds / frameDurationS) * frameDurationS;\n}\n\n/**\n * Clamp and quantize a seek time to valid range.\n * Prevents \"Sample not found\" errors at video boundaries.\n *\n * @param desiredSeekTimeMs - The desired seek time in milliseconds\n * @param durationMs - The total duration in milliseconds\n * @param fps - Frames per second (defaults to 30)\n * @returns Clamped and quantized time in milliseconds\n */\nexport function clampAndQuantizeSeekTimeMs(\n  desiredSeekTimeMs: number,\n  durationMs: number,\n  fps: number = DEFAULT_FPS,\n): number {\n  if (durationMs <= 0) return 0;\n\n  // Quantize to frame boundaries\n  const quantizedMs = quantizeToFrameTimeMs(desiredSeekTimeMs, fps);\n\n  // Clamp to valid range [0, lastFrameTime]\n  // The last valid frame is at durationMs - frameDurationMs to ensure we don't\n  // seek past the last decodable frame\n  const frameDurationMs = calculateFrameIntervalMs(fps);\n  const maxValidTime = Math.max(0, durationMs - frameDurationMs);\n  return Math.max(0, Math.min(quantizedMs, maxValidTime));\n}\n"],"mappings":";;;;;;AAMA,MAAa,cAAc;;;;AAK3B,SAAgB,yBAAyB,KAAqB;AAC5D,KAAI,OAAO,EAAG,QAAO,MAAO;AAC5B,QAAO,MAAO;;;;;;AAOhB,SAAgB,sBAAsB,QAAgB,KAAqB;AACzE,KAAI,CAAC,OAAO,OAAO,EAAG,QAAO;CAC7B,MAAM,kBAAkB,yBAAyB,IAAI;AACrD,QAAO,KAAK,MAAM,SAAS,gBAAgB,GAAG;;;;;;AAOhD,SAAgB,qBAAqB,aAAqB,KAAqB;AAC7E,KAAI,CAAC,OAAO,OAAO,EAAG,QAAO;CAC7B,MAAM,iBAAiB,IAAI;AAC3B,QAAO,KAAK,MAAM,cAAc,eAAe,GAAG"}

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@editframe/elements",
-  "version": "0.37.3-beta",
+  "version": "0.38.0",
   "description": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/editframe/elements.git",
+    "directory": "packages/elements"
+  },
   "type": "module",
   "scripts": {
-    "typecheck": "tsc --noEmit --emitDeclarationOnly false",
+    "typecheck": "tsc --noEmit",
     "build": "tsdown && node scripts/build-css.js",
     "build:watch": "tsdown --watch",
     "typedoc": "(typedoc --json ./types.json --plugin typedoc-plugin-zod --excludeExternals ./src || true) && ([ -f ./types.json ] && jq -c . ./types.json > ./types.tmp.json && mv ./types.tmp.json ./types.json || true)"
@@ -13,7 +18,7 @@
   "license": "UNLICENSED",
   "dependencies": {
     "@bramus/style-observer": "^1.3.0",
-    "@editframe/assets": "0.37.3-beta",
+    "@editframe/assets": "0.38.0",
     "@lit/context": "^1.1.6",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/context-zone": "^1.26.0",
@@ -28,15 +33,14 @@
     "zod": "^3.24.1"
   },
   "devDependencies": {
+    "@jridgewell/trace-mapping": "^0.3.28",
     "@types/dom-webcodecs": "^0.1.11",
-    "@types/node": "^20.14.13",
+    "@types/node": "^22.0.0",
     "autoprefixer": "^10.4.19",
     "postcss": "^8.4.38",
     "tailwindcss": "^3.4.3",
-    "typescript": "^5.5.4"
+    "typescript": "^5.9.3"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
@@ -63,6 +67,12 @@
           "default": "./dist/index.js"
         }
       },
+      "./server": {
+        "import": {
+          "types": "./dist/server.d.ts",
+          "default": "./dist/server.js"
+        }
+      },
       "./node": {
         "import": {
           "types": "./dist/node.d.ts",
@@ -71,7 +81,10 @@
       },
       "./package.json": "./package.json",
       "./styles.css": "./dist/style.css",
+      "./theme.css": "./dist/gui/ef-theme.css",
       "./types.json": "./types.json"
     }
-  }
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js"
 }

package/scripts/build-css.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync, cpSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import autoprefixer from "autoprefixer";
@@ -14,6 +14,7 @@ const configPath = join(__dirname, "..", "tailwind.config.ts");
 
 // Ensure dist directory exists
 mkdirSync(distDir, { recursive: true });
+mkdirSync(join(distDir, "gui"), { recursive: true });
 
 // Read source CSS
 const cssPath = join(srcDir, "elements.css");
@@ -30,6 +31,12 @@ postcss([tailwindcss({ config: configPath }), autoprefixer()])
       writeFileSync(join(distDir, "style.css.map"), result.map.toString());
     }
     console.log("✅ CSS processed and written to dist/style.css");
+
+    // Copy theme CSS file
+    const themeCssPath = join(srcDir, "gui", "ef-theme.css");
+    const themeDistPath = join(distDir, "gui", "ef-theme.css");
+    cpSync(themeCssPath, themeDistPath);
+    console.log("✅ Theme CSS copied to dist/gui/ef-theme.css");
   })
   .catch((error) => {
     console.error("❌ CSS processing failed:", error);

package/test/setup.ts

@@ -62,7 +62,6 @@ afterAll(() => {
   if (typeof window !== "undefined") {
     // Always set the flag, creating it if it doesn't exist
     // This handles both profiled and non-profiled test runs
-    console.log("[Profiler] Signaling stop...");
     (window as any).__PROFILER_STOP_REQUESTED__ = true;
 
     // Give profiler time to detect the signal and retrieve profile data

package/test/useAssetMSW.ts

@@ -100,4 +100,54 @@ export const assetMSWHandlers = [
       },
     });
   }),
+
+  http.get("/api/v1/files/:id/index", async () => {
+    const mockIndex = {
+      0: {
+        duration: 10000,
+        timescale: 1000,
+        fragments: [
+          {
+            offset: 0,
+            size: 1024,
+            timestamp: 0,
+            duration: 10000,
+          },
+        ],
+      },
+    };
+
+    return HttpResponse.json(mockIndex, {
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+  }),
+
+  http.get("/api/v1/files/:id/tracks/:trackId", async ({ request }) => {
+    const rangeHeader = request.headers.get("range");
+
+    if (rangeHeader) {
+      const mockData = new ArrayBuffer(1024);
+      return new HttpResponse(mockData, {
+        status: 206,
+        headers: {
+          "Content-Type": "video/mp4",
+          "Accept-Ranges": "bytes",
+          "Content-Range": rangeHeader,
+          "Content-Length": "1024",
+        },
+      });
+    }
+
+    const mockData = new ArrayBuffer(1024);
+    return new HttpResponse(mockData, {
+      status: 200,
+      headers: {
+        "Content-Type": "video/mp4",
+        "Accept-Ranges": "bytes",
+        "Content-Length": "1024",
+      },
+    });
+  }),
 ];

package/test/visualRegressionUtils.ts

@@ -15,14 +15,28 @@ export interface SnapshotComparisonResult {
 }
 
 /**
- * Capture a canvas element as a data URL.
+ * Capture a canvas or image as a data URL.
  * Uses JPEG format with configurable quality for smaller file sizes.
  */
 export function captureCanvasAsDataUrl(
-  canvas: HTMLCanvasElement,
+  source: CanvasImageSource | HTMLCanvasElement,
   format: "image/png" | "image/jpeg" = "image/jpeg",
   quality: number = 0.85,
 ): string {
+  // If it's already a canvas, use toDataURL directly
+  if (source instanceof HTMLCanvasElement) {
+    return source.toDataURL(format, quality);
+  }
+
+  // Otherwise, draw to temp canvas first
+  const canvas = document.createElement("canvas");
+  canvas.width = (source as any).width as number;
+  canvas.height = (source as any).height as number;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Failed to get canvas 2d context");
+  }
+  ctx.drawImage(source, 0, 0);
   return canvas.toDataURL(format, quality);
 }
 
@@ -178,7 +192,7 @@ export async function assertCanvasSnapshot(
  * Throws an assertion error if the diff exceeds the acceptable threshold.
  */
 export async function expectCanvasToMatchSnapshot(
-  canvas: HTMLCanvasElement,
+  source: CanvasImageSource | HTMLCanvasElement,
   testName: string,
   snapshotName: string,
   options: {
@@ -187,7 +201,7 @@ export async function expectCanvasToMatchSnapshot(
   } = {},
 ): Promise<void> {
   const result = await assertCanvasSnapshot(
-    canvas,
+    source as unknown as HTMLCanvasElement,
     testName,
     snapshotName,
     options,
@@ -210,12 +224,12 @@ export async function expectCanvasToMatchSnapshot(
 }
 
 /**
- * Compare two canvases directly against each other.
+ * Compare two canvases or images directly against each other.
  * Returns comparison results including diff percentage.
  */
 export async function compareTwoCanvases(
-  canvas1: HTMLCanvasElement,
-  canvas2: HTMLCanvasElement,
+  source1: CanvasImageSource | HTMLCanvasElement,
+  source2: CanvasImageSource | HTMLCanvasElement,
   testName: string,
   comparisonName: string,
   options: {
@@ -226,8 +240,8 @@ export async function compareTwoCanvases(
   const { threshold = 0.1, acceptableDiffPercentage = 1.0 } = options;
 
   // Use PNG format for consistent comparison (odiff works best with PNG)
-  const dataUrl1 = captureCanvasAsDataUrl(canvas1, "image/png");
-  const dataUrl2 = captureCanvasAsDataUrl(canvas2, "image/png");
+  const dataUrl1 = captureCanvasAsDataUrl(source1, "image/png");
+  const dataUrl2 = captureCanvasAsDataUrl(source2, "image/png");
 
   const response = await fetch("/@ef-compare-two-images", {
     method: "POST",

package/dist/_virtual/rolldown_runtime.js

@@ -1,27 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-export { __commonJS, __toESM };

package/dist/elements/EFMedia/AssetIdMediaEngine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AssetIdMediaEngine.js","names":["data: Record<number, TrackFragmentIndex>","assetId: string","apiHost: string","paths: InitSegmentPaths"],"sources":["../../../src/elements/EFMedia/AssetIdMediaEngine.ts"],"sourcesContent":["import type { TrackFragmentIndex } from \"@editframe/assets\";\nimport type {\n  InitSegmentPaths,\n  MediaEngine,\n  VideoRendition,\n} from \"../../transcoding/types\";\nimport type { UrlGenerator } from \"../../transcoding/utils/UrlGenerator\";\nimport type { EFMedia } from \"../EFMedia\";\nimport { AssetMediaEngine } from \"./AssetMediaEngine\";\n\nexport class AssetIdMediaEngine\n  extends AssetMediaEngine\n  implements MediaEngine\n{\n  static async fetchByAssetId(\n    host: EFMedia,\n    _urlGenerator: UrlGenerator,\n    assetId: string,\n    apiHost: string,\n    requiredTracks: \"audio\" | \"video\" | \"both\" = \"both\",\n    signal?: AbortSignal,\n  ) {\n    const url = `${apiHost}/api/v1/isobmff_files/${assetId}/index`;\n    const response = await host.fetch(url, { signal });\n    \n    // Check for abort after potentially slow network operation\n    signal?.throwIfAborted();\n    \n    // Check if response is ok before parsing JSON\n    if (!response.ok) {\n      const text = await response.text();\n      throw new Error(`Failed to fetch asset index: ${response.status} ${text}`);\n    }\n    \n    // Check content type to avoid parsing non-JSON responses\n    const contentType = response.headers.get(\"content-type\");\n    if (contentType && !contentType.includes(\"application/json\")) {\n      const text = await response.text();\n      throw new Error(`Expected JSON but got ${contentType}: ${text.substring(0, 100)}`);\n    }\n    \n    let data: Record<number, TrackFragmentIndex>;\n    try {\n      data = (await response.json()) as Record<number, TrackFragmentIndex>;\n      \n      // Check for abort after potentially slow JSON parsing\n      signal?.throwIfAborted();\n    } catch (error) {\n      // If aborted during JSON parsing, re-throw to propagate cancellation\n      if (error instanceof DOMException && error.name === \"AbortError\") {\n        throw error;\n      }\n      // If JSON parse fails, the response might be \"File not found\" or similar text\n      const text = await response.text();\n      throw new Error(`Failed to parse JSON response: ${text.substring(0, 100)}`);\n    }\n    \n    const engine = new AssetIdMediaEngine(host, assetId, data, apiHost, _urlGenerator);\n    \n    // Check for abort after engine construction\n    signal?.throwIfAborted();\n    \n    // Validate that segments are accessible by trying to fetch the first init segment\n    // This prevents creating a media engine that will fail on all subsequent segment fetches\n    // If segments require authentication that's not available, fail early\n    // Only validate tracks that are actually required by the consumer (e.g., EFAudio only needs audio)\n    // Skip validation if no signal provided (backwards compatibility) - validation is optional\n    if (signal) {\n      const videoTrack = engine.getVideoTrackIndex();\n      const audioTrack = engine.getAudioTrackIndex();\n      const needsVideo = requiredTracks === \"video\" || requiredTracks === \"both\";\n      const needsAudio = requiredTracks === \"audio\" || requiredTracks === \"both\";\n      \n      // Validate video track if required and available\n      if (needsVideo && videoTrack && videoTrack.track !== undefined) {\n        try {\n          await engine.fetchInitSegment(\n            { trackId: videoTrack.track, src: engine.src },\n            signal,\n          );\n        } catch (error) {\n          // If aborted, re-throw to propagate cancellation\n          if (error instanceof DOMException && error.name === \"AbortError\") {\n            throw error;\n          }\n          // If fetch fails with 401, segments require authentication that's not available\n          // Fail media engine creation early to avoid all subsequent fetch calls\n          if (\n            error instanceof Error &&\n            (error.message.includes(\"401\") ||\n              error.message.includes(\"UNAUTHORIZED\") ||\n              (error.message.includes(\"Failed to fetch\") && error.message.includes(\"401\")))\n          ) {\n            throw new Error(`Video segments require authentication: ${error.message}`);\n          }\n          // For other errors (404, network errors, etc.), allow media engine creation\n          // These might be transient or expected in some test scenarios\n        }\n      }\n      \n      // Check for abort between validations\n      signal?.throwIfAborted();\n      \n      // Validate audio track if required and available\n      if (needsAudio && audioTrack && audioTrack.track !== undefined) {\n        try {\n          await engine.fetchInitSegment(\n            { trackId: audioTrack.track, src: engine.src },\n            signal,\n          );\n        } catch (error) {\n          // If aborted, re-throw to propagate cancellation\n          if (error instanceof DOMException && error.name === \"AbortError\") {\n            throw error;\n          }\n          // If fetch fails with 401, segments require authentication that's not available\n          // Fail media engine creation early to avoid all subsequent fetch calls\n          if (\n            error instanceof Error &&\n            (error.message.includes(\"401\") ||\n              error.message.includes(\"UNAUTHORIZED\") ||\n              (error.message.includes(\"Failed to fetch\") && error.message.includes(\"401\")))\n          ) {\n            throw new Error(`Audio segments require authentication: ${error.message}`);\n          }\n          // For other errors (404, network errors, etc.), allow media engine creation\n          // These might be transient or expected in some test scenarios\n        }\n      }\n    }\n    \n    return engine;\n  }\n\n  constructor(\n    host: EFMedia,\n    public assetId: string,\n    data: Record<number, TrackFragmentIndex>,\n    private apiHost: string,\n    urlGenerator: UrlGenerator,\n  ) {\n    // Pass assetId as src to parent constructor for compatibility\n    super(host, assetId, urlGenerator);\n    // Initialize data after parent constructor\n    this.data = data;\n\n    // Calculate duration from the data\n    const longestFragment = Object.values(this.data).reduce(\n      (max, fragment) => Math.max(max, fragment.duration / fragment.timescale),\n      0,\n    );\n    this.durationMs = longestFragment * 1000;\n    \n    // Initialize MediaEngine interface properties\n    this.templates = {\n      initSegment: `${apiHost}/api/v1/isobmff_tracks/${assetId}/{trackId}`,\n      mediaSegment: `${apiHost}/api/v1/isobmff_tracks/${assetId}/{trackId}`,\n    };\n  }\n\n  // Override URL-building methods to use API endpoints instead of file paths\n  getInitSegmentPaths(): InitSegmentPaths {\n    const paths: InitSegmentPaths = {};\n    const audioTrack = this.getAudioTrackIndex();\n    const videoTrack = this.getVideoTrackIndex();\n\n    if (audioTrack !== undefined) {\n      paths.audio = {\n        path: `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${audioTrack.track}`,\n        pos: audioTrack.initSegment.offset,\n        size: audioTrack.initSegment.size,\n      };\n    }\n\n    if (videoTrack !== undefined) {\n      paths.video = {\n        path: `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${videoTrack.track}`,\n        pos: videoTrack.initSegment.offset,\n        size: videoTrack.initSegment.size,\n      };\n    }\n\n    return paths;\n  }\n\n  // MediaEngine interface property - initialized in constructor/static fetch\n  templates!: { initSegment: string; mediaSegment: string };\n\n  buildInitSegmentUrl(trackId: number) {\n    return `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${trackId}`;\n  }\n\n  buildMediaSegmentUrl(trackId: number, _segmentId: number) {\n    return `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${trackId}`;\n  }\n\n  convertToSegmentRelativeTimestamps(\n    globalTimestamps: number[],\n    segmentId: number,\n    rendition: VideoRendition,\n  ): number[] {\n    if (!rendition.trackId) {\n      throw new Error(\n        \"[convertToSegmentRelativeTimestamps] Track ID is required for asset metadata\",\n      );\n    }\n    // For AssetMediaEngine, we need to calculate the actual segment start time\n    // using the precise segment boundaries from the track fragment index\n    const trackData = this.data[rendition.trackId];\n    if (!trackData) {\n      throw new Error(\"Track not found\");\n    }\n    const segment = trackData.segments?.[segmentId];\n    if (!segment) {\n      throw new Error(\"Segment not found\");\n    }\n    const segmentStartMs = (segment.cts / trackData.timescale) * 1000;\n\n    return globalTimestamps.map(\n      (globalMs) => (globalMs - segmentStartMs) / 1000,\n    );\n  }\n}\n"],"mappings":";;;AAUA,IAAa,qBAAb,MAAa,2BACH,iBAEV;CACE,aAAa,eACX,MACA,eACA,SACA,SACA,iBAA6C,QAC7C,QACA;EACA,MAAM,MAAM,GAAG,QAAQ,wBAAwB,QAAQ;EACvD,MAAM,WAAW,MAAM,KAAK,MAAM,KAAK,EAAE,QAAQ,CAAC;AAGlD,UAAQ,gBAAgB;AAGxB,MAAI,CAAC,SAAS,IAAI;GAChB,MAAM,OAAO,MAAM,SAAS,MAAM;AAClC,SAAM,IAAI,MAAM,gCAAgC,SAAS,OAAO,GAAG,OAAO;;EAI5E,MAAM,cAAc,SAAS,QAAQ,IAAI,eAAe;AACxD,MAAI,eAAe,CAAC,YAAY,SAAS,mBAAmB,EAAE;GAC5D,MAAM,OAAO,MAAM,SAAS,MAAM;AAClC,SAAM,IAAI,MAAM,yBAAyB,YAAY,IAAI,KAAK,UAAU,GAAG,IAAI,GAAG;;EAGpF,IAAIA;AACJ,MAAI;AACF,UAAQ,MAAM,SAAS,MAAM;AAG7B,WAAQ,gBAAgB;WACjB,OAAO;AAEd,OAAI,iBAAiB,gBAAgB,MAAM,SAAS,aAClD,OAAM;GAGR,MAAM,OAAO,MAAM,SAAS,MAAM;AAClC,SAAM,IAAI,MAAM,kCAAkC,KAAK,UAAU,GAAG,IAAI,GAAG;;EAG7E,MAAM,SAAS,IAAI,mBAAmB,MAAM,SAAS,MAAM,SAAS,cAAc;AAGlF,UAAQ,gBAAgB;AAOxB,MAAI,QAAQ;GACV,MAAM,aAAa,OAAO,oBAAoB;GAC9C,MAAM,aAAa,OAAO,oBAAoB;GAC9C,MAAM,aAAa,mBAAmB,WAAW,mBAAmB;GACpE,MAAM,aAAa,mBAAmB,WAAW,mBAAmB;AAGpE,OAAI,cAAc,cAAc,WAAW,UAAU,OACnD,KAAI;AACF,UAAM,OAAO,iBACX;KAAE,SAAS,WAAW;KAAO,KAAK,OAAO;KAAK,EAC9C,OACD;YACM,OAAO;AAEd,QAAI,iBAAiB,gBAAgB,MAAM,SAAS,aAClD,OAAM;AAIR,QACE,iBAAiB,UAChB,MAAM,QAAQ,SAAS,MAAM,IAC5B,MAAM,QAAQ,SAAS,eAAe,IACrC,MAAM,QAAQ,SAAS,kBAAkB,IAAI,MAAM,QAAQ,SAAS,MAAM,EAE7E,OAAM,IAAI,MAAM,0CAA0C,MAAM,UAAU;;AAQhF,WAAQ,gBAAgB;AAGxB,OAAI,cAAc,cAAc,WAAW,UAAU,OACnD,KAAI;AACF,UAAM,OAAO,iBACX;KAAE,SAAS,WAAW;KAAO,KAAK,OAAO;KAAK,EAC9C,OACD;YACM,OAAO;AAEd,QAAI,iBAAiB,gBAAgB,MAAM,SAAS,aAClD,OAAM;AAIR,QACE,iBAAiB,UAChB,MAAM,QAAQ,SAAS,MAAM,IAC5B,MAAM,QAAQ,SAAS,eAAe,IACrC,MAAM,QAAQ,SAAS,kBAAkB,IAAI,MAAM,QAAQ,SAAS,MAAM,EAE7E,OAAM,IAAI,MAAM,0CAA0C,MAAM,UAAU;;;AAQlF,SAAO;;CAGT,YACE,MACA,AAAOC,SACP,MACA,AAAQC,SACR,cACA;AAEA,QAAM,MAAM,SAAS,aAAa;EAN3B;EAEC;AAMR,OAAK,OAAO;AAOZ,OAAK,aAJmB,OAAO,OAAO,KAAK,KAAK,CAAC,QAC9C,KAAK,aAAa,KAAK,IAAI,KAAK,SAAS,WAAW,SAAS,UAAU,EACxE,EACD,GACmC;AAGpC,OAAK,YAAY;GACf,aAAa,GAAG,QAAQ,yBAAyB,QAAQ;GACzD,cAAc,GAAG,QAAQ,yBAAyB,QAAQ;GAC3D;;CAIH,sBAAwC;EACtC,MAAMC,QAA0B,EAAE;EAClC,MAAM,aAAa,KAAK,oBAAoB;EAC5C,MAAM,aAAa,KAAK,oBAAoB;AAE5C,MAAI,eAAe,OACjB,OAAM,QAAQ;GACZ,MAAM,GAAG,KAAK,QAAQ,yBAAyB,KAAK,QAAQ,GAAG,WAAW;GAC1E,KAAK,WAAW,YAAY;GAC5B,MAAM,WAAW,YAAY;GAC9B;AAGH,MAAI,eAAe,OACjB,OAAM,QAAQ;GACZ,MAAM,GAAG,KAAK,QAAQ,yBAAyB,KAAK,QAAQ,GAAG,WAAW;GAC1E,KAAK,WAAW,YAAY;GAC5B,MAAM,WAAW,YAAY;GAC9B;AAGH,SAAO;;CAMT,oBAAoB,SAAiB;AACnC,SAAO,GAAG,KAAK,QAAQ,yBAAyB,KAAK,QAAQ,GAAG;;CAGlE,qBAAqB,SAAiB,YAAoB;AACxD,SAAO,GAAG,KAAK,QAAQ,yBAAyB,KAAK,QAAQ,GAAG;;CAGlE,mCACE,kBACA,WACA,WACU;AACV,MAAI,CAAC,UAAU,QACb,OAAM,IAAI,MACR,+EACD;EAIH,MAAM,YAAY,KAAK,KAAK,UAAU;AACtC,MAAI,CAAC,UACH,OAAM,IAAI,MAAM,kBAAkB;EAEpC,MAAM,UAAU,UAAU,WAAW;AACrC,MAAI,CAAC,QACH,OAAM,IAAI,MAAM,oBAAoB;EAEtC,MAAM,iBAAkB,QAAQ,MAAM,UAAU,YAAa;AAE7D,SAAO,iBAAiB,KACrB,cAAc,WAAW,kBAAkB,IAC7C"}