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

package/dist/memoize.js

@@ -1,14 +1,11 @@
+/** method decorator to memoize the value of a getter */
 const memoize = (_target, _propertyKey, descriptor) => {
-  const get = descriptor.get;
-  if (!get) return;
-  const memoized = /* @__PURE__ */ new WeakMap();
-  descriptor.get = function() {
-    if (!memoized.has(this)) {
-      memoized.set(this, get.call(this));
-    }
-    return memoized.get(this);
-  };
-};
-export {
-  memoize
+	const get = descriptor.get;
+	if (!get) return;
+	const memoized = /* @__PURE__ */ new WeakMap();
+	descriptor.get = function() {
+		if (!memoized.has(this)) memoized.set(this, get.call(this));
+		return memoized.get(this);
+	};
 };
+export { memoize };

package/dist/mp4FileWritable.js

@@ -1,21 +1,19 @@
 import { Writable } from "node:stream";
 const mp4FileWritable = (mp4File) => {
-  let arrayBufferStart = 0;
-  return new Writable({
-    write: (chunk, _encoding, callback) => {
-      const mp4BoxBuffer = chunk.buffer;
-      mp4BoxBuffer.fileStart = arrayBufferStart;
-      arrayBufferStart += chunk.length;
-      mp4File.appendBuffer(mp4BoxBuffer, false);
-      callback();
-    },
-    final: (callback) => {
-      mp4File.flush();
-      mp4File.processSamples(true);
-      callback();
-    }
-  });
-};
-export {
-  mp4FileWritable
+	let arrayBufferStart = 0;
+	return new Writable({
+		write: (chunk, _encoding, callback) => {
+			const mp4BoxBuffer = chunk.buffer;
+			mp4BoxBuffer.fileStart = arrayBufferStart;
+			arrayBufferStart += chunk.length;
+			mp4File.appendBuffer(mp4BoxBuffer, false);
+			callback();
+		},
+		final: (callback) => {
+			mp4File.flush();
+			mp4File.processSamples(true);
+			callback();
+		}
+	});
 };
+export { mp4FileWritable };

package/dist/tasks/cacheImage.js

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

package/dist/tasks/cacheRemoteAsset.d.ts

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

package/dist/tasks/findOrCreateCaptions.js

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

package/dist/tasks/generateTrack.js

@@ -1,72 +1,54 @@
-import { idempotentTask } from "../idempotentTask.js";
 import { MP4File } from "../MP4File.js";
-import debug from "debug";
+import { Probe } from "../Probe.js";
+import { idempotentTask } from "../idempotentTask.js";
 import { mp4FileWritable } from "../mp4FileWritable.js";
-import { PassThrough } from "node:stream";
+import debug from "debug";
 import { basename } from "node:path";
-import { Probe } from "../Probe.js";
+import { PassThrough } from "node:stream";
 const generateTrackFromPath = async (absolutePath, trackId) => {
-  const log = debug("ef:generateTrackFragment");
-  const probe = await Probe.probePath(absolutePath);
-  const readStream = probe.createConformingReadstream();
-  const mp4File = new MP4File();
-  const trackStream = new PassThrough();
-  log(`Generating track for ${absolutePath}`);
-  readStream.pipe(mp4FileWritable(mp4File));
-  (async () => {
-    try {
-      let bytesWritten = 0;
-      for await (const fragment of mp4File.fragmentIterator()) {
-        log("Writing fragment", fragment);
-        if (fragment.track === trackId) {
-          const written = trackStream.write(
-            Buffer.from(fragment.data),
-            "binary"
-          );
-          if (!written) {
-            log(`Waiting for drain for track ${trackId}`);
-            await new Promise((resolve) => trackStream.once("drain", resolve));
-          }
-          bytesWritten += fragment.data.byteLength;
-        }
-        if (!readStream.readableEnded) {
-          await Promise.race([
-            new Promise((resolve) => readStream.once("end", resolve)),
-            new Promise((resolve) => readStream.once("data", resolve))
-          ]);
-        }
-      }
-      trackStream.end();
-    } catch (error) {
-      trackStream.destroy(error);
-    }
-  })();
-  return trackStream;
+	const log = debug("ef:generateTrackFragment");
+	const probe = await Probe.probePath(absolutePath);
+	const readStream = probe.createConformingReadstream();
+	const mp4File = new MP4File();
+	const trackStream = new PassThrough();
+	log(`Generating track for ${absolutePath}`);
+	readStream.pipe(mp4FileWritable(mp4File));
+	(async () => {
+		try {
+			let bytesWritten = 0;
+			for await (const fragment of mp4File.fragmentIterator()) {
+				log("Writing fragment", fragment);
+				if (fragment.track === trackId) {
+					const written = trackStream.write(Buffer.from(fragment.data), "binary");
+					if (!written) {
+						log(`Waiting for drain for track ${trackId}`);
+						await new Promise((resolve) => trackStream.once("drain", resolve));
+					}
+					bytesWritten += fragment.data.byteLength;
+				}
+				if (!readStream.readableEnded) await Promise.race([new Promise((resolve) => readStream.once("end", resolve)), new Promise((resolve) => readStream.once("data", resolve))]);
+			}
+			trackStream.end();
+		} catch (error) {
+			trackStream.destroy(error);
+		}
+	})();
+	return trackStream;
 };
 const generateTrackTask = idempotentTask({
-  label: "track",
-  filename: (absolutePath, trackId) => `${basename(absolutePath)}.track-${trackId}.mp4`,
-  runner: generateTrackFromPath
+	label: "track",
+	filename: (absolutePath, trackId) => `${basename(absolutePath)}.track-${trackId}.mp4`,
+	runner: generateTrackFromPath
 });
 const generateTrack = async (cacheRoot, absolutePath, url) => {
-  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=0"
-      );
-    }
-    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
-  } catch (error) {
-    console.error(error);
-    console.trace("Error generating track", error);
-    throw error;
-  }
-};
-export {
-  generateTrack,
-  generateTrackFromPath,
-  generateTrackTask
+	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=0");
+		return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
+	} catch (error) {
+		console.error(error);
+		console.trace("Error generating track", error);
+		throw error;
+	}
 };
