@camstack/addon-pipeline 1.2.43 → 1.2.44

package/dist/recorder/index.js

@@ -1,5 +1,5 @@
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-UHbKZiSa.js");
+const require_dist = require("../dist-BuFE5rOK.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_model_download_service_D8B_4ktF = require("../model-download-service-D8B-4ktF-7-YxE9Wx.js");
 let node_crypto = require("node:crypto");
@@ -955,6 +955,34 @@ function parseMfra(tail, fileSize, opts = {}) {
 		trackId
 	};
 }
+/**
+* The byte range of the fragment covering `offsetTicks`, and the index of the
+* sync sample chosen.
+*
+* `end` is the START of the next fragment (exclusive), or the start of `mfra`
+* for the last one — never the end of the file, which would drag the index
+* bytes along with every final-GOP fetch.
+*/
+function fragmentRangeFor(index, offsetTicks) {
+	const { samples, mfraOffset } = index;
+	let lo = 0;
+	let hi = samples.length - 1;
+	let chosen = 0;
+	while (lo <= hi) {
+		const mid = lo + hi >> 1;
+		const s = samples[mid];
+		if (s === void 0) break;
+		if (s.timeTicks <= offsetTicks) {
+			chosen = mid;
+			lo = mid + 1;
+		} else hi = mid - 1;
+	}
+	return {
+		start: samples[chosen]?.moofOffset ?? 0,
+		end: samples[chosen + 1]?.moofOffset ?? mfraOffset,
+		sampleIndex: chosen
+	};
+}
 //#endregion
 //#region src/recorder/mfra-capture.ts
 /**
@@ -1760,6 +1788,105 @@ function subscribeEventCapture(deps) {
 	});
 }
 //#endregion
+//#region src/recorder/gop-range-read.ts
+/**
+* gop-range-read — serve ONE GOP of a recorded segment by byte range, resolved
+* through the segment's own `mfra` (D31's letter, applied to the D42 feeder
+* path).
+*
+* The recorded feeder scrubs at GOP granularity: a drag target needs the
+* fragment covering ONE instant, yet `readSegmentBytes` hands it the whole
+* file — 100–600 KB on `low` to serve a 41–173 KB GOP, and proportionally
+* worse on bigger profiles. This module reads exactly three ranges instead:
+* the `mfra` TAIL (the time→moof index `mfro` makes reachable from the end),
+* the `moov` HEAD (codec params — the decoder init), and the single
+* `moof`+`mdat` covering the requested instant. The returned bytes are
+* standalone-demuxable (`default_base_moof` makes fragment offsets
+* self-relative), so the feeder's demux consumes them exactly like a whole
+* segment. Net I/O is strictly LOWER than the whole-file read it replaces.
+*
+* PURE over an injected {@link RangeReadable}: no fs here, so the specs run
+* against a real captured segment with every read recorded — "never the whole
+* file" is asserted in bytes.
+*/
+/** Ticks → ms on the video timescale, rounded like the demux anchors samples. */
+function ticksToMs(ticks, timescale) {
+	return Math.round(ticks / timescale * 1e3);
+}
+/**
+* Read the single GOP covering `epochMs` from `file`, by byte range.
+*
+* Returns `null` when the bytes do not carry a usable `mfra`/`moov` — the
+* caller's answer to null is the whole-segment read, which is slow but
+* correct; guessing offsets would be fast and wrong. A parse failure is a
+* property of the FILE, so the caller may cache the null per segment.
+*/
+async function readGopRange(file, args) {
+	let bytesRead = 0;
+	const read = async (offset, length) => {
+		const chunk = await file.read(offset, length);
+		bytesRead += chunk.length;
+		return chunk;
+	};
+	const parsed = await parseTail(file, read);
+	if (parsed === null) return null;
+	const { tail, index } = parsed;
+	const firstMoof = index.samples[0]?.moofOffset ?? 0;
+	if (firstMoof <= 0 || firstMoof >= file.size) return null;
+	const head = await read(0, firstMoof);
+	const init = parseInitInfo(head);
+	if (init === null) return null;
+	const videoIndex = index.trackId === init.videoTrackId ? index : reparseTail(tail, file.size, init.videoTrackId);
+	if (videoIndex === null) return null;
+	const { start, end, sampleIndex } = fragmentRangeFor(videoIndex, Math.max(0, args.epochMs - args.segmentStartMs) / 1e3 * init.videoTimescale);
+	if (start <= 0 || end <= start || end > file.size) return null;
+	const fragment = await read(start, end - start);
+	const startTicks = videoIndex.samples[sampleIndex]?.timeTicks ?? 0;
+	const nextTicks = videoIndex.samples[sampleIndex + 1]?.timeTicks;
+	const gopStartOffsetMs = ticksToMs(startTicks, init.videoTimescale);
+	const gopDurMs = nextTicks !== void 0 ? ticksToMs(nextTicks - startTicks, init.videoTimescale) : Math.max(1, args.segmentDurMs - gopStartOffsetMs);
+	const data = new Uint8Array(head.length + fragment.length);
+	data.set(head, 0);
+	data.set(fragment, head.length);
+	return {
+		data,
+		gopStartMs: args.segmentStartMs + gopStartOffsetMs,
+		gopDurMs,
+		bytesRead
+	};
+}
+/**
+* Fetch + parse the `mfra` tail, honouring `MfraParseError.needBytes` with ONE
+* widened retry. Null on anything else — bytes that are not a segment.
+*/
+async function parseTail(file, read) {
+	let tailBytes = Math.min(DEFAULT_TAIL_BYTES, file.size);
+	for (let attempt = 0; attempt < 2; attempt++) {
+		const tail = await read(file.size - tailBytes, tailBytes);
+		try {
+			return {
+				tail,
+				index: parseMfra(tail, file.size)
+			};
+		} catch (err) {
+			if (err instanceof MfraParseError && err.needBytes && err.needBytes > tailBytes) {
+				tailBytes = Math.min(err.needBytes, file.size);
+				continue;
+			}
+			return null;
+		}
+	}
+	return null;
+}
+/** Re-parse an already-fetched tail for a specific track. Null when absent. */
+function reparseTail(tail, fileSize, trackId) {
+	try {
+		return parseMfra(tail, fileSize, { trackId });
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/recorder/codec-probe.ts
 /** Iterate the boxes fully contained in `bytes[start, end)`. Stops at the
 *  first malformed or truncated box (the probe only needs the front boxes). */
@@ -2360,6 +2487,34 @@ async function evictVictims(deps, deviceId, victims) {
 	};
 }
 /**
+* Resolve one indexed segment to its row + absolute path. Throws a clear error
+* when the segment or its location is unknown — shared by the whole-segment
+* and GOP byte-range reads so the two paths cannot drift on resolution.
+*/
+function resolveSegmentFile(deps, deviceId, profile, startMs) {
+	const seg = deps.index.segments(deviceId, profile).find((s) => s.startMs === startMs);
+	if (!seg) throw new Error(`recording: no segment at start ${startMs} for ${deviceId}/${profile}`);
+	const loc = deps.locations().find((l) => l.id === seg.locationId);
+	if (!loc) throw new Error(`recording: unknown location ${seg.locationId}`);
+	return {
+		seg,
+		abs: node_path.default.join(loc.root, seg.path)
+	};
+}
+/** Default ranged opener: ONE `fs.open` per GOP answer serving all its reads. */
+async function openRangeFromDisk(absPath, size) {
+	const handle = await node_fs.promises.open(absPath, "r");
+	return {
+		size,
+		read: async (offset, length) => {
+			const buf = Buffer.alloc(length);
+			const { bytesRead } = await handle.read(buf, 0, length, offset);
+			return Uint8Array.from(buf.subarray(0, bytesRead));
+		},
+		close: () => handle.close()
+	};
+}
+/**
 * Build the `IRecordingProvider`. The provider is a thin façade over the v2
 * core; all storage I/O flows through the injected deps.
 */
@@ -2472,13 +2627,41 @@ function buildRecordingProvider(deps) {
 			};
 		},
 		readSegmentBytes: async ({ deviceId, profile, startMs }) => {
-			const seg = deps.index.segments(deviceId, profile).find((s) => s.startMs === startMs);
-			if (!seg) throw new Error(`recording: no segment at start ${startMs} for ${deviceId}/${profile}`);
-			const loc = deps.locations().find((l) => l.id === seg.locationId);
-			if (!loc) throw new Error(`recording: unknown location ${seg.locationId}`);
-			const data = await readFile(node_path.default.join(loc.root, seg.path));
+			const { abs } = resolveSegmentFile(deps, deviceId, profile, startMs);
+			const data = await readFile(abs);
 			return { data: Uint8Array.from(data) };
 		},
