@camstack/addon-pipeline 1.1.31 → 1.1.33

package/dist/{frame-ring-sink-8LLV-cvH.js → frame-ring-sink-B-DxHelU.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-Cwc0TUQr.js");
+const require_dist = require("./dist-BrIE85BG.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 //#region src/shared/decoder-backend-keys.ts
 /** Built-in default when a node has no selection — the subprocess decoder. */
@@ -18,8 +18,75 @@ function normalizeDecoderNodeId(rawNodeId) {
 }
 //#endregion
 //#region src/shared/decoder-backend.ts
+/**
+* Decoder backend selection — decides which decoder addon registers the
+* `decoder` cap on a node.
+*
+* Two decoder addons ship in this bundle: `decoder-ffmpeg` (subprocess
+* decode; a decode crash is isolated to the child) and `decoder-nodeav`
+* (in-process decode via FFmpeg native bindings; no subprocess lifecycle).
+* Both are installed on every node, but only ONE may provide the `decoder`
+* cap at a time.
+*
+* ## Why selection happens at REGISTRATION time (race-free by construction)
+*
+* The `decoder` cap is a singleton. Historically both decoder addons
+* registered a provider and the active slot was resolved AFTER the fact —
+* which exposed a boot-order race: whichever addon's runner initialised
+* first briefly held the active slot, and any consumer that resolved the
+* cap inside that window was dispatched to the wrong backend (the
+* cap-declared `preferredProvider` override only corrects the slot when
+* the preferred addon's registration eventually lands).
+*
+* This module removes the race by construction instead of arbitrating it:
+* each decoder addon calls {@link resolveDecoderBackend} at the START of
+* its `onInitialize` and registers its provider ONLY when it is the
+* selected backend — the other addon returns no registrations at all. At
+* most one `decoder` provider ever exists per node, so no resolution layer
+* (kernel `CapabilityRegistry`, route resolver, UDS child preference) can
+* pick a wrong one, regardless of boot order or timing.
+*
+* ## The setting
+*
+* The per-node selection lives in the `decoder-ffmpeg` OWNER addon's global
+* settings — the standard `addon-settings` surface, visible in the admin UI
+* as the owner's `backend` select field. The store is hub-central and the
+* value is persisted node-scoped as `backend@<nodeId>`
+* (`decoder-backend-keys.ts`); the owner's `getGlobalSettings` projects the
+* requested node's value onto the bare `backend` field.
+*
+* Both decoder addons read it the SAME way, placement-agnostically: via
+* `ctx.api.addonSettings.getGlobalSettings({ addonId: 'decoder-ffmpeg',
+* nodeId })`. The `addon-settings` cap is hub-routed at the system level
+* (`AddonCallGateway.classify` sends settings calls to the addon's base
+* node — the hub instance answers for every node), so an agent addon
+* transparently reads the hub-central store with no placement branching.
+* NOT used: `ctx.settings.getSection` (node-local — empty on an agent, the
+* original bug), the raw settings-store cap, or any custom side channel.
+*
+* Resolution: the node's scoped value → the built-in default
+* {@link DEFAULT_DECODER_BACKEND} (`'ffmpeg'`). There is deliberately NO
+* bare-key fallback (see `decoder-backend-keys.ts`), and any read failure
+* resolves to the default so the safe backend still comes up.
+*
+* ## Switching backends
+*
+* Because registration is decided once at addon init, changing the setting
+* takes effect on the next restart of the two decoder addons on the
+* affected node (addon restart / redeploy / node reboot). This is the
+* price of race-freedom: there is deliberately NO live re-arbitration
+* path — a live hand-off would reintroduce a window with two providers.
+*/
 /** The addon whose global settings OWN the per-node `backend` field. */
 var DECODER_OWNER_ADDON_ID = "decoder-ffmpeg";
+/** Fail-safe when the owner's hwaccel can't be read: defer to the local probe. */
+var DEFAULT_DECODER_HWACCEL = "auto";
+/** Narrow an arbitrary stored value to a known {@link HwAccelChoice}, else null. */
+function parseDecoderHwAccel(raw) {
+	if (typeof raw !== "string") return null;
+	const match = require_dist.HWACCEL_OPTIONS.find((o) => o.value === raw);
+	return match ? match.value : null;
+}
 function isHydratedField(entry) {
 	return typeof entry === "object" && entry !== null && "key" in entry;
 }
@@ -38,38 +105,112 @@ function pickDecoderBackendFromSettings(view) {
 	return DEFAULT_DECODER_BACKEND;
 }
 /**
-* Resolve the decoder backend this node should run. Called by BOTH decoder
-* addons at the start of `onInitialize`; the addon whose backend is NOT
-* selected registers nothing.
+* Resolve the OWNER addon's (`decoder-ffmpeg`) own per-node backend from its
+* ALREADY-PROJECTED global store — the store `BaseAddon.resolveGlobalStore`
+* returns, where the `perNode` `backend` field carries THIS node's value on
+* its bare key. The owner MUST use this instead of {@link resolveDecoderBackend}:
+* routing `addonSettings.getGlobalSettings({addonId:'decoder-ffmpeg'})` back to
+* itself during its OWN `onInitialize` DEADLOCKS (the addon is not "loaded" on
+* the node until init completes, but init is blocked on the read) → the read
+* throws `transport-failed (addon not loaded)` → it silently defaults to
+* `ffmpeg` and REGISTERS even when the node selected `nodeav`, producing a
+* two-provider decode storm. Reading its own store is local, race-free, and
+* has no deadlock.
+*/
+function resolveOwnDecoderBackend(projectedGlobalStore) {
+	return parseDecoderBackend(projectedGlobalStore["backend"]) ?? "ffmpeg";
+}
+/** Transient transport/settings-store fingerprints worth retrying on. */
+function isTransientSettingsError(message) {
+	return /not routable/i.test(message) || /not loaded/i.test(message) || /transport-failed/i.test(message) || /not connected/i.test(message) || /provider not available/i.test(message) || /SqliteSettingsBackend not initialized/i.test(message);
+}
+/**
+* Resolve the decoder backend a NON-OWNER addon (`decoder-nodeav`) should run,
+* by reading the OWNER's (`decoder-ffmpeg`) hub-central per-node `backend`.
 *
-* Fails safe: no api surface, a read error, or a null payload (owner not
-* answering yet) resolves to {@link DEFAULT_DECODER_BACKEND} — the default
-* backend still registers, and the non-default one stands down (never both).
+* The read routes to the owner addon's child runner; during a simultaneous
+* (re)start the owner may not be up yet → a transient `transport-failed (addon
+* not loaded)`. Immediately defaulting to `ffmpeg` here makes `decoder-nodeav`
+* stand down even though the node selected `nodeav` → NO decoder registers at
+* all. So retry on the transient fingerprints with a bounded budget (mirrors
+* `BaseAddon.readAddonStoreWithRetry`) until the owner answers; only a
+* persistent failure falls back to {@link DEFAULT_DECODER_BACKEND}.
+*
+* The OWNER addon must NOT call this (it would self-route + deadlock) — it uses
+* {@link resolveOwnDecoderBackend} against its own store instead.
 */
 async function resolveDecoderBackend(api, nodeId, logger) {
 	if (!api) {
 		logger.warn("decoder-backend: no api surface — using default backend", { meta: { default: DEFAULT_DECODER_BACKEND } });
 		return DEFAULT_DECODER_BACKEND;
 	}
+	const normalized = normalizeDecoderNodeId(nodeId);
+	const delaysMs = [
+		150,
+		350,
+		600,
+		900,
+		1200
+	];
+	let lastErr;
+	for (let attempt = 0; attempt <= delaysMs.length; attempt++) {
+		try {
+			const view = await api.addonSettings.getGlobalSettings.query({
+				addonId: DECODER_OWNER_ADDON_ID,
+				nodeId: normalized
+			});
+			if (view !== null) return pickDecoderBackendFromSettings(view);
+			lastErr = /* @__PURE__ */ new Error("owner settings unavailable (null)");
+		} catch (err) {
+			lastErr = err;
+			const msg = err instanceof Error ? err.message : String(err);
+			if (!isTransientSettingsError(msg)) {
+				logger.warn("decoder-backend: settings read failed — using default backend", { meta: {
+					default: DEFAULT_DECODER_BACKEND,
+					error: msg
+				} });
+				return DEFAULT_DECODER_BACKEND;
+			}
+		}
+		if (attempt === delaysMs.length) break;
+		await new Promise((resolve) => setTimeout(resolve, delaysMs[attempt]));
+	}
+	logger.warn("decoder-backend: owner settings unavailable after retries — using default backend", { meta: {
+		default: DEFAULT_DECODER_BACKEND,
+		owner: DECODER_OWNER_ADDON_ID,
+		error: lastErr instanceof Error ? lastErr.message : String(lastErr)
+	} });
+	return DEFAULT_DECODER_BACKEND;
+}
+/**
+* Pure selection of the owner's `hwaccel` field from an already-read hydrated
+* settings payload. Missing/invalid/null → {@link DEFAULT_DECODER_HWACCEL}.
+*/
+function pickDecoderHwAccelFromSettings(view) {
+	if (view === null) return DEFAULT_DECODER_HWACCEL;
+	for (const section of view.sections) for (const entry of section.fields) {
+		if (!isHydratedField(entry) || entry.key !== "hwaccel") continue;
+		return parseDecoderHwAccel(entry.value) ?? "auto";
+	}
+	return DEFAULT_DECODER_HWACCEL;
+}
+/**
+* Resolve the effective decoder hwaccel override for a node by reading the
+* `decoder-ffmpeg` OWNER's `hwaccel@<node>` setting — the exact same
+* hub-routed, placement-agnostic read as {@link resolveDecoderBackend}, so
+* node-av and ffmpeg honour ONE per-node value (the one the UI edits). Fails
+* safe to {@link DEFAULT_DECODER_HWACCEL} (`'auto'` → the session's local probe).
+*/
+async function resolveDecoderHwAccel(api, nodeId, logger) {
+	if (!api) return DEFAULT_DECODER_HWACCEL;
 	try {
-		const view = await api.addonSettings.getGlobalSettings.query({
+		return pickDecoderHwAccelFromSettings(await api.addonSettings.getGlobalSettings.query({
 			addonId: DECODER_OWNER_ADDON_ID,
 			nodeId: normalizeDecoderNodeId(nodeId)
-		});
-		if (view === null) {
-			logger.warn("decoder-backend: owner settings unavailable — using default backend", { meta: {
-				default: DEFAULT_DECODER_BACKEND,
-				owner: DECODER_OWNER_ADDON_ID
-			} });
-			return DEFAULT_DECODER_BACKEND;
-		}
-		return pickDecoderBackendFromSettings(view);
+		}));
 	} catch (err) {
-		logger.warn("decoder-backend: settings read failed — using default backend", { meta: {
-			default: DEFAULT_DECODER_BACKEND,
-			error: err instanceof Error ? err.message : String(err)
-		} });
-		return DEFAULT_DECODER_BACKEND;
+		logger.warn("decoder-hwaccel: owner settings read failed — deferring to local probe", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		return DEFAULT_DECODER_HWACCEL;
 	}
 }
 //#endregion
@@ -442,3 +583,15 @@ Object.defineProperty(exports, "resolveDecoderBackend", {
 		return resolveDecoderBackend;
 	}
 });
+Object.defineProperty(exports, "resolveDecoderHwAccel", {
+	enumerable: true,
+	get: function() {
+		return resolveDecoderHwAccel;
+	}
+});
+Object.defineProperty(exports, "resolveOwnDecoderBackend", {
+	enumerable: true,
+	get: function() {
+		return resolveOwnDecoderBackend;
+	}
+});

package/dist/{frame-ring-sink-ClEWjiRU.mjs → frame-ring-sink-B_WjDX0x.mjs}

@@ -1,4 +1,4 @@
-import { p as RingBuffer } from "./dist-DjuGmyG9.mjs";
+import { d as HWACCEL_OPTIONS, p as RingBuffer } from "./dist-CfSORkv2.mjs";
 import { FrameRingWriter, MIN_RING_SLOTS, computeSegmentSize, computeSlotByteLength, createSegment, deriveSlotCount } from "@camstack/shm-ring";
 //#region src/shared/decoder-backend-keys.ts
 /** Built-in default when a node has no selection — the subprocess decoder. */
@@ -18,8 +18,75 @@ function normalizeDecoderNodeId(rawNodeId) {
 }
 //#endregion
 //#region src/shared/decoder-backend.ts
+/**
+* Decoder backend selection — decides which decoder addon registers the
+* `decoder` cap on a node.
+*
+* Two decoder addons ship in this bundle: `decoder-ffmpeg` (subprocess
+* decode; a decode crash is isolated to the child) and `decoder-nodeav`
+* (in-process decode via FFmpeg native bindings; no subprocess lifecycle).
+* Both are installed on every node, but only ONE may provide the `decoder`
+* cap at a time.
+*
+* ## Why selection happens at REGISTRATION time (race-free by construction)
+*
+* The `decoder` cap is a singleton. Historically both decoder addons
+* registered a provider and the active slot was resolved AFTER the fact —
+* which exposed a boot-order race: whichever addon's runner initialised
+* first briefly held the active slot, and any consumer that resolved the
+* cap inside that window was dispatched to the wrong backend (the
+* cap-declared `preferredProvider` override only corrects the slot when
+* the preferred addon's registration eventually lands).
+*
+* This module removes the race by construction instead of arbitrating it:
+* each decoder addon calls {@link resolveDecoderBackend} at the START of
+* its `onInitialize` and registers its provider ONLY when it is the
+* selected backend — the other addon returns no registrations at all. At
+* most one `decoder` provider ever exists per node, so no resolution layer
+* (kernel `CapabilityRegistry`, route resolver, UDS child preference) can
+* pick a wrong one, regardless of boot order or timing.
+*
+* ## The setting
+*
+* The per-node selection lives in the `decoder-ffmpeg` OWNER addon's global
+* settings — the standard `addon-settings` surface, visible in the admin UI
+* as the owner's `backend` select field. The store is hub-central and the
+* value is persisted node-scoped as `backend@<nodeId>`
+* (`decoder-backend-keys.ts`); the owner's `getGlobalSettings` projects the
+* requested node's value onto the bare `backend` field.
+*
+* Both decoder addons read it the SAME way, placement-agnostically: via
+* `ctx.api.addonSettings.getGlobalSettings({ addonId: 'decoder-ffmpeg',
+* nodeId })`. The `addon-settings` cap is hub-routed at the system level
+* (`AddonCallGateway.classify` sends settings calls to the addon's base
+* node — the hub instance answers for every node), so an agent addon
+* transparently reads the hub-central store with no placement branching.
+* NOT used: `ctx.settings.getSection` (node-local — empty on an agent, the
+* original bug), the raw settings-store cap, or any custom side channel.
+*
+* Resolution: the node's scoped value → the built-in default
+* {@link DEFAULT_DECODER_BACKEND} (`'ffmpeg'`). There is deliberately NO
+* bare-key fallback (see `decoder-backend-keys.ts`), and any read failure
+* resolves to the default so the safe backend still comes up.
+*
+* ## Switching backends
+*
+* Because registration is decided once at addon init, changing the setting
+* takes effect on the next restart of the two decoder addons on the
+* affected node (addon restart / redeploy / node reboot). This is the
+* price of race-freedom: there is deliberately NO live re-arbitration
+* path — a live hand-off would reintroduce a window with two providers.
+*/
 /** The addon whose global settings OWN the per-node `backend` field. */
 var DECODER_OWNER_ADDON_ID = "decoder-ffmpeg";
+/** Fail-safe when the owner's hwaccel can't be read: defer to the local probe. */
+var DEFAULT_DECODER_HWACCEL = "auto";
+/** Narrow an arbitrary stored value to a known {@link HwAccelChoice}, else null. */
+function parseDecoderHwAccel(raw) {
+	if (typeof raw !== "string") return null;
+	const match = HWACCEL_OPTIONS.find((o) => o.value === raw);
+	return match ? match.value : null;
+}
 function isHydratedField(entry) {
 	return typeof entry === "object" && entry !== null && "key" in entry;
 }
@@ -38,38 +105,112 @@ function pickDecoderBackendFromSettings(view) {
 	return DEFAULT_DECODER_BACKEND;
 }
 /**
-* Resolve the decoder backend this node should run. Called by BOTH decoder
-* addons at the start of `onInitialize`; the addon whose backend is NOT
-* selected registers nothing.
+* Resolve the OWNER addon's (`decoder-ffmpeg`) own per-node backend from its
+* ALREADY-PROJECTED global store — the store `BaseAddon.resolveGlobalStore`
+* returns, where the `perNode` `backend` field carries THIS node's value on
+* its bare key. The owner MUST use this instead of {@link resolveDecoderBackend}:
+* routing `addonSettings.getGlobalSettings({addonId:'decoder-ffmpeg'})` back to
+* itself during its OWN `onInitialize` DEADLOCKS (the addon is not "loaded" on
+* the node until init completes, but init is blocked on the read) → the read
+* throws `transport-failed (addon not loaded)` → it silently defaults to
+* `ffmpeg` and REGISTERS even when the node selected `nodeav`, producing a
+* two-provider decode storm. Reading its own store is local, race-free, and
+* has no deadlock.
+*/
+function resolveOwnDecoderBackend(projectedGlobalStore) {
+	return parseDecoderBackend(projectedGlobalStore["backend"]) ?? "ffmpeg";
+}
+/** Transient transport/settings-store fingerprints worth retrying on. */
+function isTransientSettingsError(message) {
+	return /not routable/i.test(message) || /not loaded/i.test(message) || /transport-failed/i.test(message) || /not connected/i.test(message) || /provider not available/i.test(message) || /SqliteSettingsBackend not initialized/i.test(message);
+}
+/**
+* Resolve the decoder backend a NON-OWNER addon (`decoder-nodeav`) should run,
+* by reading the OWNER's (`decoder-ffmpeg`) hub-central per-node `backend`.
+*
+* The read routes to the owner addon's child runner; during a simultaneous
+* (re)start the owner may not be up yet → a transient `transport-failed (addon
+* not loaded)`. Immediately defaulting to `ffmpeg` here makes `decoder-nodeav`
+* stand down even though the node selected `nodeav` → NO decoder registers at
+* all. So retry on the transient fingerprints with a bounded budget (mirrors
+* `BaseAddon.readAddonStoreWithRetry`) until the owner answers; only a
+* persistent failure falls back to {@link DEFAULT_DECODER_BACKEND}.
 *
-* Fails safe: no api surface, a read error, or a null payload (owner not
-* answering yet) resolves to {@link DEFAULT_DECODER_BACKEND} — the default
-* backend still registers, and the non-default one stands down (never both).
+* The OWNER addon must NOT call this (it would self-route + deadlock) — it uses
+* {@link resolveOwnDecoderBackend} against its own store instead.
 */
 async function resolveDecoderBackend(api, nodeId, logger) {
 	if (!api) {
 		logger.warn("decoder-backend: no api surface — using default backend", { meta: { default: DEFAULT_DECODER_BACKEND } });
 		return DEFAULT_DECODER_BACKEND;
 	}
+	const normalized = normalizeDecoderNodeId(nodeId);
+	const delaysMs = [
+		150,
+		350,
+		600,
+		900,
+		1200
+	];
+	let lastErr;
+	for (let attempt = 0; attempt <= delaysMs.length; attempt++) {
+		try {
+			const view = await api.addonSettings.getGlobalSettings.query({
+				addonId: DECODER_OWNER_ADDON_ID,
+				nodeId: normalized
+			});
+			if (view !== null) return pickDecoderBackendFromSettings(view);
+			lastErr = /* @__PURE__ */ new Error("owner settings unavailable (null)");
+		} catch (err) {
+			lastErr = err;
+			const msg = err instanceof Error ? err.message : String(err);
+			if (!isTransientSettingsError(msg)) {
+				logger.warn("decoder-backend: settings read failed — using default backend", { meta: {
+					default: DEFAULT_DECODER_BACKEND,
+					error: msg
+				} });
+				return DEFAULT_DECODER_BACKEND;
+			}
+		}
+		if (attempt === delaysMs.length) break;
+		await new Promise((resolve) => setTimeout(resolve, delaysMs[attempt]));
+	}
+	logger.warn("decoder-backend: owner settings unavailable after retries — using default backend", { meta: {
+		default: DEFAULT_DECODER_BACKEND,
+		owner: DECODER_OWNER_ADDON_ID,
+		error: lastErr instanceof Error ? lastErr.message : String(lastErr)
+	} });
+	return DEFAULT_DECODER_BACKEND;
+}
+/**
+* Pure selection of the owner's `hwaccel` field from an already-read hydrated
+* settings payload. Missing/invalid/null → {@link DEFAULT_DECODER_HWACCEL}.
+*/
+function pickDecoderHwAccelFromSettings(view) {
+	if (view === null) return DEFAULT_DECODER_HWACCEL;
+	for (const section of view.sections) for (const entry of section.fields) {
+		if (!isHydratedField(entry) || entry.key !== "hwaccel") continue;
+		return parseDecoderHwAccel(entry.value) ?? "auto";
+	}
+	return DEFAULT_DECODER_HWACCEL;
+}
+/**
+* Resolve the effective decoder hwaccel override for a node by reading the
+* `decoder-ffmpeg` OWNER's `hwaccel@<node>` setting — the exact same
+* hub-routed, placement-agnostic read as {@link resolveDecoderBackend}, so
+* node-av and ffmpeg honour ONE per-node value (the one the UI edits). Fails
+* safe to {@link DEFAULT_DECODER_HWACCEL} (`'auto'` → the session's local probe).
+*/
+async function resolveDecoderHwAccel(api, nodeId, logger) {
+	if (!api) return DEFAULT_DECODER_HWACCEL;
 	try {
-		const view = await api.addonSettings.getGlobalSettings.query({
+		return pickDecoderHwAccelFromSettings(await api.addonSettings.getGlobalSettings.query({
 			addonId: DECODER_OWNER_ADDON_ID,
 			nodeId: normalizeDecoderNodeId(nodeId)
-		});
-		if (view === null) {
-			logger.warn("decoder-backend: owner settings unavailable — using default backend", { meta: {
-				default: DEFAULT_DECODER_BACKEND,
-				owner: DECODER_OWNER_ADDON_ID
-			} });
-			return DEFAULT_DECODER_BACKEND;
-		}
-		return pickDecoderBackendFromSettings(view);
+		}));
 	} catch (err) {
-		logger.warn("decoder-backend: settings read failed — using default backend", { meta: {
-			default: DEFAULT_DECODER_BACKEND,
-			error: err instanceof Error ? err.message : String(err)
-		} });
-		return DEFAULT_DECODER_BACKEND;
+		logger.warn("decoder-hwaccel: owner settings read failed — deferring to local probe", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		return DEFAULT_DECODER_HWACCEL;
 	}
 }
 //#endregion
@@ -406,4 +547,4 @@ var DecoderFrameRingSink = class {
 	}
 };
 //#endregion
-export { resolveDecoderBackend as a, NotifyingRingBuffer as i, RING_BUDGET_MB as n, DEFAULT_DECODER_BACKEND as o, makeSegmentName as r, DecoderFrameRingSink as t };
+export { resolveDecoderBackend as a, DEFAULT_DECODER_BACKEND as c, NotifyingRingBuffer as i, RING_BUDGET_MB as n, resolveDecoderHwAccel as o, makeSegmentName as r, resolveOwnDecoderBackend as s, DecoderFrameRingSink as t };

package/dist/motion-wasm/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Cwc0TUQr.js");
+const require_dist = require("../dist-BrIE85BG.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 let node_fs = require("node:fs");
 let node_path = require("node:path");

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { A as motionDetectionCapability, T as evaluateZoneRules, V as BaseAddon, W as DeviceType, q as hydrateSchema } from "../dist-DjuGmyG9.mjs";
+import { A as motionDetectionCapability, T as evaluateZoneRules, V as BaseAddon, W as DeviceType, q as hydrateSchema } from "../dist-CfSORkv2.mjs";
 import { FrameRingReaderCache } from "@camstack/shm-ring";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/pipeline-runner/index.js

@@ -2,8 +2,8 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Cwc0TUQr.js");
-const require_frame_handle_plane = require("../frame-handle-plane-DQNCTrpC.js");
+const require_dist = require("../dist-BrIE85BG.js");
+const require_frame_handle_plane = require("../frame-handle-plane-zMju9vmk.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 //#region src/pipeline-runner/bench-actions.ts
@@ -1409,6 +1409,55 @@ function toFrameInput(frame) {
 	};
 }
 /**
+* Convert a packed RGB24 `DecodedFrame` into a packed GRAY8 one using the
+* BT.601 luma weighting (Y = 0.299R + 0.587G + 0.114B, integer-approximated as
+* 77/150/29 over 256).
+*
+* This is what lets **sensor-triggered (onboard) motion share the detection
+* decode**: the gray the motion analyzer needs is just the luma of the
+* already-decoded detection `rgb` frame, so no second decoder is spun up. Far
+* cheaper than a full second decode (a per-pixel weighted sum vs. an entire
+* H.264/H.265 decode). Persistent (analyzer-only) motion keeps its own gray
+* decode on the sub stream and never hits this path.
+*/
+function rgbFrameToGrayFrame(frame) {
+	const rgb = frame.data;
+	const pixels = frame.width * frame.height;
+	const gray = Buffer.allocUnsafe(pixels);
+	for (let i = 0, j = 0; i < pixels; i++, j += 3) gray[i] = rgb[j] * 77 + rgb[j + 1] * 150 + rgb[j + 2] * 29 >> 8;
+	return {
+		data: gray,
+		width: frame.width,
+		height: frame.height,
+		format: "gray",
+		timestamp: frame.timestamp,
+		...frame.capturedAt !== void 0 ? { capturedAt: frame.capturedAt } : {}
+	};
+}
+/**
+* Decide where the motion analyzer reads frames from.
+*
+* - `sharedWithDetection` (onboard/sensor-triggered) AND detection actually
+*   runs (`detectionMode !== 'disabled'`) → ride the detection decode:
+*   `rgb` on the MAIN (`detectionStreamId`) stream, converted to gray. No
+*   second decoder — the `FrameHandlePlane` coalesces it onto detection's session.
+* - Otherwise (persistent analyzer, or detection disabled) → a dedicated
+*   `gray` decode on the SUB (`motionStreamId`) stream, exactly as before.
+*
+* Pure so the decision is unit-testable without the addon/broker.
+*/
+function resolveMotionFrameSource(config, sharedWithDetection) {
+	return sharedWithDetection && config.detectionMode !== "disabled" ? {
+		streamId: config.detectionStreamId,
+		format: "rgb",
+		shared: true
+	} : {
+		streamId: config.motionStreamId,
+		format: "gray",
+		shared: false
+	};
+}
+/**
 * Interval for periodic metric snapshot emission. ~1 Hz strikes the
 * balance between UI freshness (overlay phase / fps numbers feel live)
 * and bus traffic (one snapshot per attached camera + one per node
@@ -1911,6 +1960,12 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 			}
 		});
 		if (this.attached.has(config.deviceId)) this.detachInternal(config.deviceId);
+		const attachment = {
+			config,
+			motionUnsubscribe: null,
+			detectionUnsubscribe: null
+		};
+		this.attached.set(config.deviceId, attachment);
 		runner.registerCamera(config.deviceId, {
 			detectionMode: config.detectionMode,
 			fps: config.detectionFps,
@@ -1918,12 +1973,6 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 			occupancyRecheckSec: config.occupancyRecheckSec,
 			occupancyRecheckFrames: config.occupancyRecheckFrames
 		});
-		const attachment = {
-			config,
-			motionUnsubscribe: null,
-			detectionUnsubscribe: null
-		};
-		this.attached.set(config.deviceId, attachment);
 		if (config.motionSources.includes("analyzer")) attachment.motionUnsubscribe = await this.subscribeMotionFrames(config);
 		const stepsCount = config.steps?.length ?? 0;
 		const dispatch = stepsCount > 0 ? `runPipeline(${stepsCount}step${stepsCount === 1 ? "" : "s"})` : config.steps !== void 0 ? "skip(0steps)" : "runFrame(legacy)";
@@ -2013,10 +2062,10 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 		if (!shouldStartOnboardAnalyzer(config)) return;
 		const log = this.ctx.logger.withTags({ deviceId });
 		if (detected && !this.onboardAnalyzerSubs.has(deviceId)) {
-			const unsub = await this.subscribeMotionFrames(config);
+			const unsub = await this.subscribeMotionFrames(config, { sharedWithDetection: true });
 			if (unsub) {
 				this.onboardAnalyzerSubs.set(deviceId, unsub);
-				log.debug("onboard-analyzer: opened motion-frame subscription");
+				log.debug("onboard-analyzer: opened motion-frame subscription (shared detection decode)");
 			}
 		}
 		const existing = this.onboardAnalyzerTeardownTimers.get(deviceId);
@@ -2140,7 +2189,21 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 		this.remotePlanes.set(config.deviceId, plane);
 		return plane;
 	}
-	async subscribeMotionFrames(config) {
+	/**
+	* Subscribe the motion analyzer to decoded frames.
+	*
+	* Two modes:
+	* - **Persistent (default)** — a dedicated `gray` decode of the camera's
+	*   `motionStreamId` (the sub stream). Cheap, always-on; used when the SW
+	*   analyzer is the motion source (`motionSources` includes `'analyzer'`).
+	* - **Shared with detection** (`opts.sharedWithDetection`) — subscribes
+	*   `rgb` on `detectionStreamId` (the MAIN stream) so it rides the SAME
+	*   decoder session detection already uses (the `FrameHandlePlane` coalesces
+	*   same-format subscribers on a stream into ONE decode), then derives the
+	*   analyzer's `gray` from that rgb frame's luma. No second decoder. Used for
+	*   onboard/sensor-triggered motion, where a decode is already active.
+	*/
+	async subscribeMotionFrames(config, opts) {
 		const ctx = this.ctx;
 		const runner = this.runner;
 		if (!ctx || !runner) return null;
@@ -2150,18 +2213,23 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 			log.warn("subscribeMotionFrames: this.ctx.api not available");
 			return null;
 		}
+		const src = resolveMotionFrameSource(config, opts?.sharedWithDetection === true);
+		const shared = src.shared;
+		const streamId = src.streamId;
 		const remote = this.remoteSourceFor(config);
 		return startFrameHandlePoller({
 			api,
-			brokerId: require_dist.makeSourceBrokerId(config.deviceId, config.motionStreamId),
-			format: "gray",
+			brokerId: require_dist.makeSourceBrokerId(config.deviceId, streamId),
+			format: src.format,
 			maxFps: config.motionFps,
-			tag: "motion",
+			tag: shared ? "motion-shared" : "motion",
 			logger: log,
 			ownNodeId: this.nodeId,
 			getRemoteFrame: (handle) => this.getRemoteFrame(handle),
-			...remote ? { source: remote.makeSource(config.motionStreamId) } : {},
-			onFrame: (frame, handle) => {
+			...remote ? { source: remote.makeSource(streamId) } : {},
+			onFrame: shared ? (frame) => {
+				runner.enqueueMotionFrame(config.deviceId, rgbFrameToGrayFrame(frame), void 0);
+			} : (frame, handle) => {
 				runner.enqueueMotionFrame(config.deviceId, frame, handle);
 			}
 		});
@@ -2588,4 +2656,6 @@ exports.PipelineTimingSampler = PipelineTimingSampler;
 exports.Semaphore = Semaphore;
 exports.customActions = pipelineRunnerBenchActions;
 exports.default = PipelineRunnerAddon;
+exports.resolveMotionFrameSource = resolveMotionFrameSource;
+exports.rgbFrameToGrayFrame = rgbFrameToGrayFrame;
 exports.shouldStartOnboardAnalyzer = shouldStartOnboardAnalyzer;