@editframe/assets 0.47.0 → 0.47.2

package/dist/generateWebmSegmentIndex.js

@@ -0,0 +1,319 @@
+import { PacketProbe } from "./Probe.js";
+import debug from "debug";
+import { readFile } from "node:fs/promises";
+
+//#region src/generateWebmSegmentIndex.ts
+const log = debug("ef:generateWebmSegmentIndex");
+const MIN_SEGMENT_DURATION_MS = 2e3;
+const ID_EBML = 440786851;
+const ID_SEGMENT = 408125543;
+const ID_INFO = 357149030;
+const ID_CLUSTER = 524531317;
+const ID_TIMESTAMP = 231;
+const ID_SIMPLE_BLOCK = 163;
+const ID_BLOCK_GROUP = 160;
+const ID_REFERENCE_BLOCK = 251;
+const ID_TIMESTAMP_SCALE = 2807729;
+/**
+* Decode an EBML variable-length integer used for **element sizes**.
+* The leading 1-bit encodes the byte-width; that bit is then stripped from
+* the value.  Returns `null` for the "unknown / streaming" sentinel value
+* (all data-bits = 1).
+*/
+function readVintSize(buf, offset) {
+	const b = buf[offset];
+	let width = 1;
+	let mask = 128;
+	while (width <= 8 && !(b & mask)) {
+		mask >>= 1;
+		width++;
+	}
+	let value = b & mask - 1;
+	for (let i = 1; i < width; i++) value = value << 8 | (buf[offset + i] ?? 0);
+	const unknownSentinel = (1 << 7 * width) - 1;
+	return {
+		value: value === unknownSentinel ? null : value,
+		width
+	};
+}
+/**
+* Decode an EBML **element ID**.  Unlike sizes, the leading marker bit is
+* *kept* in the returned value (IDs are opaque bit patterns).
+*/
+function readElementId(buf, offset) {
+	const b = buf[offset];
+	let width = 1;
+	let mask = 128;
+	while (width <= 4 && !(b & mask)) {
+		mask >>= 1;
+		width++;
+	}
+	let id = b;
+	for (let i = 1; i < width; i++) id = id << 8 | (buf[offset + i] ?? 0);
+	return {
+		id,
+		width
+	};
+}
+/** Read a big-endian unsigned integer of `size` bytes. */
+function readUintBE(buf, offset, size) {
+	let val = 0;
+	for (let i = 0; i < size; i++) val = val * 256 + (buf[offset + i] ?? 0) >>> 0;
+	return val;
+}
+/**
+* Parse the top-level EBML and Segment structure of a WebM file.
+* Only reads as deep as needed: EBML header → Segment → Info/Tracks/Clusters.
+*/
+function parseWebmStructure(buf) {
+	let pos = 0;
+	const { id: ebmlId, width: ebmlIdWidth } = readElementId(buf, pos);
+	if (ebmlId !== ID_EBML) throw new Error(`Expected EBML element (0x1A45DFA3), got 0x${ebmlId.toString(16)}`);
+	const { value: ebmlSize, width: ebmlSizeWidth } = readVintSize(buf, pos + ebmlIdWidth);
+	if (ebmlSize === null) throw new Error("EBML element has unknown size");
+	pos += ebmlIdWidth + ebmlSizeWidth + ebmlSize;
+	const { id: segId, width: segIdWidth } = readElementId(buf, pos);
+	if (segId !== ID_SEGMENT) throw new Error(`Expected Segment element (0x18538067), got 0x${segId.toString(16)}`);
+	const segmentSizeVintOffset = pos + segIdWidth;
+	const { width: segSizeWidth } = readVintSize(buf, segmentSizeVintOffset);
+	let spos = segmentSizeVintOffset + segSizeWidth;
+	let initSize = 0;
+	let timestampScaleNs = 1e6;
+	const clusters = [];
+	while (spos < buf.length) {
+		if (buf.length - spos < 2) break;
+		const { id: childId, width: childIdWidth } = readElementId(buf, spos);
+		const { value: childSize, width: childSizeWidth } = readVintSize(buf, spos + childIdWidth);
+		const headerSize = childIdWidth + childSizeWidth;
+		if (childSize === null) {
+			log(`Unknown-size element 0x${childId.toString(16)} at ${spos}, stopping`);
+			break;
+		}
+		const elementEnd = spos + headerSize + childSize;
+		if (childId === ID_INFO) {
+			let ipos = spos + headerSize;
+			while (ipos < elementEnd && ipos < buf.length) {
+				const { id: infoChildId, width: infoIdW } = readElementId(buf, ipos);
+				const { value: infoChildSize, width: infoSizeW } = readVintSize(buf, ipos + infoIdW);
+				if (infoChildSize === null) break;
+				if (infoChildId === ID_TIMESTAMP_SCALE) timestampScaleNs = readUintBE(buf, ipos + infoIdW + infoSizeW, infoChildSize);
+				ipos += infoIdW + infoSizeW + infoChildSize;
+			}
+		} else if (childId === ID_CLUSTER) {
+			if (initSize === 0) initSize = spos;
+			let clusterTimestampUnits = 0;
+			let hasKeyframe = false;
+			let cpos = spos + headerSize;
+			while (cpos < elementEnd && cpos < buf.length) {
+				if (buf.length - cpos < 2) break;
+				const { id: cid, width: cidW } = readElementId(buf, cpos);
+				const { value: csize, width: csizeW } = readVintSize(buf, cpos + cidW);
+				if (csize === null) break;
+				const cHeaderSize = cidW + csizeW;
+				if (cid === ID_TIMESTAMP) clusterTimestampUnits = readUintBE(buf, cpos + cHeaderSize, csize);
+				else if (cid === ID_SIMPLE_BLOCK) {
+					const sbOffset = cpos + cHeaderSize;
+					const { width: trackNumWidth } = readVintSize(buf, sbOffset);
+					if ((buf[sbOffset + trackNumWidth + 2] ?? 0) & 128) hasKeyframe = true;
+				} else if (cid === ID_BLOCK_GROUP) {
+					let bgpos = cpos + cHeaderSize;
+					const bgEnd = cpos + cHeaderSize + csize;
+					let hasReferenceBlock = false;
+					while (bgpos < bgEnd && bgpos < buf.length) {
+						const { id: bgid, width: bgidW } = readElementId(buf, bgpos);
+						const { value: bgsize, width: bgsizeW } = readVintSize(buf, bgpos + bgidW);
+						if (bgsize === null) break;
+						if (bgid === ID_REFERENCE_BLOCK) {
+							hasReferenceBlock = true;
+							break;
+						}
+						bgpos += bgidW + bgsizeW + bgsize;
+					}
+					if (!hasReferenceBlock) hasKeyframe = true;
+				}
+				cpos += cHeaderSize + csize;
+			}
+			const timestampMs = Math.round(clusterTimestampUnits * timestampScaleNs / 1e6);
+			clusters.push({
+				offset: spos,
+				size: headerSize + childSize,
+				timestampMs,
+				hasKeyframe
+			});
+		}
+		spos = elementEnd;
+	}
+	if (initSize === 0) throw new Error("No Cluster elements found in WebM file");
+	return {
+		segmentSizeVintOffset,
+		segmentSizeVintWidth: segSizeWidth,
+		initSize,
+		clusters,
+		timestampScaleNs
+	};
+}
+/**
+* Use ffprobe packet data to mark clusters that contain keyframe packets.
+* More reliable than parsing SimpleBlock flags in-process for large files.
+*/
+async function annotateKeyframes(clusters, absolutePath) {
+	const keyframePositions = (await PacketProbe.probePath(absolutePath)).packets.filter((p) => p.flags?.includes("K") && p.pos !== void 0).map((p) => p.pos);
+	for (const cluster of clusters) {
+		const clusterEnd = cluster.offset + cluster.size;
+		cluster.hasKeyframe = keyframePositions.some((pos) => pos >= cluster.offset && pos < clusterEnd);
+	}
+}
+function buildSegments(clusters, timescale, totalDurationMs) {
+	const segments = [];
+	let segmentClusters = [];
+	let segmentStartMs = 0;
+	const flushSegment = (nextStartMs) => {
+		if (segmentClusters.length === 0) return;
+		const first = segmentClusters[0];
+		const last = segmentClusters[segmentClusters.length - 1];
+		const offset = first.offset;
+		const size = last.offset + last.size - first.offset;
+		const cts = Math.round(segmentStartMs * timescale / 1e3);
+		const dts = cts;
+		const duration = Math.round((nextStartMs - segmentStartMs) * timescale / 1e3);
+		segments.push({
+			cts,
+			dts,
+			offset,
+			size,
+			duration
+		});
+		segmentClusters = [];
+	};
+	for (let i = 0; i < clusters.length; i++) {
+		const cluster = clusters[i];
+		const durationSoFarMs = segmentClusters.length > 0 ? cluster.timestampMs - segmentStartMs : 0;
+		if (segmentClusters.length > 0 && durationSoFarMs >= MIN_SEGMENT_DURATION_MS && cluster.hasKeyframe) {
+			flushSegment(cluster.timestampMs);
+			segmentStartMs = cluster.timestampMs;
+		}
+		if (segmentClusters.length === 0) {
+			if (!cluster.hasKeyframe) continue;
+			segmentStartMs = cluster.timestampMs;
+		}
+		segmentClusters.push(cluster);
+	}
+	flushSegment(totalDurationMs);
+	return segments;
+}
+/**
+* Build a TrackFragmentIndex for a VP9-alpha WebM source without any
+* transcoding.  The returned index contains byte offsets that point directly
+* into the cached copy of the source file (which has its Segment-size VINT
+* patched to "unknown" by generateTrack.ts).
+*/
+async function generateWebmSegmentIndex(absolutePath, startTimeOffsetMs) {
+	log(`Generating WebM segment index for ${absolutePath}`);
+	const { initSize, clusters, timestampScaleNs } = parseWebmStructure(await readFile(absolutePath));
+	const timescale = 1e3;
+	log(`Parsed ${clusters.length} clusters, init=${initSize} bytes, timestampScale=${timestampScaleNs}ns`);
+	await annotateKeyframes(clusters, absolutePath);
+	log(`Keyframe clusters: ${clusters.filter((c) => c.hasKeyframe).map((c) => `${c.timestampMs}ms@${c.offset}`).join(", ")}`);
+	const lastCluster = clusters[clusters.length - 1];
+	let finalDurationMs = lastCluster.timestampMs + lastCluster.size / 4096;
+	try {
+		const videoStream$1 = (await PacketProbe.probePath(absolutePath)).data?.streams?.find((s) => s.codec_type === "video");
+		if (videoStream$1?.duration) finalDurationMs = Math.round(parseFloat(videoStream$1.duration) * 1e3);
+	} catch {}
+	log(`Total duration: ${finalDurationMs}ms`);
+	const segments = buildSegments(clusters, timescale, finalDurationMs);
+	log(`Built ${segments.length} segments: ${segments.map((s) => `[${s.cts / timescale * 1e3 | 0}ms offset=${s.offset} size=${s.size}]`).join(", ")}`);
+	const probe2 = await PacketProbe.probePath(absolutePath);
+	const videoStream = probe2.data?.streams?.find((s) => s.codec_type === "video");
+	const width = videoStream?.width ?? 1920;
+	const height = videoStream?.height ?? 1080;
+	const codec = videoStream?.codec_tag_string ?? videoStream?.codec_name ?? "vp09";
+	const sampleCount = probe2.packets?.filter((p) => p.codec_type !== "audio").length ?? 0;
+	let trackStartTimeOffsetMs;
+	if (startTimeOffsetMs !== void 0) trackStartTimeOffsetMs = startTimeOffsetMs;
+	else if (clusters[0] && clusters[0].timestampMs > 1) trackStartTimeOffsetMs = clusters[0].timestampMs;
+	const trackIndex = {
+		track: 1,
+		type: "video",
+		width,
+		height,
+		timescale,
+		codec,
+		duration: Math.round(finalDurationMs * timescale / 1e3),
+		sample_count: sampleCount,
+		startTimeOffsetMs: trackStartTimeOffsetMs,
+		initSegment: {
+			offset: 0,
+			size: initSize
+		},
+		segments
+	};
+	return { 1: trackIndex };
+}
+const ID_SEEKHEAD = 290298740;
+const EBML_VOID_ID = 236;
+/**
+* Patch a WebM buffer in-place to make it safe for partial (segment-sliced) serving:
+*
+* 1. Segment-element size VINT → EBML unknown-size (0x01FFFFFFFFFFFFFF).
+*    Without this, mediabunny expects the full 44 MB when receiving a 5 MB chunk.
+*
+* 2. SeekHead element → EBML Void of the same byte length.
+*    The SeekHead contains Cues/cluster offsets relative to the original file.
+*    When mediabunny uses those offsets on a sliced buffer it reads garbage or
+*    falls off the end of the buffer, causing seek errors and de-sync.  Replacing
+*    it with a Void element forces linear parsing: EBML → Info → Tracks → Clusters.
+*
+* Both patches are applied to a Buffer copy; the source file on disk is not modified.
+*/
+function patchWebmForSegmentedServing(buf) {
+	try {
+		const { id: ebmlId, width: ebmlIdWidth } = readElementId(buf, 0);
+		if (ebmlId !== ID_EBML) return;
+		const { value: ebmlSize, width: ebmlSizeWidth } = readVintSize(buf, ebmlIdWidth);
+		if (ebmlSize === null) return;
+		const segPos = ebmlIdWidth + ebmlSizeWidth + ebmlSize;
+		const { id: segId, width: segIdWidth } = readElementId(buf, segPos);
+		if (segId !== ID_SEGMENT) return;
+		const segSizeOffset = segPos + segIdWidth;
+		const { width: segSizeWidth } = readVintSize(buf, segSizeOffset);
+		if (segSizeWidth === 8) Buffer.from([
+			1,
+			255,
+			255,
+			255,
+			255,
+			255,
+			255,
+			255
+		]).copy(buf, segSizeOffset);
+		let pos = segPos + segIdWidth + segSizeWidth;
+		const scanLimit = Math.min(pos + 4096, buf.length);
+		while (pos < scanLimit) {
+			const { id: childId, width: childIdWidth } = readElementId(buf, pos);
+			const { value: childSize, width: childSizeWidth } = readVintSize(buf, pos + childIdWidth);
+			if (childSize === null) break;
+			const totalElementSize = childIdWidth + childSizeWidth + childSize;
+			if (childId === ID_SEEKHEAD) {
+				const voidContentSize = totalElementSize - 1;
+				let vintBytes;
+				if (voidContentSize <= 126) vintBytes = [128 | voidContentSize];
+				else if (voidContentSize <= 16382) vintBytes = [64 | voidContentSize >> 8, voidContentSize & 255];
+				else vintBytes = [
+					32 | voidContentSize >> 16,
+					voidContentSize >> 8 & 255,
+					voidContentSize & 255
+				];
+				buf[pos] = EBML_VOID_ID;
+				for (let i = 0; i < vintBytes.length; i++) buf[pos + 1 + i] = vintBytes[i];
+				buf.fill(0, pos + 1 + vintBytes.length, pos + totalElementSize);
+				break;
+			}
+			pos += totalElementSize;
+		}
+	} catch {}
+}
+
+//#endregion
+export { generateWebmSegmentIndex, patchWebmForSegmentedServing };
+//# sourceMappingURL=generateWebmSegmentIndex.js.map

