@camstack/addon-pipeline 1.1.31 → 1.1.33

package/dist/decoder-nodeav/index.js

@@ -2,9 +2,9 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-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_dist = require("../dist-BrIE85BG.js");
+const require_frame_ring_sink = require("../frame-ring-sink-B-DxHelU.js");
+const require_ffmpeg_args = require("../ffmpeg-args-Dl9mLcOC.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 let node_crypto = require("node:crypto");
 //#region src/decoder-nodeav/scaler-geometry.ts
@@ -22,6 +22,13 @@ function resolveScalerAction(current, incoming) {
 }
 //#endregion
 //#region src/decoder-nodeav/nodeav-decoder-session.ts
+/**
+* Pull-mode re-dial backoff. On a pull input error/EOF the loop waits this long
+* before re-opening the URL — mirrors the ffmpeg pull decoder's 3s re-dial so a
+* transient RTSP restream blip (source suspended on idle, keyframe wait) does
+* not hot-loop `Demuxer.open`.
+*/
+var PULL_REDIAL_MS = 3e3;
 /** Map our canonical backend name to the node-av `AV_HWDEVICE_TYPE_*` constant. */
 function backendToHwDeviceConst(backend, consts) {
 	switch (backend) {
@@ -58,11 +65,11 @@ var _nav = null;
 var _consts = null;
 var _sharp = null;
 async function getNodeAv() {
-	if (!_nav) _nav = await Promise.resolve().then(() => require("../dist-D3Ytt-_Y.js"));
+	if (!_nav) _nav = await import("node-av");
 	return _nav;
 }
 async function getConstants() {
-	if (!_consts) _consts = await Promise.resolve().then(() => require("../constants-CAqYVigN.js"));
+	if (!_consts) _consts = await import("node-av/constants");
 	return _consts;
 }
 async function getSharp() {
@@ -196,6 +203,20 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 	activeHwAccel = "none";
 	hwDevice = null;
 	swTransferFrame = null;
+	/** True once `openStream` has armed the pull loop; drives `isPullMode`. */
+	pullActive = false;
+	/** One-shot guard so a stray push into a pull session logs once, not per-packet. */
+	pullStrayPushLogged = false;
+	/** The URL the pull loop (re)dials — updatable while active. */
+	pullUrl = null;
+	/** Pending re-dial timer + its resolver, so `destroy` can wake it instantly. */
+	pullRedialTimer = null;
+	pullRedialResolve = null;
+	/** High-level demuxer/decoder for the CURRENT dial — recreated per re-dial. */
+	pullDemuxer = null;
+	pullDecoder = null;
+	/** HW context — resolved once, reused across re-dials, freed in `destroy`. */
+	pullHwContext = null;
 	constructor(config, logger = noopLogger, options) {
 		this.config = { ...config };
 		const sessionTags = {};
@@ -465,8 +486,171 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 			this.scalerInitializing = false;
 		}
 	}
+	/**
+	* Start PULL mode: libav dials `url` and demuxes it in-process, decoding
+	* every frame through the same emit path as push mode. Idempotent while
+	* active (updates the re-dial target). Throws if the session already took a
+	* push packet — a session is push-mode or pull-mode for its whole life.
+	*/
+	openStream(url) {
+		if (this.destroyed) return Promise.resolve();
+		if (this.inputPackets > 0 || this.initialized || this.initializing) throw new Error("node-av decoder: openStream on a push-fed session — a session is push-mode or pull-mode, never both");
+		if (this.pullActive) {
+			this.pullUrl = url;
+			return Promise.resolve();
+		}
+		this.pullActive = true;
+		this.pullUrl = url;
+		this.logger.info("node-av decoder: pull-mode openStream — dialing input URL", { meta: { url } });
+		this.runPullLoop().catch((err) => {
+			this.logger.error("node-av decoder: pull loop crashed", { meta: { error: require_dist.errMsg(err) } });
+		});
+		return Promise.resolve();
+	}
+	/**
+	* The pull-mode supervisor loop: resolve HW once, then repeatedly dial +
+	* decode the URL, re-dialing after {@link PULL_REDIAL_MS} on any exit/error
+	* until the session is destroyed. Each iteration rebuilds a fresh
+	* demuxer/decoder (the previous one is disposed in `closePullInput`).
+	*/
+	async runPullLoop() {
+		const nav = await getNodeAv();
+		const C = await getConstants();
+		this.EAGAIN = C.AVERROR_EAGAIN;
+		this.PIX_FMT_GRAY8 = C.AV_PIX_FMT_GRAY8;
+		this.PIX_FMT_RGB24 = C.AV_PIX_FMT_RGB24;
+		this.SWS_FAST_BILINEAR = C.SWS_FAST_BILINEAR;
+		nav.Log.setLevel(C.AV_LOG_FATAL);
+		if (this.outputMode === "jpeg" && !this.sharpFn) this.sharpFn = await getSharp();
+		await this.ensurePullHwContext(nav, C);
+		while (!this.destroyed && this.pullActive) {
+			const url = this.pullUrl;
+			if (!url) break;
+			try {
+				await this.pullDialAndDecode(nav, C, url);
+			} catch (err) {
+				if (this.destroyed) break;
+				this.logger.warn("node-av decoder: pull-mode dial ended — re-dial scheduled", { meta: {
+					error: require_dist.errMsg(err),
+					redialInMs: PULL_REDIAL_MS
+				} });
+			} finally {
+				this.closePullInput();
+			}
+			if (this.destroyed || !this.pullActive) break;
+			await this.pullSleep(PULL_REDIAL_MS);
+		}
+	}
+	/**
+	* One dial: open the demuxer, pick the video stream, create a HW/SW decoder
+	* that downloads + normalises frames to YUV420P (so the shared scaler in
+	* `emitDecodedFrame` reads plain software planes regardless of hwaccel), and
+	* pump `demuxer.packets(video) → decoder.frames → emitDecodedFrame` until the
+	* stream ends or the session is torn down.
+	*/
+	async pullDialAndDecode(nav, C, url) {
+		const demuxer = await nav.Demuxer.open(url, { options: { rtsp_transport: "tcp" } });
+		if (this.destroyed || !this.pullActive) {
+			demuxer[Symbol.dispose]?.();
+			return;
+		}
+		this.pullDemuxer = demuxer;
+		const videoStream = demuxer.video();
+		if (!videoStream) throw new Error("node-av decoder: pull input has no video stream");
+		const decoder = await nav.Decoder.create(videoStream, {
+			...this.pullHwContext ? { hardware: this.pullHwContext } : {},
+			rescale: { pixelFormat: C.AV_PIX_FMT_YUV420P }
+		});
+		if (this.destroyed || !this.pullActive) {
+			decoder[Symbol.dispose]?.();
+			return;
+		}
+		this.pullDecoder = decoder;
+		this.logger.info("node-av pull decoder initialized", { meta: {
+			codec: this.config.codec,
+			output: this.outputMode,
+			hwAccel: this.activeHwAccel,
+			streamIndex: videoStream.index
+		} });
+		for await (const frame of decoder.frames(demuxer.packets(videoStream.index))) {
+			if (this.destroyed || !this.pullActive) break;
+			if (!frame) continue;
+			this.inputPackets++;
+			try {
+				this.emitDecodedFrame(frame);
+			} finally {
+				frame.free();
+			}
+		}
+	}
+	/**
+	* Resolve and build the HW context for pull mode ONCE. Explicit backend →
+	* single try; `'auto'` → the kernel resolver's ordered list; no resolver →
+	* software. The first `HardwareContext.create` that succeeds wins; all
+	* failures fall through to software decode (`hardware: null`).
+	*/
+	async ensurePullHwContext(nav, C) {
+		if (this.hwaccelPref === "none") {
+			this.activeHwAccel = "none";
+			return;
+		}
+		const explicit = this.hwaccelPref === "auto" ? null : this.hwaccelPref;
+		const resolution = this.hwaccelResolver ? await this.hwaccelResolver.resolve(explicit) : explicit ? {
+			preferred: [explicit],
+			rationale: "explicit (no resolver)"
+		} : {
+			preferred: [],
+			rationale: "auto + no resolver → software"
+		};
+		for (const backend of resolution.preferred) {
+			const deviceType = backendToHwDeviceConst(backend, C);
+			if (!deviceType) continue;
+			const hw = nav.HardwareContext.create(deviceType);
+			if (!hw) {
+				this.logger.warn("node-av: pull hwaccel context create failed — trying next", { meta: { backend } });
+				continue;
+			}
+			this.pullHwContext = hw;
+			this.activeHwAccel = backend;
+			return;
+		}
+		this.logger.warn("node-av: no pull hwaccel backend initialised — using software", { meta: {
+			attempted: resolution.preferred.join(","),
+			rationale: resolution.rationale
+		} });
+		this.activeHwAccel = "none";
+	}
+	/** Dispose the CURRENT dial's demuxer + decoder (HW context is reused). */
+	closePullInput() {
+		if (this.pullDecoder) {
+			this.pullDecoder[Symbol.dispose]?.();
+			this.pullDecoder = null;
+		}
+		if (this.pullDemuxer) {
+			this.pullDemuxer[Symbol.dispose]?.();
+			this.pullDemuxer = null;
+		}
+	}
+	/** Interruptible sleep for the re-dial backoff — `destroy` resolves it early. */
+	pullSleep(ms) {
+		return new Promise((resolve) => {
+			this.pullRedialResolve = resolve;
+			this.pullRedialTimer = setTimeout(() => {
+				this.pullRedialTimer = null;
+				this.pullRedialResolve = null;
+				resolve();
+			}, ms);
+		});
+	}
 	pushPacket(packet) {
 		if (this.destroyed) return;
+		if (this.pullActive) {
+			if (!this.pullStrayPushLogged) {
+				this.pullStrayPushLogged = true;
+				this.logger.debug("node-av decoder: pushPacket on a pull-mode session — ignored");
+			}
+			return;
+		}
 		this.inputPackets++;
 		if (!this.initialized && !this.initializing && packet.keyframe) {
 			this.initDecoder().then(() => {
@@ -847,6 +1031,21 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 		this.destroyed = true;
 		this.frameCallbacks.clear();
 		this.handleCallbacks.clear();
+		this.pullActive = false;
+		if (this.pullRedialTimer) {
+			clearTimeout(this.pullRedialTimer);
+			this.pullRedialTimer = null;
+		}
+		if (this.pullRedialResolve) {
+			const resolve = this.pullRedialResolve;
+			this.pullRedialResolve = null;
+			resolve();
+		}
+		this.closePullInput();
+		if (this.pullHwContext) {
+			if (!this.pullHwContext.isDisposed) this.pullHwContext.dispose();
+			this.pullHwContext = null;
+		}
 		this.frameRingSink?.destroy();
 		this.frameRingSink = null;
 		this.dstFrame?.[Symbol.dispose]?.();
@@ -876,7 +1075,7 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 		};
 	}
 	get isPullMode() {
-		return false;
+		return this.pullActive;
 	}
 };
 //#endregion
@@ -955,14 +1154,16 @@ var DecoderNodeAvAddon = class extends require_dist.BaseAddon {
 		}];
 	}
 	/**
-	* Resolve the effective hwaccel backend for a new session. Reads
-	* this addon's own `hwaccel` setting first. `'auto'` defers to the
-	* session's local resolver (`ctx.kernel.hwaccel`) which probes the
-	* host and picks. No more orchestrator round-trip — decoder addon
-	* is self-sufficient for this setting as of phase 2d.
+	* Resolve the effective hwaccel backend for a new session. Reads the SHARED
+	* per-node override from the `decoder-ffmpeg` OWNER — the single value the
+	* Pipeline UI edits — exactly as `resolveDecoderBackend` reads the owner's
+	* `backend`. This makes a manual hwaccel override take effect even when
+	* node-av is the active backend (its OWN `hwaccel@node` is never surfaced by
+	* the UI). `'auto'` defers to the session's local resolver
+	* (`ctx.kernel.hwaccel`). Fails safe to `'auto'`.
 	*/
 	resolveHwAccelPref() {
-		return this.config.hwaccel;
+		return require_frame_ring_sink.resolveDecoderHwAccel(this.ctx.api, this.resolveLocalNodeId(), this.ctx.logger);
 	}
 	/**
 	* Re-run the platform probe on this host and persist the detected
@@ -1003,7 +1204,7 @@ var DecoderNodeAvAddon = class extends require_dist.BaseAddon {
 		return {
 			id: "decoder-nodeav",
 			name: "Decoder (node-av)",
-			isPullMode: false,
+			isPullMode: true,
 			priority: 10
 		};
 	}
@@ -1021,7 +1222,7 @@ var DecoderNodeAvAddon = class extends require_dist.BaseAddon {
 	}
 	async createSession(config) {
 		const sessionId = (0, node_crypto.randomUUID)();
-		const hwaccel = this.resolveHwAccelPref();
+		const hwaccel = await this.resolveHwAccelPref();
 		const { frameSink } = config;
 		const nodeId = this.resolveLocalNodeId();
 		const session = new NodeAvDecoderSession(config, this.ctx.logger, {
@@ -1121,8 +1322,9 @@ var DecoderNodeAvAddon = class extends require_dist.BaseAddon {
 		});
 	}
 	async openStream(input) {
-		if (!this.sessions.get(input.sessionId)) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);
-		input.url;
+		const session = this.sessions.get(input.sessionId);
+		if (!session) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);
+		await session.openStream(input.url);
 	}
 	async pullFrames(input) {
 		if (!this.sessions.has(input.sessionId)) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);

package/dist/decoder-nodeav/index.mjs

@@ -1,6 +1,6 @@
-import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-DjuGmyG9.mjs";
-import { a as resolveDecoderBackend, i as NotifyingRingBuffer, n as RING_BUDGET_MB, r as makeSegmentName, t as DecoderFrameRingSink } from "../frame-ring-sink-ClEWjiRU.mjs";
-import { f as rankDecodeHwAccels } from "../ffmpeg-args-C5GPp8Cw.mjs";
+import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-CfSORkv2.mjs";
+import { a as resolveDecoderBackend, i as NotifyingRingBuffer, n as RING_BUDGET_MB, o as resolveDecoderHwAccel, r as makeSegmentName, t as DecoderFrameRingSink } from "../frame-ring-sink-B_WjDX0x.mjs";
+import { f as rankDecodeHwAccels } from "../ffmpeg-args-CpeRWwL4.mjs";
 import { FrameRingReaderCache } from "@camstack/shm-ring";
 import { randomUUID } from "node:crypto";
 //#region src/decoder-nodeav/scaler-geometry.ts
@@ -18,6 +18,13 @@ function resolveScalerAction(current, incoming) {
 }
 //#endregion
 //#region src/decoder-nodeav/nodeav-decoder-session.ts
+/**
+* Pull-mode re-dial backoff. On a pull input error/EOF the loop waits this long
+* before re-opening the URL — mirrors the ffmpeg pull decoder's 3s re-dial so a
+* transient RTSP restream blip (source suspended on idle, keyframe wait) does
+* not hot-loop `Demuxer.open`.
+*/
+var PULL_REDIAL_MS = 3e3;
 /** Map our canonical backend name to the node-av `AV_HWDEVICE_TYPE_*` constant. */
 function backendToHwDeviceConst(backend, consts) {
 	switch (backend) {
@@ -54,11 +61,11 @@ var _nav = null;
 var _consts = null;
 var _sharp = null;
 async function getNodeAv() {
-	if (!_nav) _nav = await import("../dist-DluJuxV5.mjs");
+	if (!_nav) _nav = await import("node-av");
 	return _nav;
 }
 async function getConstants() {
-	if (!_consts) _consts = await import("../constants-oYgW36Ty.mjs");
+	if (!_consts) _consts = await import("node-av/constants");
 	return _consts;
 }
 async function getSharp() {
@@ -192,6 +199,20 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 	activeHwAccel = "none";
 	hwDevice = null;
 	swTransferFrame = null;
+	/** True once `openStream` has armed the pull loop; drives `isPullMode`. */
+	pullActive = false;
+	/** One-shot guard so a stray push into a pull session logs once, not per-packet. */
+	pullStrayPushLogged = false;
+	/** The URL the pull loop (re)dials — updatable while active. */
+	pullUrl = null;
+	/** Pending re-dial timer + its resolver, so `destroy` can wake it instantly. */
+	pullRedialTimer = null;
+	pullRedialResolve = null;
+	/** High-level demuxer/decoder for the CURRENT dial — recreated per re-dial. */
+	pullDemuxer = null;
+	pullDecoder = null;
+	/** HW context — resolved once, reused across re-dials, freed in `destroy`. */
+	pullHwContext = null;
 	constructor(config, logger = noopLogger, options) {
 		this.config = { ...config };
 		const sessionTags = {};
@@ -461,8 +482,171 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 			this.scalerInitializing = false;
 		}
 	}
+	/**
+	* Start PULL mode: libav dials `url` and demuxes it in-process, decoding
+	* every frame through the same emit path as push mode. Idempotent while
+	* active (updates the re-dial target). Throws if the session already took a
+	* push packet — a session is push-mode or pull-mode for its whole life.
+	*/
+	openStream(url) {
+		if (this.destroyed) return Promise.resolve();
+		if (this.inputPackets > 0 || this.initialized || this.initializing) throw new Error("node-av decoder: openStream on a push-fed session — a session is push-mode or pull-mode, never both");
+		if (this.pullActive) {
+			this.pullUrl = url;
+			return Promise.resolve();
+		}
+		this.pullActive = true;
+		this.pullUrl = url;
+		this.logger.info("node-av decoder: pull-mode openStream — dialing input URL", { meta: { url } });
+		this.runPullLoop().catch((err) => {
+			this.logger.error("node-av decoder: pull loop crashed", { meta: { error: errMsg(err) } });
+		});
+		return Promise.resolve();
+	}
+	/**
+	* The pull-mode supervisor loop: resolve HW once, then repeatedly dial +
+	* decode the URL, re-dialing after {@link PULL_REDIAL_MS} on any exit/error
+	* until the session is destroyed. Each iteration rebuilds a fresh
+	* demuxer/decoder (the previous one is disposed in `closePullInput`).
+	*/
+	async runPullLoop() {
+		const nav = await getNodeAv();
+		const C = await getConstants();
+		this.EAGAIN = C.AVERROR_EAGAIN;
+		this.PIX_FMT_GRAY8 = C.AV_PIX_FMT_GRAY8;
+		this.PIX_FMT_RGB24 = C.AV_PIX_FMT_RGB24;
+		this.SWS_FAST_BILINEAR = C.SWS_FAST_BILINEAR;
+		nav.Log.setLevel(C.AV_LOG_FATAL);
+		if (this.outputMode === "jpeg" && !this.sharpFn) this.sharpFn = await getSharp();
+		await this.ensurePullHwContext(nav, C);
+		while (!this.destroyed && this.pullActive) {
+			const url = this.pullUrl;
+			if (!url) break;
+			try {
+				await this.pullDialAndDecode(nav, C, url);
+			} catch (err) {
+				if (this.destroyed) break;
+				this.logger.warn("node-av decoder: pull-mode dial ended — re-dial scheduled", { meta: {
+					error: errMsg(err),
+					redialInMs: PULL_REDIAL_MS
+				} });
+			} finally {
+				this.closePullInput();
+			}
+			if (this.destroyed || !this.pullActive) break;
+			await this.pullSleep(PULL_REDIAL_MS);
+		}
+	}
+	/**
+	* One dial: open the demuxer, pick the video stream, create a HW/SW decoder
+	* that downloads + normalises frames to YUV420P (so the shared scaler in
+	* `emitDecodedFrame` reads plain software planes regardless of hwaccel), and
+	* pump `demuxer.packets(video) → decoder.frames → emitDecodedFrame` until the
+	* stream ends or the session is torn down.
+	*/
+	async pullDialAndDecode(nav, C, url) {
+		const demuxer = await nav.Demuxer.open(url, { options: { rtsp_transport: "tcp" } });
+		if (this.destroyed || !this.pullActive) {
+			demuxer[Symbol.dispose]?.();
+			return;
+		}
+		this.pullDemuxer = demuxer;
+		const videoStream = demuxer.video();
+		if (!videoStream) throw new Error("node-av decoder: pull input has no video stream");
+		const decoder = await nav.Decoder.create(videoStream, {
+			...this.pullHwContext ? { hardware: this.pullHwContext } : {},
+			rescale: { pixelFormat: C.AV_PIX_FMT_YUV420P }
+		});
+		if (this.destroyed || !this.pullActive) {
+			decoder[Symbol.dispose]?.();
+			return;
+		}
+		this.pullDecoder = decoder;
+		this.logger.info("node-av pull decoder initialized", { meta: {
+			codec: this.config.codec,
+			output: this.outputMode,
+			hwAccel: this.activeHwAccel,
+			streamIndex: videoStream.index
+		} });
+		for await (const frame of decoder.frames(demuxer.packets(videoStream.index))) {
+			if (this.destroyed || !this.pullActive) break;
+			if (!frame) continue;
+			this.inputPackets++;
+			try {
+				this.emitDecodedFrame(frame);
+			} finally {
+				frame.free();
+			}
+		}
+	}
+	/**
+	* Resolve and build the HW context for pull mode ONCE. Explicit backend →
+	* single try; `'auto'` → the kernel resolver's ordered list; no resolver →
+	* software. The first `HardwareContext.create` that succeeds wins; all
+	* failures fall through to software decode (`hardware: null`).
+	*/
+	async ensurePullHwContext(nav, C) {
+		if (this.hwaccelPref === "none") {
+			this.activeHwAccel = "none";
+			return;
+		}
+		const explicit = this.hwaccelPref === "auto" ? null : this.hwaccelPref;
+		const resolution = this.hwaccelResolver ? await this.hwaccelResolver.resolve(explicit) : explicit ? {
+			preferred: [explicit],
+			rationale: "explicit (no resolver)"
+		} : {
+			preferred: [],
+			rationale: "auto + no resolver → software"
+		};
+		for (const backend of resolution.preferred) {
+			const deviceType = backendToHwDeviceConst(backend, C);
+			if (!deviceType) continue;
+			const hw = nav.HardwareContext.create(deviceType);
+			if (!hw) {
+				this.logger.warn("node-av: pull hwaccel context create failed — trying next", { meta: { backend } });
+				continue;
+			}
+			this.pullHwContext = hw;
+			this.activeHwAccel = backend;
+			return;
+		}
+		this.logger.warn("node-av: no pull hwaccel backend initialised — using software", { meta: {
+			attempted: resolution.preferred.join(","),
+			rationale: resolution.rationale
+		} });
+		this.activeHwAccel = "none";
+	}
+	/** Dispose the CURRENT dial's demuxer + decoder (HW context is reused). */
+	closePullInput() {
+		if (this.pullDecoder) {
+			this.pullDecoder[Symbol.dispose]?.();
+			this.pullDecoder = null;
+		}
+		if (this.pullDemuxer) {
+			this.pullDemuxer[Symbol.dispose]?.();
+			this.pullDemuxer = null;
+		}
+	}
+	/** Interruptible sleep for the re-dial backoff — `destroy` resolves it early. */
+	pullSleep(ms) {
+		return new Promise((resolve) => {
+			this.pullRedialResolve = resolve;
+			this.pullRedialTimer = setTimeout(() => {
+				this.pullRedialTimer = null;
+				this.pullRedialResolve = null;
+				resolve();
+			}, ms);
+		});
+	}
 	pushPacket(packet) {
 		if (this.destroyed) return;
+		if (this.pullActive) {
+			if (!this.pullStrayPushLogged) {
+				this.pullStrayPushLogged = true;
+				this.logger.debug("node-av decoder: pushPacket on a pull-mode session — ignored");
+			}
+			return;
+		}
 		this.inputPackets++;
 		if (!this.initialized && !this.initializing && packet.keyframe) {
 			this.initDecoder().then(() => {
@@ -843,6 +1027,21 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 		this.destroyed = true;
 		this.frameCallbacks.clear();
 		this.handleCallbacks.clear();
+		this.pullActive = false;
+		if (this.pullRedialTimer) {
+			clearTimeout(this.pullRedialTimer);
+			this.pullRedialTimer = null;
+		}
+		if (this.pullRedialResolve) {
+			const resolve = this.pullRedialResolve;
+			this.pullRedialResolve = null;
+			resolve();
+		}
+		this.closePullInput();
+		if (this.pullHwContext) {
+			if (!this.pullHwContext.isDisposed) this.pullHwContext.dispose();
+			this.pullHwContext = null;
+		}
 		this.frameRingSink?.destroy();
 		this.frameRingSink = null;
 		this.dstFrame?.[Symbol.dispose]?.();
@@ -872,7 +1071,7 @@ var NodeAvDecoderSession = class NodeAvDecoderSession {
 		};
 	}
 	get isPullMode() {
-		return false;
+		return this.pullActive;
 	}
 };
 //#endregion
@@ -951,14 +1150,16 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 		}];
 	}
 	/**
-	* Resolve the effective hwaccel backend for a new session. Reads
-	* this addon's own `hwaccel` setting first. `'auto'` defers to the
-	* session's local resolver (`ctx.kernel.hwaccel`) which probes the
-	* host and picks. No more orchestrator round-trip — decoder addon
-	* is self-sufficient for this setting as of phase 2d.
+	* Resolve the effective hwaccel backend for a new session. Reads the SHARED
+	* per-node override from the `decoder-ffmpeg` OWNER — the single value the
+	* Pipeline UI edits — exactly as `resolveDecoderBackend` reads the owner's
+	* `backend`. This makes a manual hwaccel override take effect even when
+	* node-av is the active backend (its OWN `hwaccel@node` is never surfaced by
+	* the UI). `'auto'` defers to the session's local resolver
+	* (`ctx.kernel.hwaccel`). Fails safe to `'auto'`.
 	*/
 	resolveHwAccelPref() {
-		return this.config.hwaccel;
+		return resolveDecoderHwAccel(this.ctx.api, this.resolveLocalNodeId(), this.ctx.logger);
 	}
 	/**
 	* Re-run the platform probe on this host and persist the detected
@@ -999,7 +1200,7 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 		return {
 			id: "decoder-nodeav",
 			name: "Decoder (node-av)",
-			isPullMode: false,
+			isPullMode: true,
 			priority: 10
 		};
 	}
@@ -1017,7 +1218,7 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 	}
 	async createSession(config) {
 		const sessionId = randomUUID();
-		const hwaccel = this.resolveHwAccelPref();
+		const hwaccel = await this.resolveHwAccelPref();
 		const { frameSink } = config;
 		const nodeId = this.resolveLocalNodeId();
 		const session = new NodeAvDecoderSession(config, this.ctx.logger, {
@@ -1117,8 +1318,9 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 		});
 	}
 	async openStream(input) {
-		if (!this.sessions.get(input.sessionId)) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);
-		input.url;
+		const session = this.sessions.get(input.sessionId);
+		if (!session) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);
+		await session.openStream(input.url);
 	}
 	async pullFrames(input) {
 		if (!this.sessions.has(input.sessionId)) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);

package/dist/detection-pipeline/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-Cwc0TUQr.js");
+const require_dist = require("../dist-BrIE85BG.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 let node_fs = require("node:fs");
@@ -185,6 +185,35 @@ function pickBestRuntime(env, bestBackendHint) {
 		device: defaultDeviceFor(chosen)
 	};
 }
+/**
+* The ordered device candidates a runtime will try for an `'auto'`/`'all'`
+* device pick — mirrors what the python inference pool actually resolves
+* (openvino `_resolve_ov_devices`: NPU>GPU>CPU; coreml compute-units `all`:
+* ANE>GPU>CPU). Surfaced in `probedBestEngine` so the UI shows the real
+* accelerator order (`openvino/auto [NPU, GPU, CPU]`) instead of a bare `auto`
+* tag. Returns `[]` for runtimes with a single fixed device (onnx → CPU) — the
+* caller then keeps the plain `backend/device` label.
+*/
+function engineDeviceSequence(runtimeId, env) {
+	const hw = env.hardware;
+	switch (runtimeId) {
+		case "openvino": {
+			const seq = [];
+			if (hw?.npu?.type === "intel-npu") seq.push("NPU");
+			if (hw?.gpu?.type === "intel") seq.push("GPU");
+			seq.push("CPU");
+			return seq;
+		}
+		case "coreml": {
+			const seq = [];
+			if (hw?.npu?.type === "apple-ane") seq.push("ANE");
+			if (hw?.gpu != null) seq.push("GPU");
+			seq.push("CPU");
+			return seq;
+		}
+		default: return [];
+	}
+}
 //#endregion
 //#region src/detection-pipeline/engine-store-keys.ts
 /**
@@ -6423,14 +6452,16 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		try {
 			hardware = await this.addonCtx?.kernel?.inferenceEngine?.resolveHardware() ?? null;
 		} catch {}
-		const pick = pickBestRuntime(runtimeEnvFromProcess(hardware ? toProbedHardware(hardware) : null), null);
+		const env = runtimeEnvFromProcess(hardware ? toProbedHardware(hardware) : null);
+		const pick = pickBestRuntime(env, null);
 		const best = {
 			runtime: "python",
 			backend: pick.runtimeId,
 			format: modelFormatFor(pick.runtimeId),
 			device: pick.device
 		};
-		const probedLabel = `${best.backend}/${best.device ?? "default"}`;
+		const deviceSeq = engineDeviceSequence(pick.runtimeId, env);
+		const probedLabel = deviceSeq.length > 1 ? `${best.backend}/${best.device ?? "default"} [${deviceSeq.join(", ")}]` : `${best.backend}/${best.device ?? "default"}`;
 		const rpNode = this.localProbeNodeId();
 		if (pick.runtimeId !== "onnx" || hardware !== null) {
 			await this.writeStore({ [nodeEngineKey("probedBestEngine", rpNode)]: probedLabel });