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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/assets",
-  "version": "0.26.3-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;
-  }
-};