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

package/dist/idempotentTask.js

@@ -1,9 +1,9 @@
 import { md5FilePath } from "./md5.js";
-import debug from "debug";
 import { createWriteStream, existsSync } from "node:fs";
+import debug from "debug";
+import { Readable } from "node:stream";
 import { mkdir, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { Readable } from "node:stream";
 const idempotentTask = ({ label, filename, runner }) => {
 	const tasks = {};
 	const downloadTasks = {};
@@ -76,43 +76,41 @@ const idempotentTask = ({ label, filename, runner }) => {
 		const maybeTask = tasks[key];
 		if (maybeTask) {
 			log(`Returning existing ef:${label} task for ${key}`);
-			await maybeTask;
-			return {
-				cachePath,
-				md5Sum: md5
-			};
+			return await maybeTask;
 		}
 		log(`Creating new ef:${label} task for ${key}`);
-		const task = runner(absolutePath, ...args);
-		tasks[key] = task;
-		try {
-			log(`Awaiting task for ${key}`);
-			const result = await task;
-			if (result instanceof Readable) {
-				log(`Piping task for ${key} to cache`);
-				const tempPath = `${cachePath}.tmp`;
-				const writeStream = createWriteStream(tempPath);
-				result.pipe(writeStream);
-				await new Promise((resolve, reject) => {
-					result.on("error", reject);
-					writeStream.on("error", reject);
-					writeStream.on("finish", resolve);
-				});
-				const { rename } = await import("node:fs/promises");
-				await rename(tempPath, cachePath);
-			} else {
-				log(`Writing to ${cachePath}`);
-				await writeFile(cachePath, result);
+		const fullTask = (async () => {
+			try {
+				log(`Awaiting task for ${key}`);
+				const result = await runner(absolutePath, ...args);
+				if (result instanceof Readable) {
+					log(`Piping task for ${key} to cache`);
+					const tempPath = `${cachePath}.tmp`;
+					const writeStream = createWriteStream(tempPath);
+					result.pipe(writeStream);
+					await new Promise((resolve, reject) => {
+						result.on("error", reject);
+						writeStream.on("error", reject);
+						writeStream.on("finish", resolve);
+					});
+					const { rename } = await import("node:fs/promises");
+					await rename(tempPath, cachePath);
+				} else {
+					log(`Writing to ${cachePath}`);
+					await writeFile(cachePath, result);
+				}
+				delete tasks[key];
+				return {
+					md5Sum: md5,
+					cachePath
+				};
+			} catch (error) {
+				delete tasks[key];
+				throw error;
 			}
-			delete tasks[key];
-			return {
-				md5Sum: md5,
-				cachePath
-			};
-		} catch (error) {
-			delete tasks[key];
-			throw error;
-		}
+		})();
+		tasks[key] = fullTask;
+		return await fullTask;
 	};
 };
 export { idempotentTask };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export type { StreamSchema, AudioStreamSchema, VideoStreamSchema, TrackSegment, TrackFragmentIndex, AudioTrackFragmentIndex, VideoTrackFragmentIndex, } from './Probe.js';
-export { Probe } from './Probe.js';
+export type { StreamSchema, AudioStreamSchema, VideoStreamSchema, ProbeSchema, PacketProbeSchema, TrackSegment, TrackFragmentIndex, AudioTrackFragmentIndex, VideoTrackFragmentIndex, } from './Probe.js';
+export { Probe, PacketProbe } from './Probe.js';
+export { generateFragmentIndex } from './generateFragmentIndex.js';
 export { md5FilePath, md5Directory, md5ReadStream, md5Buffer } from './md5.js';
 export { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath, } from './tasks/generateTrackFragmentIndex.js';
 export { generateTrack, generateTrackFromPath } from './tasks/generateTrack.js';

package/dist/index.js

@@ -1,8 +1,9 @@
-import { Probe } from "./Probe.js";
+import { PacketProbe, Probe } from "./Probe.js";
+import { generateFragmentIndex } from "./generateFragmentIndex.js";
 import { md5Buffer, md5Directory, md5FilePath, md5ReadStream } from "./md5.js";
 import { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath } from "./tasks/generateTrackFragmentIndex.js";
 import { generateTrack, generateTrackFromPath } from "./tasks/generateTrack.js";
 import { findOrCreateCaptions, generateCaptionDataFromPath } from "./tasks/findOrCreateCaptions.js";
 import { cacheImage } from "./tasks/cacheImage.js";
 import { VideoRenderOptions } from "./VideoRenderOptions.js";
-export { Probe, VideoRenderOptions, cacheImage, findOrCreateCaptions, generateCaptionDataFromPath, generateTrack, generateTrackFragmentIndex, generateTrackFragmentIndexFromPath, generateTrackFromPath, md5Buffer, md5Directory, md5FilePath, md5ReadStream };
+export { PacketProbe, Probe, VideoRenderOptions, cacheImage, findOrCreateCaptions, generateCaptionDataFromPath, generateFragmentIndex, generateTrack, generateTrackFragmentIndex, generateTrackFragmentIndexFromPath, generateTrackFromPath, md5Buffer, md5Directory, md5FilePath, md5ReadStream };

package/dist/tasks/findOrCreateCaptions.js

@@ -1,7 +1,7 @@
 import { idempotentTask } from "../idempotentTask.js";
-import debug from "debug";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import debug from "debug";
 import { basename } from "node:path";
 const execPromise = promisify(exec);
 const log = debug("ef:generateCaptions");

package/dist/tasks/generateTrack.d.ts

@@ -1,4 +1,3 @@
-import { PassThrough } from 'node:stream';
-export declare const generateTrackFromPath: (absolutePath: string, trackId: number) => Promise<PassThrough>;
+export declare const generateTrackFromPath: (absolutePath: string, trackId: number) => Promise<import('stream').PassThrough>;
 export declare const generateTrackTask: (rootDir: string, absolutePath: string, trackId: number) => Promise<import('../idempotentTask.js').TaskResult>;
 export declare const generateTrack: (cacheRoot: string, absolutePath: string, url: string) => Promise<import('../idempotentTask.js').TaskResult>;

package/dist/tasks/generateTrack.js

@@ -1,39 +1,12 @@
-import { MP4File } from "../MP4File.js";
-import { Probe } from "../Probe.js";
 import { idempotentTask } from "../idempotentTask.js";
-import { mp4FileWritable } from "../mp4FileWritable.js";
+import { generateSingleTrackFromPath } from "../generateSingleTrack.js";
 import debug from "debug";
 import { basename } from "node:path";
-import { PassThrough } from "node:stream";
 const generateTrackFromPath = async (absolutePath, trackId) => {
 	const log = debug("ef:generateTrackFragment");
-	const probe = await Probe.probePath(absolutePath);
-	const readStream = probe.createConformingReadstream();
-	const mp4File = new MP4File();
-	const trackStream = new PassThrough();
-	log(`Generating track for ${absolutePath}`);
-	readStream.pipe(mp4FileWritable(mp4File));
-	(async () => {
-		try {
-			let bytesWritten = 0;
-			for await (const fragment of mp4File.fragmentIterator()) {
-				log("Writing fragment", fragment);
-				if (fragment.track === trackId) {
-					const written = trackStream.write(Buffer.from(fragment.data), "binary");
-					if (!written) {
-						log(`Waiting for drain for track ${trackId}`);
-						await new Promise((resolve) => trackStream.once("drain", resolve));
-					}
-					bytesWritten += fragment.data.byteLength;
-				}
-				if (!readStream.readableEnded) await Promise.race([new Promise((resolve) => readStream.once("end", resolve)), new Promise((resolve) => readStream.once("data", resolve))]);
-			}
-			trackStream.end();
-		} catch (error) {
-			trackStream.destroy(error);
-		}
-	})();
-	return trackStream;
+	log(`Generating track ${trackId} for ${absolutePath}`);
+	const result = await generateSingleTrackFromPath(absolutePath, trackId);
+	return result.stream;
 };
 const generateTrackTask = idempotentTask({
 	label: "track",
@@ -43,7 +16,7 @@ const generateTrackTask = idempotentTask({
 const generateTrack = async (cacheRoot, absolutePath, url) => {
 	try {
 		const trackId = new URL(`http://localhost${url}`).searchParams.get("trackId");
-		if (trackId === null) throw new Error("No trackId provided. IT must be specified in the query string: ?trackId=0");
+		if (trackId === null) throw new Error("No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)");
 		return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
 	} catch (error) {
 		console.error(error);

package/dist/tasks/generateTrackFragmentIndex.js

@@ -1,7 +1,6 @@
-import { MP4File } from "../MP4File.js";
 import { Probe } from "../Probe.js";
+import { generateFragmentIndex } from "../generateFragmentIndex.js";
 import { idempotentTask } from "../idempotentTask.js";
-import { mp4FileWritable } from "../mp4FileWritable.js";
 import debug from "debug";
 import { basename } from "node:path";
 const generateTrackFragmentIndexFromPath = async (absolutePath) => {
@@ -18,80 +17,17 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
 			log(`Extracted video stream start_time offset: ${videoStream.start_time}s (${startTimeOffsetMs}ms)`);
 		} else log("No format/stream timing offset found - will detect from composition time");
 	}
-	const readStream = probe.createConformingReadstream();
-	const mp4File = new MP4File();
-	log(`Generating track fragment index for ${absolutePath}`);
-	readStream.pipe(mp4FileWritable(mp4File));
-	await new Promise((resolve, reject) => {
-		readStream.on("end", resolve);
-		readStream.on("error", reject);
-	});
+	log(`Generating track fragment index for ${absolutePath} using single-track approach`);
 	const trackFragmentIndexes = {};
-	const trackByteOffsets = {};
-	for await (const fragment of mp4File.fragmentIterator()) {
-		const track = mp4File.getInfo().tracks.find((track$1) => track$1.id === fragment.track);
-		if (!track) throw new Error("Track not found");
-		if (fragment.segment === "init") {
-			trackByteOffsets[fragment.track] = fragment.data.byteLength;
-			if (track?.type === "video") {
-				const videoTrack = mp4File.getInfo().videoTracks.find((track$1) => track$1.id === fragment.track);
-				if (!videoTrack) throw new Error("Video track not found");
-				trackFragmentIndexes[fragment.track] = {
-					track: fragment.track,
-					type: "video",
-					width: videoTrack.video.width,
-					height: videoTrack.video.height,
-					timescale: track.timescale,
-					sample_count: videoTrack.nb_samples,
-					codec: videoTrack.codec,
-					duration: videoTrack.duration,
-					startTimeOffsetMs,
-					initSegment: {
-						offset: 0,
-						size: fragment.data.byteLength
-					},
-					segments: []
-				};
-			}
-			if (track?.type === "audio") {
-				const audioTrack = mp4File.getInfo().audioTracks.find((track$1) => track$1.id === fragment.track);
-				if (!audioTrack) throw new Error("Audio track not found");
-				trackFragmentIndexes[fragment.track] = {
-					track: fragment.track,
-					type: "audio",
-					channel_count: audioTrack.audio.channel_count,
-					sample_rate: audioTrack.audio.sample_rate,
-					sample_size: audioTrack.audio.sample_size,
-					sample_count: audioTrack.nb_samples,
-					timescale: track.timescale,
-					codec: audioTrack.codec,
-					duration: audioTrack.duration,
-					initSegment: {
-						offset: 0,
-						size: fragment.data.byteLength
-					},
-					segments: []
-				};
-			}
-		} else {
-			const fragmentIndex = trackFragmentIndexes[fragment.track];
-			if (trackByteOffsets[fragment.track] === void 0) throw new Error("Fragment index not found");
-			if (!fragmentIndex) throw new Error("Fragment index not found");
-			if (fragmentIndex.type === "video" && fragmentIndex.segments.length === 0 && fragmentIndex.startTimeOffsetMs === void 0 && fragment.cts > fragment.dts) {
-				const compositionOffsetMs = (fragment.cts - fragment.dts) / fragmentIndex.timescale * 1e3;
-				fragmentIndex.startTimeOffsetMs = compositionOffsetMs;
-				log(`Detected composition time offset from first video segment: ${compositionOffsetMs}ms (CTS=${fragment.cts}, DTS=${fragment.dts}, timescale=${fragmentIndex.timescale})`);
-			}
-			fragmentIndex.duration += fragment.duration;
-			fragmentIndex.segments.push({
-				cts: fragment.cts,
-				dts: fragment.dts,
-				duration: fragment.duration,
-				offset: trackByteOffsets[fragment.track],
-				size: fragment.data.byteLength
-			});
-			trackByteOffsets[fragment.track] += fragment.data.byteLength;
-		}
+	for (let streamIndex = 0; streamIndex < probe.streams.length; streamIndex++) {
+		const stream = probe.streams[streamIndex];
+		if (stream.codec_type !== "audio" && stream.codec_type !== "video") continue;
+		const trackId = streamIndex + 1;
+		log(`Processing track ${trackId} (${stream.codec_type})`);
+		const trackStream = probe.createTrackReadstream(streamIndex);
+		const trackIdMapping = { 1: trackId };
+		const singleTrackIndexes = await generateFragmentIndex(trackStream, startTimeOffsetMs, trackIdMapping);
+		Object.assign(trackFragmentIndexes, singleTrackIndexes);
 	}
 	return trackFragmentIndexes;
 };

package/dist/truncateDecimal.d.ts

@@ -0,0 +1 @@
+export declare function truncateDecimal(num: number, decimals: number): number;

package/dist/truncateDecimal.js

@@ -0,0 +1,5 @@
+function truncateDecimal(num, decimals) {
+	const factor = 10 ** decimals;
+	return Math.trunc(num * factor) / factor;
+}
+export { truncateDecimal };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/assets",
-  "version": "0.18.3-beta.0",
+  "version": "0.18.8-beta.0",
   "description": "",
   "exports": {
     ".": {
@@ -9,18 +9,6 @@
         "default": "./dist/index.js"
       }
     },
-    "./EncodedAsset.js": {
-      "import": {
-        "types": "./dist/EncodedAsset.d.ts",
-        "default": "./dist/EncodedAsset.js"
-      }
-    },
-    "./MP4File.js": {
-      "import": {
-        "types": "./dist/MP4File.d.ts",
-        "default": "./dist/MP4File.js"
-      }
-    },
     "./types.json": {
       "import": {
         "default": "./types.json"
@@ -38,7 +26,7 @@
   "license": "UNLICENSED",
   "dependencies": {
     "debug": "^4.3.5",
-    "mp4box": "^0.5.2",
+    "mediabunny": "^1.5.0",
     "ora": "^8.0.1",
     "zod": "^3.23.8"
   },

package/src/tasks/generateTrack.test.ts

@@ -0,0 +1,90 @@
+import { test, describe, assert } from "vitest";
+import { generateTrackFromPath } from "./generateTrack";
+import { Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+describe("generateTrack", () => {
+  test("should generate video track", async () => {
+    const trackStream = await generateTrackFromPath("test-assets/10s-bars.mp4", 1);
+
+    // Collect the generated track data
+    const chunks: Buffer[] = [];
+    const dest = new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      }
+    });
+
+    await pipeline(trackStream, dest);
+
+    // Verify we got MP4 data
+    assert.isAbove(chunks.length, 0, "Should generate MP4 chunks");
+    const totalSize = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    assert.isAbove(totalSize, 1000, "Should generate substantial MP4 data");
+
+    // Verify it's valid MP4 by checking for ftyp box
+    const allData = Buffer.concat(chunks);
+    const ftypIndex = allData.indexOf('ftyp');
+    assert.isAbove(ftypIndex, -1, "Should contain ftyp box (valid MP4)");
+
+    console.log(`Generated ${totalSize} bytes for video track`);
+  }, 15000);
+
+  test("should generate audio track", async () => {
+    const trackStream = await generateTrackFromPath("test-assets/10s-bars.mp4", 2);
+
+    // Collect the generated track data
+    const chunks: Buffer[] = [];
+    const dest = new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      }
+    });
+
+    await pipeline(trackStream, dest);
+
+    // Verify we got MP4 data
+    assert.isAbove(chunks.length, 0, "Should generate MP4 chunks");
+    const totalSize = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    assert.isAbove(totalSize, 1000, "Should generate substantial MP4 data");
+
+    // Verify it's valid MP4 by checking for ftyp box
+    const allData = Buffer.concat(chunks);
+    const ftypIndex = allData.indexOf('ftyp');
+    assert.isAbove(ftypIndex, -1, "Should contain ftyp box (valid MP4)");
+
+    console.log(`Generated ${totalSize} bytes for audio track`);
+  }, 15000);
+
+  test("should handle invalid track IDs gracefully", async () => {
+    try {
+      await generateTrackFromPath("test-assets/frame-count.mp4", 5);
+      assert.fail("Should have thrown for invalid track ID");
+    } catch (error) {
+      assert.instanceOf(error, Error);
+      assert.include(error.message, "Track 5 not found");
+    }
+  });
+
+  test("should work with single track files", async () => {
+    const trackStream = await generateTrackFromPath("test-assets/frame-count.mp4", 1);
+
+    const chunks: Buffer[] = [];
+    const dest = new Writable({
+      write(chunk, _encoding, callback) {
+        chunks.push(chunk);
+        callback();
+      }
+    });
+
+    await pipeline(trackStream, dest);
+
+    const totalSize = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    assert.isAbove(totalSize, 1000, "Should generate data for single track file");
+
+    console.log(`Generated ${totalSize} bytes for single track file`);
+  }, 15000);
+});
+

package/src/tasks/generateTrack.ts

@@ -1,61 +1,20 @@
 import { idempotentTask } from "../idempotentTask.js";
-import { MP4File } from "../MP4File.js";
 import debug from "debug";
-import { mp4FileWritable } from "../mp4FileWritable.js";
-import { PassThrough } from "node:stream";
 import { basename } from "node:path";
-import { Probe } from "../Probe.js";
+import { generateSingleTrackFromPath } from "../generateSingleTrack.js";
 
 export const generateTrackFromPath = async (
   absolutePath: string,
   trackId: number,
 ) => {
   const log = debug("ef:generateTrackFragment");
-  const probe = await Probe.probePath(absolutePath);
-  const readStream = probe.createConformingReadstream();
-  const mp4File = new MP4File();
-  const trackStream = new PassThrough();
+  log(`Generating track ${trackId} for ${absolutePath}`);
 
-  log(`Generating track for ${absolutePath}`);
+  // Use the single-track implementation
+  const result = await generateSingleTrackFromPath(absolutePath, trackId);
 
-  // Set up pipe and processing of fragments
-  readStream.pipe(mp4FileWritable(mp4File));
-
-  // Process fragments as they become available
-  (async () => {
-    try {
-      let bytesWritten = 0;
-      for await (const fragment of mp4File.fragmentIterator()) {
-        log("Writing fragment", fragment);
-        if (fragment.track === trackId) {
-          const written = trackStream.write(
-            Buffer.from(fragment.data),
-            "binary",
-          );
-          if (!written) {
-            log(`Waiting for drain for track ${trackId}`);
-            await new Promise((resolve) => trackStream.once("drain", resolve));
-          }
-          bytesWritten += fragment.data.byteLength;
-        }
-        // There is a race condition where the mp4file writable doesn't correctly wait for the whole readSTream
-        // Waiting for data/end events seems to fix it
-        // FIXME: This is a hack, we should fix the root issue in MP4File
-        if (!readStream.readableEnded) {
-          await Promise.race([
-            new Promise((resolve) => readStream.once("end", resolve)),
-            new Promise((resolve) => readStream.once("data", resolve)),
-          ]);
-        }
-      }
-
-      trackStream.end();
-    } catch (error) {
-      trackStream.destroy(error as Error);
-    }
-  })();
-
-  return trackStream;
+  // Return just the stream for compatibility with existing API
+  return result.stream;
 };
 
 export const generateTrackTask = idempotentTask({
@@ -76,7 +35,7 @@ export const generateTrack = async (
     );
     if (trackId === null) {
       throw new Error(
-        "No trackId provided. IT must be specified in the query string: ?trackId=0",
+        "No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)",
       );
     }
     return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));

package/src/tasks/generateTrackFragmentIndex.test.ts

@@ -0,0 +1,115 @@
+import { test, describe, assert } from "vitest";
+import { generateTrackFragmentIndexFromPath } from "./generateTrackFragmentIndex";
+
+describe("generateTrackFragmentIndex", () => {
+  test("should generate fragment index", async () => {
+    const fragmentIndex = await generateTrackFragmentIndexFromPath("test-assets/10s-bars.mp4");
+
+    // Should have multiple tracks
+    const trackIds = Object.keys(fragmentIndex).map(Number);
+    assert.isAbove(trackIds.length, 0, "Should have tracks");
+
+    for (const trackId of trackIds) {
+      const track = fragmentIndex[trackId]!;
+
+      // Verify track structure
+      assert.oneOf(track.type, ['video', 'audio'], `Track ${trackId} should be video or audio`);
+      assert.isNumber(track.track, `Track ${trackId} should have track number`);
+      assert.isNumber(track.timescale, `Track ${trackId} should have timescale`);
+      assert.isNumber(track.duration, `Track ${trackId} should have duration`);
+      assert.isNumber(track.sample_count, `Track ${trackId} should have sample_count`);
+      assert.isString(track.codec, `Track ${trackId} should have codec`);
+
+      // Verify init segment
+      assert.equal(track.initSegment.offset, 0, `Track ${trackId} init should start at 0`);
+      assert.isAbove(track.initSegment.size, 0, `Track ${trackId} init should have size`);
+
+      // Verify segments
+      assert.isArray(track.segments, `Track ${trackId} should have segments array`);
+      assert.isAbove(track.segments.length, 0, `Track ${trackId} should have segments`);
+
+      // Check each segment
+      for (const segment of track.segments) {
+        assert.isNumber(segment.cts, `Track ${trackId} segment should have cts`);
+        assert.isNumber(segment.dts, `Track ${trackId} segment should have dts`);
+        assert.isNumber(segment.duration, `Track ${trackId} segment should have duration`);
+        assert.isNumber(segment.offset, `Track ${trackId} segment should have offset`);
+        assert.isNumber(segment.size, `Track ${trackId} segment should have size`);
+      }
+
+      // Type-specific checks
+      if (track.type === 'video') {
+        assert.isNumber(track.width, `Video track ${trackId} should have width`);
+        assert.isNumber(track.height, `Video track ${trackId} should have height`);
+      } else if (track.type === 'audio') {
+        assert.isNumber(track.channel_count, `Audio track ${trackId} should have channel_count`);
+        assert.isNumber(track.sample_rate, `Audio track ${trackId} should have sample_rate`);
+        assert.isNumber(track.sample_size, `Audio track ${trackId} should have sample_size`);
+      }
+
+      console.log(`Track ${trackId} (${track.type}): ${track.segments.length} segments, ${track.sample_count} samples`);
+    }
+  }, 20000);
+
+  test("should handle single track files", async () => {
+    const fragmentIndex = await generateTrackFragmentIndexFromPath("test-assets/frame-count.mp4");
+
+    const trackIds = Object.keys(fragmentIndex).map(Number);
+    assert.equal(trackIds.length, 1, "Should have exactly one track");
+
+    const track = fragmentIndex[trackIds[0]!]!;
+    assert.equal(track.type, "video", "Should be video track");
+    assert.isAbove(track.segments.length, 0, "Should have segments");
+
+    console.log(`Single track: ${track.segments.length} segments, ${track.sample_count} samples`);
+  }, 15000);
+
+  test("should generate consistent results with original implementation", async () => {
+    // Test that the new implementation produces similar structure to the old one
+    const fragmentIndex = await generateTrackFragmentIndexFromPath("test-assets/bars-n-tone.mp4");
+
+    const trackIds = Object.keys(fragmentIndex).map(Number);
+    assert.equal(trackIds.length, 2, "Should have video and audio tracks");
+
+    // Should have both video and audio
+    const videoTrack = Object.values(fragmentIndex).find(t => t.type === 'video');
+    const audioTrack = Object.values(fragmentIndex).find(t => t.type === 'audio');
+
+    assert.exists(videoTrack, "Should have video track");
+    assert.exists(audioTrack, "Should have audio track");
+
+    // Video track checks
+    assert.isAbove(videoTrack.width, 0, "Video should have width");
+    assert.isAbove(videoTrack.height, 0, "Video should have height");
+    assert.isAbove(videoTrack.segments.length, 0, "Video should have segments");
+
+    // Audio track checks  
+    assert.isAbove(audioTrack.channel_count, 0, "Audio should have channels");
+    assert.isAbove(audioTrack.sample_rate, 0, "Audio should have sample rate");
+    assert.isAbove(audioTrack.segments.length, 0, "Audio should have segments");
+
+    console.log(`Consistent results: video ${videoTrack.segments.length} segments, audio ${audioTrack.segments.length} segments`);
+  }, 20000);
+
+  test("should preserve timing offset detection", async () => {
+    // Test with a file that might have timing offsets
+    const fragmentIndex = await generateTrackFragmentIndexFromPath("test-assets/frame-count.mp4");
+
+    const trackIds = Object.keys(fragmentIndex).map(Number);
+    const track = fragmentIndex[trackIds[0]!]!;
+
+    if (track.type === 'video' && track.startTimeOffsetMs !== undefined) {
+      assert.isNumber(track.startTimeOffsetMs, "Should have timing offset");
+      console.log(`Detected timing offset: ${track.startTimeOffsetMs}ms`);
+    } else {
+      console.log("No timing offset detected (expected for this file)");
+    }
+
+    // Should still have valid timing data
+    assert.isAbove(track.duration, 0, "Should have positive duration");
+    for (const segment of track.segments) {
+      assert.isAbove(segment.duration, 0, "Each segment should have positive duration");
+    }
+  }, 15000);
+});
+