@camstack/addon-pipeline 1.1.28 → 1.1.30

package/dist/audio-analyzer/index.js

@@ -3,7 +3,7 @@ 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-Biq62zt4.js");
+const require_dist = require("../dist-Cwc0TUQr.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 let node_fs = require("node:fs");
 node_fs = require_model_download_service_C_IHWnXx.__toESM(node_fs);

package/dist/audio-analyzer/index.mjs

@@ -1,5 +1,5 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { B as errMsg, D as mapAudioLabelToMacro, V as BaseAddon, _ as audioAnalyzerCapability, g as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, o as DEFAULT_AUDIO_ANALYZER_CONFIG, q as hydrateSchema, u as HF_BASE_URL } from "../dist-C6_wgXqF.mjs";
+import { B as errMsg, D as mapAudioLabelToMacro, V as BaseAddon, _ as audioAnalyzerCapability, g as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, o as DEFAULT_AUDIO_ANALYZER_CONFIG, q as hydrateSchema, u as HF_BASE_URL } from "../dist-DjuGmyG9.mjs";
 import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
 import { r as downloadFile } from "../model-download-service-C-IHWnXx-BPy6aoAx.mjs";
 import * as fs from "node:fs";

package/dist/audio-codec-ffmpeg/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Biq62zt4.js");
+const require_dist = require("../dist-Cwc0TUQr.js");
 let node_crypto = require("node:crypto");
 let node_child_process = require("node:child_process");
 //#region src/audio-codec-ffmpeg/ffmpeg-audio-process.ts
@@ -874,10 +874,6 @@ var AudioCodecFfmpegAddon = class extends require_dist.BaseAddon {
 	* still registers the cap and a later spawn re-runs against the same path.
 	*/
 	async resolveFfmpegBinaryPath() {
-		try {
-			const bp = (await this.ctx.settings?.getSection("ffmpeg") ?? {})["binaryPath"];
-			if (typeof bp === "string" && bp.trim().length > 0) return bp;
-		} catch {}
 		try {
 			return await this.ctx.deps.ensureFfmpeg();
 		} catch (err) {

package/dist/audio-codec-ffmpeg/index.mjs

@@ -1,4 +1,4 @@
-import { B as errMsg, V as BaseAddon, v as audioCodecCapability } from "../dist-C6_wgXqF.mjs";
+import { B as errMsg, V as BaseAddon, v as audioCodecCapability } from "../dist-DjuGmyG9.mjs";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 //#region src/audio-codec-ffmpeg/ffmpeg-audio-process.ts
@@ -870,10 +870,6 @@ var AudioCodecFfmpegAddon = class extends BaseAddon {
 	* still registers the cap and a later spawn re-runs against the same path.
 	*/
 	async resolveFfmpegBinaryPath() {
-		try {
-			const bp = (await this.ctx.settings?.getSection("ffmpeg") ?? {})["binaryPath"];
-			if (typeof bp === "string" && bp.trim().length > 0) return bp;
-		} catch {}
 		try {
 			return await this.ctx.deps.ensureFfmpeg();
 		} catch (err) {

package/dist/decoder-ffmpeg/index.js

@@ -2,305 +2,13 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Biq62zt4.js");
-const require_frame_ring_sink = require("../frame-ring-sink-9J0wCdLF.js");
-const require_frame_dropper = require("../frame-dropper-7RTo_YyG.js");
+const require_dist = require("../dist-Cwc0TUQr.js");
+const require_frame_ring_sink = require("../frame-ring-sink-8LLV-cvH.js");
+const require_ffmpeg_args = require("../ffmpeg-args-D6h1edXK.js");
+const require_frame_dropper = require("../frame-dropper-DKLM6pMz.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 let node_crypto = require("node:crypto");
 let node_child_process = require("node:child_process");
-//#region src/decoder-ffmpeg/ffmpeg-args.ts
-/**
-* Pure, side-effect-free ffmpeg argument construction for the
-* `decoder-ffmpeg` addon.
-*
-* The addon decodes video in an **ffmpeg subprocess** (unlike `decoder-nodeav`
-* which decodes in-process via node-av's native bindings). On the Intel hub,
-* node-av's VA-API decode path SIGBUSes (uncatchable) on 8MP h264 and takes the
-* whole decoder runner down; ffmpeg-as-subprocess decodes the same hardware
-* cleanly because a crash is isolated to the child process.
-*
-* These helpers are extracted from the session so the argument shape is
-* unit-testable without spawning a real ffmpeg binary.
-*
-* Validated working command on the Intel hub (renderD128, 8MP h264, ~50fps,
-* exit 0):
-*
-*   ffmpeg -hwaccel vaapi -hwaccel_device /dev/dri/renderD128 \
-*     -hwaccel_output_format vaapi -f h264 -i <in> \
-*     -vf hwdownload,format=nv12,scale=640:360,format=gray \
-*     -f rawvideo -y /dev/null
-*/
-/** Default DRM render node used for the VA-API / QSV hardware decode path. */
-var DEFAULT_VAAPI_RENDER_DEVICE = "/dev/dri/renderD128";
-/** Whether a resolved hwaccel value means "decode in software" (no `-hwaccel`). */
-function isSoftwareHwAccel(hwaccel) {
-	return hwaccel === null || hwaccel === "" || hwaccel === "none";
-}
-/** Backends whose decoded frames stay on the GPU and need an explicit
-*  `-hwaccel_output_format <m>` + `hwdownload,format=nv12` chain. */
-function needsHwDownload(hwaccel) {
-	return hwaccel === "vaapi" || hwaccel === "qsv";
-}
-/** Decode backend → its GPU scaler filter. */
-var GPU_SCALE_FILTER_BY_BACKEND = {
-	vaapi: "scale_vaapi",
-	qsv: "scale_qsv",
-	videotoolbox: "scale_vt"
-};
-/** Every GPU scaler this addon knows how to drive — used to scan `-filters`. */
-var KNOWN_GPU_SCALE_FILTERS = [
-	"scale_vaapi",
-	"scale_qsv",
-	"scale_vt"
-];
-/**
-* The GPU scaler that pairs with a decode backend, ignoring build support — a
-* static hwaccel → filter map. Returns null for software / a backend with no
-* GPU scaler (e.g. `cuda`, `drm`). Case-insensitive.
-*/
-function gpuScaleFilterForBackend(hwaccel) {
-	if (hwaccel === null) return null;
-	return GPU_SCALE_FILTER_BY_BACKEND[hwaccel.toLowerCase()] ?? null;
-}
-/**
-* Resolve the GPU scaler to use for a decode backend GIVEN the filters the
-* configured ffmpeg build actually offers ({@link parseAvailableGpuScaleFilters}).
-* Returns the filter when the backend maps to one AND the build has it; null
-* otherwise — the caller then emits the CPU-scale chain (graceful fallback).
-*/
-function resolveGpuScaleFilter(hwaccel, availableFilters) {
-	const filter = gpuScaleFilterForBackend(hwaccel);
-	if (filter === null) return null;
-	return availableFilters.has(filter) ? filter : null;
-}
-/**
-* Parse `ffmpeg -filters` stdout into the set of {@link KNOWN_GPU_SCALE_FILTERS}
-* the build offers. Matches whole filter tokens (word-boundary) so the plain
-* `scale` filter is never mistaken for a GPU scaler. PURE — the spawn lives in
-* the addon; only the parse is here so it is unit-tested.
-*/
-function parseAvailableGpuScaleFilters(filtersStdout) {
-	const present = /* @__PURE__ */ new Set();
-	for (const filter of KNOWN_GPU_SCALE_FILTERS) if (new RegExp(`\\b${filter}\\b`).test(filtersStdout)) present.add(filter);
-	return present;
-}
-/**
-* Whether the decode keeps frames on the GPU — needs `-hwaccel_output_format`
-* and an `hwdownload` in the filtergraph. VA-API / QSV always do (their decoded
-* surfaces live on the GPU); another backend only when a GPU scaler will run on
-* those surfaces (e.g. `videotoolbox` + `scale_vt`).
-*/
-function keepFramesOnGpu(hwaccel, gpuScaleFilter) {
-	return needsHwDownload(hwaccel) || gpuScaleFilter !== null;
-}
-/** Map a cap codec string to the ffmpeg `-f` input demuxer/format. */
-function codecToInputFormat(codec) {
-	switch (codec.toLowerCase()) {
-		case "h265":
-		case "hevc": return "hevc";
-		default: return "h264";
-	}
-}
-/** Map the cap-level output format to a raw ffmpeg pixel format. */
-function rawPixelForFormat(outputFormat) {
-	return outputFormat === "gray" ? "gray" : "rgb24";
-}
-/** Packed bytes-per-pixel for a raw output format (rgb24 = 3, gray = 1). */
-function channelsForPixel(pixel) {
-	return pixel === "gray" ? 1 : 3;
-}
-/**
-* The maximum output width for a given `scale` divisor — matches the node-av
-* scaler's `maxW = floor(640 / scale)` rule so both decoders produce
-* comparably-sized frames for the motion / detection pipeline.
-*/
-function maxDecodeWidth(scale) {
-	return Math.max(2, Math.floor(640 / (scale > 1 ? scale : 1)));
-}
-/**
-* Compute exact output geometry from a known source resolution — the node-av
-* rule (`outWidth = min(srcW, floor(640/scale))`, `outHeight =
-* round(outWidth*srcH/srcW)`). Provided for callers that DO know the source
-* dimensions; the live broker path leaves them to ffmpeg (`-2` height).
-*/
-function computeOutputGeometry(srcWidth, srcHeight, scale) {
-	const width = Math.min(srcWidth, maxDecodeWidth(scale));
-	return {
-		width,
-		height: Math.round(width * srcHeight / srcWidth)
-	};
-}
-/** Build the `-vf` filtergraph string for the requested hwaccel + pixel format. */
-function buildVideoFilter(hwaccel, pixel, outWidth, outHeight, maxW, gpuScaleFilter) {
-	const exact = outWidth !== void 0 && outWidth > 0 && outHeight !== void 0 && outHeight > 0;
-	if (gpuScaleFilter !== null) return `${gpuScaleFilter}=${exact ? `w=${outWidth}:h=${outHeight}` : `w=min(iw\\,${maxW}):h=-2`},hwdownload,format=nv12,format=${pixel}`;
-	const scaleAndFormat = `scale=${exact ? `${outWidth}:${outHeight}` : `min(iw\\,${maxW}):-2`},format=${pixel}`;
-	return needsHwDownload(hwaccel) ? `hwdownload,format=nv12,${scaleAndFormat}` : scaleAndFormat;
-}
-/**
-* Build the full ffmpeg argv for a decode session. PURE — no spawn, no env
-* access — so the argument shape is asserted in unit tests.
-*
-* Notes:
-* - `-loglevel info -nostats`: the session parses the muxer's `Output #0`
-*   stream line from stderr to learn the exact output W×H (the broker does not
-*   pass source geometry for the shm path). `-nostats` suppresses the periodic
-*   `frame= …` counter while keeping the one-shot Output block.
-* - The input is `pipe:0` (Annex-B packets written to stdin) in push mode, or
-*   `options.inputUrl` (the owner's restream, dialed by ffmpeg itself —
-*   `-rtsp_transport tcp` for rtsp URLs) in pull mode; the output is raw video
-*   on `pipe:1` either way.
-*/
-function buildFfmpegDecodeArgs(config, options) {
-	const inputFormat = codecToInputFormat(config.codec);
-	const pixel = rawPixelForFormat(config.outputFormat);
-	const maxW = maxDecodeWidth(config.scale);
-	const { hwaccel } = options;
-	const gpuScaleFilter = options.gpuScaleFilter ?? null;
-	const vf = buildVideoFilter(hwaccel, pixel, options.outWidth, options.outHeight, maxW, gpuScaleFilter);
-	let hwaccelArgs;
-	if (isSoftwareHwAccel(hwaccel) || hwaccel === null) hwaccelArgs = [];
-	else {
-		hwaccelArgs = ["-hwaccel", hwaccel];
-		if (needsHwDownload(hwaccel)) hwaccelArgs.push("-hwaccel_device", options.renderDevice ?? "/dev/dri/renderD128");
-		if (keepFramesOnGpu(hwaccel, gpuScaleFilter)) hwaccelArgs.push("-hwaccel_output_format", hwaccel);
-	}
-	const inputArgs = options.inputUrl !== void 0 ? [
-		...options.inputUrl.startsWith("rtsp") ? ["-rtsp_transport", "tcp"] : [],
-		"-i",
-		options.inputUrl
-	] : [
-		"-f",
-		inputFormat,
-		"-i",
-		"pipe:0"
-	];
-	return [
-		...require_frame_dropper.logBannerArgs("info"),
-		"-nostats",
-		"-fflags",
-		"+nobuffer+flush_packets",
-		"-flags",
-		"low_delay",
-		"-probesize",
-		"1M",
-		"-analyzeduration",
-		"0",
-		...hwaccelArgs,
-		...inputArgs,
-		"-vf",
-		vf,
-		"-f",
-		"rawvideo",
-		"-pix_fmt",
-		pixel,
-		"pipe:1"
-	];
-}
-/**
-* Parse the exact output geometry from ffmpeg's stderr. The muxer prints an
-* `Output #0, rawvideo …` block whose `Stream #0:0: Video: rawvideo …, <fmt>,
-* WIDTHxHEIGHT …` line carries the scaled dimensions. Gating on the `Output #`
-* marker avoids picking up the INPUT stream's (source) resolution, which is
-* printed earlier.
-*
-* Returns `null` until the Output block with a `WxH` token has been seen.
-*/
-function parseFfmpegOutputDims(stderr) {
-	const outputIdx = stderr.indexOf("Output #");
-	if (outputIdx < 0) return null;
-	const match = stderr.slice(outputIdx).match(/(\d{2,5})x(\d{2,5})/);
-	if (!match) return null;
-	const width = Number(match[1]);
-	const height = Number(match[2]);
-	if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) return null;
-	return {
-		width,
-		height
-	};
-}
-/**
-* Pick the first kernel-preferred `-hwaccel` method the configured ffmpeg build
-* actually supports, or `null` (software) when it supports none. Mirrors the
-* broker's `pickDecodeHwAccel` (`ffmpeg-invocation.ts`) so the decoder gates
-* decode-hwaccel against the same probed evidence:
-* - empty `preferred` → `null` (software);
-* - empty `supportedMethods` (probe miss) → keep the top preference and let the
-*   session's per-child software fallback cover a genuine failure;
-* - otherwise the first preference the build supports, or `null`.
-*/
-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;
-}
-/**
-* Canonical decode-hwaccel preference order for the ffmpeg-subprocess decoder.
-*
-* `vaapi` is ranked ABOVE `qsv` deliberately: on the Intel hub the `qsv` decode
-* child exits early (`code=171`, no frames) while the `vaapi` path decodes 8MP
-* h264 cleanly at ~50fps. The kernel probe (`resolveHwAccel`) tends to surface
-* `qsv` first on Intel, so we re-rank its result through this table before
-* building the attempt chain. `videotoolbox` leads for macOS; `cuda` / `nvdec`
-* trail for NVIDIA. A method not listed here keeps its incoming relative order,
-* placed AFTER every ranked one.
-*/
-var DECODE_HWACCEL_RANK = [
-	"videotoolbox",
-	"vaapi",
-	"qsv",
-	"cuda",
-	"nvdec",
-	"d3d11va",
-	"dxva2",
-	"amf",
-	"vdpau",
-	"drm"
-];
-/** Rank index for {@link DECODE_HWACCEL_RANK} — unranked methods sort last. */
-function decodeHwAccelRankIndex(method) {
-	const idx = DECODE_HWACCEL_RANK.indexOf(method.toLowerCase());
-	return idx < 0 ? DECODE_HWACCEL_RANK.length : idx;
-}
-/**
-* Build the ORDERED list of hardware `-hwaccel` methods to attempt for an
-* `'auto'` decode session, best-first. The session walks this chain on an
-* early-exit-with-no-frames and only falls to software once it is exhausted.
-*
-* Strategy:
-* - Seed candidates from the kernel-preferred order UNION the canonical rank
-*   UNION the build's supported list, so a method the kernel omitted but the
-*   build supports (the Intel `vaapi` case — kernel surfaces only `qsv`) is
-*   still attempted.
-* - When the build's supported-method list is known (non-empty), keep only
-*   methods it actually offers; on a probe miss (empty) keep just the kernel
-*   preferences (avoid blindly spawning every backend).
-* - Re-rank the survivors by {@link DECODE_HWACCEL_RANK} so `vaapi` precedes
-*   `qsv`. A supported method not in the rank table keeps its position AFTER
-*   every ranked one (stable sort). Returns lowercased method names; empty ⇒
-*   pure software.
-*/
-function rankDecodeHwAccels(preferred, supportedMethods) {
-	const supported = new Set(supportedMethods.map((m) => m.toLowerCase()));
-	const hasSupportList = supported.size > 0;
-	const pool = hasSupportList ? [
-		...preferred,
-		...DECODE_HWACCEL_RANK,
-		...supportedMethods
-	] : [...preferred];
-	const seen = /* @__PURE__ */ new Set();
-	const candidates = [];
-	for (const raw of pool) {
-		const method = raw.toLowerCase();
-		if (seen.has(method)) continue;
-		seen.add(method);
-		if (hasSupportList && !supported.has(method)) continue;
-		candidates.push(method);
-	}
-	return candidates.sort((a, b) => decodeHwAccelRankIndex(a) - decodeHwAccelRankIndex(b));
-}
-//#endregion
 //#region src/decoder-ffmpeg/frame-stream-splitter.ts
 var FrameStreamSplitter = class {
 	frameSize;
@@ -490,13 +198,13 @@ var FfmpegDecoderSession = class {
 		this.nodeId = options?.nodeId ?? "local";
 		this.renderDevice = options?.renderDevice;
 		this.ffmpegPath = options?.ffmpegPath ?? "ffmpeg";
-		const seededChain = options?.hwaccelChain ?? (options?.hwaccel != null && !isSoftwareHwAccel(options.hwaccel) ? [options.hwaccel] : []);
-		this.hwaccelChain = seededChain.filter((m) => !isSoftwareHwAccel(m));
+		const seededChain = options?.hwaccelChain ?? (options?.hwaccel != null && !require_ffmpeg_args.isSoftwareHwAccel(options.hwaccel) ? [options.hwaccel] : []);
+		this.hwaccelChain = seededChain.filter((m) => !require_ffmpeg_args.isSoftwareHwAccel(m));
 		this.hwaccel = this.currentHwAccel();
 		this.availableGpuScaleFilters = options?.availableGpuScaleFilters ?? /* @__PURE__ */ new Set();
 		this.onGpuScaleUnsupported = options?.onGpuScaleUnsupported;
-		this.pixel = rawPixelForFormat(config.outputFormat);
-		this.channels = channelsForPixel(this.pixel);
+		this.pixel = require_ffmpeg_args.rawPixelForFormat(config.outputFormat);
+		this.channels = require_ffmpeg_args.channelsForPixel(this.pixel);
 		this.frameFormat = this.pixel === "gray" ? "gray" : "rgb";
 		this.frameDropper = new require_frame_dropper.FrameDropper(config.maxFps);
 	}
@@ -551,8 +259,8 @@ var FfmpegDecoderSession = class {
 		this.outWidth = 0;
 		this.outHeight = 0;
 		this.frameSize = 0;
-		this.activeGpuScaleFilter = this.gpuScaleEnabled ? resolveGpuScaleFilter(this.hwaccel, this.availableGpuScaleFilters) : null;
-		const args = buildFfmpegDecodeArgs({
+		this.activeGpuScaleFilter = this.gpuScaleEnabled ? require_ffmpeg_args.resolveGpuScaleFilter(this.hwaccel, this.availableGpuScaleFilters) : null;
+		const args = require_ffmpeg_args.buildFfmpegDecodeArgs({
 			codec: this.config.codec,
 			scale: this.config.scale,
 			outputFormat: this.config.outputFormat
@@ -621,7 +329,7 @@ var FfmpegDecoderSession = class {
 	handleExit(code, signal) {
 		if (this.destroyed) return;
 		const diedFast = Date.now() - this.spawnedAtMs < HWACCEL_FALLBACK_WINDOW_MS;
-		if (!isSoftwareHwAccel(this.hwaccel) && this.outputFrames === 0 && diedFast) {
+		if (!require_ffmpeg_args.isSoftwareHwAccel(this.hwaccel) && this.outputFrames === 0 && diedFast) {
 			if (this.activeGpuScaleFilter !== null) {
 				const brokenFilter = this.activeGpuScaleFilter;
 				this.gpuScaleEnabled = false;
@@ -640,7 +348,7 @@ var FfmpegDecoderSession = class {
 			this.hwaccelIndex += 1;
 			this.hwaccel = this.currentHwAccel();
 			this.gpuScaleEnabled = true;
-			const next = isSoftwareHwAccel(this.hwaccel) ? "software" : this.hwaccel;
+			const next = require_ffmpeg_args.isSoftwareHwAccel(this.hwaccel) ? "software" : this.hwaccel;
 			this.logger.warn("ffmpeg decoder: hwaccel child exited early with no frames — trying next decode path", { meta: {
 				failed,
 				next,
@@ -889,7 +597,7 @@ function probeGpuScaleFilters(ffmpegPath, logger) {
 			done(/* @__PURE__ */ new Set());
 		});
 		child.on("exit", () => {
-			done(parseAvailableGpuScaleFilters(stdout));
+			done(require_ffmpeg_args.parseAvailableGpuScaleFilters(stdout));
 		});
 	});
 }
@@ -898,7 +606,8 @@ function probeGpuScaleFilters(ffmpegPath, logger) {
 var FRAME_BUFFER_CAPACITY = 32;
 var DEFAULT_DECODER_FFMPEG_ADDON_CONFIG = {
 	...require_dist.DEFAULT_DECODER_HWACCEL_CONFIG,
-	backend: require_frame_ring_sink.DEFAULT_DECODER_BACKEND
+	backend: require_frame_ring_sink.DEFAULT_DECODER_BACKEND,
+	binaryPath: ""
 };
 /** The two selectable decoder backends, in default-first order. */
 var DECODER_BACKEND_OPTIONS = [{
@@ -960,27 +669,40 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 			title: "Hardware acceleration",
 			tab: "decoder",
 			description: "Backend used by ffmpeg-subprocess decoder sessions. \"Auto\" defers to the probed best (VA-API on Intel); \"Off\" forces pure software. Only the VA-API hardware path is validated — other concrete backends degrade to software. Changes apply to NEW sessions.",
-			fields: [this.field({
-				type: "select",
-				key: "hwaccel",
-				label: "Preferred backend",
-				options: [...require_dist.HWACCEL_OPTIONS],
-				default: "auto",
-				immediate: true
-			}), this.field({
-				type: "text",
-				key: "probedBestHwaccel",
-				label: "Probed best",
-				description: "Auto-detected best decoder backend on this host. Click the refresh icon to re-run the probe.",
-				readonlyField: true,
-				default: "",
-				perNode: true,
-				actions: [{
-					action: "reprobe-hwaccel",
-					icon: "refresh-cw",
-					tooltip: "Re-probe hwaccel"
-				}]
-			})]
+			fields: [
+				this.field({
+					type: "select",
+					key: "hwaccel",
+					label: "Preferred backend",
+					options: [...require_dist.HWACCEL_OPTIONS],
+					default: "auto",
+					immediate: true,
+					perNode: true
+				}),
+				this.field({
+					type: "text",
+					key: "probedBestHwaccel",
+					label: "Probed best",
+					description: "Auto-detected best decoder backend on this host. Click the refresh icon to re-run the probe.",
+					readonlyField: true,
+					default: "",
+					perNode: true,
+					actions: [{
+						action: "reprobe-hwaccel",
+						icon: "refresh-cw",
+						tooltip: "Re-probe hwaccel"
+					}]
+				}),
+				this.field({
+					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). Per-node because the path differs per OS/arch.",
+					placeholder: "ffmpeg",
+					default: "",
+					perNode: true
+				})
+			]
 		}] });
 	}
 	async onInitialize() {
@@ -1022,10 +744,8 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 	* decoder cap and a later session spawn re-runs the ensure.
 	*/
 	async resolveFfmpegBinaryPath() {
-		try {
-			const bp = (await this.ctx.settings?.getSection("ffmpeg") ?? {})["binaryPath"];
-			if (typeof bp === "string" && bp.trim().length > 0) return bp;
-		} catch {}
+		const override = this.config.binaryPath;
+		if (typeof override === "string" && override.trim().length > 0) return override;
 		try {
 			return await this.ctx.deps.ensureFfmpeg();
 		} catch (err) {
@@ -1041,21 +761,51 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 	* - `'none'` → `[]` (pure software).
 	* - explicit backend → `[<backend>]` (forced; the session still falls to
 	*   software if that one child fails).
-	* - `'auto'` → asks `platform-probe.resolveHwAccel` for the kernel-preferred
-	*   order + the node's supported `-hwaccel` methods
-	*   (`getHardwareDecodeAccels`), then ranks them via {@link rankDecodeHwAccels}
-	*   (vaapi ABOVE qsv, since qsv is broken on the Intel stack while vaapi
-	*   works). On a probe error → `[]` (software).
+	* - `'auto'` → the LOCAL node's preferred order from `ctx.kernel.hwaccel` —
+	*   the in-process resolver every forked child (hub / worker / agent) is
+	*   given, which derives the backend from `os.platform()` + a GPU-vendor probe
+	*   (darwin → `videotoolbox`; Intel → `qsv,vaapi`; NVIDIA → `cuda,nvdec`).
+	*   Ranked via {@link rankDecodeHwAccels} (vaapi ABOVE qsv, since qsv is broken
+	*   on the Intel stack while vaapi works). On a resolver error → `[]`
+	*   (software).
+	*
+	* Two things this deliberately does NOT do:
+	* - It does NOT call the `platform-probe` singleton cap. Its per-node
+	*   `nodePin` does not survive a forked agent child's link chain, so a pinned
+	*   read resolves to the HUB's elected singleton and returns the hub's
+	*   hardware — a Mac decoder was handed the hub's Intel `vaapi/qsv/...` chain
+	*   (no `videotoolbox`) and fell all the way to software h265.
+	* - It does NOT probe `ffmpeg -hwaccels` (nor node-av) to intersect the list.
+	*   The accelerator is deterministic from the host, which the kernel resolver
+	*   already knows in-process — no subprocess, no cross-process round-trip. The
+	*   rare case where the resolved backend is not usable by the actual ffmpeg
+	*   build is covered by the session's per-child runtime fallback (advance to
+	*   the next chain entry, else software). This mirrors how Scrypted resolves
+	*   hwaccel (static `os.platform()` map + try-then-fall-back), not a native
+	*   capability enumeration.
+	*
+	* macOS special-case: the resolved `videotoolbox` is emitted as `-hwaccel
+	* auto`, NOT explicit `-hwaccel videotoolbox`. Explicit videotoolbox tears the
+	* ffmpeg child down under MULTIPLE concurrent decode streams (documented by
+	* Scrypted NVR's ffmpeg path; our Mac decodes many cameras at once — exactly
+	* that case). `auto` lets ffmpeg pick VideoToolbox internally and auto-download
+	* frames to software (no GPU surface to dispose, no `scale_vt`). The in-process
+	* node-av decoder (`decoder-nodeav`) still uses explicit videotoolbox — this
+	* substitution is specific to the ffmpeg-subprocess decode.
 	*/
 	async resolveDecodeHwaccelChain() {
 		const pref = this.config.hwaccel;
 		if (pref === "none") return [];
 		if (pref !== "auto") return [pref];
 		try {
-			const pin = require_dist.nodePin(this.resolveLocalNodeId());
-			const res = await this.ctx.api.platformProbe.resolveHwAccel.query({ prefer: null }, pin);
-			const supported = await this.ctx.api.platformProbe.getHardwareDecodeAccels.query(void 0, pin);
-			return rankDecodeHwAccels(res.preferred, supported.methods);
+			const resolver = this.ctx.kernel.hwaccel;
+			if (!resolver) {
+				this.ctx.logger.warn("ffmpeg: no local kernel hwaccel resolver — software decode");
+				return [];
+			}
+			const chain = require_ffmpeg_args.rankDecodeHwAccels((await resolver.resolve(null)).preferred, []);
+			if (process.platform === "darwin") return chain.map((method) => method === "videotoolbox" ? "auto" : method);
+			return chain;
 		} catch (err) {
 			this.ctx.logger.warn("ffmpeg: decode-hwaccel probe failed — software decode", { meta: { error: err instanceof Error ? err.message : String(err) } });
 			return [];
@@ -1070,7 +820,7 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 		}
 		try {
 			const res = await resolver.resolve();
-			const backend = res.preferred[0] ?? "none";
+			const backend = require_ffmpeg_args.rankDecodeHwAccels(res.preferred, [])[0] ?? "none";
 			await this.updateGlobalSettings({ probedBestHwaccel: backend });
 			this.ctx.logger.info("reprobeHwaccel: wrote probedBestHwaccel", { meta: {
 				backend,
@@ -1283,17 +1033,17 @@ var DecoderFfmpegAddon = class extends require_dist.BaseAddon {
 	}
 };
 //#endregion
-exports.DECODE_HWACCEL_RANK = DECODE_HWACCEL_RANK;
-exports.DEFAULT_VAAPI_RENDER_DEVICE = DEFAULT_VAAPI_RENDER_DEVICE;
+exports.DECODE_HWACCEL_RANK = require_ffmpeg_args.DECODE_HWACCEL_RANK;
+exports.DEFAULT_VAAPI_RENDER_DEVICE = require_ffmpeg_args.DEFAULT_VAAPI_RENDER_DEVICE;
 exports.DecoderFfmpegAddon = DecoderFfmpegAddon;
 exports.FfmpegDecoderSession = FfmpegDecoderSession;
-exports.buildFfmpegDecodeArgs = buildFfmpegDecodeArgs;
-exports.channelsForPixel = channelsForPixel;
-exports.codecToInputFormat = codecToInputFormat;
-exports.computeOutputGeometry = computeOutputGeometry;
+exports.buildFfmpegDecodeArgs = require_ffmpeg_args.buildFfmpegDecodeArgs;
+exports.channelsForPixel = require_ffmpeg_args.channelsForPixel;
+exports.codecToInputFormat = require_ffmpeg_args.codecToInputFormat;
+exports.computeOutputGeometry = require_ffmpeg_args.computeOutputGeometry;
 exports.default = DecoderFfmpegAddon;
-exports.maxDecodeWidth = maxDecodeWidth;
-exports.parseFfmpegOutputDims = parseFfmpegOutputDims;
-exports.pickDecodeHwAccel = pickDecodeHwAccel;
-exports.rankDecodeHwAccels = rankDecodeHwAccels;
-exports.rawPixelForFormat = rawPixelForFormat;
+exports.maxDecodeWidth = require_ffmpeg_args.maxDecodeWidth;
+exports.parseFfmpegOutputDims = require_ffmpeg_args.parseFfmpegOutputDims;
+exports.pickDecodeHwAccel = require_ffmpeg_args.pickDecodeHwAccel;
+exports.rankDecodeHwAccels = require_ffmpeg_args.rankDecodeHwAccels;
+exports.rawPixelForFormat = require_ffmpeg_args.rawPixelForFormat;