@camstack/addon-pipeline 1.1.39 → 1.1.40

package/dist/session-decode/decode-worker-child.mjs

@@ -0,0 +1,510 @@
+import { n as isWorkerRequest } from "../worker-protocol-pk7qdYXt.mjs";
+//#region src/session-decode/frame-slot.ts
+function toReply(held) {
+	return {
+		frameId: held.frameId,
+		timestamp: held.timestamp,
+		width: held.width,
+		height: held.height
+	};
+}
+/**
+* Latest-wins decoded-frame slot + reserved-for-`toBuffer` holder +
+* pending-pull flag. One instance per decode-worker child session.
+*/
+var FrameSlot = class {
+	nextFrameId = 1;
+	slot = null;
+	/**
+	* The frame handed to the MOST RECENT `pull`, retained so a following
+	* `toBuffer(frameId)` still resolves even though `publish` keeps advancing
+	* the latest-wins `slot`. Freed when the next `pull` supersedes it (or on
+	* `free()`).
+	*/
+	reserved = null;
+	pendingPull = false;
+	/**
+	* Publish a newly decoded frame into the latest-wins slot, freeing
+	* whatever the slot held before (the drop-older half of "latest-wins").
+	* Returns the reply to send if a `pull` was pending (resolving it
+	* immediately and reserving the frame); otherwise returns `null` and the
+	* frame simply waits in the slot for the next `pull`.
+	*/
+	publish(frame, timestamp, minIntervalMs) {
+		if (minIntervalMs > 0 && this.slot && timestamp - this.slot.timestamp < minIntervalMs) {
+			frame.free();
+			return null;
+		}
+		const previous = this.slot;
+		const frameId = this.nextFrameId++;
+		this.slot = {
+			frameId,
+			frame,
+			timestamp,
+			width: frame.width,
+			height: frame.height
+		};
+		previous?.frame.free();
+		if (this.pendingPull) {
+			this.pendingPull = false;
+			return this.reserveSlot();
+		}
+		return null;
+	}
+	/**
+	* Hand out the newest slot frame and RESERVE it (freeing the previously
+	* reserved frame), clearing the slot. Returns `null` if no frame has been
+	* decoded yet — the caller should then call `markPendingPull()`.
+	*/
+	pull() {
+		if (!this.slot) return null;
+		return this.reserveSlot();
+	}
+	/** Record that a pull is waiting for the next `publish` to resolve it. */
+	markPendingPull() {
+		this.pendingPull = true;
+	}
+	/** The reserved frame for `frameId`, or `null` if unknown/stale. */
+	toBuffer(frameId) {
+		if (!this.reserved || this.reserved.frameId !== frameId) return null;
+		return this.reserved.frame;
+	}
+	/** Free both the slot and the reserved frame (teardown). */
+	free() {
+		this.slot?.frame.free();
+		this.slot = null;
+		this.reserved?.frame.free();
+		this.reserved = null;
+	}
+	reserveSlot() {
+		const held = this.slot;
+		if (!held) throw new Error("frame-slot: reserveSlot called with no slot held");
+		const previousReserved = this.reserved;
+		this.reserved = held;
+		this.slot = null;
+		previousReserved?.frame.free();
+		return toReply(held);
+	}
+};
+//#endregion
+//#region src/session-decode/decode-worker-child.ts
+/** Re-dial backoff on a transient dial error/EOF (mirrors the decoder's PULL_REDIAL_MS). */
+var REDIAL_MS = 3e3;
+var _nav = null;
+var _consts = null;
+async function getNodeAv() {
+	if (!_nav) _nav = await import("node-av");
+	return _nav;
+}
+async function getConstants() {
+	if (!_consts) _consts = await import("node-av/constants");
+	return _consts;
+}
+function errMessage(err) {
+	if (err instanceof Error) return err.message;
+	return String(err);
+}
+/**
+* RTSP low-latency demuxer options — mirrors
+* `addon-decoder-nodeav/src/pull-demuxer-options.ts` (duplicated here rather
+* than cross-imported: this file is a standalone forked entry point, not an
+* addon consumer of that package). `analyzeduration`/`probesize` stay small
+* but non-zero — zeroing them starves the Reolink rfc4571 restream demuxer.
+*/
+function buildDemuxerOptions() {
+	return {
+		rtsp_transport: "tcp",
+		fflags: "nobuffer",
+		analyzeduration: "1000000",
+		probesize: "1000000",
+		max_delay: "0",
+		reorder_queue_size: "0",
+		user_agent: "decode-worker"
+	};
+}
+/** Ordered hwaccel candidates per platform — first successful create() wins, else software. */
+function candidateBackends() {
+	switch (process.platform) {
+		case "darwin": return ["videotoolbox"];
+		case "linux": return [
+			"vaapi",
+			"qsv",
+			"cuda"
+		];
+		case "win32": return [
+			"d3d11va",
+			"dxva2",
+			"cuda"
+		];
+		default: return [];
+	}
+}
+/** Map a canonical backend name to the node-av `AV_HWDEVICE_TYPE_*` constant. */
+function backendToHwDeviceConst(backend, consts) {
+	switch (backend) {
+		case "videotoolbox": return consts.AV_HWDEVICE_TYPE_VIDEOTOOLBOX;
+		case "cuda":
+		case "nvdec": return consts.AV_HWDEVICE_TYPE_CUDA;
+		case "vaapi": return consts.AV_HWDEVICE_TYPE_VAAPI;
+		case "qsv": return consts.AV_HWDEVICE_TYPE_QSV;
+		case "d3d11va": return consts.AV_HWDEVICE_TYPE_D3D11VA;
+		case "dxva2": return consts.AV_HWDEVICE_TYPE_DXVA2;
+		case "amf": return consts.AV_HWDEVICE_TYPE_AMF;
+		case "vdpau": return consts.AV_HWDEVICE_TYPE_VDPAU;
+		case "drm": return consts.AV_HWDEVICE_TYPE_DRM;
+		default: return null;
+	}
+}
+/** Clamp to [min,max] then floor to the nearest even number (YUV420P chroma is 2x2 subsampled). */
+function clampEven(value, min, max) {
+	const bounded = Math.min(Math.max(value, min), max);
+	return bounded - bounded % 2;
+}
+/** Resolve `FrameImageOptions.crop` against the decoded frame's dimensions, defaulting to the full frame. */
+function resolveCropRegion(frameWidth, frameHeight, crop) {
+	const left = clampEven(crop?.left ?? 0, 0, Math.max(0, frameWidth - 2));
+	const top = clampEven(crop?.top ?? 0, 0, Math.max(0, frameHeight - 2));
+	return {
+		left,
+		top,
+		width: clampEven(crop?.width ?? frameWidth - left, 2, frameWidth - left),
+		height: clampEven(crop?.height ?? frameHeight - top, 2, frameHeight - top)
+	};
+}
+/** Resolve `FrameImageOptions.resize`, defaulting to the (already cropped) source dimensions. */
+function resolveResizeTarget(cropWidth, cropHeight, resize) {
+	if (!resize) return {
+		width: cropWidth,
+		height: cropHeight
+	};
+	return {
+		width: Math.max(1, Math.round(resize.width)),
+		height: Math.max(1, Math.round(resize.height))
+	};
+}
+/**
+* The forked child's whole runtime: decode-loop lifecycle, the latest-wins
+* frame slot, and the ROI scaler for `toBuffer`. One instance per process.
+*/
+var DecodeWorkerChild = class {
+	nav = null;
+	consts = null;
+	hwContext = null;
+	demuxer = null;
+	decoder = null;
+	abortController = null;
+	started = false;
+	stopped = false;
+	sessionFormat = "rgb";
+	minIntervalMs = 0;
+	/**
+	* The latest-wins decoded-frame slot + reserved-for-`toBuffer` holder +
+	* pending-pull flag — extracted to `FrameSlot` (Epic C P2 Task 2 / I2) so
+	* the reserve-on-pull invariant (`e3c78a9b`) is unit-tested without
+	* node-av. See that file's doc comment for the full semantics.
+	*/
+	frames = new FrameSlot();
+	/**
+	* Mirrors whether `this.frames` currently has a pull waiting, so
+	* `teardown` knows to resolve it with `{kind:'ended'}` — `FrameSlot`
+	* intentionally exposes no pending-pull query, only `markPendingPull()`,
+	* so the child tracks this in lockstep (set in `handlePull`, cleared
+	* whenever `consumeDecodedFrame`'s `publish` resolves it).
+	*/
+	pendingPull = false;
+	ended = false;
+	redialTimer = null;
+	handleMessage(message) {
+		if (!isWorkerRequest(message)) {
+			this.sendError("decode-worker-child: malformed request");
+			return;
+		}
+		switch (message.kind) {
+			case "start":
+				this.handleStart(message.source, message.opts);
+				return;
+			case "pull":
+				this.handlePull();
+				return;
+			case "toBuffer":
+				this.handleToBuffer(message.frameId, message.opts);
+				return;
+			case "stop":
+				this.handleStop();
+				return;
+		}
+	}
+	/** Channel teardown (explicit `stop` or the parent disconnecting) — dispose, then exit. */
+	teardown() {
+		this.stopped = true;
+		this.ended = true;
+		if (this.redialTimer) {
+			clearTimeout(this.redialTimer);
+			this.redialTimer = null;
+		}
+		this.abortController?.abort();
+		this.closeInput();
+		this.frames.free();
+		this.hwContext?.[Symbol.dispose]?.();
+		this.hwContext = null;
+		if (this.pendingPull) {
+			this.pendingPull = false;
+			this.send({ kind: "ended" });
+		}
+	}
+	handleStart(source, opts) {
+		if (this.started) {
+			process.stderr.write("decode-worker-child: duplicate start ignored\n");
+			return;
+		}
+		this.started = true;
+		this.sessionFormat = opts.format ?? "rgb";
+		this.minIntervalMs = opts.fps && opts.fps > 0 ? 1e3 / opts.fps : 0;
+		this.runDecodeLoop(source.restreamUrl).catch((err) => {
+			this.sendError(`decode-worker-child: decode loop crashed — ${errMessage(err)}`);
+		});
+	}
+	handlePull() {
+		if (this.ended) {
+			this.send({ kind: "ended" });
+			return;
+		}
+		const reply = this.frames.pull();
+		if (reply) {
+			this.send(this.toFrameReply(reply));
+			return;
+		}
+		this.pendingPull = true;
+		this.frames.markPendingPull();
+	}
+	handleToBuffer(frameId, opts) {
+		const frame = this.frames.toBuffer(frameId);
+		if (!frame) {
+			this.sendError(`decode-worker-child: toBuffer for unknown or stale frameId ${frameId}`, frameId);
+			return;
+		}
+		try {
+			const bytes = this.scaleRoiToBuffer(frame, opts);
+			this.send({
+				kind: "buffer",
+				frameId,
+				bytes
+			});
+		} catch (err) {
+			this.sendError(`decode-worker-child: toBuffer failed — ${errMessage(err)}`, frameId);
+		}
+	}
+	handleStop() {
+		this.teardown();
+		process.exit(0);
+	}
+	async runDecodeLoop(url) {
+		const nav = await getNodeAv();
+		const C = await getConstants();
+		if (this.stopped) return;
+		this.nav = nav;
+		this.consts = C;
+		nav.Log.setLevel(C.AV_LOG_FATAL);
+		await this.ensureHwContext(nav, C);
+		while (!this.stopped) {
+			try {
+				await this.dialAndDecode(nav, C, url);
+			} catch (err) {
+				if (this.stopped) break;
+				process.stderr.write(`decode-worker-child: dial ended — re-dial scheduled: ${errMessage(err)}\n`);
+			} finally {
+				this.closeInput();
+			}
+			if (this.stopped) break;
+			await this.sleep(REDIAL_MS);
+		}
+	}
+	/**
+	* One dial: open the demuxer, pick the video stream, build a HW/SW decoder
+	* that downloads + normalises frames to YUV420P system memory (so the ROI
+	* scaler always reads plain software planes regardless of hwaccel), and
+	* pump `demuxer.packets → decoder.frames → consumeDecodedFrame` until the
+	* stream ends, errors, or teardown aborts it.
+	*
+	* Copied from `nodeav-decoder-session.ts` `pullDialAndDecode` (lines
+	* ~916-996): same demuxer options, same `rescale.pixelFormat: YUV420P`
+	* download-always contract (keeping decoded frames on the GPU leaked the
+	* VAAPI surface pool on every re-dial — see that file's comment), same
+	* `exitOnError: false` bad-frame tolerance.
+	*/
+	async dialAndDecode(nav, C, url) {
+		this.abortController = new AbortController();
+		const demuxer = await nav.Demuxer.open(url, {
+			options: buildDemuxerOptions(),
+			signal: this.abortController.signal
+		});
+		if (this.stopped) {
+			demuxer[Symbol.dispose]?.();
+			return;
+		}
+		this.demuxer = demuxer;
+		const videoStream = demuxer.video();
+		if (!videoStream) throw new Error("decode-worker-child: pull input has no video stream");
+		const decoder = await nav.Decoder.create(videoStream, {
+			...this.hwContext ? { hardware: this.hwContext } : {},
+			rescale: { pixelFormat: C.AV_PIX_FMT_YUV420P },
+			exitOnError: false
+		});
+		if (this.stopped) {
+			decoder[Symbol.dispose]?.();
+			return;
+		}
+		this.decoder = decoder;
+		for await (const frame of decoder.frames(demuxer.packets(videoStream.index))) {
+			if (this.stopped) break;
+			if (!frame) continue;
+			this.consumeDecodedFrame(frame);
+		}
+	}
+	/**
+	* Publish a decoded frame into the latest-wins slot (mirrors Scrypted's
+	* `libav.py:32,50-53` single-slot queue) via `FrameSlot`, which handles
+	* drop-older, the `minIntervalMs` throttle, and resolving a pending `pull`.
+	*/
+	consumeDecodedFrame(frame) {
+		if (frame.isHwFrame()) {
+			frame.free();
+			return;
+		}
+		const reply = this.frames.publish(frame, Date.now(), this.minIntervalMs);
+		if (reply) {
+			this.pendingPull = false;
+			this.send(this.toFrameReply(reply));
+		}
+	}
+	toFrameReply(reply) {
+		return {
+			kind: "frame",
+			frameId: reply.frameId,
+			timestamp: reply.timestamp,
+			width: reply.width,
+			height: reply.height,
+			format: this.sessionFormat
+		};
+	}
+	/**
+	* ROI `toBuffer`: crop (via plane-pointer offset, not a re-decode) + resize
+	* + format-convert a retained decoded frame with `SoftwareScaleContext`.
+	* Writes straight into a tightly-packed destination buffer via the
+	* low-level `scaleSync` (no `dstFrame` + row-strip step needed — the same
+	* zero-copy destination technique as `scaleIntoRingSlot` in
+	* `nodeav-decoder-session.ts`, adapted to also OFFSET the source planes so
+	* a single scaler call handles the crop.
+	*/
+	scaleRoiToBuffer(frame, opts) {
+		const nav = this.nav;
+		const C = this.consts;
+		if (!nav || !C) throw new Error("node-av not initialized");
+		const region = resolveCropRegion(frame.width, frame.height, opts?.crop);
+		const target = resolveResizeTarget(region.width, region.height, opts?.resize);
+		const format = opts?.format ?? this.sessionFormat;
+		const dstFmt = format === "gray" ? C.AV_PIX_FMT_GRAY8 : C.AV_PIX_FMT_RGB24;
+		const channels = format === "gray" ? 1 : 3;
+		const planes = frame.data;
+		const strides = frame.linesize;
+		const yPlane = planes?.[0];
+		const uPlane = planes?.[1];
+		const vPlane = planes?.[2];
+		if (!yPlane || !uPlane || !vPlane) throw new Error("decode-worker-child: decoded frame missing planar YUV420P data");
+		const yStride = strides[0] ?? 0;
+		const cStride = strides[1] ?? 0;
+		const ySlice = yPlane.subarray(region.top * yStride + region.left);
+		const uSlice = uPlane.subarray(region.top / 2 * cStride + region.left / 2);
+		const vSlice = vPlane.subarray(region.top / 2 * cStride + region.left / 2);
+		const scaler = new nav.SoftwareScaleContext();
+		try {
+			scaler.getContext(region.width, region.height, C.AV_PIX_FMT_YUV420P, target.width, target.height, dstFmt, C.SWS_FAST_BILINEAR);
+			const initRet = scaler.initContext();
+			if (initRet < 0) throw new Error(`sws_init_context failed: ${initRet}`);
+			const dstStride = target.width * channels;
+			const dstBuffer = Buffer.allocUnsafe(dstStride * target.height);
+			const scaledHeight = scaler.scaleSync([
+				ySlice,
+				uSlice,
+				vSlice
+			], [
+				yStride,
+				cStride,
+				cStride
+			], 0, region.height, [dstBuffer], [dstStride]);
+			if (scaledHeight < 0) throw new Error(`sws_scale failed: ${scaledHeight}`);
+			if (scaledHeight !== target.height) throw new Error(`scaler produced ${scaledHeight} of ${target.height} rows`);
+			return dstBuffer;
+		} finally {
+			scaler[Symbol.dispose]?.();
+		}
+	}
+	/**
+	* Resolve the HW context ONCE (reused across every re-dial, freed in
+	* `teardown`). Tries the platform's ordered candidate list; the first
+	* `HardwareContext.create` that succeeds wins; every failure falls through
+	* to software decode (`hardware` omitted from `Decoder.create`).
+	*/
+	async ensureHwContext(nav, C) {
+		for (const backend of candidateBackends()) {
+			const deviceType = backendToHwDeviceConst(backend, C);
+			if (deviceType === null) continue;
+			const hw = nav.HardwareContext.create(deviceType);
+			if (!hw) {
+				process.stderr.write(`decode-worker-child: hwaccel candidate '${backend}' failed — trying next\n`);
+				continue;
+			}
+			this.hwContext = hw;
+			return;
+		}
+		process.stderr.write("decode-worker-child: no hwaccel backend available — using software decode\n");
+	}
+	/** Interruptible re-dial backoff — `teardown` clears the pending timer. */
+	sleep(ms) {
+		return new Promise((resolve) => {
+			this.redialTimer = setTimeout(() => {
+				this.redialTimer = null;
+				resolve();
+			}, ms);
+		});
+	}
+	/** Dispose the CURRENT dial's demuxer + decoder (the HW context is reused across dials). */
+	closeInput() {
+		this.decoder?.[Symbol.dispose]?.();
+		this.decoder = null;
+		this.demuxer?.[Symbol.dispose]?.();
+		this.demuxer = null;
+	}
+	send(reply) {
+		process.send?.(reply);
+	}
+	sendError(message, frameId) {
+		process.stderr.write(`${message}\n`);
+		this.send(frameId === void 0 ? {
+			kind: "error",
+			message
+		} : {
+			kind: "error",
+			message,
+			frameId
+		});
+	}
+};
+var worker = new DecodeWorkerChild();
+process.on("message", (message) => {
+	worker.handleMessage(message);
+});
+process.on("disconnect", () => {
+	worker.teardown();
+	process.exit(0);
+});
+process.on("uncaughtException", (err) => {
+	process.stderr.write(`decode-worker-child: uncaught exception — ${errMessage(err)}\n`);
+	worker.teardown();
+	process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+	process.stderr.write(`decode-worker-child: unhandled rejection — ${errMessage(reason)}\n`);
+});
+//#endregion
+export { DecodeWorkerChild };

