@camstack/addon-pipeline 1.1.42 → 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 };