+		readGopBytes: async ({ deviceId, profile, startMs, epochMs }) => {
+			const { abs, seg } = resolveSegmentFile(deps, deviceId, profile, startMs);
+			const file = await (deps.openRangeReadable ?? openRangeFromDisk)(abs, seg.bytes);
+			try {
+				const gop = await readGopRange(file, {
+					segmentStartMs: seg.startMs,
+					segmentDurMs: seg.durMs,
+					epochMs
+				});
+				if (gop !== null) return {
+					data: gop.data,
+					gopStartMs: gop.gopStartMs,
+					gopDurMs: gop.gopDurMs
+				};
+			} finally {
+				await file.close();
+			}
+			deps.logger.warn("recording: readGopBytes fell back to the WHOLE segment (mfra/moov unparseable)", {
+				tags: { deviceId },
+				meta: {
+					profile,
+					startMs
+				}
+			});
+			const data = await readFile(abs);
+			return {
+				data: Uint8Array.from(data),
+				gopStartMs: seg.startMs,
+				gopDurMs: seg.durMs
+			};
+		},
 		setDeviceConfig: async ({ deviceId, config }) => {
 			const saved = await saveDeviceConfig(deps.configStore, deviceId, config);
 			if (deps.onConfigChanged) try {

package/dist/recorder/index.mjs

@@ -1,4 +1,4 @@
-import { B as recordingExportCapability, D as deriveRecordingMode, H as storageEvictableCapability, K as errMsg, Q as hydrateSchema, X as DeviceType, at as selectAssignedProfileSlots, ct as array, f as ExportRecordSchema, gt as string, h as RecordingConfigSchema, ht as record, m as OpsLogEntrySchema, nt as nodePin, q as BaseAddon, u as EVENT_PAD_MS, vt as EventCategory, z as recordingCapability } from "../dist-B-VVBzrL.mjs";
+import { $ as storageEvictableCapability, Dt as string, Et as record, N as deriveRecordingMode, X as recordingExportCapability, Y as recordingCapability, _ as OpsLogEntrySchema, b as RecordingConfigSchema, d as EVENT_PAD_MS, gt as selectAssignedProfileSlots, it as BaseAddon, kt as EventCategory, lt as hydrateSchema, p as ExportRecordSchema, pt as nodePin, rt as errMsg, st as DeviceType, yt as array } from "../dist-DOu93i_g.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { n as createFileDataPlaneHandler, s as parseRangeHeader, t as contentTypeFor } from "../model-download-service-D8B-4ktF-BB7oZL3y.mjs";
 import { randomUUID } from "node:crypto";
@@ -953,6 +953,34 @@ function parseMfra(tail, fileSize, opts = {}) {
 		trackId
 	};
 }
+/**
+* The byte range of the fragment covering `offsetTicks`, and the index of the
+* sync sample chosen.
+*
+* `end` is the START of the next fragment (exclusive), or the start of `mfra`
+* for the last one — never the end of the file, which would drag the index
+* bytes along with every final-GOP fetch.
+*/
+function fragmentRangeFor(index, offsetTicks) {
+	const { samples, mfraOffset } = index;
+	let lo = 0;
+	let hi = samples.length - 1;
+	let chosen = 0;
+	while (lo <= hi) {
+		const mid = lo + hi >> 1;
+		const s = samples[mid];
+		if (s === void 0) break;
+		if (s.timeTicks <= offsetTicks) {
+			chosen = mid;
+			lo = mid + 1;
+		} else hi = mid - 1;
+	}
+	return {
+		start: samples[chosen]?.moofOffset ?? 0,
+		end: samples[chosen + 1]?.moofOffset ?? mfraOffset,
+		sampleIndex: chosen
+	};
+}
 //#endregion
 //#region src/recorder/mfra-capture.ts
 /**
@@ -1758,6 +1786,105 @@ function subscribeEventCapture(deps) {
 	});
 }
 //#endregion
+//#region src/recorder/gop-range-read.ts
+/**
+* gop-range-read — serve ONE GOP of a recorded segment by byte range, resolved
+* through the segment's own `mfra` (D31's letter, applied to the D42 feeder
+* path).
+*
+* The recorded feeder scrubs at GOP granularity: a drag target needs the
+* fragment covering ONE instant, yet `readSegmentBytes` hands it the whole
+* file — 100–600 KB on `low` to serve a 41–173 KB GOP, and proportionally
+* worse on bigger profiles. This module reads exactly three ranges instead:
+* the `mfra` TAIL (the time→moof index `mfro` makes reachable from the end),
+* the `moov` HEAD (codec params — the decoder init), and the single
+* `moof`+`mdat` covering the requested instant. The returned bytes are
+* standalone-demuxable (`default_base_moof` makes fragment offsets
+* self-relative), so the feeder's demux consumes them exactly like a whole
+* segment. Net I/O is strictly LOWER than the whole-file read it replaces.
+*
+* PURE over an injected {@link RangeReadable}: no fs here, so the specs run
+* against a real captured segment with every read recorded — "never the whole
+* file" is asserted in bytes.
+*/
+/** Ticks → ms on the video timescale, rounded like the demux anchors samples. */
+function ticksToMs(ticks, timescale) {
+	return Math.round(ticks / timescale * 1e3);
+}
+/**
+* Read the single GOP covering `epochMs` from `file`, by byte range.
+*
+* Returns `null` when the bytes do not carry a usable `mfra`/`moov` — the
+* caller's answer to null is the whole-segment read, which is slow but
+* correct; guessing offsets would be fast and wrong. A parse failure is a
+* property of the FILE, so the caller may cache the null per segment.
+*/
+async function readGopRange(file, args) {
+	let bytesRead = 0;
+	const read = async (offset, length) => {
+		const chunk = await file.read(offset, length);
+		bytesRead += chunk.length;
+		return chunk;
+	};
+	const parsed = await parseTail(file, read);
+	if (parsed === null) return null;
+	const { tail, index } = parsed;
+	const firstMoof = index.samples[0]?.moofOffset ?? 0;
+	if (firstMoof <= 0 || firstMoof >= file.size) return null;
+	const head = await read(0, firstMoof);
+	const init = parseInitInfo(head);
+	if (init === null) return null;
+	const videoIndex = index.trackId === init.videoTrackId ? index : reparseTail(tail, file.size, init.videoTrackId);
+	if (videoIndex === null) return null;
+	const { start, end, sampleIndex } = fragmentRangeFor(videoIndex, Math.max(0, args.epochMs - args.segmentStartMs) / 1e3 * init.videoTimescale);
+	if (start <= 0 || end <= start || end > file.size) return null;
+	const fragment = await read(start, end - start);
+	const startTicks = videoIndex.samples[sampleIndex]?.timeTicks ?? 0;
+	const nextTicks = videoIndex.samples[sampleIndex + 1]?.timeTicks;
+	const gopStartOffsetMs = ticksToMs(startTicks, init.videoTimescale);
+	const gopDurMs = nextTicks !== void 0 ? ticksToMs(nextTicks - startTicks, init.videoTimescale) : Math.max(1, args.segmentDurMs - gopStartOffsetMs);
+	const data = new Uint8Array(head.length + fragment.length);
+	data.set(head, 0);
+	data.set(fragment, head.length);
+	return {
+		data,
+		gopStartMs: args.segmentStartMs + gopStartOffsetMs,
+		gopDurMs,
+		bytesRead
+	};
+}
+/**
+* Fetch + parse the `mfra` tail, honouring `MfraParseError.needBytes` with ONE
+* widened retry. Null on anything else — bytes that are not a segment.
+*/
+async function parseTail(file, read) {
+	let tailBytes = Math.min(DEFAULT_TAIL_BYTES, file.size);
+	for (let attempt = 0; attempt < 2; attempt++) {
+		const tail = await read(file.size - tailBytes, tailBytes);
+		try {
+			return {
+				tail,
+				index: parseMfra(tail, file.size)
+			};
+		} catch (err) {
+			if (err instanceof MfraParseError && err.needBytes && err.needBytes > tailBytes) {
+				tailBytes = Math.min(err.needBytes, file.size);
+				continue;
+			}
+			return null;
+		}
+	}
+	return null;
+}
+/** Re-parse an already-fetched tail for a specific track. Null when absent. */
+function reparseTail(tail, fileSize, trackId) {
+	try {
+		return parseMfra(tail, fileSize, { trackId });
+	} catch {
+		return null;
+	}
+}
+//#endregion
 //#region src/recorder/codec-probe.ts
 /** Iterate the boxes fully contained in `bytes[start, end)`. Stops at the
 *  first malformed or truncated box (the probe only needs the front boxes). */
@@ -2358,6 +2485,34 @@ async function evictVictims(deps, deviceId, victims) {
 	};
 }
 /**
+* Resolve one indexed segment to its row + absolute path. Throws a clear error
+* when the segment or its location is unknown — shared by the whole-segment
+* and GOP byte-range reads so the two paths cannot drift on resolution.
+*/
+function resolveSegmentFile(deps, deviceId, profile, startMs) {
+	const seg = deps.index.segments(deviceId, profile).find((s) => s.startMs === startMs);
+	if (!seg) throw new Error(`recording: no segment at start ${startMs} for ${deviceId}/${profile}`);
+	const loc = deps.locations().find((l) => l.id === seg.locationId);
+	if (!loc) throw new Error(`recording: unknown location ${seg.locationId}`);
+	return {
+		seg,
+		abs: path.join(loc.root, seg.path)
+	};
+}
+/** Default ranged opener: ONE `fs.open` per GOP answer serving all its reads. */
+async function openRangeFromDisk(absPath, size) {
+	const handle = await promises.open(absPath, "r");
+	return {
+		size,
+		read: async (offset, length) => {
+			const buf = Buffer.alloc(length);
+			const { bytesRead } = await handle.read(buf, 0, length, offset);
+			return Uint8Array.from(buf.subarray(0, bytesRead));
+		},
+		close: () => handle.close()
+	};
+}
+/**
 * Build the `IRecordingProvider`. The provider is a thin façade over the v2
 * core; all storage I/O flows through the injected deps.
 */
