@editframe/assets 0.16.8-beta.0 → 0.18.3-beta.0

package/dist/EncodedAsset.js

@@ -1,572 +1,443 @@
-import * as MP4Box from "mp4box";
-import debug from "debug";
-import { memoize } from "./memoize.js";
 import { MP4File } from "./MP4File.js";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = __getOwnPropDesc(target, key);
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = decorator(target, key, result) || result;
-  if (result) __defProp(target, key, result);
-  return result;
-};
+import { memoize } from "./memoize.js";
+import { FrameBuffer } from "./FrameBuffer.js";
+import { SeekStrategy } from "./SeekStrategy.js";
+import { MP4SampleAnalyzer } from "./MP4SampleAnalyzer.js";
+import { DecoderManager } from "./DecoderManager.js";
+import debug from "debug";
+import _decorate from "@oxc-project/runtime/helpers/decorate";
 const log = debug("ef:av");
 const BUFFER_SIZE = 30;
-class AssetNotAvailableLocally extends Error {
-}
-class FileAsset {
-  constructor(localName, file) {
-    this.localName = localName;
-    this.file = file;
-  }
-  async arrayBuffer() {
-    return this.file.arrayBuffer();
-  }
-  get byteSize() {
-    return this.file.size;
-  }
-  get fileExtension() {
-    return this.file.name.split(".").pop();
-  }
-  slice(start, end) {
-    return this.file.slice(start, end);
-  }
-}
-class ISOFileAsset extends FileAsset {
-  constructor(localName, file, mp4boxFile) {
-    super(localName, file);
-    this.localName = localName;
-    this.file = file;
-    this.mp4boxFile = mp4boxFile;
-  }
-  get fileInfo() {
-    return this.mp4boxFile.getInfo();
-  }
-  get containerFormat() {
-    return "mp4";
-  }
-}
-__decorateClass([
-  memoize
-], ISOFileAsset.prototype, "fileInfo");
-const _VideoAsset = class _VideoAsset2 extends ISOFileAsset {
-  constructor(localName, mp4boxFile, file) {
-    super(localName, file, mp4boxFile);
-    this.decodedFrames = [];
-    this.requestedSampleNumber = 0;
-    this.outCursor = 0;
-    this.sampleCursor = 0;
-    this.eventListeners = {};
-    this.latestSeekCts = 0;
-    this.videoDecoder = new VideoDecoder({
-      error: (e) => {
-        console.error("Video Decoder Error", e);
-        throw e;
-      },
-      // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      output: async (decodedFrame) => {
-        const clone = decodedFrame.clone();
-        log("🖼️ frame cts=", decodedFrame.timestamp);
-        this.decodedFrames.push(clone);
-        this.pruneBuffer();
-        decodedFrame.close();
-        this.outCursor = this.samples.findIndex(
-          (sample) => sample.cts === decodedFrame.timestamp
-        );
-        log(`cursor=${this.sampleCursor} outCursor=${this.outCursor}`);
-        this.emit("frame", clone);
-      }
-    });
-    this.configureDecoder();
-  }
-  static async createFromReadableStream(id, stream, file) {
-    let fileStart = 0;
-    const inputFile = new MP4File();
-    const reader = stream.getReader();
-    const processChunk = ({
-      done,
-      value
-    }) => {
-      if (done) {
-        return;
-      }
-      if (!value) {
-        return;
-      }
-      const mp4buffer = value.buffer;
-      mp4buffer.fileStart = fileStart;
-      const isLast = file.size === fileStart + value.byteLength;
-      inputFile.appendBuffer(mp4buffer, isLast);
-      fileStart += value.byteLength;
-      return reader.read().then(processChunk);
-    };
-    await reader.read().then(processChunk);
-    return new _VideoAsset2(id, inputFile, file);
-  }
-  /**
-   * **Only use this function in tests to reset a VideoAsset to its initial state.**
-   *
-   * @deprecated
-   */
-  async TEST_ONLY_RESET() {
-    if (this.videoDecoder.state !== "closed") {
-      await this.videoDecoder.flush();
-    }
-    this.configureDecoder();
-    this.requestedSampleNumber = 0;
-    this.outCursor = 0;
-    this.sampleCursor = 0;
-    for (const frame of this.decodedFrames) {
-      frame.close();
-    }
-    this.decodedFrames = [];
-    this.lastDecodedSample = void 0;
-    this.lastSoughtFrame?.close();
-    this.lastSoughtFrame = void 0;
-  }
-  addEventListener(type, callback) {
-    this.eventListeners[type] ||= /* @__PURE__ */ new Set();
-    this.eventListeners[type]?.add(callback);
-  }
-  removeEventListener(type, callback) {
-    this.eventListeners[type]?.delete(callback);
-  }
-  emit(type, ...args) {
-    for (const listener of this.eventListeners[type] ?? []) {
-      listener(...args);
-    }
-  }
-  get videoCodec() {
-    if (!this.defaultVideoTrack) {
-      throw new Error("No default video track found");
-    }
-    return this.defaultVideoTrack?.codec;
-  }
-  get fragmentInfo() {
-    const fragments = [];
-    const [first, ...samples] = this.samples;
-    if (!first) {
-      return fragments;
-    }
-    let currentFragment = {
-      offset: first.offset,
-      size: first.size,
-      start_ms: first.cts,
-      duration_ms: 0
-    };
-    for (const sample of samples) {
-      if (sample.is_sync) {
-        if (currentFragment) {
-          currentFragment.duration_ms = sample.cts - currentFragment.start_ms;
-          fragments.push(currentFragment);
-        }
-        currentFragment = {
-          offset: sample.offset,
-          size: sample.size,
-          start_ms: sample.cts,
-          duration_ms: 0
-        };
-      } else {
-        currentFragment.size += sample.size;
-      }
-    }
-    return fragments;
-  }
-  pruneBuffer() {
-    if (this.decodedFrames.length > BUFFER_SIZE) {
-      this.decodedFrames.shift()?.close();
-    }
-  }
-  get editsOffset() {
-    if (!this.defaultVideoTrack?.edits) {
-      return 0;
-    }
-    return this.defaultVideoTrack.edits.reduce((acc, edit) => {
-      return acc + edit.media_time;
-    }, 0);
-  }
-  async waitUntilVideoQueueDrained() {
-    if (this.videoDecoder.decodeQueueSize === 0) {
-      return;
-    }
-    await new Promise((resolve) => {
-      this.videoDecoder.addEventListener(
-        "dequeue",
-        () => {
-          resolve();
-        },
-        { once: true }
-      );
-    });
-    await this.waitUntilVideoQueueDrained();
-  }
-  get canDecodeNextSample() {
-    return this.sampleCursor < this.samples.length;
-  }
-  async decodeNextSample() {
-    if (!this.canDecodeNextSample) {
-      throw new Error("No more samples to decode");
-    }
-    await this.decodeSlice(this.sampleCursor, this.sampleCursor);
-    this.sampleCursor++;
-  }
-  async decodeSlice(start, end) {
-    const samples = this.samples.slice(start, end + 1);
-    const firstSample = samples[0];
-    const lastSample = samples[samples.length - 1];
-    if (!firstSample || !lastSample) {
-      throw new Error("Samples not found");
-    }
-    const sliceStart = firstSample.offset;
-    const sliceEnd = lastSample.offset + lastSample.size;
-    const buffer = await this.file.slice(sliceStart, sliceEnd).arrayBuffer();
-    const firstSampleOffset = firstSample.offset;
-    for (let i = start; i <= end; i++) {
-      await this.waitUntilVideoQueueDrained();
-      const sample = this.getSample(i);
-      log("Decoding sample #", i, `cts=${sample.cts}`);
-      const sampleStart = sample.offset - firstSampleOffset;
-      const sampleEnd = sample.offset + sample.size - firstSampleOffset;
-      const chunk = new EncodedVideoChunk({
-        data: buffer.slice(sampleStart, sampleEnd),
-        timestamp: sample.cts,
-        duration: sample.duration,
-        type: sample.is_sync ? "key" : "delta"
-      });
-      if (this.videoDecoder.state === "closed") {
-        console.info("Decoder closed, skipping decode");
-        continue;
-      }
-      this.videoDecoder.decode(chunk);
-      const nextSample = this.defaultVideoTrak?.samples?.[i + 1];
-      if (nextSample === void 0) {
-        log("ENDFLUSH");
-        await this.videoDecoder.flush();
-      }
-    }
-  }
-  get decoderConfiguration() {
-    if (!this.defaultVideoTrack) {
-      throw new Error("No default video track found");
-    }
-    let description = new Uint8Array();
-    const trak = this.mp4boxFile.getTrackById(this.defaultVideoTrack.id);
-    for (const entry of trak.mdia.minf.stbl.stsd.entries) {
-      if (entry.avcC ?? entry.hvcC) {
-        const stream = new MP4Box.DataStream(
-          void 0,
-          0,
-          MP4Box.DataStream.BIG_ENDIAN
-        );
-        if (entry.avcC) {
-          entry.avcC.write(stream);
-        } else {
-          entry.hvcC.write(stream);
-        }
-        description = new Uint8Array(stream.buffer, 8);
-        break;
-      }
-    }
-    return {
-      codec: this.defaultVideoTrack.codec,
-      codedWidth: this.defaultVideoTrack.track_width,
-      codedHeight: this.defaultVideoTrack.track_height,
-      optimizeForLatency: true,
-      description
-    };
-  }
-  /**
-   * Configures the video decoder with the appropriate codec, dimensions, and hardware acceleration settings.
-   * If the decoder is already configured, it will be reset before being reconfigured.
-   */
-  configureDecoder() {
-    if (this.videoDecoder.state === "configured") {
-      this.videoDecoder.reset();
-    }
-    log("Attempting to configure decoder", this.decoderConfiguration);
-    this.videoDecoder.configure(this.decoderConfiguration);
-  }
-  // Default to -1 to throw error if called without an index
-  getSample(index = -1) {
-    const sample = this.samples?.[index];
-    if (!sample) {
-      throw new Error(`Sample not found at index ${index}`);
-    }
-    return sample;
-  }
-  get timescale() {
-    if (!this.defaultVideoTrack) {
-      throw new Error("No default video track found");
-    }
-    return this.defaultVideoTrack.timescale;
-  }
-  get samples() {
-    if (!this.defaultVideoTrak.samples) {
-      throw new Error("No video samples found");
-    }
-    return this.defaultVideoTrak.samples;
-  }
-  get displayOrderedSamples() {
-    return Array.from(this.samples).sort((a, b) => {
-      return a.cts - b.cts;
-    });
-  }
-  getSampleClosetToTime(seconds) {
-    const targetTime = Math.round(seconds * this.timescale + this.editsOffset);
-    const sampleIndex = this.displayOrderedSamples.findIndex(
-      (sample) => sample.cts >= targetTime
-    );
-    if (sampleIndex === -1) {
-      return this.displayOrderedSamples[this.displayOrderedSamples.length - 1];
-    }
-    return this.displayOrderedSamples[sampleIndex];
-  }
-  seekingWillEmitNewFrame(seconds) {
-    if (!this.lastSoughtFrame) {
-      return true;
-    }
-    if (this.seekingWillGoBackwards(seconds)) {
-      return true;
-    }
-    const nextCts = this.getSampleClosetToTime(seconds).cts;
-    return nextCts > this.lastSoughtFrame.timestamp;
-  }
-  seekingWillSkipPictureGroup(seconds) {
-    let start = this.sampleCursor;
-    const end = this.getSampleClosetToTime(seconds).number;
-    let syncFrameCrossings = 0;
-    while (start <= end) {
-      const sample = this.getSample(start);
-      if (sample.is_sync) {
-        if (syncFrameCrossings > 1) {
-          return true;
-        }
-        syncFrameCrossings++;
-      }
-      start++;
-    }
-    return false;
-  }
-  seekingWillGoBackwards(seconds) {
-    const targetSample = this.getSampleClosetToTime(seconds);
-    const targetIndex = this.displayOrderedSamples.indexOf(targetSample);
-    const targetInCache = this.decodedFrames.find(
-      (frame) => frame.timestamp === targetSample.cts
-    );
-    const atEnd = this.sampleCursor === this.samples.length - 1;
-    log(
-      "this.outCursor <= targetSample.number",
-      this.outCursor <= targetSample.number
-    );
-    log("this.outCursor <= targetIndex", this.outCursor <= targetIndex);
-    if (atEnd) {
-      return false;
-    }
-    if (targetInCache) {
-      return false;
-    }
-    log({
-      sampleCursor: this.sampleCursor,
-      outCursor: this.outCursor,
-      target: targetSample.number,
-      targetIndex,
-      inCache: !!targetInCache,
-      atEnd
-    });
-    return this.outCursor > targetIndex;
-  }
-  async seekToTime(seconds) {
-    const sample = this.getSampleClosetToTime(seconds);
-    const cts = sample.cts;
-    this.latestSeekCts = cts;
-    const alreadyDecodedFrame = this.decodedFrames.find(
-      (f) => f.timestamp === cts
-    );
-    if (alreadyDecodedFrame) {
-      return alreadyDecodedFrame;
-    }
-    if (this.seekingWillSkipPictureGroup(seconds)) {
-      await this.videoDecoder.flush();
-      let syncSampleNumber = sample.number;
-      while (!this.getSample(syncSampleNumber).is_sync) {
-        syncSampleNumber--;
-        if (syncSampleNumber < 0) {
-          throw new Error("No sync sample found when traversing backwards");
-        }
-      }
-      this.sampleCursor = syncSampleNumber;
-    }
-    if (this.seekingWillGoBackwards(seconds)) {
-      log("BACKWARDS FLUSH");
-      await this.videoDecoder.flush();
-      for (const frame2 of this.decodedFrames) {
-        frame2.close();
-      }
-      this.decodedFrames = [];
-      let syncSampleNumber = sample.number;
-      while (!this.getSample(syncSampleNumber).is_sync) {
-        syncSampleNumber--;
-        if (syncSampleNumber < 0) {
-          throw new Error("No sync sample found when traversing backwards");
-        }
-      }
-      this.sampleCursor = syncSampleNumber;
-    }
-    let frame;
-    const maybeFrame = (_frame) => {
-      if (frame) {
-        return;
-      }
-      log("Maybe frame", _frame.timestamp, cts);
-      if (_frame.timestamp === cts) {
-        this.removeEventListener("frame", maybeFrame);
-        frame = _frame;
-      }
-    };
-    this.addEventListener("frame", maybeFrame);
-    while (frame === void 0 && this.canDecodeNextSample) {
-      await this.decodeNextSample();
-    }
-    this.removeEventListener("frame", maybeFrame);
-    if (frame) {
-      if (this.lastSoughtFrame && !this.decodedFrames.includes(this.lastSoughtFrame)) {
-        try {
-          this.lastSoughtFrame.close();
-        } catch (error) {
-        }
-      }
-      this.lastSoughtFrame = frame;
-    }
-    return frame;
-  }
-  get defaultVideoTrack() {
-    return this.fileInfo.videoTracks[0];
-  }
-  get defaultVideoTrak() {
-    return this.mp4boxFile.getTrackById(this.defaultVideoTrack?.id ?? -1);
-  }
-  get duration() {
-    return this.fileInfo.duration / this.fileInfo.timescale;
-  }
+var AssetNotAvailableLocally = class extends Error {};
+var FileAsset = class {
+	constructor(localName, file) {
+		this.localName = localName;
+		this.file = file;
+	}
+	async arrayBuffer() {
+		return this.file.arrayBuffer();
+	}
+	get byteSize() {
+		return this.file.size;
+	}
+	get fileExtension() {
+		return this.file.name.split(".").pop();
+	}
+	slice(start, end) {
+		return this.file.slice(start, end);
+	}
+};
+var ISOFileAsset = class extends FileAsset {
+	constructor(localName, file, mp4boxFile) {
+		super(localName, file);
+		this.localName = localName;
+		this.file = file;
+		this.mp4boxFile = mp4boxFile;
+	}
+	get fileInfo() {
+		return this.mp4boxFile.getInfo();
+	}
+	get containerFormat() {
+		return "mp4";
+	}
 };
