@camstack/addon-pipeline 1.1.43 → 1.1.44

package/dist/pipeline-runner/index.mjs

@@ -1,5 +1,5 @@
-import { D as nodePin, G as makeSourceBrokerId, H as createEvent, I as errMsg, L as BaseAddon, Q as boolean, V as EventCategory, X as _enum, Z as array, _ as customAction, at as string, et as lazy, k as pipelineRunnerCapability, nt as number, rt as object, y as defineCustomActions } from "../dist-GFd8M6KO.mjs";
-import { t as FrameHandlePlane } from "../frame-handle-plane-E_AsR77T.mjs";
+import { $ as boolean, D as nodePin, H as createEvent, I as errMsg, K as makeSourceBrokerId, L as BaseAddon, Q as array, V as EventCategory, Z as _enum, _ as customAction, it as object, k as pipelineRunnerCapability, ot as string, rt as number, tt as lazy, y as defineCustomActions } from "../dist-CgBGV988.mjs";
+import { n as isRemoteRestream, r as profileForStreamId, t as RemoteSourcePlane } from "../remote-source-plane-B4hRwchu.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { t as isWorkerReply } from "../worker-protocol-pk7qdYXt.mjs";
 import { FrameRingReaderCache } from "@camstack/shm-ring";
@@ -422,221 +422,6 @@ function startPolling(options, source, subscriptionId, resolvedMaxFps, lifecycle
 	};
 }
 //#endregion
