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

package/dist/Probe.js

@@ -1,8 +1,9 @@
-import debug from "debug";
+import { truncateDecimal } from "./truncateDecimal.js";
 import { exec, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { createReadStream } from "node:fs";
 import * as z$1 from "zod";
+import debug from "debug";
 const execPromise = promisify(exec);
 const log = debug("ef:assets:probe");
 const AudioStreamSchema = z$1.object({
@@ -64,37 +65,56 @@ const ProbeFormatSchema = z$1.object({
 const DataStreamSchema = z$1.object({
 	index: z$1.number(),
 	codec_type: z$1.literal("data"),
-	duration: z$1.string().optional()
+	duration: z$1.string().optional(),
+	duration_ts: z$1.number().optional(),
+	start_pts: z$1.number().optional()
 });
 const StreamSchema = z$1.discriminatedUnion("codec_type", [
 	AudioStreamSchema,
 	VideoStreamSchema,
 	DataStreamSchema
 ]);
+const PacketSchema = z$1.object({
+	stream_index: z$1.number(),
+	pts: z$1.number(),
+	pts_time: z$1.coerce.number(),
+	dts: z$1.number(),
+	dts_time: z$1.coerce.number()
+});
 const ProbeSchema = z$1.object({
 	streams: z$1.array(StreamSchema),
 	format: ProbeFormatSchema
 });
-var Probe = class Probe {
-	static async probePath(absolutePath) {
-		const probeCommand = `ffprobe -v error -show_format -show_streams -of json ${absolutePath}`;
+const PacketProbeSchema = z$1.object({
+	packets: z$1.array(PacketSchema),
+	format: ProbeFormatSchema,
+	streams: z$1.array(StreamSchema)
+});
+const buildProbeArgs = (options) => {
+	return [
+		"-v",
+		"error",
+		"-show_format",
+		"-show_streams",
+		"-of",
+		"json",
+		...options.showPackets ? ["-show_entries", "packet=stream_index,pts,pts_time,dts,dts_time"] : []
+	];
+};
+var FFProbeRunner = class {
+	static async probePath(absolutePath, includePackets) {
+		const probeCommand = `ffprobe ${buildProbeArgs({ showPackets: includePackets }).join(" ")} ${absolutePath}`;
 		log("Probing", probeCommand);
 		const probeResult = await execPromise(probeCommand);
 		log("Probe result", probeResult.stdout);
 		log("Probe stderr", probeResult.stderr);
-		const json = JSON.parse(probeResult.stdout);
-		return new Probe(absolutePath, json);
+		return JSON.parse(probeResult.stdout);
 	}
-	static async probeStream(stream) {
+	static async probeStream(stream, includePackets) {
 		const probe = spawn("ffprobe", [
 			"-i",
 			"-",
-			"-v",
-			"error",
-			"-show_format",
-			"-show_streams",
-			"-of",
-			"json"
+			...buildProbeArgs({ showPackets: includePackets })
 		], { stdio: [
 			"pipe",
 			"pipe",
@@ -126,24 +146,21 @@ var Probe = class Probe {
 				probe.stdout.on("end", () => {
 					try {
 						const buffer = Buffer.concat(chunks).toString("utf8");
-						log("Got probe from stream", buffer);
 						resolve(JSON.parse(buffer));
 					} catch (error) {
 						reject(error);
 					}
 				});
 			}), processExit]);
-			return new Probe("pipe:0", json);
+			return json;
 		} finally {
 			stream.unpipe(probe.stdin);
 			probe.stdin.end();
 			stream.destroy();
 		}
 	}
-	constructor(absolutePath, rawData) {
-		this.absolutePath = absolutePath;
-		this.data = ProbeSchema.parse(rawData);
-	}
+};
+var ProbeBase = class {
 	get audioStreams() {
 		return this.data.streams.filter((stream) => stream.codec_type === "audio");
 	}
@@ -186,6 +203,26 @@ var Probe = class Probe {
 	get mustProcess() {
 		return this.mustReencodeAudio || this.mustReencodeVideo || this.mustRemux;
 	}
+	get audioTimebase() {
+		const audioStream = this.audioStreams[0];
+		if (!audioStream) return null;
+		const [num, den] = audioStream.time_base.split("/").map(Number);
+		if (num === void 0 || den === void 0) return null;
+		return {
+			num,
+			den
+		};
+	}
+	get videoTimebase() {
+		const videoStream = this.videoStreams[0];
+		if (!videoStream) return null;
+		const [num, den] = videoStream.time_base.split("/").map(Number);
+		if (num === void 0 || den === void 0) return null;
+		return {
+			num,
+			den
+		};
+	}
 	get ffmpegAudioInputOptions() {
 		if (!this.hasAudio) return [];
 		if (this.isMp3) return ["-c:a", "mp3"];
@@ -223,6 +260,9 @@ var Probe = class Probe {
 			"filter_units=remove_types=6"
 		];
 	}
+	constructor(absolutePath) {
+		this.absolutePath = absolutePath;
+	}
 	createConformingReadstream() {
 		if (this.absolutePath === "pipe:0") throw new Error("Cannot create conforming readstream from pipe");
 		if (!this.mustProcess) return createReadStream(this.absolutePath);
@@ -241,6 +281,7 @@ var Probe = class Probe {
 			...this.ffmpegVideoOutputOptions,
 			"-f",
 			"mp4",
+			"-bitexact",
 			...fragmenterArgs,
 			"pipe:1"
 		];
@@ -260,6 +301,7 @@ var Probe = class Probe {
 			"copy",
 			"-f",
 			"mp4",
+			"-bitexact",
 			...fragmenterArgs,
 			"pipe:1"
 		];
@@ -281,5 +323,98 @@ var Probe = class Probe {
 		});
 		return ffmpegFragmenter.stdout;
 	}
+	createTrackReadstream(trackIndex) {
+		if (this.absolutePath === "pipe:0") throw new Error("Cannot create track readstream from pipe");
+		const track = this.data.streams[trackIndex];
+		if (!track) throw new Error(`Track ${trackIndex} not found`);
+		const isAudioTrack = track.codec_type === "audio";
+		const isVideoTrack = track.codec_type === "video";
+		if (!isAudioTrack && !isVideoTrack) throw new Error(`Track ${trackIndex} is not audio or video`);
+		const fragmenterArgs = isAudioTrack ? [
+			"-movflags",
+			"empty_moov+default_base_moof",
+			"-frag_duration",
+			"4000000"
+		] : ["-movflags", "frag_keyframe+empty_moov+default_base_moof"];
+		const ffmpegArgs = [
+			...this.ffmpegAudioInputOptions,
+			...this.ffmpegVideoInputOptions,
+			"-i",
+			this.absolutePath,
+			"-map",
+			`0:${trackIndex}`,
+			"-c",
+			"copy",
+			"-f",
+			"mp4",
+			"-bitexact",
+			...fragmenterArgs,
+			"pipe:1"
+		];
+		log("Creating track stream", ffmpegArgs);
+		const ffmpegProcess = spawn("ffmpeg", ffmpegArgs, { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		ffmpegProcess.stderr.on("data", (data) => {
+			log(`TRACK ${trackIndex}: `, data.toString());
+		});
+		ffmpegProcess.on("error", (error) => {
+			ffmpegProcess.stdout.emit("error", error);
+		});
+		return ffmpegProcess.stdout;
+	}
+};
+var Probe = class Probe extends ProbeBase {
+	static async probePath(absolutePath) {
+		const json = await FFProbeRunner.probePath(absolutePath, false);
+		return new Probe(absolutePath, json);
+	}
+	static async probeStream(stream) {
+		const json = await FFProbeRunner.probeStream(stream, false);
+		return new Probe("pipe:0", json);
+	}
+	constructor(absolutePath, rawData) {
+		super(absolutePath);
+		this.data = ProbeSchema.parse(rawData);
+	}
+};
+var PacketProbe = class PacketProbe extends ProbeBase {
+	static async probePath(absolutePath) {
+		const json = await FFProbeRunner.probePath(absolutePath, true);
+		return new PacketProbe(absolutePath, json);
+	}
+	static async probeStream(stream) {
+		const json = await FFProbeRunner.probeStream(stream, true);
+		return new PacketProbe("pipe:0", json);
+	}
+	constructor(absolutePath, rawData) {
+		super(absolutePath);
+		this.data = PacketProbeSchema.parse(rawData);
+	}
+	get packets() {
+		return this.data.packets;
+	}
+	get bestEffortAudioDuration() {
+		const stream = this.audioStreams[0];
+		if (!stream) throw new Error("No audio stream found");
+		return truncateDecimal(((stream.duration_ts ?? 0) - (stream.start_pts ?? 0)) / (this.audioTimebase?.den ?? 0), 5);
+	}
+	get videoPacketDuration() {
+		const videoStream = this.videoStreams[0];
+		if (!videoStream) return [];
+		const videoPackets = this.packets.filter((packet) => packet.stream_index === videoStream.index);
+		const frameRate = videoStream.r_frame_rate;
+		const [num, den] = frameRate.split("/").map(Number);
+		if (!num || !den) return [];
+		const packetDuration = den / num;
+		if (videoPackets.length === 0) return [];
+		const ptsTimes = videoPackets.map((p) => p.pts_time);
+		const minPts = Math.min(...ptsTimes);
+		const maxPts = Math.max(...ptsTimes);
+		const totalDuration = maxPts - minPts + packetDuration;
+		return truncateDecimal(Math.round(totalDuration * 1e4) / 1e4, 5);
+	}
 };
-export { Probe };
+export { PacketProbe, Probe };

package/dist/generateTrackFragmentIndexMediabunny.d.ts

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

package/dist/generateTrackFragmentIndexMediabunny.js

@@ -0,0 +1,343 @@
+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");
+/**
+* Streaming MP4 box parser that detects box boundaries without loading entire file into memory
+*/
+var StreamingBoxParser = class extends Transform {
+	constructor() {
+		super({ objectMode: false });
+		this.buffer = Buffer.alloc(0);
+		this.globalOffset = 0;
+		this.fragments = [];
+		this.currentMoof = null;
+		this.initSegmentEnd = 0;
+		this.foundBoxes = [];
+	}
+	_transform(chunk, _encoding, callback) {
+		this.buffer = Buffer.concat([this.buffer, chunk]);
+		this.parseBoxes();
+		this.push(chunk);
+		callback();
+	}
+	parseBoxes() {
+		let bufferOffset = 0;
+		while (this.buffer.length - bufferOffset >= 8) {
+			const size = this.buffer.readUInt32BE(bufferOffset);
+			const type = this.buffer.subarray(bufferOffset + 4, bufferOffset + 8).toString("ascii");
+			if (size === 0 || size < 8 || this.buffer.length < bufferOffset + size) break;
+			const box = {
+				type,
+				offset: this.globalOffset + bufferOffset,
+				size,
+				headerSize: 8
+			};
+			log(`Found box: ${box.type} at offset ${box.offset}, size ${box.size}`);
+			this.foundBoxes.push(box);
+			this.handleBox(box);
+			bufferOffset += size;
+		}
+		this.globalOffset += bufferOffset;
+		this.buffer = this.buffer.subarray(bufferOffset);
+	}
+	handleBox(box) {
+		switch (box.type) {
+			case "ftyp":
+			case "moov":
+				this.initSegmentEnd = Math.max(this.initSegmentEnd, box.offset + box.size);
+				break;
+			case "moof":
+				this.currentMoof = box;
+				break;
+			case "mdat":
+				if (this.currentMoof) {
+					this.fragments.push({
+						type: "media",
+						offset: this.currentMoof.offset,
+						size: box.offset + box.size - this.currentMoof.offset,
+						moofOffset: this.currentMoof.offset,
+						mdatOffset: box.offset
+					});
+					this.currentMoof = null;
+				} else this.fragments.push({
+					type: "media",
+					offset: box.offset,
+					size: box.size,
+					mdatOffset: box.offset
+				});
+				break;
+		}
+	}
+	_flush(callback) {
+		this.parseBoxes();
+		if (this.initSegmentEnd > 0) this.fragments.unshift({
+			type: "init",
+			offset: 0,
+			size: this.initSegmentEnd
+		});
+		callback();
+	}
+	getFragments() {
+		return this.fragments;
+	}
+};
+function extractFragmentData(mediabunnyChunks, initFragment, mediaFragment) {
+	const extractBytes = (offset, size) => {
+		const buffer = Buffer.alloc(size);
+		let written = 0;
+		let currentOffset = 0;
+		for (const chunk of mediabunnyChunks) {
+			if (currentOffset + chunk.length <= offset) {
+				currentOffset += chunk.length;
+				continue;
+			}
+			if (currentOffset >= offset + size) break;
+			const chunkStart = Math.max(0, offset - currentOffset);
+			const chunkEnd = Math.min(chunk.length, offset + size - currentOffset);
+			const copySize = chunkEnd - chunkStart;
+			chunk.copy(buffer, written, chunkStart, chunkEnd);
+			written += copySize;
+			currentOffset += chunk.length;
+			if (written >= size) break;
+		}
+		return new Uint8Array(buffer.buffer, buffer.byteOffset, written);
+	};
+	if (!initFragment) return extractBytes(mediaFragment.offset, mediaFragment.size);
+	const initData = extractBytes(initFragment.offset, initFragment.size);
+	const mediaData = extractBytes(mediaFragment.offset, mediaFragment.size);
+	const combined = new Uint8Array(initData.length + mediaData.length);
+	combined.set(initData, 0);
+	combined.set(mediaData, initData.length);
+	return combined;
+}
+const generateTrackFragmentIndexMediabunny = async (inputStream, startTimeOffsetMs, trackIdMapping) => {
+	const parser = new StreamingBoxParser();
+	const mediabunnyChunks = [];
+	let totalSize = 0;
+	const mediabunnyDest = new Writable({ write(chunk, _encoding, callback) {
+		mediabunnyChunks.push(chunk);
+		totalSize += chunk.length;
+		callback();
+	} });
+	await pipeline(inputStream, parser, mediabunnyDest);
+	const fragments = parser.getFragments();
+	if (totalSize === 0) return {};
+	const source = new StreamSource({
+		read: async (start, end) => {
+			const size = end - start;
+			const buffer = Buffer.alloc(size);
+			let written = 0;
+			let currentOffset = 0;
+			for (const chunk of mediabunnyChunks) {
+				if (currentOffset + chunk.length <= start) {
+					currentOffset += chunk.length;
+					continue;
+				}
+				if (currentOffset >= end) break;
+				const chunkStart = Math.max(0, start - currentOffset);
+				const chunkEnd = Math.min(chunk.length, end - currentOffset);
+				const copySize = chunkEnd - chunkStart;
+				chunk.copy(buffer, written, chunkStart, chunkEnd);
+				written += copySize;
+				currentOffset += chunk.length;
+				if (written >= size) break;
+			}
+			return new Uint8Array(buffer.buffer, buffer.byteOffset, written);
+		},
+		getSize: async () => totalSize
+	});
+	let input;
+	let videoTracks;
+	let audioTracks;
+	try {
+		input = new Input({
+			formats: [MP4],
+			source
+		});
+		videoTracks = await input.getVideoTracks();
+		audioTracks = await input.getAudioTracks();
+	} catch (error) {
+		console.warn("Failed to parse with Mediabunny:", error);
+		return {};
+	}
+	const trackIndexes = {};
+	const initFragment = fragments.find((f) => f.type === "init");
+	const mediaFragments = fragments.filter((f) => f.type === "media");
+	const videoFragmentTimings = [];
+	const audioFragmentTimings = [];
+	for (let fragmentIndex = 0; fragmentIndex < mediaFragments.length; fragmentIndex++) {
+		const fragment = mediaFragments[fragmentIndex];
+		const fragmentData = extractFragmentData(mediabunnyChunks, initFragment, fragment);
+		const fragmentSource = new StreamSource({
+			read: async (start, end) => fragmentData.subarray(start, end),
+			getSize: async () => fragmentData.length
+		});
+		try {
+			const fragmentInput = new Input({
+				formats: [MP4],
+				source: fragmentSource
+			});
+			const fragmentVideoTracks = await fragmentInput.getVideoTracks();
+			if (fragmentVideoTracks.length > 0) {
+				const track = fragmentVideoTracks[0];
+				const sink = new EncodedPacketSink(track);
+				const packets = [];
+				for await (const packet of sink.packets()) packets.push({
+					timestamp: packet.timestamp,
+					duration: packet.duration
+				});
+				if (packets.length > 0) {
+					const firstPacket = packets[0];
+					const lastPacket = packets[packets.length - 1];
+					const actualDuration = lastPacket.timestamp + lastPacket.duration - firstPacket.timestamp;
+					videoFragmentTimings.push({
+						fragmentIndex,
+						cts: Math.round(firstPacket.timestamp * track.timeResolution),
+						dts: Math.round(firstPacket.timestamp * track.timeResolution),
+						duration: Math.round(actualDuration * track.timeResolution),
+						sampleCount: packets.length,
+						timescale: track.timeResolution
+					});
+				}
+			}
+			const fragmentAudioTracks = await fragmentInput.getAudioTracks();
+			if (fragmentAudioTracks.length > 0) {
+				const track = fragmentAudioTracks[0];
+				const sink = new EncodedPacketSink(track);
+				const packets = [];
+				for await (const packet of sink.packets()) packets.push({
+					timestamp: packet.timestamp,
+					duration: packet.duration
+				});
+				if (packets.length > 0) {
+					const firstPacket = packets[0];
+					const lastPacket = packets[packets.length - 1];
+					const actualDuration = lastPacket.timestamp + lastPacket.duration - firstPacket.timestamp;
+					audioFragmentTimings.push({
+						fragmentIndex,
+						cts: Math.round(firstPacket.timestamp * track.timeResolution),
+						dts: Math.round(firstPacket.timestamp * track.timeResolution),
+						duration: Math.round(actualDuration * track.timeResolution),
+						sampleCount: packets.length,
+						timescale: track.timeResolution
+					});
+				}
+			}
+		} catch (error) {
+			console.warn(`Failed to parse fragment ${fragmentIndex}:`, error);
+			continue;
+		}
+	}
+	for (const track of videoTracks) {
+		const sink = new EncodedPacketSink(track);
+		const segments = [];
+		let sampleCount = 0;
+		let totalDuration = 0;
+		const allPackets = [];
+		for await (const packet of sink.packets()) {
+			allPackets.push({
+				timestamp: packet.timestamp,
+				duration: packet.duration
+			});
+			sampleCount++;
+		}
+		let trackStartTimeOffsetMs;
+		if (allPackets.length > 0) {
+			const firstPacketTime = allPackets[0].timestamp;
+			if (Math.abs(firstPacketTime) > .01) trackStartTimeOffsetMs = firstPacketTime * 1e3;
+		}
+		if (startTimeOffsetMs !== void 0) trackStartTimeOffsetMs = startTimeOffsetMs;
+		const timescale = Math.round(track.timeResolution);
+		for (const timing of videoFragmentTimings) {
+			const fragment = mediaFragments[timing.fragmentIndex];
+			segments.push({
+				cts: timing.cts,
+				dts: timing.dts,
+				duration: timing.duration,
+				offset: fragment.offset,
+				size: fragment.size
+			});
+			totalDuration += timing.duration / timescale;
+		}
+		let width = 1920;
+		let height = 1080;
+		try {
+			const decoderConfig = await track.getDecoderConfig();
+			if (decoderConfig) {
+				width = decoderConfig.codedWidth ?? decoderConfig.width ?? width;
+				height = decoderConfig.codedHeight ?? decoderConfig.height ?? height;
+			}
+		} catch (e) {}
+		const finalTrackId = trackIdMapping?.[track.id] ?? track.id;
+		trackIndexes[finalTrackId] = {
+			track: finalTrackId,
+			type: "video",
+			width,
+			height,
+			timescale: Math.round(track.timeResolution),
+			sample_count: sampleCount,
+			codec: await track.getCodecParameterString() || "",
+			duration: Math.round(totalDuration * track.timeResolution),
+			startTimeOffsetMs: trackStartTimeOffsetMs,
+			initSegment: {
+				offset: 0,
+				size: initFragment?.size || 0
+			},
+			segments
+		};
+	}
+	for (const track of audioTracks) {
+		const sink = new EncodedPacketSink(track);
+		const segments = [];
+		let sampleCount = 0;
+		let totalDuration = 0;
+		const allPackets = [];
+		for await (const packet of sink.packets()) {
+			allPackets.push({
+				timestamp: packet.timestamp,
+				duration: packet.duration
+			});
+			sampleCount++;
+		}
+		let trackStartTimeOffsetMs;
+		if (allPackets.length > 0) {
+			const firstPacketTime = allPackets[0].timestamp;
+			if (Math.abs(firstPacketTime) > .01) trackStartTimeOffsetMs = firstPacketTime * 1e3;
+		}
+		if (startTimeOffsetMs !== void 0) trackStartTimeOffsetMs = startTimeOffsetMs;
+		const timescale = Math.round(track.timeResolution);
+		for (const timing of audioFragmentTimings) {
+			const fragment = mediaFragments[timing.fragmentIndex];
+			segments.push({
+				cts: timing.cts,
+				dts: timing.dts,
+				duration: timing.duration,
+				offset: fragment.offset,
+				size: fragment.size
+			});
+			totalDuration += timing.duration / timescale;
+		}
+		const finalTrackId = trackIdMapping?.[track.id] ?? track.id;
+		trackIndexes[finalTrackId] = {
+			track: finalTrackId,
+			type: "audio",
+			channel_count: track.numberOfChannels,
+			sample_rate: track.sampleRate,
+			sample_size: 16,
+			sample_count: sampleCount,
+			timescale: Math.round(track.timeResolution),
+			codec: await track.getCodecParameterString() || "",
+			duration: Math.round(totalDuration * track.timeResolution),
+			startTimeOffsetMs: trackStartTimeOffsetMs,
+			initSegment: {
+				offset: 0,
+				size: initFragment?.size || 0
+			},
+			segments
+		};
+	}
+	return trackIndexes;
+};
+export { generateTrackFragmentIndexMediabunny };

package/dist/generateTrackMediabunny.d.ts

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

package/dist/generateTrackMediabunny.js

@@ -0,0 +1,69 @@
+import { Probe } from "./Probe.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) => {
+	log(`Generating track ${trackId} for ${absolutePath}`);
+	const probe = await Probe.probePath(absolutePath);
+	const streamIndex = trackId - 1;
+	if (streamIndex < 0 || streamIndex >= probe.streams.length) throw new Error(`Track ${trackId} not found (valid tracks: 1-${probe.streams.length})`);
+	const trackStream = probe.createTrackReadstream(streamIndex);
+	const outputStream = new PassThrough();
+	const indexStream = new PassThrough();
+	trackStream.pipe(outputStream, { end: false });
+	trackStream.pipe(indexStream);
+	let sourceStreamEnded = false;
+	trackStream.on("end", () => {
+		sourceStreamEnded = true;
+	});
+	trackStream.on("error", (error) => {
+		outputStream.destroy(error);
+		indexStream.destroy(error);
+	});
+	const trackIdMapping = { 1: trackId };
+	const fragmentIndexPromise = generateTrackFragmentIndexMediabunny(indexStream, void 0, trackIdMapping);
+	fragmentIndexPromise.then(() => {
+		if (sourceStreamEnded) outputStream.end();
+		else trackStream.once("end", () => {
+			outputStream.end();
+		});
+	}).catch((error) => {
+		outputStream.destroy(error);
+	});
+	return {
+		stream: outputStream,
+		fragmentIndex: fragmentIndexPromise
+	};
+};
+const generateTrackTaskMediabunny = idempotentTask({
+	label: "track-mediabunny",
+	filename: (absolutePath, trackId) => `${basename(absolutePath)}.track-${trackId}.mp4`,
+	runner: async (absolutePath, trackId) => {
+		const result = await generateTrackFromPathMediabunny(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();
+		});
+		result.stream.on("error", (error) => {
+			finalStream.destroy(error);
+		});
+		result.fragmentIndex.then(() => {
+			fragmentIndexCompleted = true;
+			checkCompletion();
+		}).catch((error) => {
+			finalStream.destroy(error);
+		});
+		return finalStream;
+	}
+});
+export { generateTrackFromPathMediabunny };