-__decorateClass([
-  memoize
-], _VideoAsset.prototype, "editsOffset");
-__decorateClass([
-  memoize
-], _VideoAsset.prototype, "timescale");
-__decorateClass([
-  memoize
-], _VideoAsset.prototype, "samples");
-__decorateClass([
-  memoize
-], _VideoAsset.prototype, "displayOrderedSamples");
-__decorateClass([
-  memoize
-], _VideoAsset.prototype, "defaultVideoTrack");
-__decorateClass([
-  memoize
-], _VideoAsset.prototype, "defaultVideoTrak");
-__decorateClass([
-  memoize
-], _VideoAsset.prototype, "duration");
-let VideoAsset = _VideoAsset;
-const _AudioAsset = class _AudioAsset2 extends ISOFileAsset {
-  static async createFromReadableStream(id, stream, file) {
-    let fileStart = 0;
-    const inputFile = new MP4File();
-    const reader = stream.getReader();
-    const processChunk = ({
-      done,
-      value
-    }) => {
-      if (done) {
-        return;
-      }
-      if (!value) {
-        return;
-      }
-      const mp4buffer = value.buffer;
-      mp4buffer.fileStart = fileStart;
-      fileStart += value.byteLength;
-      inputFile.appendBuffer(mp4buffer);
-      return reader.read().then(processChunk);
-    };
-    await reader.read().then(processChunk);
-    return new _AudioAsset2(id, file, inputFile);
-  }
-  get defaultAudioTrack() {
-    return this.fileInfo.audioTracks[0];
-  }
-  get defaultAudioTrak() {
-    return this.mp4boxFile.getTrackById(this.defaultAudioTrack?.id ?? -1);
-  }
-  get audioCodec() {
-    if (!this.defaultAudioTrack) {
-      throw new Error("No default audio track found");
-    }
-    return this.defaultAudioTrack.codec;
-  }
-  get samplerate() {
-    if (!this.defaultAudioTrack) {
-      throw new Error("No default audio track found");
-    }
-    return this.defaultAudioTrack.audio.sample_rate;
-  }
-  get channelCount() {
-    if (!this.defaultAudioTrack) {
-      throw new Error("No default audio track found");
-    }
-    return this.defaultAudioTrack.audio.channel_count;
-  }
+_decorate([memoize], ISOFileAsset.prototype, "fileInfo", null);
+var VideoAsset = class VideoAsset extends ISOFileAsset {
+	static async createFromReadableStream(id, stream, file, options = {}) {
+		let fileStart = 0;
+		const inputFile = new MP4File();
+		const reader = stream.getReader();
+		const processChunk = ({ done, value }) => {
+			if (done) return;
+			if (!value) return;
+			const mp4buffer = value.buffer;
+			mp4buffer.fileStart = fileStart;
+			const isLast = file.size === fileStart + value.byteLength;
+			inputFile.appendBuffer(mp4buffer, isLast);
+			fileStart += value.byteLength;
+			return reader.read().then(processChunk);
+		};
+		await reader.read().then(processChunk);
+		const asset = new VideoAsset(id, inputFile, file);
+		asset.startTimeOffsetMs = options.startTimeOffsetMs;
+		return asset;
+	}
+	/**
+	* Creates a VideoAsset from a complete MP4 file (like JIT transcoded segments).
+	* 
+	* This is used for JIT transcoded segments which are complete MP4 files that always
+	* start on keyframes, unlike fragmented MP4s used in the asset pipeline.
+	*/
+	static async createFromCompleteMP4(id, file, options = {}) {
+		const fileBuffer = await file.arrayBuffer();
+		const inputFile = new MP4File();
+		const mp4buffer = fileBuffer;
+		mp4buffer.fileStart = 0;
+		inputFile.appendBuffer(mp4buffer, true);
+		inputFile.flush();
+		await inputFile.readyPromise;
+		const asset = new VideoAsset(id, inputFile, file);
+		asset.isJitSegment = true;
+		asset.startTimeOffsetMs = options.startTimeOffsetMs;
+		return asset;
+	}
+	/**
+	* **Only use this function in tests to reset a VideoAsset to its initial state.**
+	*
+	* @deprecated
+	*/
+	async TEST_ONLY_RESET() {
+		if (this.decoderManager.state !== "closed") await this.decoderManager.flush();
+		this.decoderManager.configureDecoder();
+		this.requestedSampleNumber = 0;
+		this.outCursor = 0;
+		this.sampleCursor = 0;
+		this.frameBuffer.clear();
+		this.lastDecodedSample = void 0;
+		this.lastSoughtFrame?.close();
+		this.lastSoughtFrame = void 0;
+	}
+	addEventListener(type, callback) {
+		this.eventListeners[type] ||= /* @__PURE__ */ new Set();
+		this.eventListeners[type]?.add(callback);
+	}
+	removeEventListener(type, callback) {
+		this.eventListeners[type]?.delete(callback);
+	}
+	emit(type, ...args) {
+		for (const listener of this.eventListeners[type] ?? []) listener(...args);
+	}
+	constructor(localName, mp4boxFile, file) {
+		super(localName, file, mp4boxFile);
+		this.requestedSampleNumber = 0;
+		this.outCursor = 0;
+		this.sampleCursor = 0;
+		this.latestSeekCts = 0;
+		this.isJitSegment = false;
+		this.isBeingReplaced = false;
+		this.eventListeners = {};
+		this.frameBuffer = new FrameBuffer(BUFFER_SIZE);
+		this.sampleAnalyzer = new MP4SampleAnalyzer(mp4boxFile, this.defaultVideoTrack);
+		this.seekStrategy = new SeekStrategy();
+		this.decoderManager = new DecoderManager(mp4boxFile, this.defaultVideoTrack, (decodedFrame) => {
+			const clone = decodedFrame.clone();
+			this.frameBuffer.add(clone);
+			decodedFrame.close();
+			this.outCursor = this.samples.findIndex((sample) => sample.cts === decodedFrame.timestamp);
+			this.emit("frame", clone);
+		}, (e) => {
+			console.error("Video Decoder Error", e);
+			throw e;
+		});
+		this.decoderManager.configureDecoder();
+	}
+	get videoDecoder() {
+		return this.decoderManager.videoDecoder;
+	}
+	get decodedFrames() {
+		return this.frameBuffer.frames;
+	}
+	set decodedFrames(frames) {
+		this.frameBuffer.clear();
+		frames.forEach((frame) => this.frameBuffer.add(frame));
+	}
+	get videoCodec() {
+		if (!this.defaultVideoTrack) throw new Error("No default video track found");
+		return this.defaultVideoTrack?.codec;
+	}
+	get fragmentInfo() {
+		const fragments = [];
+		const [first, ...samples] = this.samples;
+		if (!first) return fragments;
+		let currentFragment = {
+			offset: first.offset,
+			size: first.size,
+			start_ms: first.cts,
+			duration_ms: 0
+		};
+		for (const sample of samples) if (sample.is_sync) {
+			if (currentFragment) {
+				currentFragment.duration_ms = sample.cts - currentFragment.start_ms;
+				fragments.push(currentFragment);
+			}
+			currentFragment = {
+				offset: sample.offset,
+				size: sample.size,
+				start_ms: sample.cts,
+				duration_ms: 0
+			};
+		} else currentFragment.size += sample.size;
+		return fragments;
+	}
+	pruneBuffer() {}
+	get editsOffset() {
+		return this.sampleAnalyzer.editsOffset;
+	}
+	async waitUntilVideoQueueDrained() {
+		return this.decoderManager.waitUntilVideoQueueDrained();
+	}
+	get canDecodeNextSample() {
+		return this.sampleCursor < this.samples.length;
+	}
+	async decodeNextSample() {
+		if (!this.canDecodeNextSample) throw new Error("No more samples to decode");
+		await this.decodeSlice(this.sampleCursor, this.sampleCursor);
+		this.sampleCursor++;
+	}
+	async decodeSlice(start, end) {
+		const samples = this.samples.slice(start, end + 1);
+		const firstSample = samples[0];
+		const lastSample = samples[samples.length - 1];
+		if (!firstSample || !lastSample) throw new Error("Samples not found");
+		const sliceStart = firstSample.offset;
+		const sliceEnd = lastSample.offset + lastSample.size;
+		const buffer = await this.file.slice(sliceStart, sliceEnd).arrayBuffer();
+		const firstSampleOffset = firstSample.offset;
+		for (let i = start; i <= end; i++) {
+			await this.waitUntilVideoQueueDrained();
+			const sample = this.getSample(i);
+			log("Decoding sample #", i, `cts=${sample.cts}`);
+			const sampleStart = sample.offset - firstSampleOffset;
+			const sampleEnd = sample.offset + sample.size - firstSampleOffset;
+			const chunk = new EncodedVideoChunk({
+				data: buffer.slice(sampleStart, sampleEnd),
+				timestamp: sample.cts,
+				duration: sample.duration,
+				type: sample.is_sync ? "key" : "delta"
+			});
+			this.decoderManager.decode(chunk);
+			const nextSample = this.defaultVideoTrak?.samples?.[i + 1];
+			if (nextSample === void 0) {
+				log("ENDFLUSH");
+				await this.decoderManager.flush();
+			}
+		}
+	}
+	get decoderConfiguration() {
+		return this.decoderManager.decoderConfiguration;
+	}
+	configureDecoder() {
+		this.decoderManager.configureDecoder();
+	}
+	getSample(index = -1) {
+		return this.sampleAnalyzer.getSample(index);
+	}
+	get timescale() {
+		return this.sampleAnalyzer.timescale;
+	}
+	get samples() {
+		return this.sampleAnalyzer.samples;
+	}
+	get displayOrderedSamples() {
+		return this.sampleAnalyzer.displayOrderedSamples;
+	}
+	getSampleClosetToTime(seconds) {
+		return this.sampleAnalyzer.getSampleClosetToTime(seconds);
+	}
+	seekingWillEmitNewFrame(seconds) {
+		if (!this.lastSoughtFrame) return true;
+		if (this.seekingWillGoBackwards(seconds)) return true;
+		const nextCts = this.getSampleClosetToTime(seconds).cts;
+		return nextCts > this.lastSoughtFrame.timestamp;
+	}
+	seekingWillSkipPictureGroup(seconds) {
+		const targetSample = this.getSampleClosetToTime(seconds);
+		const state = {
+			sampleCursor: this.sampleCursor,
+			outCursor: this.outCursor,
+			frameBuffer: this.frameBuffer
+		};
+		return this.seekStrategy.seekingWillSkipPictureGroup(state, targetSample, this.samples);
+	}
+	seekingWillGoBackwards(seconds) {
+		const targetSample = this.getSampleClosetToTime(seconds);
+		const state = {
+			sampleCursor: this.sampleCursor,
+			outCursor: this.outCursor,
+			frameBuffer: this.frameBuffer
+		};
+		return this.seekStrategy.seekingWillGoBackwards(state, targetSample, this.displayOrderedSamples);
+	}
+	/**
+	* Optimized flush decision for JIT segments that always start on keyframes.
+	* JIT segments have better keyframe distribution and shorter duration,
+	* so we can be less aggressive about flushing.
+	*/
+	shouldFlushForJitSegment(seconds, _shouldFlushPictureGroup, shouldFlushBackwards) {
+		if (shouldFlushBackwards) {
+			const targetSample = this.getSampleClosetToTime(seconds);
+			const targetInCache = this.frameBuffer.findByTimestamp(targetSample.cts);
+			if (!targetInCache) {
+				const currentPosition = this.outCursor;
+				const targetPosition = this.samples.findIndex((s) => s.cts === targetSample.cts);
+				const jumpDistance = currentPosition - targetPosition;
+				if (jumpDistance > 10) return true;
+				return false;
+			}
+		}
+		return false;
+	}
+	/**
+	* Finds the optimal sample cursor position for segments with keyframes.
+	* Uses optimal keyframe selection for both single and multi-keyframe segments.
+	*/
+	findOptimalSampleCursorForJitSeek(targetSample) {
+		let syncSampleNumber = targetSample.number;
+		while (!this.getSample(syncSampleNumber).is_sync) {
+			syncSampleNumber--;
+			if (syncSampleNumber < 0) throw new Error("No sync sample found when traversing backwards");
+		}
+		return syncSampleNumber;
+	}
+	/**
+	* Marks this VideoAsset as being replaced, which will abort any ongoing seek operations
+	*/
+	markAsBeingReplaced() {
+		this.isBeingReplaced = true;
+		if (this.activeSeekAbortController) this.activeSeekAbortController.abort("VideoAsset being replaced");
+	}
+	async seekToTime(seconds) {
+		seconds += (this.startTimeOffsetMs ?? 0) / 1e3;
+		const correctedSeconds = seconds;
+		this.activeSeekAbortController = new AbortController();
+		const abortSignal = this.activeSeekAbortController.signal;
+		if (this.isBeingReplaced) throw new Error("VideoAsset seek aborted - VideoAsset being replaced");
+		const sample = this.getSampleClosetToTime(correctedSeconds);
+		const cts = sample.cts;
+		this.latestSeekCts = cts;
+		const alreadyDecodedFrame = this.frameBuffer.findByTimestamp(cts);
+		if (alreadyDecodedFrame) return alreadyDecodedFrame;
+		const shouldFlushPictureGroup = this.seekingWillSkipPictureGroup(seconds);
+		const shouldFlushBackwards = this.seekingWillGoBackwards(seconds);
+		const shouldFlush = this.isJitSegment ? this.shouldFlushForJitSegment(seconds, shouldFlushPictureGroup, shouldFlushBackwards) : shouldFlushPictureGroup || shouldFlushBackwards;
+		if (shouldFlush) {
+			if (this.isBeingReplaced) throw new Error("VideoAsset seek aborted - VideoAsset being replaced");
+			if (this.decoderManager.state === "closed") throw new Error("VideoAsset decoder closed - recreation in progress");
+			try {
+				await this.decoderManager.flush();
+			} catch (error) {
+				if (error instanceof Error && error.name === "InvalidStateError" && error.message.includes("closed codec")) throw new Error("VideoAsset decoder closed during flush - recreation in progress");
+				throw error;
+			}
+			this.sampleCursor = this.findOptimalSampleCursorForJitSeek(sample);
+		}
+		let frame;
+		const maybeFrame = (_frame) => {
+			if (frame) return;
+			log("Maybe frame", _frame.timestamp, cts);
+			if (_frame.timestamp === cts) {
+				this.removeEventListener("frame", maybeFrame);
+				frame = _frame;
+			}
+		};
+		this.addEventListener("frame", maybeFrame);
+		while (frame === void 0 && this.canDecodeNextSample) {
+			if (abortSignal.aborted) {
+				this.removeEventListener("frame", maybeFrame);
+				throw new Error("VideoAsset seek aborted - VideoAsset being replaced");
+			}
+			if (this.isBeingReplaced) {
+				this.removeEventListener("frame", maybeFrame);
+				throw new Error("VideoAsset seek aborted - VideoAsset being replaced");
+			}
+			if (this.decoderManager.state === "closed") {
+				this.removeEventListener("frame", maybeFrame);
+				throw new Error("VideoAsset decoder closed during seek - recreation in progress");
+			}
+			try {
+				await this.decodeNextSample();
+			} catch (error) {
+				if (error instanceof Error && error.name === "InvalidStateError" && error.message.includes("closed codec")) {
+					console.log("🎬 VideoAsset: Decoder was closed during decode - VideoAsset being replaced");
+					this.removeEventListener("frame", maybeFrame);
+					throw new Error("VideoAsset decoder closed during decode - recreation in progress");
+				}
+				throw error;
+			}
+		}
+		this.removeEventListener("frame", maybeFrame);
+		this.activeSeekAbortController = void 0;
+		if (frame) {
+			if (this.lastSoughtFrame && !this.frameBuffer.frames.includes(this.lastSoughtFrame)) try {
+				this.lastSoughtFrame.close();
+			} catch (error) {}
+			this.lastSoughtFrame = frame;
+		}
+		return frame;
+	}
+	get defaultVideoTrack() {
+		return this.fileInfo.videoTracks?.[0];
+	}
+	get defaultVideoTrak() {
+		return this.mp4boxFile.getTrackById(this.defaultVideoTrack?.id ?? -1);
+	}
+	get duration() {
+		return this.fileInfo.duration / this.fileInfo.timescale;
+	}
 };
-__decorateClass([
-  memoize
-], _AudioAsset.prototype, "defaultAudioTrack");
-__decorateClass([
-  memoize
-], _AudioAsset.prototype, "defaultAudioTrak");
-__decorateClass([
-  memoize
-], _AudioAsset.prototype, "audioCodec");
-__decorateClass([
-  memoize
-], _AudioAsset.prototype, "samplerate");
-__decorateClass([
-  memoize
-], _AudioAsset.prototype, "channelCount");
-let AudioAsset = _AudioAsset;
-const _ImageAsset = class _ImageAsset2 extends FileAsset {
-  static async createFromReadableStream(id, file) {
-    if (file.size === 0) {
-      throw new AssetNotAvailableLocally();
-    }
-    return new _ImageAsset2(id, file);
-  }
-  get objectUrl() {
-    return URL.createObjectURL(this.file);
-  }
-  get format() {
-    return this.fileExtension;
-  }
-  get type() {
-    return `image/${this.format}`;
-  }
+_decorate([memoize], VideoAsset.prototype, "editsOffset", null);
+_decorate([memoize], VideoAsset.prototype, "timescale", null);
+_decorate([memoize], VideoAsset.prototype, "samples", null);
+_decorate([memoize], VideoAsset.prototype, "displayOrderedSamples", null);
+_decorate([memoize], VideoAsset.prototype, "defaultVideoTrack", null);
+_decorate([memoize], VideoAsset.prototype, "defaultVideoTrak", null);
+_decorate([memoize], VideoAsset.prototype, "duration", null);
+var AudioAsset = class AudioAsset extends ISOFileAsset {
+	static async createFromReadableStream(id, stream, file) {
+		let fileStart = 0;
+		const inputFile = new MP4File();
+		const reader = stream.getReader();
+		const processChunk = ({ done, value }) => {
+			if (done) return;
+			if (!value) return;
+			const mp4buffer = value.buffer;
+			mp4buffer.fileStart = fileStart;
+			fileStart += value.byteLength;
+			inputFile.appendBuffer(mp4buffer);
+			return reader.read().then(processChunk);
+		};
+		await reader.read().then(processChunk);
+		return new AudioAsset(id, file, inputFile);
+	}
+	get defaultAudioTrack() {
+		return this.fileInfo.audioTracks[0];
+	}
+	get defaultAudioTrak() {
+		return this.mp4boxFile.getTrackById(this.defaultAudioTrack?.id ?? -1);
+	}
+	get audioCodec() {
+		if (!this.defaultAudioTrack) throw new Error("No default audio track found");
+		return this.defaultAudioTrack.codec;
+	}
+	get samplerate() {
+		if (!this.defaultAudioTrack) throw new Error("No default audio track found");
+		return this.defaultAudioTrack.audio.sample_rate;
+	}
+	get channelCount() {
+		if (!this.defaultAudioTrack) throw new Error("No default audio track found");
+		return this.defaultAudioTrack.audio.channel_count;
+	}
 };
-__decorateClass([
-  memoize
-], _ImageAsset.prototype, "objectUrl");
-__decorateClass([
-  memoize
-], _ImageAsset.prototype, "format");
-let ImageAsset = _ImageAsset;
-export {
-  AssetNotAvailableLocally,
-  AudioAsset,
-  FileAsset,
-  ISOFileAsset,
-  ImageAsset,
-  VideoAsset
+_decorate([memoize], AudioAsset.prototype, "defaultAudioTrack", null);
+_decorate([memoize], AudioAsset.prototype, "defaultAudioTrak", null);
+_decorate([memoize], AudioAsset.prototype, "audioCodec", null);
+_decorate([memoize], AudioAsset.prototype, "samplerate", null);
+_decorate([memoize], AudioAsset.prototype, "channelCount", null);
+var ImageAsset = class ImageAsset extends FileAsset {
+	static async createFromReadableStream(id, file) {
+		if (file.size === 0) throw new AssetNotAvailableLocally();
+		return new ImageAsset(id, file);
+	}
+	get objectUrl() {
+		return URL.createObjectURL(this.file);
+	}
+	get format() {
+		return this.fileExtension;
+	}
+	get type() {
+		return `image/${this.format}`;
+	}
 };
+_decorate([memoize], ImageAsset.prototype, "objectUrl", null);
+_decorate([memoize], ImageAsset.prototype, "format", null);
+export { AssetNotAvailableLocally, AudioAsset, FileAsset, ISOFileAsset, ImageAsset, VideoAsset };