-//#region src/pipeline-runner/remote-source-plane.ts
-/**
-* Runner-side mode selection (pure): whether an attach payload routes this
-* camera through the remote-source leg. Absent `frameSource` (a pre-P2c
-* payload) and `local-broker` both take today's co-located broker path —
-* the rollout-OFF safety invariant.
-*/
-function isRemoteRestream(frameSource) {
-	return frameSource !== void 0 && frameSource.kind === "remote-restream";
-}
-/**
-* Resolve WHICH broker profile a camStream id feeds for a device (pure).
-*
-* `getStreamWithCodec` targets a PROFILE (its assigned camStream), while the
-* runner is dispatched with camStream ids (`motionStreamId` /
-* `detectionStreamId`). The broker's profile slots carry the mapping
-* (`sourceCamStreamId`); a stream no slot feeds returns `null` — the acquire
-* fails fast and the poller's backoff retries (the assignment may still be
-* propagating).
-*/
-function profileForStreamId(slots, deviceId, streamId) {
-	for (const slot of slots) if (slot.deviceId === deviceId && slot.sourceCamStreamId === streamId) return slot.profile;
-	return null;
-}
-var RemoteSourcePlane = class {
-	api;
-	logger;
-	deviceId;
-	ownNodeId;
-	hostname;
-	/** Single-flight entry creation per camStream id. */
-	entries = /* @__PURE__ */ new Map();
-	disposed = false;
-	constructor(options) {
-		this.api = options.api;
-		this.logger = options.logger.withTags({ deviceId: options.deviceId });
-		this.deviceId = options.deviceId;
-		this.ownNodeId = options.ownNodeId;
-		this.hostname = options.hostname;
-	}
-	/**
-	* A {@link FrameHandleSource} for one camStream id, pluggable into
-	* `startFrameHandlePoller`. Motion (`gray`) and detection (`rgb`)
-	* subscriptions of the same stream share ONE acquired restream and ONE
-	* satellite plane (per-format decoder sessions inside it — hub parity).
-	*/
-	makeSource(streamId) {
-		return {
-			subscribe: async (input) => {
-				if (this.disposed) throw new Error("RemoteSourcePlane: subscribe after dispose");
-				const entry = await this.ensureEntry(streamId);
-				const result = await entry.plane.subscribe({
-					format: input.format,
-					maxFps: input.maxFps,
-					tag: input.tag
-				});
-				entry.subscriptionIds.add(result.subscriptionId);
-				return result;
-			},
-			pullHandles: async (input) => {
-				const entry = await this.peekEntry(streamId);
-				if (!entry) return [];
-				return entry.plane.pullHandles(input.subscriptionId, input.maxCount);
-			},
-			unsubscribe: async (input) => {
-				const entry = await this.peekEntry(streamId);
-				if (!entry) return;
-				entry.subscriptionIds.delete(input.subscriptionId);
-				await entry.plane.unsubscribe(input.subscriptionId).catch(() => {});
-				if (entry.subscriptionIds.size === 0) {
-					this.entries.delete(streamId);
-					await this.teardownEntry(entry, streamId);
-				}
-			}
-		};
-	}
-	/** Dispose every entry: satellite planes destroyed, restreams released. Idempotent. */
-	async dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		const pending = [...this.entries.entries()];
-		this.entries.clear();
-		for (const [streamId, entryPromise] of pending) try {
-			const entry = await entryPromise;
-			await this.teardownEntry(entry, streamId);
-		} catch {}
-	}
-	/** The live entry for a stream, or `null` (never creates one). */
-	async peekEntry(streamId) {
-		const pending = this.entries.get(streamId);
-		if (!pending) return null;
-		try {
-			return await pending;
-		} catch {
-			return null;
-		}
-	}
-	/** Single-flight: acquire the restream + build the satellite plane once per stream. */
-	ensureEntry(streamId) {
-		const existing = this.entries.get(streamId);
-		if (existing) return existing;
-		const creation = this.createEntry(streamId);
-		this.entries.set(streamId, creation);
-		creation.catch(() => {
-			if (this.entries.get(streamId) === creation) this.entries.delete(streamId);
-		});
-		return creation;
-	}
-	async createEntry(streamId) {
-		const { api, deviceId, ownNodeId } = this;
-		if (this.hostname === void 0) throw new Error("RemoteSourcePlane: owner hostname unresolvable — set frameSource.hubHostnameOverride or CAMSTACK_HUB_URL (a 127.0.0.1 restream URL would dial the wrong box)");
-		const profile = profileForStreamId(await api.streamBroker.listAllProfileSlots.query(), deviceId, streamId);
-		if (profile === null) throw new Error(`RemoteSourcePlane: no broker profile is fed by camStream '${streamId}' of device ${deviceId} — cannot acquire the owner restream`);
-		const rtpSource = await api.streamBroker.getStreamWithCodec.mutate({
-			deviceId,
-			video: "copy",
-			audio: "none",
-			profile,
-			hostname: this.hostname,
-			tag: `runner:${ownNodeId}:remote-src:${deviceId}/${streamId}`
-		});
-		const codec = rtpSource.videoCodec === "H265" ? "h265" : "h264";
-		const plane = new FrameHandlePlane({
-			decoderApi: this.buildPinnedDecoderCapApi(),
-			logger: this.logger,
-			localNodeId: ownNodeId,
-			resolveStreamInfo: () => ({
-				codec,
-				numericDeviceId: deviceId,
-				tag: `runner-remote:${deviceId}/${streamId}`,
-				pullModeUrl: rtpSource.url
-			})
-		});
-		this.logger.info("remote-source plane: owner restream acquired", { meta: {
-			streamId,
-			profile,
-			codec,
-			pipelineKey: rtpSource.pipelineKey,
-			hostname: this.hostname
-		} });
-		return {
-			plane,
-			pipelineKey: rtpSource.pipelineKey,
-			subscriptionIds: /* @__PURE__ */ new Set(),
-			released: false
-		};
-	}
-	/** Destroy an entry's satellite plane and release its restream refcount once. */
-	async teardownEntry(entry, streamId) {
-		await entry.plane.dispose().catch((err) => {
-			this.logger.warn("remote-source plane: satellite plane dispose failed", { meta: {
-				streamId,
-				error: errMsg(err)
-			} });
-		});
-		if (entry.released) return;
-		entry.released = true;
-		await this.api.streamBroker.releaseStreamWithCodec.mutate({ pipelineKey: entry.pipelineKey }).catch((err) => {
-			this.logger.debug("remote-source plane: releaseStreamWithCodec failed (benign on hub restart)", { meta: {
-				streamId,
-				pipelineKey: entry.pipelineKey,
-				error: errMsg(err)
-			} });
-		});
-	}
-	/**
-	* Every decoder call pinned to THIS runner's node — mirror of the hub
-	* broker's wrapper (`stream-broker-manager.buildDecoderCapApi`): the
-	* `decoder` cap is a singleton whose UNPINNED calls resolve to the
-	* cluster-elected node, which is generally NOT this agent. Pinning create
-	* AND every session op to the same local node keeps the session + its shm
-	* ring here, where this plane's readers live.
-	*/
-	buildPinnedDecoderCapApi() {
-		const api = this.api;
-		const pin = nodePin(this.ownNodeId);
-		const toWireBytes = (bytes) => {
-			const copy = new Uint8Array(new ArrayBuffer(bytes.byteLength));
-			copy.set(bytes);
-			return copy;
-		};
-		return {
-			supportsCodec: async (input) => api.decoder.supportsCodec.query({ ...input }, pin),
-			getInfo: async () => api.decoder.getInfo.query(void 0, pin),
-			createSession: async (config) => api.decoder.createSession.query({ ...config }, pin),
-			pushPacket: async (input) => {
-				await api.decoder.pushPacket.query({
-					sessionId: input.sessionId,
-					packet: {
-						...input.packet,
-						data: toWireBytes(input.packet.data)
-					}
-				}, pin);
-			},
-			pullFrames: async (input) => {
-				return (await api.decoder.pullFrames.query({ ...input }, pin)).map((frame) => ({
-					...frame,
-					data: Buffer.from(frame.data)
-				}));
-			},
-			pullHandles: async (input) => api.decoder.pullHandles.query({ ...input }, pin),
-			destroySession: async (input) => {
-				await api.decoder.destroySession.query({ ...input }, pin);
-			},
-			openStream: async (input) => {
-				await api.decoder.openStream.query({ ...input }, pin);
-			},
-			updateConfig: async (input) => {
-				await api.decoder.updateConfig.query({ ...input }, pin);
-			},
-			getStats: async (input) => api.decoder.getStats.query({ ...input }, pin)
-		};
-	}
-};
-//#endregion
 //#region src/pipeline-runner/frame-queue.ts
 /**
 * Latest-frame-only buffer. Keeps only the most recent item, dropping all
@@ -1924,21 +1709,25 @@ function startSessionDecodePump(deps) {
 					const decoded = await toDecodedFrame(frame, format);
 					deps.onDecodedFrame(decoded);
 				} catch (err) {
-					deps.logger.debug("session-decode pump: skipped a frame (decode/consume error)", { meta: {
-						deviceId: deps.source.deviceId,
-						format,
-						error: errMsg(err)
-					} });
+					deps.logger.debug("session-decode pump: skipped a frame (decode/consume error)", {
+						tags: { deviceId: deps.source.deviceId },
+						meta: {
+							format,
+							error: errMsg(err)
+						}
+					});
 				} finally {
 					frame.image.close();
 				}
 			}
 		} catch (err) {
-			deps.logger.warn("session-decode pump: frame loop ended with error", { meta: {
-				deviceId: deps.source.deviceId,
-				format,
-				error: errMsg(err)
-			} });
+			deps.logger.warn("session-decode pump: frame loop ended with error", {
+				tags: { deviceId: deps.source.deviceId },
+				meta: {
+					format,
+					error: errMsg(err)
+				}
+			});
 		} finally {
 			releaseSpawnSlotOnce();
 		}
@@ -2061,9 +1850,95 @@ function resolveMotionFrameSource(config, sharedWithDetection) {
 function resolveSessionDecodeHostname(config, hubUrl) {
 	const frameSource = config.frameSource;
 	if (!isRemoteRestream(frameSource)) return void 0;
+	return resolveOwnerRestreamHost(frameSource, hubUrl);
+}
+/**
+* The camera-source OWNER node for a session-decode acquire, or `undefined`
+* when the source is node-local (co-located, pre-cross-node). Mirrors
+* `resolveSessionDecodeHostname`: only a `remote-restream` frame source names an
+* owner. Used to `nodePin` the broker calls at the actual owner.
+*/
+function resolveSessionDecodeOwnerNodeId(config) {
+	const frameSource = config.frameSource;
+	if (!isRemoteRestream(frameSource)) return void 0;
+	return frameSource.ownerNodeId;
+}
+/**
+* The host a cross-node consumer dials for the owner's compressed restream.
+* Precedence: the orchestrator-resolved `ownerReachableHost` (the per-node
+* Cluster-UI override) → the operator `hubHostnameOverride` escape hatch →
+* the `CAMSTACK_HUB_URL`-derived host (the auto-detected Moleculer address).
+* `undefined` only when none resolve (the acquire then fails loudly rather
+* than silently dialing `127.0.0.1` on a remote node).
+*/
+function resolveOwnerRestreamHost(frameSource, hubUrl) {
+	const reachable = frameSource.ownerReachableHost?.trim();
+	if (reachable !== void 0 && reachable.length > 0) return reachable;
 	return resolveHubHostname(frameSource.hubHostnameOverride, hubUrl);
 }
 /**
+* Acquire the broker's COMPRESSED passthrough restream for one camStream and
+* wrap it as a {@link VideoFrameSource} the decode worker can dial. Mirrors
+* {@link RemoteSourcePlane}'s acquire: resolve the profile the camStream
+* feeds, then `getStreamWithCodec({ video: 'copy' })` (refcounted — rides the
+* broker's single source pull, never a second camera dial). No `hostname`:
+* the P1 flagged camera is HUB-LOCAL, so the returned `127.0.0.1` URL is
+* dialable from this hub-resident runner. Returns `null` (loudly logged) when
+* no profile is bound yet — the caller opens no subscription.
+*
+* Extracted as a standalone exported function (rather than a private method)
+* so the owner-node pin threading through the three `streamBroker` calls
+* (`listAllProfileSlots`, `getStreamWithCodec`, `releaseStreamWithCodec`) is
+* directly unit-testable without instantiating the addon class. The private
+* `acquireSessionDecodeRestream` method on {@link PipelineRunnerAddon} is a
+* thin delegator to this function — its two call sites are unchanged.
+*/
+async function acquireSessionDecodeRestreamFrom(api, logger, params) {
+	const { deviceId, streamId, tag, hostname, ownerNodeId } = params;
+	const pin = ownerNodeId !== void 0 ? nodePin(ownerNodeId) : void 0;
+	const profile = profileForStreamId(await api.streamBroker.listAllProfileSlots.query(void 0, pin), deviceId, streamId);
+	if (profile === null) {
+		logger.error("session-decode: no broker profile feeds camStream — cannot acquire restream", {
+			tags: { deviceId },
+			meta: { streamId }
+		});
+		return null;
+	}
+	const rtpSource = await api.streamBroker.getStreamWithCodec.mutate({
+		deviceId,
+		video: "copy",
+		audio: "none",
+		profile,
+		tag,
+		...hostname !== void 0 ? { hostname } : {}
+	}, pin);
+	const codec = rtpSource.videoCodec === "H265" ? "h265" : "h264";
+	const source = {
+		restreamUrl: rtpSource.url,
+		deviceId,
+		codec
+	};
+	const pipelineKey = rtpSource.pipelineKey;
+	let released = false;
+	const release = async () => {
+		if (released) return;
+		released = true;
+		await api.streamBroker.releaseStreamWithCodec.mutate({ pipelineKey }, pin).catch((err) => {
+			logger.debug("session-decode: releaseStreamWithCodec failed (benign on hub restart)", {
+				tags: { deviceId },
+				meta: {
+					pipelineKey,
+					error: errMsg(err)
+				}
+			});
+		});
+	};
+	return {
+		source,
+		release
+	};
+}
+/**
 * 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
@@ -2624,7 +2499,6 @@ var PipelineRunnerAddon = class extends BaseAddon {
 		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)";
-		const engineLabel = config.engine ? `${config.engine.runtime}+${config.engine.backend}/${config.engine.format}` : "default";
 		this.ctx.logger.info("attachCamera", {
 			tags: { deviceId: config.deviceId },
 			meta: {
@@ -2634,7 +2508,7 @@ var PipelineRunnerAddon = class extends BaseAddon {
 				detectionFps: config.detectionFps,
 				motionSources: config.motionSources,
 				dispatch,
-				engine: engineLabel
+				engine: "node-local"
 			}
 		});
 		return { success: true };
@@ -2823,12 +2697,13 @@ var PipelineRunnerAddon = class extends BaseAddon {
 		if (existing) return existing;
 		const api = this.ctx.api;
 		if (!api) return null;
-		const hostname = resolveHubHostname(frameSource.hubHostnameOverride, process.env["CAMSTACK_HUB_URL"]);
+		const hostname = resolveOwnerRestreamHost(frameSource, process.env["CAMSTACK_HUB_URL"]);
 		const plane = new RemoteSourcePlane({
 			api,
 			logger: this.ctx.logger,
 			deviceId: config.deviceId,
 			ownNodeId: this.nodeId,
+			ownerNodeId: frameSource.ownerNodeId,
 			hostname
 		});
 		this.ctx.logger.info("remote-source leg armed for camera", {
@@ -2842,57 +2717,18 @@ var PipelineRunnerAddon = class extends BaseAddon {
 		return plane;
 	}
 	/**
-	* Acquire the broker's COMPRESSED passthrough restream for one camStream and
-	* wrap it as a {@link VideoFrameSource} the decode worker can dial. Mirrors
-	* {@link RemoteSourcePlane}'s acquire: resolve the profile the camStream
-	* feeds, then `getStreamWithCodec({ video: 'copy' })` (refcounted — rides the
-	* broker's single source pull, never a second camera dial). No `hostname`:
-	* the P1 flagged camera is HUB-LOCAL, so the returned `127.0.0.1` URL is
-	* dialable from this hub-resident runner. Returns `null` (loudly logged) when
-	* no profile is bound yet — the caller opens no subscription.
+	* Thin delegator to the module-level {@link acquireSessionDecodeRestreamFrom}
+	* (see its doc for the acquire behavior) — supplies this addon's `ctx.logger`.
+	* Kept as a method so the two call sites need no change.
 	*/
