@editframe/assets 0.26.3-beta.0 → 0.30.0-beta.13

package/dist/Probe.d.ts

@@ -93,6 +93,8 @@ 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;
@@ -103,8 +105,6 @@ 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,6 +115,8 @@ 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;
@@ -125,8 +127,6 @@ 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,6 +227,8 @@ 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;
@@ -237,8 +239,6 @@ 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,6 +249,8 @@ 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;
@@ -259,8 +261,6 @@ 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,6 +380,8 @@ 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;
@@ -390,8 +392,6 @@ 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,6 +402,8 @@ 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;
@@ -412,8 +414,6 @@ 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,6 +512,8 @@ 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;
@@ -522,8 +524,6 @@ 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,6 +576,8 @@ 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;
@@ -586,8 +588,6 @@ 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,6 +757,8 @@ 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;
@@ -767,8 +769,6 @@ 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,6 +779,8 @@ 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;
@@ -789,8 +791,6 @@ 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,6 +865,8 @@ 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;
@@ -875,8 +877,6 @@ 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,6 +939,8 @@ 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;
@@ -949,8 +951,6 @@ 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,6 +1039,8 @@ 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;
@@ -1049,8 +1051,6 @@ 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,19 +76,6 @@ 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;
@@ -98,15 +85,6 @@ 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;
@@ -114,6 +92,15 @@ 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;
@@ -123,6 +110,19 @@ 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,19 +131,6 @@ 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;
@@ -153,6 +140,19 @@ 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,19 +163,6 @@ 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;
@@ -185,6 +172,19 @@ 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.3-beta.0",
+  "version": "0.30.0-beta.13",
   "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;
-  }
-};