package/dist/generateWebmSegmentIndex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateWebmSegmentIndex.js","names":["clusters: ClusterInfo[]","segments: TrackSegment[]","segmentClusters: ClusterInfo[]","videoStream","width: number","height: number","codec: string","sampleCount: number","trackStartTimeOffsetMs: number | undefined","trackIndex: TrackFragmentIndex","vintBytes: number[]"],"sources":["../src/generateWebmSegmentIndex.ts"],"sourcesContent":["/**\n * WebM / Matroska segment index generator.\n *\n * Instead of transcoding VP9-alpha WebM → fragmented MP4 (which strips the\n * alpha BlockAdditions), this module parses the source WebM's EBML structure\n * to produce byte-range segment maps directly into the original file.\n *\n * The pipeline:\n *  1. EBML parse: locate init region (EBML + Segment header + Info + Tracks)\n *     and enumerate every Cluster with its timestamp.\n *  2. Keyframe detection: cross-reference cluster byte ranges with ffprobe\n *     packet positions+flags to mark which clusters are keyframe-aligned.\n *  3. Segment grouping: accumulate clusters into ≥2-second segments that\n *     start on keyframe clusters (mirrors generateFragmentIndex.ts logic).\n *  4. Output: same TrackFragmentIndex shape used by the MP4 path so the\n *     rest of the pipeline (middleware, SegmentIndex.ts, EFVideo) is unchanged.\n *\n * Segment size patching\n * ---------------------\n * ffmpeg writes a known Segment-element size in the WebM header.  When we\n * serve a subset of clusters, the size field must be replaced with the EBML\n * \"unknown\" value (0x01FFFFFFFFFFFFFF) so mediabunny does not expect more\n * bytes than we provide.  This patch is applied once to the cached copy of\n * the source file (see generateTrack.ts).\n */\n\nimport { readFile } from \"node:fs/promises\";\nimport debug from \"debug\";\nimport type { TrackFragmentIndex, TrackSegment } from \"./Probe.js\";\nimport { PacketProbe } from \"./Probe.js\";\n\nconst log = debug(\"ef:generateWebmSegmentIndex\");\n\nconst MIN_SEGMENT_DURATION_MS = 2000;\n\n// ---------------------------------------------------------------------------\n// EBML element IDs (big-endian, variable width)\n// ---------------------------------------------------------------------------\nconst ID_EBML = 0x1a45dfa3;\nconst ID_SEGMENT = 0x18538067;\nconst ID_INFO = 0x1549a966;\nconst ID_CLUSTER = 0x1f43b675;\nconst ID_TIMESTAMP = 0xe7; // inside Cluster\nconst ID_SIMPLE_BLOCK = 0xa3; // inside Cluster\nconst ID_BLOCK_GROUP = 0xa0; // inside Cluster (contains Block + optional ReferenceBlock)\nconst ID_REFERENCE_BLOCK = 0xfb; // inside BlockGroup — presence means delta frame\nconst ID_TIMESTAMP_SCALE = 0x2ad7b1; // inside Info (nanoseconds per timestamp unit)\n\n// ---------------------------------------------------------------------------\n// EBML primitive decoders\n// ---------------------------------------------------------------------------\n\n/**\n * Decode an EBML variable-length integer used for **element sizes**.\n * The leading 1-bit encodes the byte-width; that bit is then stripped from\n * the value.  Returns `null` for the \"unknown / streaming\" sentinel value\n * (all data-bits = 1).\n */\nfunction readVintSize(buf: Buffer, offset: number): { value: number | null; width: number } {\n  const b = buf[offset]!;\n  let width = 1;\n  let mask = 0x80;\n  while (width <= 8 && !(b & mask)) {\n    mask >>= 1;\n    width++;\n  }\n  let value = b & (mask - 1); // strip leading marker bit\n  for (let i = 1; i < width; i++) {\n    value = (value << 8) | (buf[offset + i] ?? 0);\n  }\n  // All data-bits = 1 means \"unknown size\" in EBML\n  const unknownSentinel = (1 << (7 * width)) - 1;\n  return { value: value === unknownSentinel ? null : value, width };\n}\n\n/**\n * Decode an EBML **element ID**.  Unlike sizes, the leading marker bit is\n * *kept* in the returned value (IDs are opaque bit patterns).\n */\nfunction readElementId(buf: Buffer, offset: number): { id: number; width: number } {\n  const b = buf[offset]!;\n  let width = 1;\n  let mask = 0x80;\n  while (width <= 4 && !(b & mask)) {\n    mask >>= 1;\n    width++;\n  }\n  let id = b;\n  for (let i = 1; i < width; i++) {\n    id = (id << 8) | (buf[offset + i] ?? 0);\n  }\n  return { id, width };\n}\n\n/** Read a big-endian unsigned integer of `size` bytes. */\nfunction readUintBE(buf: Buffer, offset: number, size: number): number {\n  let val = 0;\n  for (let i = 0; i < size; i++) {\n    val = (val * 256 + (buf[offset + i] ?? 0)) >>> 0;\n  }\n  return val;\n}\n\n// ---------------------------------------------------------------------------\n// WebM structure parser\n// ---------------------------------------------------------------------------\n\ninterface ClusterInfo {\n  /** Byte offset of the Cluster element's ID field in the file. */\n  offset: number;\n  /** Total byte length of the Cluster element (header + content). */\n  size: number;\n  /** Cluster base timestamp converted to milliseconds. */\n  timestampMs: number;\n  /** True if any SimpleBlock within the cluster has the keyframe flag set. */\n  hasKeyframe: boolean;\n}\n\ninterface WebmStructure {\n  /**\n   * Byte offset of the 8-byte Segment-size VINT that must be patched to the\n   * EBML unknown-size sentinel when serving partial content.\n   */\n  segmentSizeVintOffset: number;\n  /** Byte length of the Segment-size VINT (should be 8 for ffmpeg output). */\n  segmentSizeVintWidth: number;\n  /** Byte offset of the first Cluster element == end of the \"init\" region. */\n  initSize: number;\n  /** All Cluster elements found in the file, in order. */\n  clusters: ClusterInfo[];\n  /** TimestampScale in nanoseconds per unit (default 1 000 000 = 1 ms/unit). */\n  timestampScaleNs: number;\n}\n\n/**\n * Parse the top-level EBML and Segment structure of a WebM file.\n * Only reads as deep as needed: EBML header → Segment → Info/Tracks/Clusters.\n */\nfunction parseWebmStructure(buf: Buffer): WebmStructure {\n  let pos = 0;\n\n  // ── EBML element ─────────────────────────────────────────────────────────\n  const { id: ebmlId, width: ebmlIdWidth } = readElementId(buf, pos);\n  if (ebmlId !== ID_EBML) {\n    throw new Error(`Expected EBML element (0x1A45DFA3), got 0x${ebmlId.toString(16)}`);\n  }\n  const { value: ebmlSize, width: ebmlSizeWidth } = readVintSize(buf, pos + ebmlIdWidth);\n  if (ebmlSize === null) throw new Error(\"EBML element has unknown size\");\n  pos += ebmlIdWidth + ebmlSizeWidth + ebmlSize; // skip to Segment\n\n  // ── Segment element ───────────────────────────────────────────────────────\n  const { id: segId, width: segIdWidth } = readElementId(buf, pos);\n  if (segId !== ID_SEGMENT) {\n    throw new Error(`Expected Segment element (0x18538067), got 0x${segId.toString(16)}`);\n  }\n  const segmentSizeVintOffset = pos + segIdWidth;\n  const { width: segSizeWidth } = readVintSize(buf, segmentSizeVintOffset);\n  const segContentStart = segmentSizeVintOffset + segSizeWidth;\n\n  // ── Segment children ──────────────────────────────────────────────────────\n  let spos = segContentStart;\n  let initSize = 0;\n  let timestampScaleNs = 1_000_000; // default: 1 ms per unit\n  const clusters: ClusterInfo[] = [];\n\n  while (spos < buf.length) {\n    if (buf.length - spos < 2) break; // not enough bytes for a header\n\n    const { id: childId, width: childIdWidth } = readElementId(buf, spos);\n    const { value: childSize, width: childSizeWidth } = readVintSize(buf, spos + childIdWidth);\n    const headerSize = childIdWidth + childSizeWidth;\n\n    if (childSize === null) {\n      // Unknown-size element (rare in well-formed WebM) — stop scanning.\n      log(`Unknown-size element 0x${childId.toString(16)} at ${spos}, stopping`);\n      break;\n    }\n\n    const elementEnd = spos + headerSize + childSize;\n\n    if (childId === ID_INFO) {\n      // Extract TimestampScale from Info\n      let ipos = spos + headerSize;\n      while (ipos < elementEnd && ipos < buf.length) {\n        const { id: infoChildId, width: infoIdW } = readElementId(buf, ipos);\n        const { value: infoChildSize, width: infoSizeW } = readVintSize(buf, ipos + infoIdW);\n        if (infoChildSize === null) break;\n        if (infoChildId === ID_TIMESTAMP_SCALE) {\n          timestampScaleNs = readUintBE(buf, ipos + infoIdW + infoSizeW, infoChildSize);\n        }\n        ipos += infoIdW + infoSizeW + infoChildSize;\n      }\n    } else if (childId === ID_CLUSTER) {\n      if (initSize === 0) {\n        initSize = spos; // first cluster offset = init region ends here\n      }\n\n      // Extract Cluster Timestamp and scan for keyframe SimpleBlocks\n      let clusterTimestampUnits = 0;\n      let hasKeyframe = false;\n      let cpos = spos + headerSize;\n\n      while (cpos < elementEnd && cpos < buf.length) {\n        if (buf.length - cpos < 2) break;\n        const { id: cid, width: cidW } = readElementId(buf, cpos);\n        const { value: csize, width: csizeW } = readVintSize(buf, cpos + cidW);\n        if (csize === null) break;\n        const cHeaderSize = cidW + csizeW;\n\n        if (cid === ID_TIMESTAMP) {\n          clusterTimestampUnits = readUintBE(buf, cpos + cHeaderSize, csize);\n        } else if (cid === ID_SIMPLE_BLOCK) {\n          // SimpleBlock layout: [track VINT][relative timecode int16BE][flags byte][frame data]\n          const sbOffset = cpos + cHeaderSize;\n          const { width: trackNumWidth } = readVintSize(buf, sbOffset);\n          const flagsByte = buf[sbOffset + trackNumWidth + 2] ?? 0;\n          if (flagsByte & 0x80) {\n            hasKeyframe = true;\n          }\n        } else if (cid === ID_BLOCK_GROUP) {\n          // BlockGroup: check for absence of ReferenceBlock → keyframe\n          let bgpos = cpos + cHeaderSize;\n          const bgEnd = cpos + cHeaderSize + csize;\n          let hasReferenceBlock = false;\n          while (bgpos < bgEnd && bgpos < buf.length) {\n            const { id: bgid, width: bgidW } = readElementId(buf, bgpos);\n            const { value: bgsize, width: bgsizeW } = readVintSize(buf, bgpos + bgidW);\n            if (bgsize === null) break;\n            if (bgid === ID_REFERENCE_BLOCK) {\n              hasReferenceBlock = true;\n              break;\n            }\n            bgpos += bgidW + bgsizeW + bgsize;\n          }\n          if (!hasReferenceBlock) hasKeyframe = true;\n        }\n\n        cpos += cHeaderSize + csize;\n      }\n\n      const timestampMs = Math.round((clusterTimestampUnits * timestampScaleNs) / 1_000_000);\n      clusters.push({ offset: spos, size: headerSize + childSize, timestampMs, hasKeyframe });\n    }\n\n    spos = elementEnd;\n  }\n\n  if (initSize === 0) {\n    throw new Error(\"No Cluster elements found in WebM file\");\n  }\n\n  return {\n    segmentSizeVintOffset,\n    segmentSizeVintWidth: segSizeWidth,\n    initSize,\n    clusters,\n    timestampScaleNs,\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Keyframe detection via ffprobe packet positions\n// ---------------------------------------------------------------------------\n\n/**\n * Use ffprobe packet data to mark clusters that contain keyframe packets.\n * More reliable than parsing SimpleBlock flags in-process for large files.\n */\nasync function annotateKeyframes(clusters: ClusterInfo[], absolutePath: string): Promise<void> {\n  const probe = await PacketProbe.probePath(absolutePath);\n  const keyframePositions = (probe.packets as Array<{ pos?: number; flags?: string }>)\n    .filter((p) => p.flags?.includes(\"K\") && p.pos !== undefined)\n    .map((p) => p.pos as number);\n\n  for (const cluster of clusters) {\n    const clusterEnd = cluster.offset + cluster.size;\n    cluster.hasKeyframe = keyframePositions.some(\n      (pos) => pos >= cluster.offset && pos < clusterEnd,\n    );\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Segment grouping (mirrors generateFragmentIndex.ts logic)\n// ---------------------------------------------------------------------------\n\nfunction buildSegments(\n  clusters: ClusterInfo[],\n  timescale: number,\n  totalDurationMs: number,\n): TrackSegment[] {\n  const segments: TrackSegment[] = [];\n\n  let segmentClusters: ClusterInfo[] = [];\n  let segmentStartMs = 0;\n\n  const flushSegment = (nextStartMs: number) => {\n    if (segmentClusters.length === 0) return;\n    const first = segmentClusters[0]!;\n    const last = segmentClusters[segmentClusters.length - 1]!;\n    const offset = first.offset;\n    const size = last.offset + last.size - first.offset;\n    const cts = Math.round((segmentStartMs * timescale) / 1000);\n    const dts = cts;\n    const duration = Math.round(((nextStartMs - segmentStartMs) * timescale) / 1000);\n    segments.push({ cts, dts, offset, size, duration });\n    segmentClusters = [];\n  };\n\n  for (let i = 0; i < clusters.length; i++) {\n    const cluster = clusters[i]!;\n    const durationSoFarMs = segmentClusters.length > 0 ? cluster.timestampMs - segmentStartMs : 0;\n\n    const shouldFinalize =\n      segmentClusters.length > 0 &&\n      durationSoFarMs >= MIN_SEGMENT_DURATION_MS &&\n      cluster.hasKeyframe;\n\n    if (shouldFinalize) {\n      flushSegment(cluster.timestampMs);\n      segmentStartMs = cluster.timestampMs;\n    }\n\n    if (segmentClusters.length === 0) {\n      if (!cluster.hasKeyframe) continue; // wait for first keyframe\n      segmentStartMs = cluster.timestampMs;\n    }\n\n    segmentClusters.push(cluster);\n  }\n\n  // Flush final segment\n  flushSegment(totalDurationMs);\n\n  return segments;\n}\n\n// ---------------------------------------------------------------------------\n// Public entry point\n// ---------------------------------------------------------------------------\n\n/**\n * Build a TrackFragmentIndex for a VP9-alpha WebM source without any\n * transcoding.  The returned index contains byte offsets that point directly\n * into the cached copy of the source file (which has its Segment-size VINT\n * patched to \"unknown\" by generateTrack.ts).\n */\nexport async function generateWebmSegmentIndex(\n  absolutePath: string,\n  startTimeOffsetMs?: number,\n): Promise<Record<number, TrackFragmentIndex>> {\n  log(`Generating WebM segment index for ${absolutePath}`);\n\n  const buf = await readFile(absolutePath);\n  const structure = parseWebmStructure(buf);\n\n  const { initSize, clusters, timestampScaleNs } = structure;\n  const timescale = 1000; // work in milliseconds\n\n  log(\n    `Parsed ${clusters.length} clusters, init=${initSize} bytes, ` +\n      `timestampScale=${timestampScaleNs}ns`,\n  );\n\n  // Annotate keyframes via ffprobe for accuracy\n  await annotateKeyframes(clusters, absolutePath);\n\n  const keyframeClusters = clusters.filter((c) => c.hasKeyframe);\n  log(\n    `Keyframe clusters: ${keyframeClusters.map((c) => `${c.timestampMs}ms@${c.offset}`).join(\", \")}`,\n  );\n\n  // Total duration from last cluster\n  const lastCluster = clusters[clusters.length - 1]!;\n  const totalDurationMs = lastCluster.timestampMs + lastCluster.size / 4096; // rough estimate\n  // Better: use ffprobe stream duration\n  let finalDurationMs = totalDurationMs;\n  try {\n    const probe = await PacketProbe.probePath(absolutePath);\n    const videoStream = (probe as any).data?.streams?.find((s: any) => s.codec_type === \"video\");\n    if (videoStream?.duration) {\n      finalDurationMs = Math.round(parseFloat(videoStream.duration) * 1000);\n    }\n  } catch {\n    // fall back to rough estimate\n  }\n\n  log(`Total duration: ${finalDurationMs}ms`);\n\n  const segments = buildSegments(clusters, timescale, finalDurationMs);\n\n  log(\n    `Built ${segments.length} segments: ${segments.map((s) => `[${((s.cts / timescale) * 1000) | 0}ms offset=${s.offset} size=${s.size}]`).join(\", \")}`,\n  );\n\n  // Track metadata from ffprobe\n  const probe2 = await PacketProbe.probePath(absolutePath);\n  const videoStream = (probe2 as any).data?.streams?.find((s: any) => s.codec_type === \"video\");\n  const width: number = videoStream?.width ?? 1920;\n  const height: number = videoStream?.height ?? 1080;\n  const codec: string = videoStream?.codec_tag_string ?? videoStream?.codec_name ?? \"vp09\";\n  const sampleCount: number =\n    (probe2 as any).packets?.filter((p: any) => p.codec_type !== \"audio\").length ?? 0;\n\n  let trackStartTimeOffsetMs: number | undefined;\n  if (startTimeOffsetMs !== undefined) {\n    trackStartTimeOffsetMs = startTimeOffsetMs;\n  } else if (clusters[0] && clusters[0].timestampMs > 1) {\n    trackStartTimeOffsetMs = clusters[0].timestampMs;\n  }\n\n  const trackIndex: TrackFragmentIndex = {\n    track: 1,\n    type: \"video\",\n    width,\n    height,\n    timescale,\n    codec,\n    duration: Math.round((finalDurationMs * timescale) / 1000),\n    sample_count: sampleCount,\n    startTimeOffsetMs: trackStartTimeOffsetMs,\n    initSegment: { offset: 0, size: initSize },\n    segments,\n  };\n\n  return { 1: trackIndex };\n}\n\n// ---------------------------------------------------------------------------\n// Helpers exported for use in generateTrack.ts\n// ---------------------------------------------------------------------------\n\nconst ID_SEEKHEAD = 0x114d9b74;\nconst EBML_VOID_ID = 0xec;\n\n/**\n * Patch a WebM buffer in-place to make it safe for partial (segment-sliced) serving:\n *\n * 1. Segment-element size VINT → EBML unknown-size (0x01FFFFFFFFFFFFFF).\n *    Without this, mediabunny expects the full 44 MB when receiving a 5 MB chunk.\n *\n * 2. SeekHead element → EBML Void of the same byte length.\n *    The SeekHead contains Cues/cluster offsets relative to the original file.\n *    When mediabunny uses those offsets on a sliced buffer it reads garbage or\n *    falls off the end of the buffer, causing seek errors and de-sync.  Replacing\n *    it with a Void element forces linear parsing: EBML → Info → Tracks → Clusters.\n *\n * Both patches are applied to a Buffer copy; the source file on disk is not modified.\n */\nexport function patchWebmForSegmentedServing(buf: Buffer): void {\n  try {\n    // ── Locate EBML and Segment headers ───────────────────────────────────\n    const { id: ebmlId, width: ebmlIdWidth } = readElementId(buf, 0);\n    if (ebmlId !== ID_EBML) return;\n    const { value: ebmlSize, width: ebmlSizeWidth } = readVintSize(buf, ebmlIdWidth);\n    if (ebmlSize === null) return;\n    const segPos = ebmlIdWidth + ebmlSizeWidth + ebmlSize;\n    const { id: segId, width: segIdWidth } = readElementId(buf, segPos);\n    if (segId !== ID_SEGMENT) return;\n\n    // ── Patch 1: Segment size → unknown ───────────────────────────────────\n    const segSizeOffset = segPos + segIdWidth;\n    const { width: segSizeWidth } = readVintSize(buf, segSizeOffset);\n    if (segSizeWidth === 8) {\n      const UNKNOWN_SIZE = Buffer.from([0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]);\n      UNKNOWN_SIZE.copy(buf, segSizeOffset);\n    }\n\n    // ── Patch 2: SeekHead → Void ──────────────────────────────────────────\n    const segContentStart = segPos + segIdWidth + segSizeWidth;\n    let pos = segContentStart;\n\n    // Scan segment children until we find SeekHead (it is always the first child\n    // in ffmpeg-generated WebM files, but scan defensively up to 4 KB).\n    const scanLimit = Math.min(pos + 4096, buf.length);\n    while (pos < scanLimit) {\n      const { id: childId, width: childIdWidth } = readElementId(buf, pos);\n      const { value: childSize, width: childSizeWidth } = readVintSize(buf, pos + childIdWidth);\n      if (childSize === null) break;\n      const totalElementSize = childIdWidth + childSizeWidth + childSize;\n\n      if (childId === ID_SEEKHEAD) {\n        // Overwrite the entire SeekHead element with a Void element of equal size.\n        // Void layout: 1-byte ID (0xEC) + VINT size + zero content.\n        // We need VINT(totalElementSize - 1) to account for the 1-byte Void ID.\n        const voidContentSize = totalElementSize - 1; // after the 0xEC ID byte\n\n        // Encode the size as a VINT.  voidContentSize is small enough for 2-byte VINT\n        // (max 16383) or even 1-byte (max 127) for typical SeekHead sizes.\n        let vintBytes: number[];\n        if (voidContentSize <= 126) {\n          // 1-byte VINT: 0x80 | value\n          vintBytes = [0x80 | voidContentSize];\n        } else if (voidContentSize <= 16382) {\n          // 2-byte VINT: 0x40xx\n          vintBytes = [0x40 | (voidContentSize >> 8), voidContentSize & 0xff];\n        } else {\n          // 3-byte VINT (should never be needed for SeekHead)\n          vintBytes = [\n            0x20 | (voidContentSize >> 16),\n            (voidContentSize >> 8) & 0xff,\n            voidContentSize & 0xff,\n          ];\n        }\n\n        buf[pos] = EBML_VOID_ID;\n        for (let i = 0; i < vintBytes.length; i++) {\n          buf[pos + 1 + i] = vintBytes[i]!;\n        }\n        // Zero out the rest of the element\n        buf.fill(0, pos + 1 + vintBytes.length, pos + totalElementSize);\n        break; // only one SeekHead per file\n      }\n\n      pos += totalElementSize;\n    }\n  } catch {\n    // Best-effort — if parsing fails the file is served unpatched\n  }\n}\n"],"mappings":"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"}