-	async acquireSessionDecodeRestream(api, deviceId, streamId, tag, hostname) {
-		const profile = profileForStreamId(await api.streamBroker.listAllProfileSlots.query(), deviceId, streamId);
-		if (profile === null) {
-			this.ctx.logger.error("session-decode: no broker profile feeds camStream — cannot acquire restream", {
-				tags: { deviceId },
-				meta: { streamId }
-			});
-			return null;
-		}
-		const rtpSource = await api.streamBroker.getStreamWithCodec.mutate({
+	async acquireSessionDecodeRestream(api, deviceId, streamId, tag, hostname, ownerNodeId) {
+		return acquireSessionDecodeRestreamFrom(api, this.ctx.logger, {
 			deviceId,
-			video: "copy",
-			audio: "none",
-			profile,
+			streamId,
 			tag,
-			...hostname !== void 0 ? { hostname } : {}
+			hostname,
+			ownerNodeId
 		});
-		const codec = rtpSource.videoCodec === "H265" ? "h265" : "h264";
-		const source = {
-			restreamUrl: rtpSource.url,
-			deviceId,
-			codec
-		};
-		const pipelineKey = rtpSource.pipelineKey;
-		let released = false;
-		const release = async () => {
-			if (released) return;
-			released = true;
-			await api.streamBroker.releaseStreamWithCodec.mutate({ pipelineKey }).catch((err) => {
-				this.ctx.logger.debug("session-decode: releaseStreamWithCodec failed (benign on hub restart)", {
-					tags: { deviceId },
-					meta: {
-						pipelineKey,
-						error: errMsg(err)
-					}
-				});
-			});
-		};
-		return {
-			source,
-			release
-		};
 	}
 	/**
 	* Register this device's motion to ride the detection session-decode worker
@@ -2970,7 +2806,7 @@ var PipelineRunnerAddon = class extends BaseAddon {
 		if (!runner) return () => {};
 		return startGuardedSessionDecode({
 			logger: log,
-			acquire: () => this.acquireSessionDecodeRestream(api, config.deviceId, config.detectionStreamId, `session-decode:detect:${config.deviceId}`, resolveSessionDecodeHostname(config, process.env["CAMSTACK_HUB_URL"])),
+			acquire: () => this.acquireSessionDecodeRestream(api, config.deviceId, config.detectionStreamId, `session-decode:detect:${config.deviceId}`, resolveSessionDecodeHostname(config, process.env["CAMSTACK_HUB_URL"]), resolveSessionDecodeOwnerNodeId(config)),
 			startPump: (source) => {
 				log.info("session-decode: detection routed through per-session decode worker (rgb)", { meta: {
 					streamId: config.detectionStreamId,
@@ -3009,7 +2845,7 @@ var PipelineRunnerAddon = class extends BaseAddon {
 		if (!runner) return () => {};
 		return startGuardedSessionDecode({
 			logger: log,
-			acquire: () => this.acquireSessionDecodeRestream(api, config.deviceId, config.motionStreamId, `session-decode:motion:${config.deviceId}`, resolveSessionDecodeHostname(config, process.env["CAMSTACK_HUB_URL"])),
+			acquire: () => this.acquireSessionDecodeRestream(api, config.deviceId, config.motionStreamId, `session-decode:motion:${config.deviceId}`, resolveSessionDecodeHostname(config, process.env["CAMSTACK_HUB_URL"]), resolveSessionDecodeOwnerNodeId(config)),
 			startPump: (source) => {
 				log.info("session-decode: motion routed through per-session decode worker (gray)", { meta: {
 					streamId: config.motionStreamId,
@@ -3191,9 +3027,7 @@ var PipelineRunnerAddon = class extends BaseAddon {
 			log.error("runInference: this.ctx.api not available");
 			return null;
 		}
-		const camConfig = this.attached.get(deviceId)?.config;
-		const steps = camConfig?.steps;
-		const engine = camConfig?.engine;
+		const steps = (this.attached.get(deviceId)?.config)?.steps;
 		if (!steps) {
 			log.warn("runInference: no steps in attach config — skipping frame (legacy attach?)");
 			return null;
@@ -3204,8 +3038,7 @@ var PipelineRunnerAddon = class extends BaseAddon {
 			return await api.pipelineExecutor.runPipeline.mutate({
 				steps: [...steps],
 				...useHandle ? { frameHandle: handle } : { frame },
-				deviceId,
-				...engine ? { engine } : {}
+				deviceId
 			});
 		} catch (err) {
 			const msg = errMsg(err);
@@ -3563,4 +3396,4 @@ var PipelineRunnerAddon = class extends BaseAddon {
 	}
 };
 //#endregion
-export { DEFAULT_CONFIG, FrameQueue, PipelineRunner, PipelineTimingSampler, Semaphore, pipelineRunnerBenchActions as customActions, PipelineRunnerAddon as default, resolveMotionFrameSource, resolveSessionDecodeHostname, rgbFrameToGrayFrame, shouldStartOnboardAnalyzer };
+export { DEFAULT_CONFIG, FrameQueue, PipelineRunner, PipelineTimingSampler, Semaphore, acquireSessionDecodeRestreamFrom, pipelineRunnerBenchActions as customActions, PipelineRunnerAddon as default, resolveMotionFrameSource, resolveSessionDecodeHostname, resolveSessionDecodeOwnerNodeId, rgbFrameToGrayFrame, shouldStartOnboardAnalyzer };

package/dist/recorder/index.js

@@ -1,10 +1,11 @@
-const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-DxM2DSns.js");
-const require_dist = require("../dist-NvwN60Fq.js");
+const require_chunk = require("../chunk-D6vf50IK.js");
+const require_dist = require("../dist-CySHUkXY.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
+const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-BLXzxpRB.js");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
-node_path = require_model_download_service_C_IHWnXx.__toESM(node_path);
+node_path = require_chunk.__toESM(node_path);
 //#region src/recorder/segment-path.ts
 function segmentRelPath(deviceId, profile, startMs, durMs, bytes) {
 	if (profile.includes("/")) throw new Error(`segmentRelPath: profile must not contain '/': ${profile}`);
@@ -224,7 +225,10 @@ var SegmentStore = class SegmentStore {
 		try {
 			bytes = await this.deps.statBytes(input.flatAbsPath);
 		} catch (err) {
-			this.deps.logger.warn("segment stat failed", err);
+			this.deps.logger.warn("segment stat failed", {
+				tags: { deviceId: input.deviceId },
+				error: err
+			});
 			return null;
 		}
 		if (bytes <= 0) return null;
@@ -233,7 +237,10 @@ var SegmentStore = class SegmentStore {
 		try {
 			await this.deps.moveFile(input.flatAbsPath, toAbs);
 		} catch (err) {
-			this.deps.logger.warn("segment relocate failed", err);
+			this.deps.logger.warn("segment relocate failed", {
+				tags: { deviceId: input.deviceId },
+				error: err
+			});
 			return null;
 		}
 		const row = {
@@ -283,7 +290,10 @@ var SegmentStore = class SegmentStore {
 				}
 				continue;
 			} catch (err) {
-				this.deps.logger.warn("bucket removeDir failed — falling back to per-file deletes", err);
+				this.deps.logger.warn("bucket removeDir failed — falling back to per-file deletes", {
+					tags: { deviceId: bucketRows[0]?.deviceId },
+					error: err
+				});
 			}
 			for (const r of bucketRows) try {
 				await this.deps.deletePath({
@@ -293,7 +303,10 @@ var SegmentStore = class SegmentStore {
 				removed.push(r.path);
 				reclaimed += r.bytes;
 			} catch (err) {
-				this.deps.logger.warn("segment delete failed", err);
+				this.deps.logger.warn("segment delete failed", {
+					tags: { deviceId: r.deviceId },
+					error: err
+				});
 			}
 		}
 		if (removed.length > 0) this.deps.index.removeSegments(removed);
@@ -1863,7 +1876,7 @@ var RecordingController = class {
 	* assigned sources is ignored (record every assigned source — minimum of 1).
 	*/
 	async resolveProfiles(deviceId, override) {
-		const assigned = require_dist.selectAssignedProfileSlots(await this.deps.brokerCall(() => this.deps.api.streamBroker.listAllProfileSlots.query()), deviceId).map((slot) => slot.profile);
+		const assigned = require_dist.selectAssignedProfileSlots(await this.deps.brokerCall(() => this.deps.api.streamBroker.listAllProfileSlots.query(void 0, require_dist.nodePin(this.deps.ownerNodeId))), deviceId).map((slot) => slot.profile);
 		if (!override || override.length === 0) return assigned;
 		const selected = assigned.filter((p) => override.includes(p));
 		return selected.length > 0 ? selected : assigned;
@@ -1883,7 +1896,7 @@ var RecordingController = class {
 			profile,
 			...this.deps.consumerHostname !== void 0 ? { hostname: this.deps.consumerHostname } : {},
 			tag: `recorder:${deviceId}/${profile}`
-		}));
+		}, require_dist.nodePin(this.deps.ownerNodeId)));
 		const outDir = node_path.default.join(placement.root, STAGING_DIR_NAME, String(deviceId), profile);
 		await node_fs.promises.mkdir(outDir, { recursive: true });
 		const deviceLog = this.deps.logger.withTags({ deviceId });
