@camstack/addon-pipeline 1.1.23 → 1.1.25

package/dist/recorder/index.js

@@ -1,5 +1,6 @@
-const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-BnQ_awK4.js");
-const require_dist = require("../dist-CE3a05qT.js");
+const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-DxM2DSns.js");
+const require_dist = require("../dist-wzWBZ26C.js");
+const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_model_download_service_C_IHWnXx.__toESM(node_path);
@@ -206,7 +207,7 @@ var RecordingIndex = class {
 };
 //#endregion
 //#region src/recorder/segment-store.ts
-var SegmentStore = class {
+var SegmentStore = class SegmentStore {
 	deps;
 	constructor(deps) {
 		this.deps = deps;
@@ -253,23 +254,68 @@ var SegmentStore = class {
 	* `location` (`row.locationId === location`) — the caller guarantees this (e.g. the evictable
 	* provider feeds rows from `segmentsOnLocation(location)`). Mixed-location rows would be deleted
 	* against the wrong location.
+	*
+	* Bucket-granular fast path (R4): rows are grouped by their hour-bucket dir
+	* (`<dev>/<profile>/Y/M/D/H`). When a group covers EVERY indexed segment of
+	* its bucket — and the bucket's hour is fully in the past, so no relocate can
+	* still land in it (in-flight staging lives in the separate `.rec-tmp`) — the
+	* whole dir goes with ONE `removeDir` instead of hundreds of per-file
+	* deletes. Partial buckets, current-hour buckets, and a failed removeDir fall
+	* back to the per-file `storage.delete` loop.
 	*/
 	async evict(location, rows) {
 		let reclaimed = 0;
 		const removed = [];
-		for (const r of rows) try {
-			await this.deps.deletePath({
-				location,
-				relativePath: r.path
-			});
-			removed.push(r.path);
-			reclaimed += r.bytes;
-		} catch (err) {
-			this.deps.logger.warn("segment delete failed", err);
+		const byBucket = /* @__PURE__ */ new Map();
+		for (const r of rows) {
+			const cut = r.path.lastIndexOf("/");
+			const bucketDir = cut > 0 ? r.path.slice(0, cut) : "";
+			const group = byBucket.get(bucketDir);
+			if (group) group.push(r);
+			else byBucket.set(bucketDir, [r]);
+		}
+		for (const [bucketDir, bucketRows] of byBucket) {
+			if (bucketDir !== "" && this.bucketFullyEvicted(bucketDir, bucketRows)) try {
+				await this.deps.removeDir(location, bucketDir);
+				for (const r of bucketRows) {
+					removed.push(r.path);
+					reclaimed += r.bytes;
+				}
+				continue;
+			} catch (err) {
+				this.deps.logger.warn("bucket removeDir failed — falling back to per-file deletes", err);
+			}
+			for (const r of bucketRows) try {
+				await this.deps.deletePath({
+					location,
+					relativePath: r.path
+				});
+				removed.push(r.path);
+				reclaimed += r.bytes;
+			} catch (err) {
+				this.deps.logger.warn("segment delete failed", err);
+			}
 		}
 		if (removed.length > 0) this.deps.index.removeSegments(removed);
 		return reclaimed;
 	}
+	/** Hour of one UTC hour-bucket in ms. */
+	static HOUR_MS = 36e5;
+	/**
+	* True when `victims` cover EVERY indexed segment of `bucketDir` AND the
+	* bucket's hour has fully elapsed. The current-hour guard matters because
+	* `onFinalized` relocates new segments INTO the current bucket concurrently —
+	* an rm racing that rename would orphan a just-indexed segment.
+	*/
+	bucketFullyEvicted(bucketDir, victims) {
+		const first = victims[0];
+		if (!first) return false;
+		const bucketStartMs = Math.floor(first.startMs / SegmentStore.HOUR_MS) * SegmentStore.HOUR_MS;
+		if ((this.deps.now?.() ?? Date.now()) < bucketStartMs + SegmentStore.HOUR_MS) return false;
+		const victimPaths = new Set(victims.map((v) => v.path));
+		const indexed = this.deps.index.segments(first.deviceId, first.profile).filter((s) => s.path.startsWith(`${bucketDir}/`));
+		return indexed.length === victimPaths.size && indexed.every((s) => victimPaths.has(s.path));
+	}
 };
 //#endregion
 //#region src/recorder/evict-select.ts
@@ -471,6 +517,129 @@ function subscribeEventCapture(deps) {
 	});
 }
 //#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). */
+function* boxes(bytes, start, end) {
+	let off = start;
+	while (off + 8 <= end) {
+		const view = new DataView(bytes.buffer, bytes.byteOffset + off);
+		let size = view.getUint32(0);
+		let headerLen = 8;
+		if (size === 1) {
+			if (off + 16 > end) return;
+			const large = view.getBigUint64(8);
+			if (large > BigInt(Number.MAX_SAFE_INTEGER)) return;
+			size = Number(large);
+			headerLen = 16;
+		} else if (size === 0) size = end - off;
+		if (size < headerLen) return;
+		const boxEnd = off + size;
+		if (boxEnd > end) return;
+		yield {
+			type: String.fromCharCode(bytes[off + 4], bytes[off + 5], bytes[off + 6], bytes[off + 7]),
+			payloadStart: off + headerLen,
+			payloadEnd: boxEnd
+		};
+		off = boxEnd;
+	}
+}
+/** First child box with `type` inside a payload window, or null. */
+function findBox(bytes, start, end, type) {
+	for (const b of boxes(bytes, start, end)) if (b.type === type) return b;
+	return null;
+}
+/** Descend a container-box path (`moov/trak/mdia/…`), or null when broken. */
+function descend(bytes, path) {
+	let start = 0;
+	let end = bytes.length;
+	let cur = null;
+	for (const type of path) {
+		cur = findBox(bytes, start, end, type);
+		if (!cur) return null;
+		start = cur.payloadStart;
+		end = cur.payloadEnd;
+	}
+	return cur;
+}
+/** VisualSampleEntry fixed fields before its child boxes: 6 reserved + 2
+*  data_reference_index + 70 bytes (pre_defined/width/height/…/depth). */
+var VISUAL_SAMPLE_ENTRY_FIXED_BYTES = 78;
+/** stsd FullBox payload head: version(1) + flags(3) + entry_count(4). */
+var STSD_HEAD_BYTES = 8;
+var hex2 = (n) => n.toString(16).padStart(2, "0");
+/** `avc1.PPCCLL` from the avcC payload (profile, constraint flags, level). */
+function avcCodecString(bytes, avcC) {
+	if (avcC.payloadEnd - avcC.payloadStart < 4) return void 0;
+	const p = avcC.payloadStart;
+	return `avc1.${hex2(bytes[p + 1])}${hex2(bytes[p + 2])}${hex2(bytes[p + 3])}`;
+}
+/** Reverse the bit order of a 32-bit value (HEVC general_profile_compatibility
+*  flags are written MSB-first but the codec string wants them reversed). */
+function reverseBits32(v) {
+	let out = 0;
+	for (let i = 0; i < 32; i++) out = out << 1 | v >>> i & 1;
+	return out >>> 0;
+}
+/** ISO/IEC 14496-15 Annex E HEVC codec string from the hvcC payload. The
+*  prefix is the SAMPLE ENTRY code (`hvc1` vs `hev1` — they differ in
+*  parameter-set placement, which players honour). */
+function hevcCodecString(bytes, entryType, hvcC) {
+	if (hvcC.payloadEnd - hvcC.payloadStart < 13) return void 0;
+	const p = hvcC.payloadStart;
+	const byte1 = bytes[p + 1];
+	const profileSpace = byte1 >> 6 & 3;
+	const tier = byte1 >> 5 & 1;
+	const profileIdc = byte1 & 31;
+	const compat = new DataView(bytes.buffer, bytes.byteOffset + p + 2).getUint32(0);
+	const levelIdc = bytes[p + 12];
+	const spacePrefix = profileSpace === 0 ? "" : String.fromCharCode(64 + profileSpace);
+	const compatHex = reverseBits32(compat).toString(16).toUpperCase();
+	let constraints = "";
+	for (let i = 5; i >= 0; i--) {
+		const b = bytes[p + 6 + i];
+		if (b !== 0 || constraints !== "") constraints = `.${b.toString(16).toUpperCase().padStart(2, "0")}${constraints}`;
+	}
+	return `${entryType}.${spacePrefix}${profileIdc}.${compatHex}.${tier === 0 ? "L" : "H"}${levelIdc}${constraints}`;
+}
+/** Sample-entry codes the probe recognizes, mapped to their config-box type. */
+var VIDEO_SAMPLE_ENTRIES = {
+	avc1: "avcC",
+	avc3: "avcC",
+	hvc1: "hvcC",
+	hev1: "hvcC"
+};
+/**
+* Walk an fMP4 fragment's moov for the first recognized video sample entry
+* (avc1/avc3 → avcC, hvc1/hev1 → hvcC) and build its RFC 6381 codec string.
+* Accepts a bounded PREFIX of the fragment (the moov leads the file). Returns
+* `undefined` for anything malformed, truncated, or unrecognized.
+*/
+function codecStringFromFragment(bytes) {
+	const moov = descend(bytes, ["moov"]);
+	if (!moov) return void 0;
+	for (const trak of boxes(bytes, moov.payloadStart, moov.payloadEnd)) {
+		if (trak.type !== "trak") continue;
+		let cur = trak;
+		for (const type of [
+			"mdia",
+			"minf",
+			"stbl",
+			"stsd"
+		]) cur = cur ? findBox(bytes, cur.payloadStart, cur.payloadEnd, type) : null;
+		if (!cur) continue;
+		const entriesStart = cur.payloadStart + STSD_HEAD_BYTES;
+		for (const entry of boxes(bytes, entriesStart, cur.payloadEnd)) {
+			const configType = VIDEO_SAMPLE_ENTRIES[entry.type];
+			if (!configType) continue;
+			const config = findBox(bytes, entry.payloadStart + VISUAL_SAMPLE_ENTRY_FIXED_BYTES, entry.payloadEnd, configType);
+			if (!config) continue;
+			const codec = configType === "avcC" ? avcCodecString(bytes, config) : hevcCodecString(bytes, entry.type, config);
+			if (codec) return codec;
+		}
+	}
+}
+//#endregion
 //#region src/recorder/day-bucket.ts
 /** Pure helpers to bucket recording segment starts into local calendar days. */
 var DAY_MS$1 = 1440 * 60 * 1e3;
@@ -674,6 +843,42 @@ function noPlayback(deviceId) {
 function playbackDirFor(dataDir, deviceId) {
 	return node_path.default.join(dataDir, "playback", String(deviceId));
 }
+/** Prefix window the CODECS probe reads — the fragment's moov (with its
+*  avcC/hvcC) leads the file and is ~1-2KB, so 64KB is a generous bound. */
+var PROBE_PREFIX_BYTES = 65536;
+/** Default bounded prefix reader: `fs.open` + one positioned `read`, never the
+*  whole file. */
+async function readPrefixFromDisk(absPath, maxBytes) {
+	const fh = await node_fs.promises.open(absPath, "r");
+	try {
+		const buf = Buffer.alloc(maxBytes);
+		const { bytesRead } = await fh.read(buf, 0, maxBytes, 0);
+		return buf.subarray(0, bytesRead);
+	} finally {
+		await fh.close();
+	}
+}
+/**
+* RFC 6381 codec string for one variant: probe the first PRESENT fragment's
+* moov once and cache the result. Failures (unreadable file / unrecognized
+* bytes) return `undefined` — the playlist then omits `CODECS` for that
+* variant, exactly today's behaviour — and are NOT cached, so a later healthy
+* fragment can still populate it.
+*/
+async function probeVariantCodec(readPrefix, cache, deviceId, profile, firstPresentAbs) {
+	const key = `${deviceId}/${profile}`;
+	const cached = cache.get(key);
+	if (cached !== void 0) return cached;
+	if (firstPresentAbs === null) return void 0;
+	try {
+		const prefix = await readPrefix(firstPresentAbs, PROBE_PREFIX_BYTES);
+		const codec = codecStringFromFragment(prefix instanceof Uint8Array ? prefix : new Uint8Array(prefix));
+		if (codec !== void 0) cache.set(key, codec);
+		return codec;
+	} catch {
+		return;
+	}
+}
 /**
 * Build a master + per-profile variant HLS playlist on disk for the requested
 * window and return a RELATIVE playback URL through the hub's data-plane
@@ -683,9 +888,10 @@ function playbackDirFor(dataDir, deviceId) {
 * URIs are relative so the master + variants + segments form a self-contained
 * tree the player resolves against the master URL.
 */
-async function buildPlaybackManifest(deps, deviceId, fromMs, toMs) {
+async function buildPlaybackManifest(deps, codecCache, deviceId, fromMs, toMs) {
 	const base = deps.playbackBaseUrl();
 	if (base === null) return noPlayback(deviceId);
+	const readPrefix = deps.readFilePrefix ?? readPrefixFromDisk;
 	const rootById = new Map(deps.locations().map((l) => [l.id, l.root]));
 	const playbackDir = playbackDirFor(deps.dataDir, deviceId);
 	const profiles = [...new Set(deps.index.segments(deviceId).map((s) => s.profile))];
@@ -694,15 +900,18 @@ async function buildPlaybackManifest(deps, deviceId, fromMs, toMs) {
 		const segs = deps.index.segments(deviceId, profile).filter((s) => s.startMs < toMs && s.startMs + s.durMs > fromMs).toSorted((a, b) => a.startMs - b.startMs);
 		if (segs.length === 0) continue;
 		const variantSegments = [];
+		let firstPresentAbs = null;
 		for (const s of segs) {
 			const rel = segmentRelPath(deviceId, profile, s.startMs, s.durMs, s.bytes);
 			const root = rootById.get(s.locationId);
 			if (root === void 0) continue;
+			const abs = node_path.default.join(root, rel);
 			try {
-				await node_fs.promises.stat(node_path.default.join(root, rel));
+				await node_fs.promises.stat(abs);
 			} catch {
 				continue;
 			}
+			if (firstPresentAbs === null) firstPresentAbs = abs;
 			variantSegments.push({
 				uri: rel.split("/").slice(1).join("/"),
 				startMs: s.startMs,
@@ -710,12 +919,14 @@ async function buildPlaybackManifest(deps, deviceId, fromMs, toMs) {
 			});
 		}
 		if (variantSegments.length === 0) continue;
+		const codecs = await probeVariantCodec(readPrefix, codecCache, deviceId, profile, firstPresentAbs);
 		await node_fs.promises.mkdir(playbackDir, { recursive: true });
 		await node_fs.promises.writeFile(node_path.default.join(playbackDir, `${profile}.m3u8`), buildVariantPlaylist(variantSegments), "utf8");
 		variants.push({
 			profile,
 			bandwidth: PROFILE_BANDWIDTH[profile] ?? DEFAULT_BANDWIDTH,
-			uri: `${profile}.m3u8`
+			uri: `${profile}.m3u8`,
+			...codecs !== void 0 ? { codecs } : {}
 		});
 	}
 	if (variants.length === 0) return noPlayback(deviceId);
@@ -757,6 +968,7 @@ function segmentsByLocation(rows) {
 */
 function buildRecordingProvider(deps) {
 	const readFile = deps.readFile ?? ((absPath) => node_fs.promises.readFile(absPath));
+	const codecCache = /* @__PURE__ */ new Map();
 	return {
 		getStatus: async ({ deviceId }) => {
 			return statusFor(deps, deviceId, await loadDeviceConfig(deps.configStore, deviceId));
@@ -777,7 +989,7 @@ function buildRecordingProvider(deps) {
 				days: distinctRecordingDays(deps.index.segments(deviceId).map((s) => s.startMs), fromMs, toMs, tzOffsetMinutes)
 			};
 		},
-		getPlaybackManifest: ({ deviceId, fromMs, toMs }) => buildPlaybackManifest(deps, deviceId, fromMs, toMs),
+		getPlaybackManifest: ({ deviceId, fromMs, toMs }) => buildPlaybackManifest(deps, codecCache, deviceId, fromMs, toMs),
 		getStorageUsage: async () => {
 			const locations = deps.locations();
 			const devices = [];
@@ -1447,6 +1659,15 @@ var SegmentWriter = class {
 var DEFAULT_WATCH_INTERVAL_MS = 2e3;
 /** Periodic re-evaluation to catch band boundaries crossed with no config change. */
 var TICK_MS = 3e4;
+/**
+* Staging dir name, created UNDER each recordings location root
+* (`<locationRoot>/.rec-tmp/<deviceId>/<profile>`). Per-location staging means
+* the rec-tmp→final relocate is ALWAYS a same-filesystem rename — never the
+* EXDEV copy+unlink fallback that rewrites every segment (2x disk writes, F1).
+* The leading dot keeps it out of the recorder's own hydrate walk (which only
+* descends `<root>/<deviceId>/`) and `parseSegmentPath` (digits-first layout).
+*/
+var STAGING_DIR_NAME = ".rec-tmp";
 var RecordingController = class {
 	deps;
 	active = /* @__PURE__ */ new Map();
@@ -1645,11 +1866,13 @@ var RecordingController = class {
 		return selected.length > 0 ? selected : assigned;
 	}
 	/**
-	* Attach one (device, profile): acquire the broker source, mkdir the temp
-	* outDir, spawn the SegmentWriter, and start the watcher that feeds finalized
-	* flat segments into `SegmentStore.onFinalized`.
+	* Attach one (device, profile): acquire the broker source, mkdir the staging
+	* outDir UNDER the profile's placement root (same-fs relocate — see
+	* {@link STAGING_DIR_NAME}), spawn the SegmentWriter, and start the watcher
+	* that feeds finalized flat segments into `SegmentStore.onFinalized`.
 	*/
 	async attachProfile(deviceId, profile, segmentSeconds) {
+		const placement = this.resolvePlacement(profile);
 		const source = await this.deps.brokerCall(() => this.deps.api.streamBroker.getStreamWithCodec.mutate({
 			deviceId,
 			video: "copy",
@@ -1658,7 +1881,7 @@ var RecordingController = class {
 			...this.deps.consumerHostname !== void 0 ? { hostname: this.deps.consumerHostname } : {},
 			tag: `recorder:${deviceId}/${profile}`
 		}));
-		const outDir = node_path.default.join(this.deps.tmpRoot, String(deviceId), profile);
+		const outDir = node_path.default.join(placement.root, STAGING_DIR_NAME, String(deviceId), profile);
 		await node_fs.promises.mkdir(outDir, { recursive: true });
 		const writer = new SegmentWriter({
 			rtspUrl: source.url,
@@ -1672,7 +1895,6 @@ var RecordingController = class {
 			}
 		});
 		writer.start();
-		const placement = this.resolvePlacement(profile);
 		return {
 			profile,
 			writer,
@@ -1797,44 +2019,14 @@ function makeBrokerCall(handle) {
 * Resolve the host a REMOTE recording node should use to dial the hub-only
 * stream-broker's restream port.
 *
-* The broker mints `127.0.0.1` restream URLs (hub-local). When the operator
-* designates an AGENT as the recording node, that agent's recorder must pull
-* from the hub, so it needs the hub's cluster-resolvable host. Resolution
-* order:
-*
-*   1. `override` — the `recordingHubHostname` global setting, when the
-*      operator set one explicitly (e.g. the auto-derived host isn't reachable
-*      for RTSP on the recording interface).
-*   2. `hubUrl` — derived from the agent's `CAMSTACK_HUB_URL` (the address it
-*      already uses to reach the hub). The RTSP restream port differs from the
-*      hub API port, but the HOST is the same — only the host is extracted.
-*
-* Returns `undefined` when neither yields a host (the caller logs and the pull
-* stays hub-local, which simply won't reach a remote node — never a crash).
-*
-* Pure: the env string is passed in (not read here) so it can be unit-tested.
+* The implementation was promoted to the package-shared
+* `src/shared/hub-hostname.ts` in P2d (cross-node Phase 2) so the
+* pipeline-runner's remote-source leg shares the exact same resolver instead
+* of copying it. This module keeps the recorder-facing name as a thin alias —
+* resolution order and semantics are unchanged (operator override first, then
+* the host extracted from `CAMSTACK_HUB_URL`).
 */
-function resolveRecordingHubHostname(override, hubUrl) {
-	const trimmedOverride = override?.trim();
-	if (trimmedOverride !== void 0 && trimmedOverride.length > 0) return trimmedOverride;
-	return extractHost(hubUrl);
-}
-/** Extract the bare host from a URL/authority string, scheme + port optional. */
-function extractHost(raw) {
-	const value = raw?.trim();
-	if (value === void 0 || value.length === 0) return void 0;
-	try {
-		const parsed = new URL(value);
-		if (parsed.hostname.length > 0) return parsed.hostname;
-	} catch {}
-	const authority = value.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//, "").split("/")[0] ?? "";
-	if (authority.startsWith("[")) {
-		const end = authority.indexOf("]");
-		if (end > 0) return authority.slice(0, end + 1);
-	}
-	const host = authority.split(":")[0] ?? "";
-	return host.length > 0 ? host : void 0;
-}
+var resolveRecordingHubHostname = require_hub_hostname.resolveHubHostname;
 //#endregion
 //#region src/recorder/addon/index.ts
 /**
@@ -1861,13 +2053,18 @@ function extractHost(raw) {
 * file ships dormant (separate tree, not wired into the manifest yet).
 */
 var DEFAULT_CONFIG = {
-	segmentSeconds: 4,
+	segmentSeconds: 10,
 	watchIntervalMs: 2e3
 };
 /** Playback-marker window padding around a motion event (EventMap only; the
-*  controller's events-band gating uses the raw trigger ms, not this pad). */
-var MARKER_PAD_PRE_MS = 2e3;
-var MARKER_PAD_POST_MS = 5e3;
+*  controller's events-band gating uses the raw trigger ms, not this pad).
+*  Derived from the SHARED `EVENT_PAD_MS` (R5/C1): markers are ephemeral
+*  in-RAM and consumed by nothing today, but aligning their window with the
+*  canonical clip pad means that IF they are ever surfaced, their boundaries
+*  match the videoclips/admin-ui clip window for the same event — one pad
+*  convention, not three. */
+var MARKER_PAD_PRE_MS = require_dist.EVENT_PAD_MS.preMs;
+var MARKER_PAD_POST_MS = require_dist.EVENT_PAD_MS.postMs;
 /** This addon's manifest id + the playback data-plane prefix — together they
 *  form the hub reverse-proxy client path `/addon/recorder/playback`. */
 var RECORDER_ADDON_ID = "recorder";
@@ -1940,11 +2137,17 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 					await node_fs.promises.unlink(fromAbs);
 				}
 			},
+			removeDir: async (locationId, relDir) => {
+				const loc = this.resolvedLocations.find((l) => l.id === locationId);
+				if (!loc) throw new Error(`recorder: unknown recordings location ${locationId}`);
+				await node_fs.promises.rm(node_path.default.join(loc.root, relDir), {
+					recursive: true,
+					force: true
+				});
+			},
 			logger: { warn: (message, extras) => this.ctx.logger.warn(message, { meta: { extras } }) }
 		};
 		this.segmentStore = new SegmentStore(segmentStoreDeps);
-		const mediaRoot = process.env.CAMSTACK_MEDIA_ROOT?.trim();
-		const tmpRoot = node_path.default.join(mediaRoot ?? this.ctx.dataDir, "rec-tmp");
 		const brokerHandle = this.ctx.useCapability("stream-broker", brokerScope(BROKER_HOST_NODE_ID));
 		this.controller = new RecordingController({
 			api: this.ctx.api,
@@ -1954,7 +2157,6 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			loadConfig: (deviceId) => loadDeviceConfig(this.configStore(), deviceId),
 			enabledDeviceIds: async () => [...(await readDeviceConfigs(this.configStore())).keys()],
 			locations: () => this.resolvedLocations,
-			tmpRoot,
 			spawn: node_child_process.spawn,
 			segmentSeconds: this.config.segmentSeconds,
 			watchIntervalMs: this.config.watchIntervalMs,