package/dist/stream-broker/_stub.js

@@ -1,8 +1,8 @@
-import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c, u as l } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_camstack_mf_1_ui_mf_2_library__loadShare__.js-BsrrdOBU.mjs";
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c, u as l } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_camstack_mf_1_ui_mf_2_library__loadShare__.js-dGka8yZY.mjs";
 import { a as u, i as d, n as f, o as p, r as m, t as h } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare__react__loadShare__.js-C9j-2lBe.mjs";
 import { n as g, r as _, t as v } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare__react_mf_1_jsx_mf_2_runtime__loadShare__.js-XO0-Pyu6.mjs";
 import { n as y, t as b } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_tanstack_mf_1_react_mf_2_query__loadShare__.js-BO7TIbJV.mjs";
-import { t as x } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_camstack_mf_1_types__loadShare__.js-DhY3MZ2C.mjs";
+import { t as x } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_camstack_mf_1_types__loadShare__.js-DqJvWBKS.mjs";
 //#region ../../node_modules/lucide-react/dist/esm/shared/src/utils.js
 var S = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), C = (e) => e.replace(/^([A-Z])|[\s-_]+(\w)/g, (e, t, n) => n ? n.toUpperCase() : t.toLowerCase()), w = (e) => {
 	let t = C(e);
@@ -918,42 +918,42 @@ function le({ profile: e }) {
 		] })
 	] });
 }