@@ -1969,7 +1982,7 @@ var RecordingController = class {
 			r.writer.stop();
 		} catch {}
 		try {
-			await this.deps.api.streamBroker.releaseStreamWithCodec.mutate({ pipelineKey: r.pipelineKey });
+			await this.deps.api.streamBroker.releaseStreamWithCodec.mutate({ pipelineKey: r.pipelineKey }, require_dist.nodePin(this.deps.ownerNodeId));
 		} catch (err) {
 			this.deps.logger.warn("recorder: releaseStreamWithCodec failed", {
 				tags: { deviceId },
@@ -2080,9 +2093,13 @@ var MARKER_PAD_POST_MS = require_dist.EVENT_PAD_MS.postMs;
 *  form the hub reverse-proxy client path `/addon/recorder/playback`. */
 var RECORDER_ADDON_ID = "recorder";
 var PLAYBACK_PREFIX = "playback";
-/** Node the hub-only `stream-broker` runs on. Every recorder — on the hub or on
-*  a designated agent — gates on, and pulls from, THIS node's broker. */
-var BROKER_HOST_NODE_ID = "hub";
+/** Narrows the `unknown` extras `SegmentStore`'s logger contract accepts down
+*  to the structured `{ tags, error }` shape the device-scoped call sites
+*  (stat/relocate failures) pass — as opposed to the raw caught error most
+*  other call sites still pass directly. */
+function isSegmentStoreLogExtras(extras) {
+	return typeof extras === "object" && extras !== null && ("tags" in extras || "error" in extras);
+}
 var RecorderV2Addon = class extends require_dist.BaseAddon {
 	nodeId = "hub";
 	/** True when THIS node is the designated recording node (`recordingNodeId`).
@@ -2117,14 +2134,15 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			} });
 			return { providers: [] };
 		}
-		const consumerHostname = this.nodeId === BROKER_HOST_NODE_ID ? void 0 : resolveRecordingHubHostname(this.config.recordingHubHostname, process.env["CAMSTACK_HUB_URL"]);
-		if (this.nodeId !== BROKER_HOST_NODE_ID) {
+		const ingestOwner = await this.resolveIngestOwner();
+		const consumerHostname = this.nodeId === ingestOwner.ownerNodeId ? void 0 : ingestOwner.reachableHost ?? resolveRecordingHubHostname(this.config.recordingHubHostname, process.env["CAMSTACK_HUB_URL"]);
+		if (this.nodeId !== ingestOwner.ownerNodeId) {
 			this.ctx.logger.info("recorder is a REMOTE recording node — pulling broker streams cross-node", { meta: {
 				ownNodeId: this.nodeId,
-				brokerHost: BROKER_HOST_NODE_ID,
+				brokerHost: ingestOwner.ownerNodeId,
 				consumerHostname: consumerHostname ?? "(unresolved)"
 			} });
-			if (consumerHostname === void 0) this.ctx.logger.warn("recorder: could not resolve the hub host for cross-node pull — set the `recordingHubHostname` global setting or CAMSTACK_HUB_URL; recording will not reach this node", { meta: { ownNodeId: this.nodeId } });
+			if (consumerHostname === void 0) this.ctx.logger.warn("recorder: could not resolve the ingest owner host for cross-node pull — set the `recordingHubHostname` global setting or CAMSTACK_HUB_URL; recording will not reach this node", { meta: { ownNodeId: this.nodeId } });
 		}
 		const segmentStoreDeps = {
 			index: this.index,
@@ -2149,14 +2167,21 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 					force: true
 				});
 			},
-			logger: { warn: (message, extras) => this.ctx.logger.warn(message, { meta: { extras } }) }
+			logger: { warn: (message, extras) => {
+				if (isSegmentStoreLogExtras(extras)) this.ctx.logger.warn(message, {
+					tags: extras.tags,
+					meta: { error: extras.error }
+				});
+				else this.ctx.logger.warn(message, { meta: { extras } });
+			} }
 		};
 		this.segmentStore = new SegmentStore(segmentStoreDeps);
-		const brokerHandle = this.ctx.useCapability("stream-broker", brokerScope(BROKER_HOST_NODE_ID));
+		const brokerHandle = this.ctx.useCapability("stream-broker", brokerScope(ingestOwner.ownerNodeId));
 		this.controller = new RecordingController({
 			api: this.ctx.api,
 			logger: this.ctx.logger,
 			nodeId: this.nodeId,
+			ownerNodeId: ingestOwner.ownerNodeId,
 			segmentStore: this.segmentStore,
 			loadConfig: (deviceId) => loadDeviceConfig(this.configStore(), deviceId),
 			enabledDeviceIds: async () => [...(await readDeviceConfigs(this.configStore())).keys()],
@@ -2165,7 +2190,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			segmentSeconds: this.config.segmentSeconds,
 			watchIntervalMs: this.config.watchIntervalMs,
 			...consumerHostname !== void 0 ? { consumerHostname } : {},
-			onBrokerReady: (handler) => this.ctx.onCapabilityStateChange("stream-broker", brokerScope(BROKER_HOST_NODE_ID), (state) => {
+			onBrokerReady: (handler) => this.ctx.onCapabilityStateChange("stream-broker", brokerScope(ingestOwner.ownerNodeId), (state) => {
 				if (state === "ready") handler();
 			}),
 			brokerCall: makeBrokerCall(brokerHandle)
@@ -2291,6 +2316,21 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		return this.resolvedLocations;
 	}
 	/**
+	* Resolve the cluster's camera-source owner. Graceful degrade: the
+	* `pipeline-orchestrator` cap may not be mounted yet (pre-image-release),
+	* in which case we fall back to `{ ownerNodeId: 'hub' }` — the same default
+	* `getIngestOwner` itself returns absent an explicit `clusterRoles.ingestNode`,
+	* so an unresolved owner is byte-identical to today's hub-only behaviour.
+	*/
+	async resolveIngestOwner() {
+		try {
+			return await this.ctx.api.pipelineOrchestrator.getIngestOwner.query();
+		} catch (err) {
+			this.ctx.logger.warn("recorder: getIngestOwner unavailable — defaulting to hub (cap not mounted yet?)", { meta: { error: require_dist.errMsg(err) } });
+			return { ownerNodeId: "hub" };
+		}
+	}
+	/**
 	* Roots the playback data-plane handler searches, IN ORDER: `<dataDir>/playback`
 	* FIRST (the freshly-written master/variant `.m3u8` playlists), then every
 	* recordings location root (the segment `.m4s` files at