package/dist/tasks/generateTrack.cjs

@@ -1,19 +1,35 @@
 const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_Probe = require('../Probe.cjs');
 const require_idempotentTask = require('../idempotentTask.cjs');
+const require_generateWebmSegmentIndex = require('../generateWebmSegmentIndex.cjs');
 const require_generateSingleTrack = require('../generateSingleTrack.cjs');
 let debug = require("debug");
 debug = require_rolldown_runtime.__toESM(debug);
+let node_stream = require("node:stream");
+node_stream = require_rolldown_runtime.__toESM(node_stream);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path);
 
 //#region src/tasks/generateTrack.ts
 const generateTrackFromPath = async (absolutePath, trackId) => {
-	(0, debug.default)("ef:generateTrackFragment")(`Generating track ${trackId} for ${absolutePath}`);
+	const log = (0, debug.default)("ef:generateTrackFragment");
+	log(`Generating track ${trackId} for ${absolutePath}`);
+	if ((await require_Probe.Probe.probePath(absolutePath)).hasAlphaVideo) {
+		log(`VP9 alpha WebM: copying source with Segment size + SeekHead patched`);
+		const buf = await (0, node_fs_promises.readFile)(absolutePath);
+		require_generateWebmSegmentIndex.patchWebmForSegmentedServing(buf);
+		return node_stream.Readable.from(buf);
+	}
 	return (await require_generateSingleTrack.generateSingleTrackFromPath(absolutePath, trackId)).stream;
 };
 const generateTrackTask = require_idempotentTask.idempotentTask({
 	label: "track",
-	filename: (absolutePath, trackId) => `${(0, node_path.basename)(absolutePath)}.track-${trackId}.mp4`,
+	filename: (absolutePath, _trackId) => {
+		const ext = absolutePath.endsWith(".webm") ? "webm" : "mp4";
+		return `${(0, node_path.basename)(absolutePath)}.track-1.${ext}`;
+	},
 	runner: generateTrackFromPath
 });
 const generateTrack = async (cacheRoot, absolutePath, url) => {

package/dist/tasks/generateTrack.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"generateTrack.cjs","names":["generateSingleTrackFromPath","idempotentTask"],"sources":["../../src/tasks/generateTrack.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { generateSingleTrackFromPath } from \"../generateSingleTrack.js\";\n\nexport const generateTrackFromPath = async (absolutePath: string, trackId: number) => {\n  const log = debug(\"ef:generateTrackFragment\");\n  log(`Generating track ${trackId} for ${absolutePath}`);\n\n  // Use the single-track implementation\n  const result = await generateSingleTrackFromPath(absolutePath, trackId);\n\n  // Return just the stream for compatibility with existing API\n  return result.stream;\n};\n\nexport const generateTrackTask = idempotentTask({\n  label: \"track\",\n  filename: (absolutePath: string, trackId: number) =>\n    `${basename(absolutePath)}.track-${trackId}.mp4`,\n  runner: generateTrackFromPath,\n});\n\nexport const generateTrack = async (cacheRoot: string, absolutePath: string, url: string) => {\n  try {\n    const trackId = new URL(`http://localhost${url}`).searchParams.get(\"trackId\");\n    if (trackId === null) {\n      throw new Error(\n        \"No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)\",\n      );\n    }\n    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));\n  } catch (error) {\n    console.error(error);\n    console.trace(\"Error generating track\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;;AAKA,MAAa,wBAAwB,OAAO,cAAsB,YAAoB;AAEpF,oBADkB,2BAA2B,CACzC,oBAAoB,QAAQ,OAAO,eAAe;AAMtD,SAHe,MAAMA,wDAA4B,cAAc,QAAQ,EAGzD;;AAGhB,MAAa,oBAAoBC,sCAAe;CAC9C,OAAO;CACP,WAAW,cAAsB,YAC/B,2BAAY,aAAa,CAAC,SAAS,QAAQ;CAC7C,QAAQ;CACT,CAAC;AAEF,MAAa,gBAAgB,OAAO,WAAmB,cAAsB,QAAgB;AAC3F,KAAI;EACF,MAAM,UAAU,IAAI,IAAI,mBAAmB,MAAM,CAAC,aAAa,IAAI,UAAU;AAC7E,MAAI,YAAY,KACd,OAAM,IAAI,MACR,kHACD;AAEH,SAAO,MAAM,kBAAkB,WAAW,cAAc,OAAO,QAAQ,CAAC;UACjE,OAAO;AACd,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,0BAA0B,MAAM;AAC9C,QAAM"}
+{"version":3,"file":"generateTrack.cjs","names":["Probe","Readable","generateSingleTrackFromPath","idempotentTask"],"sources":["../../src/tasks/generateTrack.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { Readable } from \"node:stream\";\nimport { readFile } from \"node:fs/promises\";\nimport { Probe } from \"../Probe.js\";\nimport { generateSingleTrackFromPath } from \"../generateSingleTrack.js\";\nimport { patchWebmForSegmentedServing } from \"../generateWebmSegmentIndex.js\";\n\nexport const generateTrackFromPath = async (absolutePath: string, trackId: number) => {\n  const log = debug(\"ef:generateTrackFragment\");\n  log(`Generating track ${trackId} for ${absolutePath}`);\n\n  const probe = await Probe.probePath(absolutePath);\n\n  // For VP9-alpha WebM sources: no transcoding needed.\n  // Copy the source to cache with two in-place patches so mediabunny can\n  // parse partial (segment-sliced) chunks without expecting the full file:\n  //   1. Segment-element size → EBML unknown-size (0x01FFFFFFFFFFFFFF)\n  //   2. SeekHead → Void element of equal size (prevents stale seeks to\n  //      positions that don't exist in the sliced chunk, which was causing\n  //      de-sync in Scene A).\n  // Alpha BlockAdditions travel untouched in every cluster.\n  if (probe.hasAlphaVideo) {\n    log(`VP9 alpha WebM: copying source with Segment size + SeekHead patched`);\n    const buf = await readFile(absolutePath);\n    patchWebmForSegmentedServing(buf);\n    return Readable.from(buf);\n  }\n\n  const result = await generateSingleTrackFromPath(absolutePath, trackId);\n  return result.stream;\n};\n\nexport const generateTrackTask = idempotentTask({\n  label: \"track\",\n  filename: (absolutePath: string, _trackId: number) => {\n    // VP9-alpha WebM sources are cached as .webm; everything else is .mp4.\n    const ext = absolutePath.endsWith(\".webm\") ? \"webm\" : \"mp4\";\n    return `${basename(absolutePath)}.track-1.${ext}`;\n  },\n  runner: generateTrackFromPath,\n});\n\nexport const generateTrack = async (cacheRoot: string, absolutePath: string, url: string) => {\n  try {\n    const trackId = new URL(`http://localhost${url}`).searchParams.get(\"trackId\");\n    if (trackId === null) {\n      throw new Error(\n        \"No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)\",\n      );\n    }\n    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));\n  } catch (error) {\n    console.error(error);\n    console.trace(\"Error generating track\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;AASA,MAAa,wBAAwB,OAAO,cAAsB,YAAoB;CACpF,MAAM,yBAAY,2BAA2B;AAC7C,KAAI,oBAAoB,QAAQ,OAAO,eAAe;AAYtD,MAVc,MAAMA,oBAAM,UAAU,aAAa,EAUvC,eAAe;AACvB,MAAI,sEAAsE;EAC1E,MAAM,MAAM,qCAAe,aAAa;AACxC,gEAA6B,IAAI;AACjC,SAAOC,qBAAS,KAAK,IAAI;;AAI3B,SADe,MAAMC,wDAA4B,cAAc,QAAQ,EACzD;;AAGhB,MAAa,oBAAoBC,sCAAe;CAC9C,OAAO;CACP,WAAW,cAAsB,aAAqB;EAEpD,MAAM,MAAM,aAAa,SAAS,QAAQ,GAAG,SAAS;AACtD,SAAO,2BAAY,aAAa,CAAC,WAAW;;CAE9C,QAAQ;CACT,CAAC;AAEF,MAAa,gBAAgB,OAAO,WAAmB,cAAsB,QAAgB;AAC3F,KAAI;EACF,MAAM,UAAU,IAAI,IAAI,mBAAmB,MAAM,CAAC,aAAa,IAAI,UAAU;AAC7E,MAAI,YAAY,KACd,OAAM,IAAI,MACR,kHACD;AAEH,SAAO,MAAM,kBAAkB,WAAW,cAAc,OAAO,QAAQ,CAAC;UACjE,OAAO;AACd,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,0BAA0B,MAAM;AAC9C,QAAM"}

package/dist/tasks/generateTrack.js

@@ -1,16 +1,30 @@
+import { Probe } from "../Probe.js";
 import { idempotentTask } from "../idempotentTask.js";
+import { patchWebmForSegmentedServing } from "../generateWebmSegmentIndex.js";
 import { generateSingleTrackFromPath } from "../generateSingleTrack.js";
 import debug from "debug";
+import { Readable } from "node:stream";
+import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
 
 //#region src/tasks/generateTrack.ts
 const generateTrackFromPath = async (absolutePath, trackId) => {
-	debug("ef:generateTrackFragment")(`Generating track ${trackId} for ${absolutePath}`);
+	const log = debug("ef:generateTrackFragment");
+	log(`Generating track ${trackId} for ${absolutePath}`);
+	if ((await Probe.probePath(absolutePath)).hasAlphaVideo) {
+		log(`VP9 alpha WebM: copying source with Segment size + SeekHead patched`);
+		const buf = await readFile(absolutePath);
+		patchWebmForSegmentedServing(buf);
+		return Readable.from(buf);
+	}
 	return (await generateSingleTrackFromPath(absolutePath, trackId)).stream;
 };
 const generateTrackTask = idempotentTask({
 	label: "track",
-	filename: (absolutePath, trackId) => `${basename(absolutePath)}.track-${trackId}.mp4`,
+	filename: (absolutePath, _trackId) => {
+		const ext = absolutePath.endsWith(".webm") ? "webm" : "mp4";
+		return `${basename(absolutePath)}.track-1.${ext}`;
+	},
 	runner: generateTrackFromPath
 });
 const generateTrack = async (cacheRoot, absolutePath, url) => {

package/dist/tasks/generateTrack.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateTrack.js","names":[],"sources":["../../src/tasks/generateTrack.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { generateSingleTrackFromPath } from \"../generateSingleTrack.js\";\n\nexport const generateTrackFromPath = async (absolutePath: string, trackId: number) => {\n  const log = debug(\"ef:generateTrackFragment\");\n  log(`Generating track ${trackId} for ${absolutePath}`);\n\n  // Use the single-track implementation\n  const result = await generateSingleTrackFromPath(absolutePath, trackId);\n\n  // Return just the stream for compatibility with existing API\n  return result.stream;\n};\n\nexport const generateTrackTask = idempotentTask({\n  label: \"track\",\n  filename: (absolutePath: string, trackId: number) =>\n    `${basename(absolutePath)}.track-${trackId}.mp4`,\n  runner: generateTrackFromPath,\n});\n\nexport const generateTrack = async (cacheRoot: string, absolutePath: string, url: string) => {\n  try {\n    const trackId = new URL(`http://localhost${url}`).searchParams.get(\"trackId\");\n    if (trackId === null) {\n      throw new Error(\n        \"No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)\",\n      );\n    }\n    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));\n  } catch (error) {\n    console.error(error);\n    console.trace(\"Error generating track\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;AAKA,MAAa,wBAAwB,OAAO,cAAsB,YAAoB;AAEpF,CADY,MAAM,2BAA2B,CACzC,oBAAoB,QAAQ,OAAO,eAAe;AAMtD,SAHe,MAAM,4BAA4B,cAAc,QAAQ,EAGzD;;AAGhB,MAAa,oBAAoB,eAAe;CAC9C,OAAO;CACP,WAAW,cAAsB,YAC/B,GAAG,SAAS,aAAa,CAAC,SAAS,QAAQ;CAC7C,QAAQ;CACT,CAAC;AAEF,MAAa,gBAAgB,OAAO,WAAmB,cAAsB,QAAgB;AAC3F,KAAI;EACF,MAAM,UAAU,IAAI,IAAI,mBAAmB,MAAM,CAAC,aAAa,IAAI,UAAU;AAC7E,MAAI,YAAY,KACd,OAAM,IAAI,MACR,kHACD;AAEH,SAAO,MAAM,kBAAkB,WAAW,cAAc,OAAO,QAAQ,CAAC;UACjE,OAAO;AACd,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,0BAA0B,MAAM;AAC9C,QAAM"}
+{"version":3,"file":"generateTrack.js","names":[],"sources":["../../src/tasks/generateTrack.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { Readable } from \"node:stream\";\nimport { readFile } from \"node:fs/promises\";\nimport { Probe } from \"../Probe.js\";\nimport { generateSingleTrackFromPath } from \"../generateSingleTrack.js\";\nimport { patchWebmForSegmentedServing } from \"../generateWebmSegmentIndex.js\";\n\nexport const generateTrackFromPath = async (absolutePath: string, trackId: number) => {\n  const log = debug(\"ef:generateTrackFragment\");\n  log(`Generating track ${trackId} for ${absolutePath}`);\n\n  const probe = await Probe.probePath(absolutePath);\n\n  // For VP9-alpha WebM sources: no transcoding needed.\n  // Copy the source to cache with two in-place patches so mediabunny can\n  // parse partial (segment-sliced) chunks without expecting the full file:\n  //   1. Segment-element size → EBML unknown-size (0x01FFFFFFFFFFFFFF)\n  //   2. SeekHead → Void element of equal size (prevents stale seeks to\n  //      positions that don't exist in the sliced chunk, which was causing\n  //      de-sync in Scene A).\n  // Alpha BlockAdditions travel untouched in every cluster.\n  if (probe.hasAlphaVideo) {\n    log(`VP9 alpha WebM: copying source with Segment size + SeekHead patched`);\n    const buf = await readFile(absolutePath);\n    patchWebmForSegmentedServing(buf);\n    return Readable.from(buf);\n  }\n\n  const result = await generateSingleTrackFromPath(absolutePath, trackId);\n  return result.stream;\n};\n\nexport const generateTrackTask = idempotentTask({\n  label: \"track\",\n  filename: (absolutePath: string, _trackId: number) => {\n    // VP9-alpha WebM sources are cached as .webm; everything else is .mp4.\n    const ext = absolutePath.endsWith(\".webm\") ? \"webm\" : \"mp4\";\n    return `${basename(absolutePath)}.track-1.${ext}`;\n  },\n  runner: generateTrackFromPath,\n});\n\nexport const generateTrack = async (cacheRoot: string, absolutePath: string, url: string) => {\n  try {\n    const trackId = new URL(`http://localhost${url}`).searchParams.get(\"trackId\");\n    if (trackId === null) {\n      throw new Error(\n        \"No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)\",\n      );\n    }\n    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));\n  } catch (error) {\n    console.error(error);\n    console.trace(\"Error generating track\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;;;AASA,MAAa,wBAAwB,OAAO,cAAsB,YAAoB;CACpF,MAAM,MAAM,MAAM,2BAA2B;AAC7C,KAAI,oBAAoB,QAAQ,OAAO,eAAe;AAYtD,MAVc,MAAM,MAAM,UAAU,aAAa,EAUvC,eAAe;AACvB,MAAI,sEAAsE;EAC1E,MAAM,MAAM,MAAM,SAAS,aAAa;AACxC,+BAA6B,IAAI;AACjC,SAAO,SAAS,KAAK,IAAI;;AAI3B,SADe,MAAM,4BAA4B,cAAc,QAAQ,EACzD;;AAGhB,MAAa,oBAAoB,eAAe;CAC9C,OAAO;CACP,WAAW,cAAsB,aAAqB;EAEpD,MAAM,MAAM,aAAa,SAAS,QAAQ,GAAG,SAAS;AACtD,SAAO,GAAG,SAAS,aAAa,CAAC,WAAW;;CAE9C,QAAQ;CACT,CAAC;AAEF,MAAa,gBAAgB,OAAO,WAAmB,cAAsB,QAAgB;AAC3F,KAAI;EACF,MAAM,UAAU,IAAI,IAAI,mBAAmB,MAAM,CAAC,aAAa,IAAI,UAAU;AAC7E,MAAI,YAAY,KACd,OAAM,IAAI,MACR,kHACD;AAEH,SAAO,MAAM,kBAAkB,WAAW,cAAc,OAAO,QAAQ,CAAC;UACjE,OAAO;AACd,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,0BAA0B,MAAM;AAC9C,QAAM"}

package/dist/tasks/generateTrackFragmentIndex.cjs

@@ -2,6 +2,7 @@ const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
 const require_Probe = require('../Probe.cjs');
 const require_generateFragmentIndex = require('../generateFragmentIndex.cjs');
 const require_idempotentTask = require('../idempotentTask.cjs');
+const require_generateWebmSegmentIndex = require('../generateWebmSegmentIndex.cjs');
 let debug = require("debug");
 debug = require_rolldown_runtime.__toESM(debug);
 let node_path = require("node:path");
@@ -14,6 +15,24 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
 	const startTimeOffsetMs = probe.startTimeOffsetMs;
 	if (startTimeOffsetMs !== void 0) log(`Extracted start_time offset: ${startTimeOffsetMs}ms`);
 	else log("No format/stream timing offset found - will detect from composition time");
+	if (probe.hasAlphaVideo) {
+		log(`VP9 alpha WebM: using EBML cluster index (no transcoding)`);
+		const webmIndex = await require_generateWebmSegmentIndex.generateWebmSegmentIndex(absolutePath, startTimeOffsetMs);
+		const scrubResult$1 = await (async () => {
+			try {
+				log("Generating scrub track fragment index for alpha WebM");
+				const result = await require_generateFragmentIndex.generateFragmentIndex(probe.createScrubTrackReadstream(), startTimeOffsetMs, { 0: -1 });
+				log("Scrub track fragment index generated successfully");
+				return result;
+			} catch (error) {
+				log(`Failed to generate scrub track fragment index: ${error}`);
+				return null;
+			}
+		})();
+		const trackFragmentIndexes$1 = { ...webmIndex };
+		if (scrubResult$1) Object.assign(trackFragmentIndexes$1, scrubResult$1);
+		return trackFragmentIndexes$1;
+	}
 	log(`Generating track fragment index for ${absolutePath} using single-track approach`);
 	const trackTasks = probe.streams.map((stream, streamIndex) => {
 		if (stream.codec_type !== "audio" && stream.codec_type !== "video") return null;
@@ -24,9 +43,7 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
 	const scrubTask = probe.videoStreams.length > 0 ? (async () => {
 		try {
 			log("Generating scrub track fragment index");
-			const scrubStream = probe.createScrubTrackReadstream();
-			const scrubTrackId = -1;
-			const result = await require_generateFragmentIndex.generateFragmentIndex(scrubStream, startTimeOffsetMs, { 0: scrubTrackId });
+			const result = await require_generateFragmentIndex.generateFragmentIndex(probe.createScrubTrackReadstream(), startTimeOffsetMs, { 0: -1 });
 			log("Scrub track fragment index generated successfully");
 			return result;
 		} catch (error) {

package/dist/tasks/generateTrackFragmentIndex.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"generateTrackFragmentIndex.cjs","names":["Probe","generateFragmentIndex","scrubTask: Promise<Record<number, TrackFragmentIndex> | null>","trackFragmentIndexes: Record<number, TrackFragmentIndex>","idempotentTask"],"sources":["../../src/tasks/generateTrackFragmentIndex.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { Probe } from \"../Probe.js\";\nimport { generateFragmentIndex } from \"../generateFragmentIndex.js\";\nimport type { TrackFragmentIndex } from \"../Probe.js\";\n\nexport const generateTrackFragmentIndexFromPath = async (absolutePath: string) => {\n  const log = debug(\"ef:generateTrackFragment\");\n  const probe = await Probe.probePath(absolutePath);\n\n  const startTimeOffsetMs = probe.startTimeOffsetMs;\n  if (startTimeOffsetMs !== undefined) {\n    log(`Extracted start_time offset: ${startTimeOffsetMs}ms`);\n  } else {\n    log(\"No format/stream timing offset found - will detect from composition time\");\n  }\n\n  log(`Generating track fragment index for ${absolutePath} using single-track approach`);\n\n  // Process all audio/video streams and scrub track in parallel\n  const trackTasks = probe.streams\n    .map((stream, streamIndex) => {\n      if (stream.codec_type !== \"audio\" && stream.codec_type !== \"video\") {\n        return null;\n      }\n      const trackId = streamIndex + 1;\n      log(`Processing track ${trackId} (${stream.codec_type})`);\n      const trackStream = probe.createTrackReadstream(streamIndex);\n      const trackIdMapping = { 0: trackId };\n      return generateFragmentIndex(trackStream, startTimeOffsetMs, trackIdMapping);\n    })\n    .filter((task): task is Promise<Record<number, TrackFragmentIndex>> => task !== null);\n\n  const scrubTask: Promise<Record<number, TrackFragmentIndex> | null> =\n    probe.videoStreams.length > 0\n      ? (async () => {\n          try {\n            log(\"Generating scrub track fragment index\");\n            const scrubStream = probe.createScrubTrackReadstream();\n            const scrubTrackId = -1;\n            const result = await generateFragmentIndex(scrubStream, startTimeOffsetMs, {\n              0: scrubTrackId,\n            });\n            log(\"Scrub track fragment index generated successfully\");\n            return result;\n          } catch (error) {\n            log(`Failed to generate scrub track fragment index: ${error}`);\n            return null;\n          }\n        })()\n      : Promise.resolve(null);\n\n  const [trackResults, scrubResult] = await Promise.all([Promise.all(trackTasks), scrubTask]);\n\n  const trackFragmentIndexes: Record<number, TrackFragmentIndex> = {};\n  for (const result of trackResults) {\n    Object.assign(trackFragmentIndexes, result);\n  }\n  if (scrubResult) {\n    Object.assign(trackFragmentIndexes, scrubResult);\n  }\n\n  return trackFragmentIndexes;\n};\n\nconst generateTrackFragmentIndexTask = idempotentTask({\n  label: \"trackFragmentIndex\",\n  filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,\n  runner: async (absolutePath: string) => {\n    const index = await generateTrackFragmentIndexFromPath(absolutePath);\n    return JSON.stringify(index, null, 2);\n  },\n});\n\nexport const generateTrackFragmentIndex = async (cacheRoot: string, absolutePath: string) => {\n  try {\n    return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);\n  } catch (error) {\n    console.trace(\"Error generating track fragment index\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;;;AAOA,MAAa,qCAAqC,OAAO,iBAAyB;CAChF,MAAM,yBAAY,2BAA2B;CAC7C,MAAM,QAAQ,MAAMA,oBAAM,UAAU,aAAa;CAEjD,MAAM,oBAAoB,MAAM;AAChC,KAAI,sBAAsB,OACxB,KAAI,gCAAgC,kBAAkB,IAAI;KAE1D,KAAI,2EAA2E;AAGjF,KAAI,uCAAuC,aAAa,8BAA8B;CAGtF,MAAM,aAAa,MAAM,QACtB,KAAK,QAAQ,gBAAgB;AAC5B,MAAI,OAAO,eAAe,WAAW,OAAO,eAAe,QACzD,QAAO;EAET,MAAM,UAAU,cAAc;AAC9B,MAAI,oBAAoB,QAAQ,IAAI,OAAO,WAAW,GAAG;AAGzD,SAAOC,oDAFa,MAAM,sBAAsB,YAAY,EAElB,mBADnB,EAAE,GAAG,SAAS,CACuC;GAC5E,CACD,QAAQ,SAA8D,SAAS,KAAK;CAEvF,MAAMC,YACJ,MAAM,aAAa,SAAS,KACvB,YAAY;AACX,MAAI;AACF,OAAI,wCAAwC;GAC5C,MAAM,cAAc,MAAM,4BAA4B;GACtD,MAAM,eAAe;GACrB,MAAM,SAAS,MAAMD,oDAAsB,aAAa,mBAAmB,EACzE,GAAG,cACJ,CAAC;AACF,OAAI,oDAAoD;AACxD,UAAO;WACA,OAAO;AACd,OAAI,kDAAkD,QAAQ;AAC9D,UAAO;;KAEP,GACJ,QAAQ,QAAQ,KAAK;CAE3B,MAAM,CAAC,cAAc,eAAe,MAAM,QAAQ,IAAI,CAAC,QAAQ,IAAI,WAAW,EAAE,UAAU,CAAC;CAE3F,MAAME,uBAA2D,EAAE;AACnE,MAAK,MAAM,UAAU,aACnB,QAAO,OAAO,sBAAsB,OAAO;AAE7C,KAAI,YACF,QAAO,OAAO,sBAAsB,YAAY;AAGlD,QAAO;;AAGT,MAAM,iCAAiCC,sCAAe;CACpD,OAAO;CACP,WAAW,iBAAiB,2BAAY,aAAa,CAAC;CACtD,QAAQ,OAAO,iBAAyB;EACtC,MAAM,QAAQ,MAAM,mCAAmC,aAAa;AACpE,SAAO,KAAK,UAAU,OAAO,MAAM,EAAE;;CAExC,CAAC;AAEF,MAAa,6BAA6B,OAAO,WAAmB,iBAAyB;AAC3F,KAAI;AACF,SAAO,MAAM,+BAA+B,WAAW,aAAa;UAC7D,OAAO;AACd,UAAQ,MAAM,yCAAyC,MAAM;AAC7D,QAAM"}
+{"version":3,"file":"generateTrackFragmentIndex.cjs","names":["Probe","generateWebmSegmentIndex","scrubResult","generateFragmentIndex","trackFragmentIndexes: Record<number, TrackFragmentIndex>","trackFragmentIndexes","scrubTask: Promise<Record<number, TrackFragmentIndex> | null>","idempotentTask"],"sources":["../../src/tasks/generateTrackFragmentIndex.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { Probe } from \"../Probe.js\";\nimport { generateFragmentIndex } from \"../generateFragmentIndex.js\";\nimport { generateWebmSegmentIndex } from \"../generateWebmSegmentIndex.js\";\nimport type { TrackFragmentIndex } from \"../Probe.js\";\n\nexport const generateTrackFragmentIndexFromPath = async (absolutePath: string) => {\n  const log = debug(\"ef:generateTrackFragment\");\n  const probe = await Probe.probePath(absolutePath);\n\n  const startTimeOffsetMs = probe.startTimeOffsetMs;\n  if (startTimeOffsetMs !== undefined) {\n    log(`Extracted start_time offset: ${startTimeOffsetMs}ms`);\n  } else {\n    log(\"No format/stream timing offset found - will detect from composition time\");\n  }\n\n  // ── VP9-alpha WebM fast path ─────────────────────────────────────────────\n  // For VP9-alpha WebM sources we skip all transcoding and instead build a\n  // byte-range index directly from the source file's EBML cluster structure.\n  // Alpha BlockAdditions are preserved in every cluster — no H264 matte needed.\n  if (probe.hasAlphaVideo) {\n    log(`VP9 alpha WebM: using EBML cluster index (no transcoding)`);\n    const webmIndex = await generateWebmSegmentIndex(absolutePath, startTimeOffsetMs);\n\n    // Scrub track still needs transcoding (low-res H264 thumbnails)\n    const scrubTask: Promise<Record<number, TrackFragmentIndex> | null> = (async () => {\n      try {\n        log(\"Generating scrub track fragment index for alpha WebM\");\n        const scrubStream = probe.createScrubTrackReadstream();\n        const result = await generateFragmentIndex(scrubStream, startTimeOffsetMs, { 0: -1 });\n        log(\"Scrub track fragment index generated successfully\");\n        return result;\n      } catch (error) {\n        log(`Failed to generate scrub track fragment index: ${error}`);\n        return null;\n      }\n    })();\n\n    const scrubResult = await scrubTask;\n    const trackFragmentIndexes: Record<number, TrackFragmentIndex> = { ...webmIndex };\n    if (scrubResult) Object.assign(trackFragmentIndexes, scrubResult);\n    return trackFragmentIndexes;\n  }\n\n  // ── Standard MP4 path ────────────────────────────────────────────────────\n  log(`Generating track fragment index for ${absolutePath} using single-track approach`);\n\n  const trackTasks = probe.streams\n    .map((stream, streamIndex) => {\n      if (stream.codec_type !== \"audio\" && stream.codec_type !== \"video\") {\n        return null;\n      }\n      const trackId = streamIndex + 1;\n      log(`Processing track ${trackId} (${stream.codec_type})`);\n      const trackStream = probe.createTrackReadstream(streamIndex);\n      const trackIdMapping = { 0: trackId };\n      return generateFragmentIndex(trackStream, startTimeOffsetMs, trackIdMapping);\n    })\n    .filter((task): task is Promise<Record<number, TrackFragmentIndex>> => task !== null);\n\n  const scrubTask: Promise<Record<number, TrackFragmentIndex> | null> =\n    probe.videoStreams.length > 0\n      ? (async () => {\n          try {\n            log(\"Generating scrub track fragment index\");\n            const scrubStream = probe.createScrubTrackReadstream();\n            const result = await generateFragmentIndex(scrubStream, startTimeOffsetMs, { 0: -1 });\n            log(\"Scrub track fragment index generated successfully\");\n            return result;\n          } catch (error) {\n            log(`Failed to generate scrub track fragment index: ${error}`);\n            return null;\n          }\n        })()\n      : Promise.resolve(null);\n\n  const [trackResults, scrubResult] = await Promise.all([Promise.all(trackTasks), scrubTask]);\n\n  const trackFragmentIndexes: Record<number, TrackFragmentIndex> = {};\n  for (const result of trackResults) {\n    Object.assign(trackFragmentIndexes, result);\n  }\n  if (scrubResult) {\n    Object.assign(trackFragmentIndexes, scrubResult);\n  }\n\n  return trackFragmentIndexes;\n};\n\nconst generateTrackFragmentIndexTask = idempotentTask({\n  label: \"trackFragmentIndex\",\n  filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,\n  runner: async (absolutePath: string) => {\n    const index = await generateTrackFragmentIndexFromPath(absolutePath);\n    return JSON.stringify(index, null, 2);\n  },\n});\n\nexport const generateTrackFragmentIndex = async (cacheRoot: string, absolutePath: string) => {\n  try {\n    return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);\n  } catch (error) {\n    console.trace(\"Error generating track fragment index\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;;;;AAQA,MAAa,qCAAqC,OAAO,iBAAyB;CAChF,MAAM,yBAAY,2BAA2B;CAC7C,MAAM,QAAQ,MAAMA,oBAAM,UAAU,aAAa;CAEjD,MAAM,oBAAoB,MAAM;AAChC,KAAI,sBAAsB,OACxB,KAAI,gCAAgC,kBAAkB,IAAI;KAE1D,KAAI,2EAA2E;AAOjF,KAAI,MAAM,eAAe;AACvB,MAAI,4DAA4D;EAChE,MAAM,YAAY,MAAMC,0DAAyB,cAAc,kBAAkB;EAgBjF,MAAMC,gBAAc,OAbmD,YAAY;AACjF,OAAI;AACF,QAAI,uDAAuD;IAE3D,MAAM,SAAS,MAAMC,oDADD,MAAM,4BAA4B,EACE,mBAAmB,EAAE,GAAG,IAAI,CAAC;AACrF,QAAI,oDAAoD;AACxD,WAAO;YACA,OAAO;AACd,QAAI,kDAAkD,QAAQ;AAC9D,WAAO;;MAEP;EAGJ,MAAMC,yBAA2D,EAAE,GAAG,WAAW;AACjF,MAAIF,cAAa,QAAO,OAAOG,wBAAsBH,cAAY;AACjE,SAAOG;;AAIT,KAAI,uCAAuC,aAAa,8BAA8B;CAEtF,MAAM,aAAa,MAAM,QACtB,KAAK,QAAQ,gBAAgB;AAC5B,MAAI,OAAO,eAAe,WAAW,OAAO,eAAe,QACzD,QAAO;EAET,MAAM,UAAU,cAAc;AAC9B,MAAI,oBAAoB,QAAQ,IAAI,OAAO,WAAW,GAAG;AAGzD,SAAOF,oDAFa,MAAM,sBAAsB,YAAY,EAElB,mBADnB,EAAE,GAAG,SAAS,CACuC;GAC5E,CACD,QAAQ,SAA8D,SAAS,KAAK;CAEvF,MAAMG,YACJ,MAAM,aAAa,SAAS,KACvB,YAAY;AACX,MAAI;AACF,OAAI,wCAAwC;GAE5C,MAAM,SAAS,MAAMH,oDADD,MAAM,4BAA4B,EACE,mBAAmB,EAAE,GAAG,IAAI,CAAC;AACrF,OAAI,oDAAoD;AACxD,UAAO;WACA,OAAO;AACd,OAAI,kDAAkD,QAAQ;AAC9D,UAAO;;KAEP,GACJ,QAAQ,QAAQ,KAAK;CAE3B,MAAM,CAAC,cAAc,eAAe,MAAM,QAAQ,IAAI,CAAC,QAAQ,IAAI,WAAW,EAAE,UAAU,CAAC;CAE3F,MAAMC,uBAA2D,EAAE;AACnE,MAAK,MAAM,UAAU,aACnB,QAAO,OAAO,sBAAsB,OAAO;AAE7C,KAAI,YACF,QAAO,OAAO,sBAAsB,YAAY;AAGlD,QAAO;;AAGT,MAAM,iCAAiCG,sCAAe;CACpD,OAAO;CACP,WAAW,iBAAiB,2BAAY,aAAa,CAAC;CACtD,QAAQ,OAAO,iBAAyB;EACtC,MAAM,QAAQ,MAAM,mCAAmC,aAAa;AACpE,SAAO,KAAK,UAAU,OAAO,MAAM,EAAE;;CAExC,CAAC;AAEF,MAAa,6BAA6B,OAAO,WAAmB,iBAAyB;AAC3F,KAAI;AACF,SAAO,MAAM,+BAA+B,WAAW,aAAa;UAC7D,OAAO;AACd,UAAQ,MAAM,yCAAyC,MAAM;AAC7D,QAAM"}

package/dist/tasks/generateTrackFragmentIndex.js

@@ -1,6 +1,7 @@
 import { Probe } from "../Probe.js";
 import { generateFragmentIndex } from "../generateFragmentIndex.js";
 import { idempotentTask } from "../idempotentTask.js";
+import { generateWebmSegmentIndex } from "../generateWebmSegmentIndex.js";
 import debug from "debug";
 import { basename } from "node:path";
 
@@ -11,6 +12,24 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
 	const startTimeOffsetMs = probe.startTimeOffsetMs;
 	if (startTimeOffsetMs !== void 0) log(`Extracted start_time offset: ${startTimeOffsetMs}ms`);
 	else log("No format/stream timing offset found - will detect from composition time");
+	if (probe.hasAlphaVideo) {
+		log(`VP9 alpha WebM: using EBML cluster index (no transcoding)`);
+		const webmIndex = await generateWebmSegmentIndex(absolutePath, startTimeOffsetMs);
+		const scrubResult$1 = await (async () => {
+			try {
+				log("Generating scrub track fragment index for alpha WebM");
+				const result = await generateFragmentIndex(probe.createScrubTrackReadstream(), startTimeOffsetMs, { 0: -1 });
+				log("Scrub track fragment index generated successfully");
+				return result;
+			} catch (error) {
+				log(`Failed to generate scrub track fragment index: ${error}`);
+				return null;
+			}
+		})();
+		const trackFragmentIndexes$1 = { ...webmIndex };
+		if (scrubResult$1) Object.assign(trackFragmentIndexes$1, scrubResult$1);
+		return trackFragmentIndexes$1;
+	}
 	log(`Generating track fragment index for ${absolutePath} using single-track approach`);
 	const trackTasks = probe.streams.map((stream, streamIndex) => {
 		if (stream.codec_type !== "audio" && stream.codec_type !== "video") return null;
@@ -21,9 +40,7 @@ const generateTrackFragmentIndexFromPath = async (absolutePath) => {
 	const scrubTask = probe.videoStreams.length > 0 ? (async () => {
 		try {
 			log("Generating scrub track fragment index");
-			const scrubStream = probe.createScrubTrackReadstream();
-			const scrubTrackId = -1;
-			const result = await generateFragmentIndex(scrubStream, startTimeOffsetMs, { 0: scrubTrackId });
+			const result = await generateFragmentIndex(probe.createScrubTrackReadstream(), startTimeOffsetMs, { 0: -1 });
 			log("Scrub track fragment index generated successfully");
 			return result;
 		} catch (error) {