@editframe/assets 0.26.2-beta.0 → 0.26.4-beta.0

package/dist/Probe.d.ts

@@ -93,8 +93,6 @@ declare const VideoStreamSchema: z$1.ZodObject<{
   bit_rate: z$1.ZodOptional<z$1.ZodString>;
   disposition: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
 }, "strip", z$1.ZodTypeAny, {
-  width: number;
-  height: number;
   index: number;
   codec_name: string;
   codec_long_name: string;
@@ -105,6 +103,8 @@ declare const VideoStreamSchema: z$1.ZodObject<{
   avg_frame_rate: string;
   time_base: string;
   disposition: Record<string, unknown>;
+  width: number;
+  height: number;
   coded_width: number;
   coded_height: number;
   start_pts?: number | undefined;
@@ -115,8 +115,6 @@ declare const VideoStreamSchema: z$1.ZodObject<{
   profile?: string | undefined;
   level?: number | undefined;
 }, {
-  width: number;
-  height: number;
   index: number;
   codec_name: string;
   codec_long_name: string;
@@ -127,6 +125,8 @@ declare const VideoStreamSchema: z$1.ZodObject<{
   avg_frame_rate: string;
   time_base: string;
   disposition: Record<string, unknown>;
+  width: number;
+  height: number;
   coded_width: number;
   coded_height: number;
   start_pts?: number | undefined;
@@ -227,8 +227,6 @@ declare const StreamSchema: z$1.ZodDiscriminatedUnion<"codec_type", [z$1.ZodObje
   bit_rate: z$1.ZodOptional<z$1.ZodString>;
   disposition: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
 }, "strip", z$1.ZodTypeAny, {
-  width: number;
-  height: number;
   index: number;
   codec_name: string;
   codec_long_name: string;
@@ -239,6 +237,8 @@ declare const StreamSchema: z$1.ZodDiscriminatedUnion<"codec_type", [z$1.ZodObje
   avg_frame_rate: string;
   time_base: string;
   disposition: Record<string, unknown>;
+  width: number;
+  height: number;
   coded_width: number;
   coded_height: number;
   start_pts?: number | undefined;
@@ -249,8 +249,6 @@ declare const StreamSchema: z$1.ZodDiscriminatedUnion<"codec_type", [z$1.ZodObje
   profile?: string | undefined;
   level?: number | undefined;
 }, {
-  width: number;
-  height: number;
   index: number;
   codec_name: string;
   codec_long_name: string;
@@ -261,6 +259,8 @@ declare const StreamSchema: z$1.ZodDiscriminatedUnion<"codec_type", [z$1.ZodObje
   avg_frame_rate: string;
   time_base: string;
   disposition: Record<string, unknown>;
+  width: number;
+  height: number;
   coded_width: number;
   coded_height: number;
   start_pts?: number | undefined;
@@ -380,8 +380,6 @@ declare const ProbeSchema: z$1.ZodObject<{
     bit_rate: z$1.ZodOptional<z$1.ZodString>;
     disposition: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
   }, "strip", z$1.ZodTypeAny, {
-    width: number;
-    height: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -392,6 +390,8 @@ declare const ProbeSchema: z$1.ZodObject<{
     avg_frame_rate: string;
     time_base: string;
     disposition: Record<string, unknown>;
+    width: number;
+    height: number;
     coded_width: number;
     coded_height: number;
     start_pts?: number | undefined;
@@ -402,8 +402,6 @@ declare const ProbeSchema: z$1.ZodObject<{
     profile?: string | undefined;
     level?: number | undefined;
   }, {
-    width: number;
-    height: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -414,6 +412,8 @@ declare const ProbeSchema: z$1.ZodObject<{
     avg_frame_rate: string;
     time_base: string;
     disposition: Record<string, unknown>;
+    width: number;
+    height: number;
     coded_width: number;
     coded_height: number;
     start_pts?: number | undefined;
@@ -512,8 +512,6 @@ declare const ProbeSchema: z$1.ZodObject<{
     start_pts?: number | undefined;
     start_time?: number | undefined;
   } | {
-    width: number;
-    height: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -524,6 +522,8 @@ declare const ProbeSchema: z$1.ZodObject<{
     avg_frame_rate: string;
     time_base: string;
     disposition: Record<string, unknown>;
+    width: number;
+    height: number;
     coded_width: number;
     coded_height: number;
     start_pts?: number | undefined;
@@ -576,8 +576,6 @@ declare const ProbeSchema: z$1.ZodObject<{
     start_pts?: number | undefined;
     start_time?: number | undefined;
   } | {
-    width: number;
-    height: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -588,6 +586,8 @@ declare const ProbeSchema: z$1.ZodObject<{
     avg_frame_rate: string;
     time_base: string;
     disposition: Record<string, unknown>;
+    width: number;
+    height: number;
     coded_width: number;
     coded_height: number;
     start_pts?: number | undefined;
@@ -757,8 +757,6 @@ declare const PacketProbeSchema: z$1.ZodObject<{
     bit_rate: z$1.ZodOptional<z$1.ZodString>;
     disposition: z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>;
   }, "strip", z$1.ZodTypeAny, {
-    width: number;
-    height: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -769,6 +767,8 @@ declare const PacketProbeSchema: z$1.ZodObject<{
     avg_frame_rate: string;
     time_base: string;
     disposition: Record<string, unknown>;
+    width: number;
+    height: number;
     coded_width: number;
     coded_height: number;
     start_pts?: number | undefined;
@@ -779,8 +779,6 @@ declare const PacketProbeSchema: z$1.ZodObject<{
     profile?: string | undefined;
     level?: number | undefined;
   }, {
-    width: number;
-    height: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -791,6 +789,8 @@ declare const PacketProbeSchema: z$1.ZodObject<{
     avg_frame_rate: string;
     time_base: string;
     disposition: Record<string, unknown>;
+    width: number;
+    height: number;
     coded_width: number;
     coded_height: number;
     start_pts?: number | undefined;
@@ -865,8 +865,6 @@ declare const PacketProbeSchema: z$1.ZodObject<{
     start_pts?: number | undefined;
     start_time?: number | undefined;
   } | {
-    width: number;
-    height: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -877,6 +875,8 @@ declare const PacketProbeSchema: z$1.ZodObject<{
     avg_frame_rate: string;
     time_base: string;
     disposition: Record<string, unknown>;
+    width: number;
+    height: number;
     coded_width: number;
     coded_height: number;
     start_pts?: number | undefined;
@@ -939,8 +939,6 @@ declare const PacketProbeSchema: z$1.ZodObject<{
     start_pts?: number | undefined;
     start_time?: number | undefined;
   } | {
-    width: number;
-    height: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -951,6 +949,8 @@ declare const PacketProbeSchema: z$1.ZodObject<{
     avg_frame_rate: string;
     time_base: string;
     disposition: Record<string, unknown>;
+    width: number;
+    height: number;
     coded_width: number;
     coded_height: number;
     start_pts?: number | undefined;
@@ -1039,8 +1039,6 @@ declare abstract class ProbeBase {
     start_pts?: number | undefined;
     start_time?: number | undefined;
   } | {
-    width: number;
-    height: number;
     index: number;
     codec_name: string;
     codec_long_name: string;
@@ -1051,6 +1049,8 @@ declare abstract class ProbeBase {
     avg_frame_rate: string;
     time_base: string;
     disposition: Record<string, unknown>;
+    width: number;
+    height: number;
     coded_width: number;
     coded_height: number;
     start_pts?: number | undefined;

package/dist/VideoRenderOptions.d.ts

@@ -76,6 +76,19 @@ declare const VideoRenderOptions: z.ZodObject<{
       numberOfChannels: number;
     }>;
   }, "strip", z.ZodTypeAny, {
+    audio: {
+      codec: string;
+      bitrate: number;
+      sampleRate: number;
+      numberOfChannels: number;
+    };
+    video: {
+      width: number;
+      height: number;
+      framerate: number;
+      codec: string;
+      bitrate: number;
+    };
     sequenceNumber: number;
     keyframeIntervalMs: number;
     fromMs: number;
@@ -85,6 +98,15 @@ declare const VideoRenderOptions: z.ZodObject<{
     alignedFromUs: number;
     alignedToUs: number;
     isInitSegment: boolean;
+    noVideo?: boolean | undefined;
+    noAudio?: boolean | undefined;
+  }, {
+    audio: {
+      codec: string;
+      bitrate: number;
+      sampleRate: number;
+      numberOfChannels: number;
+    };
     video: {
       width: number;
       height: number;
@@ -92,15 +114,6 @@ declare const VideoRenderOptions: z.ZodObject<{
       codec: string;
       bitrate: number;
     };
-    audio: {
-      codec: string;
-      bitrate: number;
-      sampleRate: number;
-      numberOfChannels: number;
-    };
-    noVideo?: boolean | undefined;
-    noAudio?: boolean | undefined;
-  }, {
     sequenceNumber: number;
     keyframeIntervalMs: number;
     fromMs: number;
@@ -110,19 +123,6 @@ declare const VideoRenderOptions: z.ZodObject<{
     alignedFromUs: number;
     alignedToUs: number;
     isInitSegment: boolean;
-    video: {
-      width: number;
-      height: number;
-      framerate: number;
-      codec: string;
-      bitrate: number;
-    };
-    audio: {
-      codec: string;
-      bitrate: number;
-      sampleRate: number;
-      numberOfChannels: number;
-    };
     noVideo?: boolean | undefined;
     noAudio?: boolean | undefined;
   }>;
@@ -131,6 +131,19 @@ declare const VideoRenderOptions: z.ZodObject<{
   mode: "canvas" | "screenshot";
   strategy: "v1" | "v2";
   encoderOptions: {
+    audio: {
+      codec: string;
+      bitrate: number;
+      sampleRate: number;
+      numberOfChannels: number;
+    };
+    video: {
+      width: number;
+      height: number;
+      framerate: number;
+      codec: string;
+      bitrate: number;
+    };
     sequenceNumber: number;
     keyframeIntervalMs: number;
     fromMs: number;
@@ -140,19 +153,6 @@ declare const VideoRenderOptions: z.ZodObject<{
     alignedFromUs: number;
     alignedToUs: number;
     isInitSegment: boolean;
-    video: {
-      width: number;
-      height: number;
-      framerate: number;
-      codec: string;
-      bitrate: number;
-    };
-    audio: {
-      codec: string;
-      bitrate: number;
-      sampleRate: number;
-      numberOfChannels: number;
-    };
     noVideo?: boolean | undefined;
     noAudio?: boolean | undefined;
   };
@@ -163,6 +163,19 @@ declare const VideoRenderOptions: z.ZodObject<{
   mode: "canvas" | "screenshot";
   strategy: "v1" | "v2";
   encoderOptions: {
+    audio: {
+      codec: string;
+      bitrate: number;
+      sampleRate: number;
+      numberOfChannels: number;
+    };
+    video: {
+      width: number;
+      height: number;
+      framerate: number;
+      codec: string;
+      bitrate: number;
+    };
     sequenceNumber: number;
     keyframeIntervalMs: number;
     fromMs: number;
@@ -172,19 +185,6 @@ declare const VideoRenderOptions: z.ZodObject<{
     alignedFromUs: number;
     alignedToUs: number;
     isInitSegment: boolean;
-    video: {
-      width: number;
-      height: number;
-      framerate: number;
-      codec: string;
-      bitrate: number;
-    };
-    audio: {
-      codec: string;
-      bitrate: number;
-      sampleRate: number;
-      numberOfChannels: number;
-    };
     noVideo?: boolean | undefined;
     noAudio?: boolean | undefined;
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/assets",
-  "version": "0.26.2-beta.0",
+  "version": "0.26.4-beta.0",
   "description": "",
   "type": "module",
   "scripts": {

package/src/tasks/cacheImage.ts

@@ -1,22 +0,0 @@
-import { idempotentTask } from "../idempotentTask.js";
-import { createReadStream } from "node:fs";
-
-import path from "node:path";
-
-const cacheImageTask = idempotentTask({
-  label: "image",
-  filename: (absolutePath: string) => path.basename(absolutePath),
-  runner: async (absolutePath) => {
-    return createReadStream(absolutePath);
-  },
-});
-
-export const cacheImage = async (cacheRoot: string, absolutePath: string) => {
-  try {
-    return await cacheImageTask(cacheRoot, absolutePath);
-  } catch (error) {
-    console.error(error);
-    console.trace("Error caching image", error);
-    throw error;
-  }
-};

package/src/tasks/findOrCreateCaptions.ts

@@ -1,36 +0,0 @@
-import { basename } from "node:path";
-import { promisify } from "node:util";
-import { exec } from "node:child_process";
-
-import debug from "debug";
-
-import { idempotentTask } from "../idempotentTask.js";
-
-const execPromise = promisify(exec);
-
-const log = debug("ef:generateCaptions");
-
-export const generateCaptionDataFromPath = async (absolutePath: string) => {
-  const command = `whisper_timestamped --language en --efficient --output_format vtt ${absolutePath}`;
-  log(`Running command: ${command}`);
-  const { stdout } = await execPromise(command);
-  return stdout;
-};
-
-const generateCaptionDataTask = idempotentTask({
-  label: "captions",
-  filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,
-  runner: generateCaptionDataFromPath,
-});
-
-export const findOrCreateCaptions = async (
-  cacheRoot: string,
-  absolutePath: string,
-) => {
-  try {
-    return await generateCaptionDataTask(cacheRoot, absolutePath);
-  } catch (error) {
-    console.trace("Error finding or creating captions", error);
-    throw error;
-  }
-};

package/src/tasks/generateTrack.test.ts

@@ -1,90 +0,0 @@
-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,47 +0,0 @@
-import { idempotentTask } from "../idempotentTask.js";
-import debug from "debug";
-import { basename } from "node:path";
-import { generateSingleTrackFromPath } from "../generateSingleTrack.js";
-
-export const generateTrackFromPath = async (
-  absolutePath: string,
-  trackId: number,
-) => {
-  const log = debug("ef:generateTrackFragment");
-  log(`Generating track ${trackId} for ${absolutePath}`);
-
-  // Use the single-track implementation
-  const result = await generateSingleTrackFromPath(absolutePath, trackId);
-
-  // Return just the stream for compatibility with existing API
-  return result.stream;
-};
-
-export const generateTrackTask = idempotentTask({
-  label: "track",
-  filename: (absolutePath: string, trackId: number) =>
-    `${basename(absolutePath)}.track-${trackId}.mp4`,
-  runner: generateTrackFromPath,
-});
-
-export const generateTrack = async (
-  cacheRoot: string,
-  absolutePath: string,
-  url: string,
-) => {
-  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=1 (for video) or ?trackId=2 (for audio)",
-      );
-    }
-    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
-  } catch (error) {
-    console.error(error);
-    console.trace("Error generating track", error);
-    throw error;
-  }
-};

package/src/tasks/generateTrackFragmentIndex.test.ts

@@ -1,105 +0,0 @@
-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`);
-      }
-    }
-  });
-
-  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");
-  });
-
-  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");
-  }, 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]!]!;
-
-    assert.equal(track.startTimeOffsetMs, 200);
-    assert.equal(track.type, "video");
-
-    // 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);
-});
-

package/src/tasks/generateTrackFragmentIndex.ts

@@ -1,86 +0,0 @@
-import { idempotentTask } from "../idempotentTask.js";
-import debug from "debug";
-import { basename } from "node:path";
-import { Probe } from "../Probe.js";
-import { generateFragmentIndex } from "../generateFragmentIndex.js";
-import type { TrackFragmentIndex } from "../Probe.js";
-
-export const generateTrackFragmentIndexFromPath = async (
-  absolutePath: string,
-) => {
-  const log = debug("ef:generateTrackFragment");
-  const probe = await Probe.probePath(absolutePath);
-
-  // Extract timing offset from probe metadata (same logic as processISOBMFF.ts)
-  let startTimeOffsetMs: number | undefined;
-
-  // First check format-level start_time
-  if (probe.format.start_time && Number(probe.format.start_time) !== 0) {
-    startTimeOffsetMs = Number(probe.format.start_time) * 1000;
-    log(`Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`);
-  } else {
-    // Check for video stream start_time (more common)
-    const videoStream = probe.streams.find(stream => stream.codec_type === 'video');
-    if (videoStream && videoStream.start_time && Number(videoStream.start_time) !== 0) {
-      startTimeOffsetMs = Number(videoStream.start_time) * 1000;
-      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");
-    }
-  }
-
-  log(`Generating track fragment index for ${absolutePath} using single-track approach`);
-
-  // FIXED: Generate fragment indexes from individual single-track files
-  // This ensures byte offsets match the actual single-track files that clients will request
-  const trackFragmentIndexes: Record<number, TrackFragmentIndex> = {};
-
-  // Process each audio/video stream as a separate track
-  for (let streamIndex = 0; streamIndex < probe.streams.length; streamIndex++) {
-    const stream = probe.streams[streamIndex]!;
-
-    // Only process audio and video streams
-    if (stream.codec_type !== 'audio' && stream.codec_type !== 'video') {
-      continue;
-    }
-
-    const trackId = streamIndex + 1; // Convert to 1-based track ID
-    log(`Processing track ${trackId} (${stream.codec_type})`);
-
-    // Generate single-track file and its fragment index
-    const trackStream = probe.createTrackReadstream(streamIndex);
-    const trackIdMapping = { 0: trackId }; // Map single-track stream index 0 to original track ID
-
-    const singleTrackIndexes = await generateFragmentIndex(
-      trackStream,
-      startTimeOffsetMs,
-      trackIdMapping
-    );
-
-    // Merge the single-track index into the combined result
-    Object.assign(trackFragmentIndexes, singleTrackIndexes);
-  }
-
-  return trackFragmentIndexes;
-};
-
-const generateTrackFragmentIndexTask = idempotentTask({
-  label: "trackFragmentIndex",
-  filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
-  runner: async (absolutePath: string) => {
-    const index = await generateTrackFragmentIndexFromPath(absolutePath);
-    return JSON.stringify(index, null, 2);
-  },
-});
-
-export const generateTrackFragmentIndex = async (
-  cacheRoot: string,
-  absolutePath: string,
-) => {
-  try {
-    return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);
-  } catch (error) {
-    console.trace("Error generating track fragment index", error);
-    throw error;
-  }
-};