@editframe/assets 0.47.0 → 0.47.2

package/dist/generateWebmSegmentIndex.cjs

@@ -0,0 +1,323 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_Probe = require('./Probe.cjs');
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
+
+//#region src/generateWebmSegmentIndex.ts
+const log = (0, debug.default)("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 require_Probe.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 (0, node_fs_promises.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 require_Probe.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 require_Probe.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
+exports.generateWebmSegmentIndex = generateWebmSegmentIndex;
+exports.patchWebmForSegmentedServing = patchWebmForSegmentedServing;
+//# sourceMappingURL=generateWebmSegmentIndex.cjs.map

package/dist/generateWebmSegmentIndex.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateWebmSegmentIndex.cjs","names":["clusters: ClusterInfo[]","PacketProbe","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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"}