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

package/dist/MP4File.js

@@ -7,8 +7,8 @@ var MP4File = class extends MP4Box.ISOFile {
 		this.waitingForSamples = [];
 		this._hasSeenLastSamples = false;
 		this._arrayBufferFileStart = 0;
-		this.readyTimeoutMs = options.readyTimeoutMs ?? 100;
-		this.sampleWaitTimeoutMs = options.sampleWaitTimeoutMs ?? 100;
+		this.readyTimeoutMs = options.readyTimeoutMs ?? 1e3;
+		this.sampleWaitTimeoutMs = options.sampleWaitTimeoutMs ?? 1e3;
 		this.readyPromise = new Promise((resolve, reject) => {
 			this.onReady = () => {
 				if (this.timeoutId) {
@@ -26,7 +26,7 @@ var MP4File = class extends MP4Box.ISOFile {
 			};
 			this.timeoutId = setTimeout(() => {
 				this.timeoutId = void 0;
-				reject(/* @__PURE__ */ new Error("MP4File ready timeout - file may be invalid or incomplete"));
+				reject(/* @__PURE__ */ new Error(`MP4File ready timeout ${this.readyTimeoutMs}ms - file may be invalid or incomplete`));
 			}, this.readyTimeoutMs);
 		});
 		this.readyPromise.catch(() => {});

package/dist/VideoRenderOptions.d.ts

@@ -6,11 +6,33 @@ export declare const VideoRenderOptions: z.ZodObject<{
     encoderOptions: z.ZodObject<{
         sequenceNumber: z.ZodNumber;
         keyframeIntervalMs: z.ZodNumber;
-        toMs: z.ZodNumber;
+        /**
+         * The nominal start time of the segment in milliseconds.
+         * Does not include any padding.
+         */
         fromMs: z.ZodNumber;
+        /**
+         * The nominal end time of the segment in milliseconds.
+         * Does not include any padding.
+         */
+        toMs: z.ZodNumber;
+        /**
+         * Whether or not this segment has audio padding at the start.
+         */
         shouldPadStart: z.ZodBoolean;
+        /**
+         * Whether or not this segment has audio padding at the end.
+         */
         shouldPadEnd: z.ZodBoolean;
+        /**
+         * The aligned start time of the segment in microseconds.
+         * This includes the padding if any.
+         */
         alignedFromUs: z.ZodNumber;
+        /**
+         * The aligned end time of the segment in microseconds.
+         * This includes the padding if any.
+         */
         alignedToUs: z.ZodNumber;
         isInitSegment: z.ZodBoolean;
         noVideo: z.ZodOptional<z.ZodBoolean>;
@@ -66,8 +88,8 @@ export declare const VideoRenderOptions: z.ZodObject<{
         };
         sequenceNumber: number;
         keyframeIntervalMs: number;
-        toMs: number;
         fromMs: number;
+        toMs: number;
         shouldPadStart: boolean;
         shouldPadEnd: boolean;
         alignedFromUs: number;
@@ -91,8 +113,8 @@ export declare const VideoRenderOptions: z.ZodObject<{
         };
         sequenceNumber: number;
         keyframeIntervalMs: number;
-        toMs: number;
         fromMs: number;
+        toMs: number;
         shouldPadStart: boolean;
         shouldPadEnd: boolean;
         alignedFromUs: number;
@@ -121,8 +143,8 @@ export declare const VideoRenderOptions: z.ZodObject<{
         };
         sequenceNumber: number;
         keyframeIntervalMs: number;
-        toMs: number;
         fromMs: number;
+        toMs: number;
         shouldPadStart: boolean;
         shouldPadEnd: boolean;
         alignedFromUs: number;
@@ -152,8 +174,8 @@ export declare const VideoRenderOptions: z.ZodObject<{
         };
         sequenceNumber: number;
         keyframeIntervalMs: number;
-        toMs: number;
         fromMs: number;
+        toMs: number;
         shouldPadStart: boolean;
         shouldPadEnd: boolean;
         alignedFromUs: number;

package/dist/VideoRenderOptions.js

@@ -6,8 +6,8 @@ const VideoRenderOptions = z.object({
 	encoderOptions: z.object({
 		sequenceNumber: z.number(),
 		keyframeIntervalMs: z.number(),
-		toMs: z.number(),
 		fromMs: z.number(),
+		toMs: z.number(),
 		shouldPadStart: z.boolean(),
 		shouldPadEnd: z.boolean(),
 		alignedFromUs: z.number(),

package/dist/idempotentTask.js

@@ -1,11 +1,20 @@
 import { md5FilePath } from "./md5.js";
 import debug from "debug";
 import { createWriteStream, existsSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
+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 = {};
+	const isValidCacheFile = async (filePath, allowEmpty = false) => {
+		try {
+			const stats = await stat(filePath);
+			return allowEmpty || stats.size > 0;
+		} catch {
+			return false;
+		}
+	};
 	return async (rootDir, absolutePath, ...args) => {
 		const log = debug(`ef:${label}`);
 		const cacheDirRoot = path.join(rootDir, ".cache");
@@ -13,22 +22,42 @@ const idempotentTask = ({ label, filename, runner }) => {
 		log(`Running ef:${label} task for ${absolutePath} in ${rootDir}`);
 		if (absolutePath.includes("http")) {
 			const safePath = absolutePath.replace(/[^a-zA-Z0-9]/g, "_");
-			const cachePath$1 = path.join(rootDir, ".cache", `${safePath}.file`);
-			if (existsSync(absolutePath)) log(`Already cached ${absolutePath}`);
-			else {
-				const response = await fetch(absolutePath);
-				const stream = response.body;
-				if (response.ok && stream) {
-					const writeStream = createWriteStream(cachePath$1);
-					const readable = Readable.fromWeb(stream);
-					readable.pipe(writeStream);
-					await new Promise((resolve, reject) => {
-						readable.on("error", reject);
-						writeStream.on("error", reject);
-						writeStream.on("finish", resolve);
-					});
-					absolutePath = cachePath$1;
-				} else throw new Error(`Failed to fetch file from URL ${absolutePath}`);
+			const downloadCachePath = path.join(rootDir, ".cache", `${safePath}.file`);
+			if (existsSync(downloadCachePath) && await isValidCacheFile(downloadCachePath, true)) {
+				log(`Already cached ${absolutePath}`);
+				absolutePath = downloadCachePath;
+			} else {
+				const downloadKey = absolutePath;
+				if (!downloadTasks[downloadKey]) {
+					log(`Starting download for ${absolutePath}`);
+					downloadTasks[downloadKey] = (async () => {
+						try {
+							const response = await fetch(absolutePath);
+							if (!response.ok) throw new Error(`Failed to fetch file from URL ${absolutePath}: ${response.status} ${response.statusText}`);
+							const stream = response.body;
+							if (!stream) throw new Error(`No response body for URL ${absolutePath}`);
+							const tempPath = `${downloadCachePath}.tmp`;
+							const writeStream = createWriteStream(tempPath);
+							const readable = Readable.fromWeb(stream);
+							readable.pipe(writeStream);
+							await new Promise((resolve, reject) => {
+								readable.on("error", reject);
+								writeStream.on("error", reject);
+								writeStream.on("finish", resolve);
+							});
+							const { rename } = await import("node:fs/promises");
+							await rename(tempPath, downloadCachePath);
+							log(`Download completed for ${absolutePath}`);
+							return downloadCachePath;
+						} catch (error) {
+							log(`Download failed for ${absolutePath}: ${error}`);
+							delete downloadTasks[downloadKey];
+							throw error;
+						}
+					})();
+				}
+				absolutePath = await downloadTasks[downloadKey];
+				delete downloadTasks[downloadKey];
 			}
 		}
 		const md5 = await md5FilePath(absolutePath);
@@ -37,7 +66,7 @@ const idempotentTask = ({ label, filename, runner }) => {
 		await mkdir(cacheDir, { recursive: true });
 		const cachePath = path.join(cacheDir, filename(absolutePath, ...args));
 		const key = cachePath;
-		if (existsSync(cachePath)) {
+		if (existsSync(cachePath) && await isValidCacheFile(cachePath)) {
 			log(`Returning cached ef:${label} task for ${key}`);
 			return {
 				cachePath,
@@ -56,28 +85,34 @@ const idempotentTask = ({ label, filename, runner }) => {
 		log(`Creating new ef:${label} task for ${key}`);
 		const task = runner(absolutePath, ...args);
 		tasks[key] = task;
-		log(`Awaiting task for ${key}`);
-		const result = await task;
-		if (result instanceof Readable) {
-			log(`Piping task for ${key} to cache`);
-			const writeStream = createWriteStream(cachePath);
-			result.pipe(writeStream);
-			await new Promise((resolve, reject) => {
-				result.on("error", reject);
-				writeStream.on("error", reject);
-				writeStream.on("finish", resolve);
-			});
+		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);
+			}
+			delete tasks[key];
 			return {
-				cachePath,
-				md5Sum: md5
+				md5Sum: md5,
+				cachePath
 			};
+		} catch (error) {
+			delete tasks[key];
+			throw error;
 		}
-		log(`Writing to ${cachePath}`);
-		await writeFile(cachePath, result);
-		return {
-			md5Sum: md5,
-			cachePath
-		};
 	};
 };
 export { idempotentTask };

package/dist/tasks/cacheRemoteAsset.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tasks/generateTrackFragmentIndex.js

@@ -7,6 +7,17 @@ import { basename } from "node:path";
 const generateTrackFragmentIndexFromPath = async (absolutePath) => {
 	const log = debug("ef:generateTrackFragment");
 	const probe = await Probe.probePath(absolutePath);
+	let startTimeOffsetMs;
+	if (probe.format.start_time && Number(probe.format.start_time) !== 0) {
+		startTimeOffsetMs = Number(probe.format.start_time) * 1e3;
+		log(`Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`);
+	} else {
+		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) * 1e3;
+			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}`);
@@ -34,6 +45,7 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
 					sample_count: videoTrack.nb_samples,
 					codec: videoTrack.codec,
 					duration: videoTrack.duration,
+					startTimeOffsetMs,
 					initSegment: {
 						offset: 0,
 						size: fragment.data.byteLength
@@ -65,6 +77,11 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
 			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,

package/package.json

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

package/src/tasks/generateTrackFragmentIndex.ts

@@ -10,6 +10,25 @@ export const generateTrackFragmentIndexFromPath = async (
 ) => {
   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");
+    }
+  }
+
   const readStream = probe.createConformingReadstream();
 
   const mp4File = new MP4File();
@@ -50,6 +69,7 @@ export const generateTrackFragmentIndexFromPath = async (
           sample_count: videoTrack.nb_samples,
           codec: videoTrack.codec,
           duration: videoTrack.duration,
+          startTimeOffsetMs: startTimeOffsetMs, // Add FFmpeg start_time offset
           initSegment: {
             offset: 0,
             size: fragment.data.byteLength,
@@ -89,6 +109,18 @@ export const generateTrackFragmentIndexFromPath = async (
       if (!fragmentIndex) {
         throw new Error("Fragment index not found");
       }
+
+      // Detect composition time offset from first video segment if no timing offset was found from metadata
+      if (fragmentIndex.type === "video" &&
+        fragmentIndex.segments.length === 0 &&
+        fragmentIndex.startTimeOffsetMs === undefined &&
+        fragment.cts > fragment.dts) {
+        // Calculate composition time offset in milliseconds
+        const compositionOffsetMs = ((fragment.cts - fragment.dts) / fragmentIndex.timescale) * 1000;
+        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,