+export { generateTrack, generateTrackFromPath };

package/dist/tasks/generateTrackFragmentIndex.js

@@ -1,110 +1,114 @@
-import { idempotentTask } from "../idempotentTask.js";
 import { MP4File } from "../MP4File.js";
-import debug from "debug";
+import { Probe } from "../Probe.js";
+import { idempotentTask } from "../idempotentTask.js";
 import { mp4FileWritable } from "../mp4FileWritable.js";
+import debug from "debug";
 import { basename } from "node:path";
-import { Probe } from "../Probe.js";
 const generateTrackFragmentIndexFromPath = async (absolutePath) => {
-  const log = debug("ef:generateTrackFragment");
-  const probe = await Probe.probePath(absolutePath);
-  const readStream = probe.createConformingReadstream();
-  const mp4File = new MP4File();
-  log(`Generating track fragment index for ${absolutePath}`);
-  readStream.pipe(mp4FileWritable(mp4File));
-  await new Promise((resolve, reject) => {
-    readStream.on("end", resolve);
-    readStream.on("error", reject);
-  });
-  const trackFragmentIndexes = {};
-  const trackByteOffsets = {};
-  for await (const fragment of mp4File.fragmentIterator()) {
-    const track = mp4File.getInfo().tracks.find((track2) => track2.id === fragment.track);
-    if (!track) {
-      throw new Error("Track not found");
-    }
-    if (fragment.segment === "init") {
-      trackByteOffsets[fragment.track] = fragment.data.byteLength;
-      if (track?.type === "video") {
-        const videoTrack = mp4File.getInfo().videoTracks.find((track2) => track2.id === fragment.track);
-        if (!videoTrack) {
-          throw new Error("Video track not found");
-        }
-        trackFragmentIndexes[fragment.track] = {
-          track: fragment.track,
-          type: "video",
-          width: videoTrack.video.width,
-          height: videoTrack.video.height,
-          timescale: track.timescale,
-          sample_count: videoTrack.nb_samples,
-          codec: videoTrack.codec,
-          duration: videoTrack.duration,
-          initSegment: {
-            offset: 0,
-            size: fragment.data.byteLength
-          },
-          segments: []
-        };
-      }
-      if (track?.type === "audio") {
-        const audioTrack = mp4File.getInfo().audioTracks.find((track2) => track2.id === fragment.track);
-        if (!audioTrack) {
-          throw new Error("Audio track not found");
-        }
-        trackFragmentIndexes[fragment.track] = {
-          track: fragment.track,
-          type: "audio",
-          channel_count: audioTrack.audio.channel_count,
-          sample_rate: audioTrack.audio.sample_rate,
-          sample_size: audioTrack.audio.sample_size,
-          sample_count: audioTrack.nb_samples,
-          timescale: track.timescale,
-          codec: audioTrack.codec,
-          duration: audioTrack.duration,
-          initSegment: {
-            offset: 0,
-            size: fragment.data.byteLength
-          },
-          segments: []
-        };
-      }
-    } else {
-      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");
-      }
-      fragmentIndex.duration += fragment.duration;
-      fragmentIndex.segments.push({
-        cts: fragment.cts,
-        dts: fragment.dts,
-        duration: fragment.duration,
-        offset: trackByteOffsets[fragment.track],
-        size: fragment.data.byteLength
-      });
-      trackByteOffsets[fragment.track] += fragment.data.byteLength;
-    }
-  }
-  return trackFragmentIndexes;
+	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}`);
+	readStream.pipe(mp4FileWritable(mp4File));
+	await new Promise((resolve, reject) => {
+		readStream.on("end", resolve);
+		readStream.on("error", reject);
+	});
+	const trackFragmentIndexes = {};
+	const trackByteOffsets = {};
+	for await (const fragment of mp4File.fragmentIterator()) {
+		const track = mp4File.getInfo().tracks.find((track$1) => track$1.id === fragment.track);
+		if (!track) throw new Error("Track not found");
+		if (fragment.segment === "init") {
+			trackByteOffsets[fragment.track] = fragment.data.byteLength;
+			if (track?.type === "video") {
+				const videoTrack = mp4File.getInfo().videoTracks.find((track$1) => track$1.id === fragment.track);
+				if (!videoTrack) throw new Error("Video track not found");
+				trackFragmentIndexes[fragment.track] = {
+					track: fragment.track,
+					type: "video",
+					width: videoTrack.video.width,
+					height: videoTrack.video.height,
+					timescale: track.timescale,
+					sample_count: videoTrack.nb_samples,
+					codec: videoTrack.codec,
+					duration: videoTrack.duration,
+					startTimeOffsetMs,
+					initSegment: {
+						offset: 0,
+						size: fragment.data.byteLength
+					},
+					segments: []
+				};
+			}
+			if (track?.type === "audio") {
+				const audioTrack = mp4File.getInfo().audioTracks.find((track$1) => track$1.id === fragment.track);
+				if (!audioTrack) throw new Error("Audio track not found");
+				trackFragmentIndexes[fragment.track] = {
+					track: fragment.track,
+					type: "audio",
+					channel_count: audioTrack.audio.channel_count,
+					sample_rate: audioTrack.audio.sample_rate,
+					sample_size: audioTrack.audio.sample_size,
+					sample_count: audioTrack.nb_samples,
+					timescale: track.timescale,
+					codec: audioTrack.codec,
+					duration: audioTrack.duration,
+					initSegment: {
+						offset: 0,
+						size: fragment.data.byteLength
+					},
+					segments: []
+				};
+			}
+		} else {
+			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,
+				dts: fragment.dts,
+				duration: fragment.duration,
+				offset: trackByteOffsets[fragment.track],
+				size: fragment.data.byteLength
+			});
+			trackByteOffsets[fragment.track] += fragment.data.byteLength;
+		}
+	}
+	return trackFragmentIndexes;
 };
 const generateTrackFragmentIndexTask = idempotentTask({
-  label: "trackFragmentIndex",
-  filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
-  runner: async (absolutePath) => {
-    const index = await generateTrackFragmentIndexFromPath(absolutePath);
-    return JSON.stringify(index, null, 2);
-  }
+	label: "trackFragmentIndex",
+	filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,
+	runner: async (absolutePath) => {
+		const index = await generateTrackFragmentIndexFromPath(absolutePath);
+		return JSON.stringify(index, null, 2);
+	}
 });
 const generateTrackFragmentIndex = async (cacheRoot, absolutePath) => {
-  try {
-    return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);
-  } catch (error) {
-    console.trace("Error generating track fragment index", error);
-    throw error;
-  }
-};
-export {
-  generateTrackFragmentIndex,
-  generateTrackFragmentIndexFromPath
+	try {
+		return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);
+	} catch (error) {
+		console.trace("Error generating track fragment index", error);
+		throw error;
+	}
 };
+export { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/assets",
-  "version": "0.16.8-beta.0",
+  "version": "0.18.3-beta.0",
   "description": "",
   "exports": {
     ".": {
@@ -39,15 +39,15 @@
   "dependencies": {
     "debug": "^4.3.5",
     "mp4box": "^0.5.2",
-    "zod": "^3.23.8",
-    "ora": "^8.0.1"
+    "ora": "^8.0.1",
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@types/dom-webcodecs": "^0.1.11",
     "@types/node": "^20.14.13",
     "rollup-plugin-tsconfig-paths": "^1.5.2",
     "typescript": "^5.5.4",
-    "vite-plugin-dts": "^4.0.3",
+    "vite-plugin-dts": "^4.5.4",
     "vite-tsconfig-paths": "^4.3.2"
   }
 }

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,