@camstack/addon-pipeline 1.1.27 → 1.1.29

package/dist/stream-broker/index.js

@@ -3,9 +3,10 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-DxM2DSns.js");
-const require_dist = require("../dist-DAIlCdAx.js");
-const require_frame_handle_plane = require("../frame-handle-plane-DtTRX_0n.js");
-const require_frame_dropper = require("../frame-dropper-7RTo_YyG.js");
+const require_dist = require("../dist-Cwc0TUQr.js");
+const require_frame_handle_plane = require("../frame-handle-plane-DQNCTrpC.js");
+const require_ffmpeg_args = require("../ffmpeg-args-D6h1edXK.js");
+const require_frame_dropper = require("../frame-dropper-DKLM6pMz.js");
 let node_crypto = require("node:crypto");
 node_crypto = require_model_download_service_C_IHWnXx.__toESM(node_crypto);
 let node_fs = require("node:fs");
@@ -2527,7 +2528,7 @@ function planAudioSilencePadPackets(input) {
 *   audio plane honours the profile literally.
 */
 function buildTranscodeFfmpegArgs(inputFormat, profile, decodeHwAccel, sourceUrl) {
-	const args = [...require_frame_dropper.logBannerArgs("error")];
+	const args = [...require_ffmpeg_args.logBannerArgs("error")];
 	if (profile.inputArgs?.length) args.push(...profile.inputArgs);
 	if (decodeHwAccel && decodeHwAccel !== "none") args.push("-hwaccel", decodeHwAccel);
 	args.push("-fflags", "+discardcorrupt", "-rtsp_transport", "tcp", "-i", sourceUrl);
@@ -2549,7 +2550,7 @@ function buildTranscodeFfmpegArgs(inputFormat, profile, decodeHwAccel, sourceUrl
 	if (profile.audio === "passthrough") args.push("-an");
 	else {
 		const a = profile.audio;
-		args.push(...require_frame_dropper.audioEncoderArgs(a.codec, {
+		args.push(...require_ffmpeg_args.audioEncoderArgs(a.codec, {
 			bitrateKbps: a.bitrateKbps,
 			sampleRateHz: a.sampleRateHz,
 			channels: a.channels
@@ -5912,24 +5913,6 @@ function toAudioSidecarCodec(audio) {
 	return audio === "aac" || audio === "opus" || audio === "pcmu" ? audio : null;
 }
 /**
-* Pick the decode `-hwaccel` backend, gated by what the configured ffmpeg
-* binary actually supports (`platformProbe.getHardwareDecodeAccels`).
-*
-* `preferred` entries are literal `-hwaccel` names (kernel-resolved), so they
-* intersect directly with the probed method list. Conservative by design:
-* - empty `preferred` → `null` (software decode);
-* - empty `supportedMethods` (probe miss / build reports none) → keep the top
-*   preference and let the egress's per-stream software fallback cover failures;
-* - otherwise return the first preference the build supports, or `null` when it
-*   supports none of them (positive evidence to skip a doomed hw-decode spawn).
-*/
-function pickDecodeHwAccel(preferred, supportedMethods) {
-	if (preferred.length === 0) return null;
-	if (supportedMethods.length === 0) return preferred[0] ?? null;
-	const supported = new Set(supportedMethods.map((m) => m.toLowerCase()));
-	return preferred.find((name) => supported.has(name.toLowerCase())) ?? null;
-}
-/**
 * Pick the video encoder, honouring the `hwAccel` preference: `'none'`/`'copy'`
 * (software-decode settings) force the software ENCODER too; otherwise the
 * probe's default (hw when available) is used, falling back to software when no
@@ -5944,26 +5927,80 @@ function pickVideoEncoder(target, encoders, hwAccel) {
 	if (hwAccel === "none" || hwAccel === "copy" || !encoders) return software;
 	return target === "H264" ? encoders.defaultH264 : encoders.defaultH265;
 }
+/**
+* The h264/hevc hardware ENCODER ids for a decode-hwaccel backend name — a
+* static, deterministic map (the same shape Scrypted uses: platform → encoder,
+* no probe). Consumed by {@link localHardwareEncoders}. `null` for a backend
+* with no hardware encoder (software / unknown).
+*/
+var ENCODER_IDS_BY_BACKEND = {
+	videotoolbox: {
+		h264: "h264_videotoolbox",
+		h265: "hevc_videotoolbox"
+	},
+	vaapi: {
+		h264: "h264_vaapi",
+		h265: "hevc_vaapi"
+	},
+	cuda: {
+		h264: "h264_nvenc",
+		h265: "hevc_nvenc"
+	},
+	nvdec: {
+		h264: "h264_nvenc",
+		h265: "hevc_nvenc"
+	},
+	qsv: {
+		h264: "h264_qsv",
+		h265: "hevc_qsv"
+	},
+	amf: {
+		h264: "h264_amf",
+		h265: "hevc_amf"
+	}
+};
+/**
+* Build the {@link HardwareEncoders} default pair for THIS node's decode-hwaccel
+* backend — resolved LOCALLY from `ctx.kernel.hwaccel` — WITHOUT probing
+* `ffmpeg -encoders` via the `platform-probe` singleton (whose per-node
+* `nodePin` does not survive a forked agent child's link chain → it answers with
+* the HUB's encoders). Mirrors how Scrypted derives encoders: a static
+* platform→encoder map. Returns `null` for software / an unmapped backend, which
+* makes {@link pickVideoEncoder} fall back to the software encoder. Only
+* `defaultH264`/`defaultH265` are consumed downstream, so `encoders` is left
+* empty (the per-encoder capability list was never read here).
+*/
+function localHardwareEncoders(backend) {
+	if (backend === null) return null;
+	const ids = ENCODER_IDS_BY_BACKEND[backend.toLowerCase()];
+	if (!ids) return null;
+	return {
+		encoders: [],
+		defaultH264: ids.h264,
+		defaultH265: ids.h265,
+		probedAt: Date.now()
+	};
+}
 /** Audio encoder args for a transcode target (preset values over the shared low-level builder). */
 function pickAudioEncoderArgs(audio) {
 	switch (audio) {
-		case "aac": return require_frame_dropper.audioEncoderArgs("aac", {
+		case "aac": return require_ffmpeg_args.audioEncoderArgs("aac", {
 			bitrateKbps: 128,
 			sampleRateHz: 48e3,
 			channels: 2
 		});
-		case "opus": return require_frame_dropper.audioEncoderArgs("opus", {
+		case "opus": return require_ffmpeg_args.audioEncoderArgs("opus", {
 			bitrateKbps: 64,
 			sampleRateHz: 48e3,
 			channels: 2
 		});
-		case "pcmu": return require_frame_dropper.audioEncoderArgs("pcmu", {
+		case "pcmu": return require_ffmpeg_args.audioEncoderArgs("pcmu", {
 			sampleRateHz: 8e3,
 			channels: 1
 		});
-		case "copy": return require_frame_dropper.audioEncoderArgs("copy");
+		case "copy": return require_ffmpeg_args.audioEncoderArgs("copy");
 		case "none": return ["-an"];
-		default: return require_frame_dropper.audioEncoderArgs("aac", { bitrateKbps: 128 });
+		default: return require_ffmpeg_args.audioEncoderArgs("aac", { bitrateKbps: 128 });
 	}
 }
 /**
@@ -6028,7 +6065,7 @@ function buildFfmpegArgs$1(inv) {
 	const threadArgs = inv.threadCount > 0 ? ["-threads", String(inv.threadCount)] : [];
 	const audioArgs = inv.sink.kind === "stdout" && (inv.sink.container === "h264" || inv.sink.container === "hevc") ? ["-an"] : pickAudioEncoderArgs(inv.audio);
 	return [
-		...require_frame_dropper.logBannerArgs("warning"),
+		...require_ffmpeg_args.logBannerArgs("warning"),
 		...decodeArgs,
 		"-rtsp_transport",
 		"tcp",
@@ -11364,7 +11401,7 @@ var TranscodePipelineManager = class {
 	*  async egress start so concurrent acquires share one egress. */
 	pending = /* @__PURE__ */ new Map();
 	logger;
-	api;
+	hwaccel;
 	cameraStreamLookup;
 	rtspEntryLookup;
 	resolveProfileSource;
@@ -11375,7 +11412,7 @@ var TranscodePipelineManager = class {
 	acquireChannel;
 	constructor(opts) {
 		this.logger = opts.logger;
-		this.api = opts.api;
+		this.hwaccel = opts.hwaccel ?? null;
 		this.cameraStreamLookup = opts.cameraStreamLookup;
 		this.rtspEntryLookup = opts.rtspEntryLookup;
 		this.resolveProfileSource = opts.resolveProfileSource ?? null;
@@ -11576,13 +11613,21 @@ var TranscodePipelineManager = class {
 		if (!stream) throw new Error(`getStreamWithCodec: profile "${profile}" source "${camStreamId}" not published for device ${deviceId}`);
 		return stream;
 	}
-	/** Query the typed, cached hardware-encoder probe; null on any failure. */
+	/**
+	* The h264/hevc hardware ENCODER defaults for THIS node — derived locally
+	* from `ctx.kernel.hwaccel` (os.platform + GPU-vendor probe) via a static
+	* backend→encoder map, NOT the `platform-probe` singleton's `ffmpeg -encoders`
+	* probe (whose per-node `nodePin` answers with the HUB's encoders). `null` →
+	* software encode (also the outcome when no local resolver is wired). vaapi is
+	* ranked above qsv (qsv is broken on the Intel stack) so an Intel node
+	* transcodes with `h264_vaapi`.
+	*/
 	async resolveHardwareEncoders() {
-		if (!this.api) return null;
+		if (!this.hwaccel) return null;
 		try {
-			return await this.api.platformProbe.getHardwareEncoders.query();
+			return localHardwareEncoders(require_ffmpeg_args.rankDecodeHwAccels((await this.hwaccel.resolve(null)).preferred, [])[0] ?? null);
 		} catch (err) {
-			this.logger.warn("platformProbe.getHardwareEncoders failed — software encode fallback", { meta: { error: require_dist.errMsg(err) } });
+			this.logger.warn("local hardware-encoder resolve failed — software encode fallback", { meta: { error: require_dist.errMsg(err) } });
 			return null;
 		}
 	}
@@ -11610,35 +11655,20 @@ var TranscodePipelineManager = class {
 		if (strategy.kind === "software") return null;
 		return this.resolveSpecificDecodeHwAccel(strategy.prefer);
 	}
-	/** Gate a specific backend against the probed support list; null on miss/error. */
-	async resolveSpecificDecodeHwAccel(prefer) {
-		if (!this.api) return null;
-		try {
-			const res = await this.api.platformProbe.resolveHwAccel.query({ prefer });
-			const supported = await this.resolveDecodeAccelMethods();
-			const picked = pickDecodeHwAccel(res.preferred, supported);
-			if (picked === null && res.preferred.length > 0) this.logger.info("decode hw-accel: configured ffmpeg supports none of the preferred backends — software decode", { meta: {
-				preferred: res.preferred,
-				supported
-			} });
-			return picked;
-		} catch (err) {
-			this.logger.warn("platformProbe.resolveHwAccel failed — software decode fallback", { meta: { error: require_dist.errMsg(err) } });
-			return null;
-		}
-	}
 	/**
-	* The `-hwaccel` methods the configured ffmpeg supports; `[]` on any failure
-	* (treated as "unknown" by {@link pickDecodeHwAccel}, which then keeps the
-	* top preference rather than filtering it out).
+	* Resolve a specific operator-forced decode backend against THIS node's local
+	* hwaccel resolver. `ctx.kernel.hwaccel.resolve(prefer)` echoes the forced
+	* backend (re-ranked so vaapi precedes qsv); the egress's per-stream software
+	* fallback still catches a backend the actual ffmpeg build can't drive. Null
+	* when no local resolver is wired.
 	*/
-	async resolveDecodeAccelMethods() {
-		if (!this.api) return [];
+	async resolveSpecificDecodeHwAccel(prefer) {
+		if (!this.hwaccel) return null;
 		try {
-			return (await this.api.platformProbe.getHardwareDecodeAccels.query()).methods;
+			return require_ffmpeg_args.rankDecodeHwAccels((await this.hwaccel.resolve(prefer)).preferred, [])[0] ?? null;
 		} catch (err) {
-			this.logger.warn("platformProbe.getHardwareDecodeAccels failed — decode gate skipped", { meta: { error: require_dist.errMsg(err) } });
-			return [];
+			this.logger.warn("local decode hw-accel resolve failed — software decode fallback", { meta: { error: require_dist.errMsg(err) } });
+			return null;
 		}
 	}
 	shareEntry(entry) {
@@ -11956,6 +11986,14 @@ var StreamBrokerManager = class {
 	*/
 	api = null;
 	/**
+	* This node's LOCAL hwaccel resolver (`ctx.kernel.hwaccel`), wired by
+	* `setApiAccess`. Drives the transcode manager's decode/encode backend picks
+	* and `getHwAccelOptions` from THIS node's hardware in-process — never the
+	* `platform-probe` singleton (whose per-node `nodePin` answers with the hub's
+	* hardware from a forked agent child).
+	*/
+	hwaccel = null;
+	/**
 	* This broker node's own Moleculer nodeID (`ctx.kernel.localNodeId`). The
 	* shm frame plane's decoder sessions MUST be co-located on this node — an
 	* shm frame ring is node-local, so a decoder placed on any OTHER node can
@@ -11997,7 +12035,7 @@ var StreamBrokerManager = class {
 	getTranscodeManager() {
 		if (!this.transcodeManager) this.transcodeManager = new TranscodePipelineManager({
 			logger: this.logger.child("transcode"),
-			api: this.api,
+			hwaccel: this.hwaccel ?? void 0,
 			cameraStreamLookup: (deviceId) => this.getCameraStreamsForDevice(deviceId),
 			rtspEntryLookup: (brokerId) => {
 				const entry = this.rtspProvider.getEntry(brokerId);
@@ -12203,9 +12241,10 @@ var StreamBrokerManager = class {
 	* resolve the `decoder` capability via tRPC — see
 	* `buildDecoderCapApi` for the full rationale.
 	*/
-	setApiAccess(api, localNodeId) {
+	setApiAccess(api, localNodeId, hwaccel) {
 		this.api = api;
 		if (localNodeId !== void 0) this.localNodeId = localNodeId;
+		if (hwaccel !== void 0) this.hwaccel = hwaccel;
 	}
 	/** Update the system `ffmpeg` config snapshot used by the transcode egress. */
 	setFfmpegConfig(cfg) {
@@ -12213,11 +12252,11 @@ var StreamBrokerManager = class {
 	}
 	/**
 	* The decode `hwaccel` options surfaceable in a (future) UI: the always-valid
-	* settings (`copy`, `auto`, `none`) plus the concrete backends the configured
-	* ffmpeg build actually supports (probed via `getHardwareDecodeAccels`). Lets
-	* a settings form offer exactly the backends this host can use, instead of the
-	* full static list that may include unsupported ones. Best-effort: on a probe
-	* miss it returns the always-valid settings only.
+	* settings (`copy`, `auto`, `none`) plus the concrete hardware backends THIS
+	* node can use, resolved from the LOCAL `ctx.kernel.hwaccel` (os.platform +
+	* GPU-vendor probe), ranked so vaapi precedes qsv. Node-local — never the
+	* `platform-probe` singleton (which answers with the hub's methods from a
+	* forked agent broker). Best-effort: no resolver / error → always-valid only.
 	*/
 	async getHwAccelOptions() {
 		const always = [
@@ -12225,12 +12264,12 @@ var StreamBrokerManager = class {
 			"auto",
 			"none"
 		];
-		if (!this.api) return always;
+		if (!this.hwaccel) return always;
 		try {
-			const probed = (await this.api.platformProbe.getHardwareDecodeAccels.query()).methods.filter((m) => FFMPEG_HW_ACCEL_SETTINGS.includes(m));
+			const probed = require_ffmpeg_args.rankDecodeHwAccels((await this.hwaccel.resolve(null)).preferred, []).filter((m) => FFMPEG_HW_ACCEL_SETTINGS.includes(m));
 			return [...always, ...probed];
 		} catch (err) {
-			this.logger.warn("getHwAccelOptions: getHardwareDecodeAccels failed — static options only", { meta: { error: require_dist.errMsg(err) } });
+			this.logger.warn("getHwAccelOptions: local hwaccel resolve failed — static options only", { meta: { error: require_dist.errMsg(err) } });
 			return always;
 		}
 	}
@@ -17061,8 +17100,24 @@ var WebrtcSessionProvider = class WebrtcSessionProvider {
 };
 //#endregion
 //#region src/stream-broker/addon.ts
-function isFfmpegHwAccel(v) {
-	return typeof v === "string" && FFMPEG_HW_ACCEL_SETTINGS.includes(v);
+/**
+* Hydrate the persisted RTSP restream state (`rtspTokens` / `rtspEnabled`)
+* through the durable `state()` handles — the sanctioned settings accessor —
+* instead of a raw `readAddonStore()`. Same store keys, same persisted
+* shapes; a corrupt blob falls back to empty (durable-state semantics) and
+* absent keys keep first-boot silence (no loader call, no log).
+*/
+async function hydratePersistedRtspState(deps) {
+	const tokens = new Map(Object.entries(await deps.tokensState.get()));
+	if (tokens.size > 0) {
+		deps.loadTokens(tokens);
+		deps.logger.info("Loaded persisted RTSP tokens", { meta: { tokenCount: tokens.size } });
+	}
+	const states = new Map(Object.entries(await deps.enabledState.get()));
+	if (states.size > 0) {
+		deps.loadEnabled(states);
+		deps.logger.info("Loaded persisted RTSP enabled states", { meta: { stateCount: states.size } });
+	}
 }
 var PROFILE_KEYS = [
 	"high",
@@ -17153,39 +17208,54 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 			maxDecodeFps: 5,
 			initialReconnectDelayMs: 1e3,
 			maxReconnectDelayMs: 3e4,
-			catalogReconcileIntervalSec: 30
+			catalogReconcileIntervalSec: 30,
+			binaryPath: "",
+			hwaccel: "copy"
 		});
 	}
 	/**
-	* Read the cluster `ffmpeg` config section (binaryPath / hwAccel /
-	* threadCount) and push it into the broker. Defensive: any missing or
-	* malformed field falls back to the safe default (PATH `ffmpeg`, `'copy'`
-	* software decode, `0` threads), and a read failure leaves the defaults in
-	* place. `'copy'` is the safe default — it decodes every HEVC source rather
-	* than hard-failing on a fragile one (the forced-backend trap).
+	* Resolve the ffmpeg binary for THIS node: a per-node `binaryPath` override
+	* (`binaryPath@<node>`) → else `ensureFfmpeg()` which provisions a guaranteed
+	* portable static binary locally (hub / agent / Mac). Replaces the retired
+	* global `ffmpeg` system section (node-local/empty on agents → a cross-node
+	* footgun). Falls back to PATH `ffmpeg` only if the provision genuinely fails.
+	*/
+	async resolveFfmpegBinaryPath() {
+		const override = this.config.binaryPath;
+		if (typeof override === "string" && override.trim().length > 0) return override;
+		try {
+			return await this.ctx.deps.ensureFfmpeg();
+		} catch (err) {
+			this.ctx.logger.error("stream-broker: ensureFfmpeg() failed to provision ffmpeg — falling back to PATH \"ffmpeg\"", { meta: { error: require_dist.errMsg(err) } });
+			return "ffmpeg";
+		}
+	}
+	/**
+	* Push THIS node's ffmpeg config into the broker — all node-local now, NOT the
+	* retired global `ffmpeg` section. `binaryPath` via {@link resolveFfmpegBinaryPath}
+	* (per-node override → ensureFfmpeg); `hwAccel` = the per-node `hwaccel`
+	* preference (default `'copy'` = software, the safe HEVC-compatible choice; the
+	* concrete backend is resolved node-locally in `resolveTranscodeDecodeHwAccel`
+	* / the transcode manager). `threadCount` is always `0` (auto — ffmpeg uses the
+	* node's own cores; the manual knob was removed).
 	*/
 	async loadFfmpegConfig() {
 		if (!this.brokerManager) return;
 		try {
-			const section = await this.ctx.settings?.getSection("ffmpeg") ?? {};
-			const binaryPathRaw = section["binaryPath"];
-			const binaryPath = typeof binaryPathRaw === "string" && binaryPathRaw.trim().length > 0 ? binaryPathRaw : "ffmpeg";
-			const hwAccel = isFfmpegHwAccel(section["hwAccel"]) ? section["hwAccel"] : "copy";
-			const threadCountRaw = section["threadCount"];
-			const threadCount = typeof threadCountRaw === "number" && Number.isFinite(threadCountRaw) && threadCountRaw >= 0 ? Math.floor(threadCountRaw) : 0;
+			const binaryPath = await this.resolveFfmpegBinaryPath();
+			const hwAccel = this.config.hwaccel;
 			this.brokerManager.setFfmpegConfig({
 				binaryPath,
 				hwAccel,
-				threadCount
+				threadCount: 0
 			});
 			this.ffmpegBinaryPath = binaryPath;
 			this.ctx.logger.info("Loaded ffmpeg config", { meta: {
 				binaryPath,
-				hwAccel,
-				threadCount
+				hwAccel
 			} });
 		} catch (err) {
-			this.ctx.logger.warn("Failed to read ffmpeg config section — using defaults", { meta: { error: require_dist.errMsg(err) } });
+			this.ctx.logger.warn("Failed to load ffmpeg config — using defaults", { meta: { error: require_dist.errMsg(err) } });
 		}
 	}
 	/**
@@ -17193,20 +17263,19 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 	* configured `ffmpeg.hwAccel` preference (default `'copy'` = software):
 	* - `'auto'` → the literal `'auto'` (ffmpeg self-selects + software-fallbacks).
 	* - `'copy'`/`'none'` → `null` (software decode).
-	* - a specific backend → gated against what the configured ffmpeg can decode
-	*   (`getHardwareDecodeAccels`); the feed still falls back to software on a
+	* - a specific backend → resolved from THIS node's LOCAL `ctx.kernel.hwaccel`
+	*   (ranked so vaapi precedes qsv); the feed still falls back to software on a
 	*   per-stream miss.
 	* Mirrors the transcode egress's resolution.
 	*/
 	async resolveTranscodeDecodeHwAccel() {
 		try {
-			const section = await this.ctx.settings?.getSection("ffmpeg") ?? {};
-			const strategy = classifyDecodeHwAccel(isFfmpegHwAccel(section["hwAccel"]) ? section["hwAccel"] : "copy");
+			const strategy = classifyDecodeHwAccel(this.config.hwaccel);
 			if (strategy.kind === "auto") return "auto";
 			if (strategy.kind === "software") return null;
-			const res = await this.ctx.api.platformProbe.resolveHwAccel.query({ prefer: strategy.prefer });
-			const supported = await this.ctx.api.platformProbe.getHardwareDecodeAccels.query();
-			return pickDecodeHwAccel(res.preferred, supported.methods);
+			const resolver = this.ctx.kernel.hwaccel;
+			if (!resolver) return null;
+			return require_ffmpeg_args.rankDecodeHwAccels((await resolver.resolve(strategy.prefer)).preferred, [])[0] ?? null;
 		} catch (err) {
 			this.ctx.logger.warn("resolveTranscodeDecodeHwAccel failed — software decode", { meta: { error: require_dist.errMsg(err) } });
 			return null;
@@ -17218,28 +17287,22 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 		this.brokerManager.setEventBus(this.ctx.eventBus);
 		const localNode = this.ctx.kernel.localNodeId;
 		const localNodeId = localNode ? localNode.includes("/") ? localNode.split("/")[0] : localNode : void 0;
-		this.brokerManager.setApiAccess(this.ctx.api, localNodeId);
+		this.brokerManager.setApiAccess(this.ctx.api, localNodeId, this.ctx.kernel.hwaccel);
 		if (this.capabilities) this.brokerManager.setCapabilitiesAccess(this.capabilities);
 		await this.loadFfmpegConfig();
 		const rtspProvider = this.brokerManager.getRtspRestreamProvider();
+		const brokerManager = this.brokerManager;
+		const rtspTokensState = this.state("rtspTokens", RtspTokensSchema, {});
+		const rtspEnabledState = this.state("rtspEnabled", RtspEnabledSchema, {});
 		try {
-			const addonStore = await this.ctx.settings?.readAddonStore() ?? {};
-			const tokenData = require_dist.asJsonObject(addonStore["rtspTokens"]);
-			if (tokenData) {
-				const tokens = /* @__PURE__ */ new Map();
-				for (const [k, v] of Object.entries(tokenData)) if (typeof v === "string") tokens.set(k, v);
-				this.brokerManager.loadPersistedTokens(tokens);
-				this.ctx.logger.info("Loaded persisted RTSP tokens", { meta: { tokenCount: tokens.size } });
-			}
-			const enabledData = require_dist.asJsonObject(addonStore["rtspEnabled"]);
-			if (enabledData) {
-				const states = /* @__PURE__ */ new Map();
-				for (const [k, v] of Object.entries(enabledData)) states.set(k, Boolean(v));
-				rtspProvider.loadPersistedEnabled(states);
-				this.ctx.logger.info("Loaded persisted RTSP enabled states", { meta: { stateCount: states.size } });
-			}
+			await hydratePersistedRtspState({
+				tokensState: rtspTokensState,
+				enabledState: rtspEnabledState,
+				loadTokens: (tokens) => brokerManager.loadPersistedTokens(tokens),
+				loadEnabled: (states) => rtspProvider.loadPersistedEnabled(states),
+				logger: this.ctx.logger
+			});
 		} catch {}
-		const rtspTokensState = this.state("rtspTokens", RtspTokensSchema, {});
 		rtspProvider.setTokenPersister(async (tokens) => {
 			try {
 				await rtspTokensState.update((prev) => {
@@ -17252,7 +17315,6 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 				this.ctx.logger.warn("Failed to persist RTSP tokens", { meta: { error: require_dist.errMsg(err) } });
 			}
 		});
-		const rtspEnabledState = this.state("rtspEnabled", RtspEnabledSchema, {});
 		rtspProvider.setEnabledPersister((states) => {
 			const obj = {};
 			for (const [k, v] of states) obj[k] = v;
@@ -17684,6 +17746,27 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 					step: 1,
 					default: 5
 				},
+				{
+					type: "select",
+					key: "hwaccel",
+					label: "Transcode hardware acceleration",
+					description: "Per-node decode/encode hwaccel for the WebRTC/restream transcode path. \"Software (copy)\" is the safe default (decodes every HEVC source); a concrete backend is resolved from this node’s own hardware. Per-node because hardware differs per node.",
+					options: [...FFMPEG_HW_ACCEL_SETTINGS].map((s) => ({
+						value: s,
+						label: hwAccelOptionLabel(s)
+					})),
+					default: "copy",
+					perNode: true
+				},
+				{
+					type: "text",
+					key: "binaryPath",
+					label: "ffmpeg binary path (override)",
+					description: "Optional per-node override for the ffmpeg binary. Leave empty to auto-provision a portable static ffmpeg on this node (recommended).",
+					placeholder: "ffmpeg",
+					default: "",
+					perNode: true
+				},
 				{
 					type: "number",
 					key: "catalogReconcileIntervalSec",
@@ -17753,7 +17836,7 @@ function codecToInputFormat(codec) {
 function buildFfmpegArgs(config) {
 	const inputFormat = codecToInputFormat(config.codec);
 	const args = [
-		...require_frame_dropper.logBannerArgs("error"),
+		...require_ffmpeg_args.logBannerArgs("error"),
 		"-fflags",
 		"+nobuffer+flush_packets",
 		"-flags",