-function ue(e) {
-	let t = e.config ?? {}, n = i(), [r, a] = p(() => t.initialValue), o = m((r) => {
-		if (a(r), e.deviceId === void 0) return;
-		let i = t.writerCapName, o = t.writerAddonId, s = t.fieldKey;
+function ue(t) {
+	let n = t.config ?? {}, r = e(), [i, a] = p(() => n.initialValue), o = m((e) => {
+		if (a(e), t.deviceId === void 0) return;
+		let i = n.writerCapName, o = n.writerAddonId, s = n.fieldKey;
 		if (i === void 0 || o === void 0 || s === void 0) {
 			console.warn(`[ffmpeg-params] widgetConfig is missing writerCapName/writerAddonId/fieldKey — field ${s ?? "(unknown)"} cannot be saved. Fix the contribution builder.`);
 			return;
 		}
-		n.mutate({
-			deviceId: e.deviceId,
+		r.mutate({
+			deviceId: t.deviceId,
 			writerCapName: i,
 			writerAddonId: o,
 			key: s,
-			value: r ?? null
+			value: e ?? null
 		});
 	}, [
-		e.deviceId,
-		t.fieldKey,
-		t.writerCapName,
-		t.writerAddonId,
-		n
+		t.deviceId,
+		n.fieldKey,
+		n.writerCapName,
+		n.writerAddonId,
+		r
 	]);
-	if (e.deviceId === void 0) return /* @__PURE__ */ g("div", {
+	if (t.deviceId === void 0) return /* @__PURE__ */ g("div", {
 		className: "rounded-lg border border-warning/30 bg-warning/10 px-3 py-2 text-xs text-warning",
 		children: "ffmpeg-params: no deviceId in widget context — this widget only renders inside a device tab."
 	});
-	let s = t.fieldKey;
+	let s = n.fieldKey;
 	return s === void 0 || s.length === 0 ? /* @__PURE__ */ g("div", {
 		className: "rounded-lg border border-warning/30 bg-warning/10 px-3 py-2 text-xs text-warning",
 		children: "ffmpeg-params: widgetConfig.fieldKey is required — fix the contribution builder."
 	}) : /* @__PURE__ */ g(ce, {
 		config: {
-			...t,
+			...n,
 			fieldKey: s
 		},
-		value: r,
+		value: i,
 		onSave: o
 	});
 }
@@ -1081,14 +1081,14 @@ function _e(e) {
 		hideEmpty: t.hideEmpty
 	});
 }
-function ve({ deviceId: e, title: t = "Stream Brokers", variant: i = "full", hideEmpty: a = !1 }) {
-	n(["streamBroker", "listAllProfileSlots"], [
+function ve({ deviceId: e, title: t = "Stream Brokers", variant: r = "full", hideEmpty: o = !1 }) {
+	s(["streamBroker", "listAllProfileSlots"], [
 		"device.streams-registered",
 		"device.streams-unregistered",
 		"device.registered",
 		"device.unregistered"
 	]);
-	let { data: s } = r(void 0, { staleTime: 3e4 }), l = (s ?? []).filter((t) => t.deviceId === e && t.sourceCamStreamId !== null).slice().toSorted((e, t) => W.indexOf(e.profile) - W.indexOf(t.profile)), u = o(c().trpcClient, e), { data: d } = b({
+	let { data: c } = i(void 0, { staleTime: 3e4 }), l = (c ?? []).filter((t) => t.deviceId === e && t.sourceCamStreamId !== null).slice().toSorted((e, t) => W.indexOf(e.profile) - W.indexOf(t.profile)), u = a(n().trpcClient, e), { data: d } = b({
 		queryKey: [
 			"device",
 			e,
@@ -1100,7 +1100,7 @@ function ve({ deviceId: e, title: t = "Stream Brokers", variant: i = "full", hid
 	}), f = /* @__PURE__ */ new Map();
 	for (let e of d ?? []) f.set(e.camStreamId, e);
 	let p = new Set(l.map((e) => e.sourceCamStreamId).filter((e) => e !== null)), m = (d ?? []).filter((e) => !p.has(e.camStreamId)), h = l.length > 0, v = m.length > 0;
-	return a && !h && !v ? null : i === "compact" ? h ? /* @__PURE__ */ g("div", {
+	return o && !h && !v ? null : r === "compact" ? h ? /* @__PURE__ */ g("div", {
 		className: "divide-y divide-border/30",
 		children: l.map((e) => /* @__PURE__ */ g(q, {
 			slot: e,
@@ -1170,8 +1170,8 @@ function ye({ deviceId: e, camStreamIds: t, camStreams: n }) {
 		})]
 	});
 }
-function be({ deviceId: t, camStreamId: n, camStreams: r }) {
-	let i = x(t, n), a = e("stream-broker.metrics-snapshot", (e) => e.brokerId === i)?.stats, o = r.get(n), s = a?.status === "streaming";
+function be({ deviceId: e, camStreamId: n, camStreams: r }) {
+	let i = x(e, n), a = t("stream-broker.metrics-snapshot", (e) => e.brokerId === i)?.stats, o = r.get(n), s = a?.status === "streaming";
 	return /* @__PURE__ */ _("div", {
 		className: "px-4 py-2",
 		children: [/* @__PURE__ */ g("div", {
@@ -1266,29 +1266,29 @@ function K(e, t) {
 		if (t !== void 0) return t;
 	}
 }
-function q({ slot: r, camStreams: i, compact: o }) {
-	let c = y(), u = e("stream-broker.metrics-snapshot", (e) => e.brokerId === r.brokerId)?.stats;
-	n(["streamBroker", "listClients"], ["stream-broker.metrics-snapshot"]);
-	let { data: d } = l({ brokerId: r.brokerId }, {
+function q({ slot: e, camStreams: n, compact: i }) {
+	let a = y(), u = t("stream-broker.metrics-snapshot", (t) => t.brokerId === e.brokerId)?.stats;
+	s(["streamBroker", "listClients"], ["stream-broker.metrics-snapshot"]);
+	let { data: d } = o({ brokerId: e.brokerId }, {
 		enabled: u?.status === "streaming",
 		staleTime: 2e3
-	}), { data: f } = s({ deviceId: r.deviceId }, { staleTime: 15e3 }), p = r.sourceCamStreamId ?? r.profile, h = !!(K(f, `preBufferEnabled:${p}`) ?? !0), b = K(f, `preBufferSec:${p}`), x = a({ onSuccess: () => {
-		c.invalidateQueries({ queryKey: [["streamBroker", "getDeviceSettingsContribution"]] });
-	} }), S = (e) => {
+	}), { data: f } = l({ deviceId: e.deviceId }, { staleTime: 15e3 }), p = e.sourceCamStreamId ?? e.profile, h = !!(K(f, `preBufferEnabled:${p}`) ?? !0), b = K(f, `preBufferSec:${p}`), x = r({ onSuccess: () => {
+		a.invalidateQueries({ queryKey: [["streamBroker", "getDeviceSettingsContribution"]] });
+	} }), S = (t) => {
 		x.mutate({
-			deviceId: r.deviceId,
-			patch: { [`preBufferEnabled:${p}`]: e }
+			deviceId: e.deviceId,
+			patch: { [`preBufferEnabled:${p}`]: t }
 		});
-	}, C = t({ onSuccess: () => {
-		c.invalidateQueries({ queryKey: [["streamBroker", "listClients"]] });
-	} }), w = m((e) => {
+	}, C = c({ onSuccess: () => {
+		a.invalidateQueries({ queryKey: [["streamBroker", "listClients"]] });
+	} }), w = m((t) => {
 		C.mutate({
-			brokerId: r.brokerId,
-			...e
+			brokerId: e.brokerId,
+			...t
 		});
-	}, [C, r.brokerId]), T = (r.sourceCamStreamId ? i.get(r.sourceCamStreamId) : void 0)?.resolution ?? r.resolution, E = u?.status === "streaming", D = T ? `${U[r.profile]} (${T.width}×${T.height})` : U[r.profile], O = u ? u.encodedSubscribers + u.decodedSubscribers + (u.rtspClients ?? 0) + (u.pipeClients ?? 0) : 0;
+	}, [C, e.brokerId]), T = (e.sourceCamStreamId ? n.get(e.sourceCamStreamId) : void 0)?.resolution ?? e.resolution, E = u?.status === "streaming", D = T ? `${U[e.profile]} (${T.width}×${T.height})` : U[e.profile], O = u ? u.encodedSubscribers + u.decodedSubscribers + (u.rtspClients ?? 0) + (u.pipeClients ?? 0) : 0;
 	return /* @__PURE__ */ _("div", {
-		className: `@container ${o ? "px-3 py-1.5" : "px-4 py-2"}`,
+		className: `@container ${i ? "px-3 py-1.5" : "px-4 py-2"}`,
 		style: { containerType: "inline-size" },
 		children: [
 			/* @__PURE__ */ _("div", {
@@ -1296,7 +1296,7 @@ function q({ slot: r, camStreams: i, compact: o }) {
 				children: [/* @__PURE__ */ _("div", {
 					className: "flex items-center gap-1.5",
 					children: [
-						/* @__PURE__ */ g("span", { className: `h-1.5 w-1.5 rounded-full ${E ? r.profile === "high" ? "bg-success" : r.profile === "mid" ? "bg-warning" : "bg-foreground-subtle" : "bg-foreground-subtle/40"}` }),
+						/* @__PURE__ */ g("span", { className: `h-1.5 w-1.5 rounded-full ${E ? e.profile === "high" ? "bg-success" : e.profile === "mid" ? "bg-warning" : "bg-foreground-subtle" : "bg-foreground-subtle/40"}` }),
 						/* @__PURE__ */ g("span", {
 							className: "text-[11px] font-medium text-foreground",
 							children: D
@@ -1305,9 +1305,9 @@ function q({ slot: r, camStreams: i, compact: o }) {
 							className: `text-[10px] ${E ? "text-success" : "text-foreground-subtle"}`,
 							children: u?.status ?? "loading"
 						}),
-						r.sourceCamStreamId && /* @__PURE__ */ _("span", {
+						e.sourceCamStreamId && /* @__PURE__ */ _("span", {
 							className: "text-[10px] text-foreground-subtle",
-							children: ["← ", r.sourceCamStreamId]
+							children: ["← ", e.sourceCamStreamId]
 						})
 					]
 				}), /* @__PURE__ */ g("span", {
@@ -1315,7 +1315,7 @@ function q({ slot: r, camStreams: i, compact: o }) {
 					children: u && u.uptimeMs > 0 ? pe(u.uptimeMs) : "—"
 				})]
 			}),
-			u && E ? o ? /* @__PURE__ */ _("div", {
+			u && E ? i ? /* @__PURE__ */ _("div", {
 				className: "flex flex-wrap gap-x-3 gap-y-0.5 text-[10px]",
 				children: [
 					/* @__PURE__ */ _("span", {