@editframe/assets 0.18.7-beta.0 → 0.18.19-beta.0

package/dist/generateFragmentIndex.d.ts

@@ -0,0 +1,3 @@
+import { Readable } from 'node:stream';
+import { TrackFragmentIndex } from './Probe.js';
+export declare const generateFragmentIndex: (inputStream: Readable, startTimeOffsetMs?: number, trackIdMapping?: Record<number, number>) => Promise<Record<number, TrackFragmentIndex>>;

package/dist/{generateTrackFragmentIndexMediabunny.js → generateFragmentIndex.js}

@@ -2,7 +2,7 @@ import debug from "debug";
 import { Transform, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { EncodedPacketSink, Input, MP4, StreamSource } from "mediabunny";
-const log = debug("ef:generateTrackFragmentIndexMediabunny");
+const log = debug("ef:generateFragmentIndex");
 /**
 * Streaming MP4 box parser that detects box boundaries without loading entire file into memory
 */
@@ -83,12 +83,12 @@ var StreamingBoxParser = class extends Transform {
 		return this.fragments;
 	}
 };
-function extractFragmentData(mediabunnyChunks, initFragment, mediaFragment) {
+function extractFragmentData(chunks, initFragment, mediaFragment) {
 	const extractBytes = (offset, size) => {
 		const buffer = Buffer.alloc(size);
 		let written = 0;
 		let currentOffset = 0;
-		for (const chunk of mediabunnyChunks) {
+		for (const chunk of chunks) {
 			if (currentOffset + chunk.length <= offset) {
 				currentOffset += chunk.length;
 				continue;
@@ -112,16 +112,16 @@ function extractFragmentData(mediabunnyChunks, initFragment, mediaFragment) {
 	combined.set(mediaData, initData.length);
 	return combined;
 }
-const generateTrackFragmentIndexMediabunny = async (inputStream, startTimeOffsetMs, trackIdMapping) => {
+const generateFragmentIndex = async (inputStream, startTimeOffsetMs, trackIdMapping) => {
 	const parser = new StreamingBoxParser();
-	const mediabunnyChunks = [];
+	const chunks = [];
 	let totalSize = 0;
-	const mediabunnyDest = new Writable({ write(chunk, _encoding, callback) {
-		mediabunnyChunks.push(chunk);
+	const dest = new Writable({ write(chunk, _encoding, callback) {
+		chunks.push(chunk);
 		totalSize += chunk.length;
 		callback();
 	} });
-	await pipeline(inputStream, parser, mediabunnyDest);
+	await pipeline(inputStream, parser, dest);
 	const fragments = parser.getFragments();
 	if (totalSize === 0) return {};
 	const source = new StreamSource({
@@ -130,7 +130,7 @@ const generateTrackFragmentIndexMediabunny = async (inputStream, startTimeOffset
 			const buffer = Buffer.alloc(size);
 			let written = 0;
 			let currentOffset = 0;
-			for (const chunk of mediabunnyChunks) {
+			for (const chunk of chunks) {
 				if (currentOffset + chunk.length <= start) {
 					currentOffset += chunk.length;
 					continue;
@@ -159,7 +159,7 @@ const generateTrackFragmentIndexMediabunny = async (inputStream, startTimeOffset
 		videoTracks = await input.getVideoTracks();
 		audioTracks = await input.getAudioTracks();
 	} catch (error) {
-		console.warn("Failed to parse with Mediabunny:", error);
+		console.warn("Failed to parse with parser:", error);
 		return {};
 	}
 	const trackIndexes = {};
@@ -169,7 +169,7 @@ const generateTrackFragmentIndexMediabunny = async (inputStream, startTimeOffset
 	const audioFragmentTimings = [];
 	for (let fragmentIndex = 0; fragmentIndex < mediaFragments.length; fragmentIndex++) {
 		const fragment = mediaFragments[fragmentIndex];
-		const fragmentData = extractFragmentData(mediabunnyChunks, initFragment, fragment);
+		const fragmentData = extractFragmentData(chunks, initFragment, fragment);
 		const fragmentSource = new StreamSource({
 			read: async (start, end) => fragmentData.subarray(start, end),
 			getSize: async () => fragmentData.length
@@ -250,15 +250,19 @@ const generateTrackFragmentIndexMediabunny = async (inputStream, startTimeOffset
 		}
 		if (startTimeOffsetMs !== void 0) trackStartTimeOffsetMs = startTimeOffsetMs;
 		const timescale = Math.round(track.timeResolution);
+		let accumulatedDts = 0;
+		let accumulatedCts = 0;
 		for (const timing of videoFragmentTimings) {
 			const fragment = mediaFragments[timing.fragmentIndex];
 			segments.push({
-				cts: timing.cts,
-				dts: timing.dts,
+				cts: accumulatedCts,
+				dts: accumulatedDts,
 				duration: timing.duration,
 				offset: fragment.offset,
 				size: fragment.size
 			});
+			accumulatedDts += timing.duration;
+			accumulatedCts += timing.duration;
 			totalDuration += timing.duration / timescale;
 		}
 		let width = 1920;
@@ -308,15 +312,19 @@ const generateTrackFragmentIndexMediabunny = async (inputStream, startTimeOffset
 		}
 		if (startTimeOffsetMs !== void 0) trackStartTimeOffsetMs = startTimeOffsetMs;
 		const timescale = Math.round(track.timeResolution);
+		let accumulatedDts = 0;
+		let accumulatedCts = 0;
 		for (const timing of audioFragmentTimings) {
 			const fragment = mediaFragments[timing.fragmentIndex];
 			segments.push({
-				cts: timing.cts,
-				dts: timing.dts,
+				cts: accumulatedCts,
+				dts: accumulatedDts,
 				duration: timing.duration,
 				offset: fragment.offset,
 				size: fragment.size
 			});
+			accumulatedDts += timing.duration;
+			accumulatedCts += timing.duration;
 			totalDuration += timing.duration / timescale;
 		}
 		const finalTrackId = trackIdMapping?.[track.id] ?? track.id;
@@ -340,4 +348,4 @@ const generateTrackFragmentIndexMediabunny = async (inputStream, startTimeOffset
 	}
 	return trackIndexes;
 };
-export { generateTrackFragmentIndexMediabunny };
+export { generateFragmentIndex };

package/dist/generateSingleTrack.d.ts

@@ -0,0 +1,8 @@
+import { PassThrough } from 'node:stream';
+export declare const generateSingleTrackFromPath: (absolutePath: string, trackId: number) => Promise<{
+    stream: PassThrough;
+    fragmentIndex: Promise<Record<number, import('./Probe.js').TrackFragmentIndex>>;
+}>;
+export declare const generateSingleTrackTask: (rootDir: string, absolutePath: string, trackId: number) => Promise<import('./idempotentTask.js').TaskResult>;
+export declare const generateSingleTrack: (cacheRoot: string, absolutePath: string, url: string) => Promise<import('./idempotentTask.js').TaskResult>;
+export declare const generateSingleTrackWithIndex: (absolutePath: string, trackId: number) => Promise<PassThrough>;

package/dist/{generateTrackMediabunny.js → generateSingleTrack.js}

@@ -1,11 +1,11 @@
 import { Probe } from "./Probe.js";
+import { generateFragmentIndex } from "./generateFragmentIndex.js";
 import { idempotentTask } from "./idempotentTask.js";
-import { generateTrackFragmentIndexMediabunny } from "./generateTrackFragmentIndexMediabunny.js";
 import debug from "debug";
-import { basename } from "node:path";
 import { PassThrough } from "node:stream";
-const log = debug("ef:generateTrackMediabunny");
-const generateTrackFromPathMediabunny = async (absolutePath, trackId) => {
+import { basename } from "node:path";
+const log = debug("ef:generateSingleTrack");
+const generateSingleTrackFromPath = async (absolutePath, trackId) => {
 	log(`Generating track ${trackId} for ${absolutePath}`);
 	const probe = await Probe.probePath(absolutePath);
 	const streamIndex = trackId - 1;
@@ -24,7 +24,7 @@ const generateTrackFromPathMediabunny = async (absolutePath, trackId) => {
 		indexStream.destroy(error);
 	});
 	const trackIdMapping = { 1: trackId };
-	const fragmentIndexPromise = generateTrackFragmentIndexMediabunny(indexStream, void 0, trackIdMapping);
+	const fragmentIndexPromise = generateFragmentIndex(indexStream, void 0, trackIdMapping);
 	fragmentIndexPromise.then(() => {
 		if (sourceStreamEnded) outputStream.end();
 		else trackStream.once("end", () => {
@@ -38,32 +38,37 @@ const generateTrackFromPathMediabunny = async (absolutePath, trackId) => {
 		fragmentIndex: fragmentIndexPromise
 	};
 };
-const generateTrackTaskMediabunny = idempotentTask({
-	label: "track-mediabunny",
+const generateSingleTrackTask = idempotentTask({
+	label: "track-single",
 	filename: (absolutePath, trackId) => `${basename(absolutePath)}.track-${trackId}.mp4`,
 	runner: async (absolutePath, trackId) => {
-		const result = await generateTrackFromPathMediabunny(absolutePath, trackId);
+		const result = await generateSingleTrackFromPath(absolutePath, trackId);
 		const finalStream = new PassThrough();
-		let streamEnded = false;
-		let fragmentIndexCompleted = false;
-		const checkCompletion = () => {
-			if (streamEnded && fragmentIndexCompleted) finalStream.end();
-		};
-		result.stream.pipe(finalStream, { end: false });
-		result.stream.on("end", () => {
-			streamEnded = true;
-			checkCompletion();
+		const fragmentIndexPromise = result.fragmentIndex.catch((error) => {
+			console.warn(`Fragment index generation failed for track ${trackId}:`, error);
 		});
-		result.stream.on("error", (error) => {
-			finalStream.destroy(error);
+		let progressTimeout = null;
+		const resetProgressTimeout = () => {
+			if (progressTimeout) clearTimeout(progressTimeout);
+			progressTimeout = setTimeout(() => {
+				if (!finalStream.destroyed) {
+					console.warn(`Progress timeout triggered for track ${trackId} - no activity for 10 seconds`);
+					finalStream.end();
+				}
+			}, 1e4);
+		};
+		resetProgressTimeout();
+		result.stream.on("data", () => {
+			resetProgressTimeout();
 		});
-		result.fragmentIndex.then(() => {
-			fragmentIndexCompleted = true;
-			checkCompletion();
-		}).catch((error) => {
-			finalStream.destroy(error);
+		result.stream.on("end", () => {
+			resetProgressTimeout();
 		});
+		result.stream.pipe(finalStream, { end: false });
+		await fragmentIndexPromise;
+		finalStream.end();
+		if (progressTimeout) clearTimeout(progressTimeout);
 		return finalStream;
 	}
 });
-export { generateTrackFromPathMediabunny };
+export { generateSingleTrackFromPath };

package/dist/idempotentTask.js

@@ -1,9 +1,9 @@
 import { md5FilePath } from "./md5.js";
 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 = {};

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 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 { 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 { PacketProbe, 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/generateTrack.js

@@ -1,11 +1,11 @@
 import { idempotentTask } from "../idempotentTask.js";
-import { generateTrackFromPathMediabunny } from "../generateTrackMediabunny.js";
+import { generateSingleTrackFromPath } from "../generateSingleTrack.js";
 import debug from "debug";
 import { basename } from "node:path";
 const generateTrackFromPath = async (absolutePath, trackId) => {
 	const log = debug("ef:generateTrackFragment");
-	log(`Generating track ${trackId} for ${absolutePath} using Mediabunny`);
-	const result = await generateTrackFromPathMediabunny(absolutePath, trackId);
+	log(`Generating track ${trackId} for ${absolutePath}`);
+	const result = await generateSingleTrackFromPath(absolutePath, trackId);
 	return result.stream;
 };
 const generateTrackTask = idempotentTask({

package/dist/tasks/generateTrackFragmentIndex.js

@@ -1,6 +1,6 @@
 import { Probe } from "../Probe.js";
+import { generateFragmentIndex } from "../generateFragmentIndex.js";
 import { idempotentTask } from "../idempotentTask.js";
-import { generateTrackFragmentIndexMediabunny } from "../generateTrackFragmentIndexMediabunny.js";
 import debug from "debug";
 import { basename } from "node:path";
 const generateTrackFragmentIndexFromPath = async (absolutePath) => {
@@ -26,7 +26,7 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
 		log(`Processing track ${trackId} (${stream.codec_type})`);
 		const trackStream = probe.createTrackReadstream(streamIndex);
 		const trackIdMapping = { 1: trackId };
-		const singleTrackIndexes = await generateTrackFragmentIndexMediabunny(trackStream, startTimeOffsetMs, trackIdMapping);
+		const singleTrackIndexes = await generateFragmentIndex(trackStream, startTimeOffsetMs, trackIdMapping);
 		Object.assign(trackFragmentIndexes, singleTrackIndexes);
 	}
 	return trackFragmentIndexes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/assets",
-  "version": "0.18.7-beta.0",
+  "version": "0.18.19-beta.0",
   "description": "",
   "exports": {
     ".": {

package/src/tasks/generateTrack.test.ts

@@ -3,8 +3,8 @@ import { generateTrackFromPath } from "./generateTrack";
 import { Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 
-describe("generateTrack (updated with Mediabunny)", () => {
-  test("should generate video track using Mediabunny backend", async () => {
+describe("generateTrack", () => {
+  test("should generate video track", async () => {
     const trackStream = await generateTrackFromPath("test-assets/10s-bars.mp4", 1);
 
     // Collect the generated track data
@@ -31,7 +31,7 @@ describe("generateTrack (updated with Mediabunny)", () => {
     console.log(`Generated ${totalSize} bytes for video track`);
   }, 15000);
 
-  test("should generate audio track using Mediabunny backend", async () => {
+  test("should generate audio track", async () => {
     const trackStream = await generateTrackFromPath("test-assets/10s-bars.mp4", 2);
 
     // Collect the generated track data

package/src/tasks/generateTrack.ts

@@ -1,17 +1,17 @@
 import { idempotentTask } from "../idempotentTask.js";
 import debug from "debug";
 import { basename } from "node:path";
-import { generateTrackFromPathMediabunny } from "../generateTrackMediabunny.js";
+import { generateSingleTrackFromPath } from "../generateSingleTrack.js";
 
 export const generateTrackFromPath = async (
   absolutePath: string,
   trackId: number,
 ) => {
   const log = debug("ef:generateTrackFragment");
-  log(`Generating track ${trackId} for ${absolutePath} using Mediabunny`);
+  log(`Generating track ${trackId} for ${absolutePath}`);
 
-  // Use the new Mediabunny-based implementation
-  const result = await generateTrackFromPathMediabunny(absolutePath, trackId);
+  // Use the single-track implementation
+  const result = await generateSingleTrackFromPath(absolutePath, trackId);
 
   // Return just the stream for compatibility with existing API
   return result.stream;

package/src/tasks/generateTrackFragmentIndex.test.ts

@@ -1,8 +1,8 @@
 import { test, describe, assert } from "vitest";
 import { generateTrackFragmentIndexFromPath } from "./generateTrackFragmentIndex";
 
-describe("generateTrackFragmentIndex (updated with Mediabunny)", () => {
-  test("should generate fragment index using Mediabunny backend", async () => {
+describe("generateTrackFragmentIndex", () => {
+  test("should generate fragment index", async () => {
     const fragmentIndex = await generateTrackFragmentIndexFromPath("test-assets/10s-bars.mp4");
 
     // Should have multiple tracks

package/src/tasks/generateTrackFragmentIndex.ts

@@ -2,7 +2,7 @@ import { idempotentTask } from "../idempotentTask.js";
 import debug from "debug";
 import { basename } from "node:path";
 import { Probe } from "../Probe.js";
-import { generateTrackFragmentIndexMediabunny } from "../generateTrackFragmentIndexMediabunny.js";
+import { generateFragmentIndex } from "../generateFragmentIndex.js";
 import type { TrackFragmentIndex } from "../Probe.js";
 
 export const generateTrackFragmentIndexFromPath = async (
@@ -51,7 +51,7 @@ export const generateTrackFragmentIndexFromPath = async (
     const trackStream = probe.createTrackReadstream(streamIndex);
     const trackIdMapping = { 1: trackId }; // Map single-track ID 1 to original track ID
 
-    const singleTrackIndexes = await generateTrackFragmentIndexMediabunny(
+    const singleTrackIndexes = await generateFragmentIndex(
       trackStream,
       startTimeOffsetMs,
       trackIdMapping