@@ -2470,13 +2625,41 @@ function buildRecordingProvider(deps) {
 			};
 		},
 		readSegmentBytes: async ({ deviceId, profile, startMs }) => {
-			const seg = deps.index.segments(deviceId, profile).find((s) => s.startMs === startMs);
-			if (!seg) throw new Error(`recording: no segment at start ${startMs} for ${deviceId}/${profile}`);
-			const loc = deps.locations().find((l) => l.id === seg.locationId);
-			if (!loc) throw new Error(`recording: unknown location ${seg.locationId}`);
-			const data = await readFile(path.join(loc.root, seg.path));
+			const { abs } = resolveSegmentFile(deps, deviceId, profile, startMs);
+			const data = await readFile(abs);
 			return { data: Uint8Array.from(data) };
 		},
+		readGopBytes: async ({ deviceId, profile, startMs, epochMs }) => {
+			const { abs, seg } = resolveSegmentFile(deps, deviceId, profile, startMs);
+			const file = await (deps.openRangeReadable ?? openRangeFromDisk)(abs, seg.bytes);
+			try {
+				const gop = await readGopRange(file, {
+					segmentStartMs: seg.startMs,
+					segmentDurMs: seg.durMs,
+					epochMs
+				});
+				if (gop !== null) return {
+					data: gop.data,
+					gopStartMs: gop.gopStartMs,
+					gopDurMs: gop.gopDurMs
+				};
+			} finally {
+				await file.close();
+			}
+			deps.logger.warn("recording: readGopBytes fell back to the WHOLE segment (mfra/moov unparseable)", {
+				tags: { deviceId },
+				meta: {
+					profile,
+					startMs
+				}
+			});
+			const data = await readFile(abs);
+			return {
+				data: Uint8Array.from(data),
+				gopStartMs: seg.startMs,
+				gopDurMs: seg.durMs
+			};
+		},
 		setDeviceConfig: async ({ deviceId, config }) => {
 			const saved = await saveDeviceConfig(deps.configStore, deviceId, config);
 			if (deps.onConfigChanged) try {