@camstack/addon-pipeline 1.1.24 → 1.1.25

package/dist/hub-hostname-cCknRYKj.mjs

@@ -0,0 +1,49 @@
+//#region src/shared/hub-hostname.ts
+/**
+* Resolve the host a REMOTE node should use to dial the hub-only
+* stream-broker's restream port.
+*
+* The broker mints `127.0.0.1` restream URLs (hub-local). A cross-node
+* consumer — the recorder on a designated remote recording node, or the
+* pipeline-runner's remote-source leg (cross-node Phase 2) — must pull from
+* the hub, so it needs the hub's cluster-resolvable host. Resolution order:
+*
+*   1. `override` — an explicit operator setting (the recorder's
+*      `recordingHubHostname` global, or the runner attach payload's
+*      `frameSource.hubHostnameOverride`), when the auto-derived host isn't
+*      reachable for RTSP on the consuming interface.
+*   2. `hubUrl` — derived from the node's `CAMSTACK_HUB_URL` (the address it
+*      already uses to reach the hub). The RTSP restream port differs from
+*      the hub API port, but the HOST is the same — only the host is
+*      extracted.
+*
+* Returns `undefined` when neither yields a host (the caller logs / fails the
+* acquire; a `127.0.0.1` URL on a remote node would dial the wrong box).
+*
+* Pure: the env string is passed in (not read here) so it can be unit-tested.
+* Promoted from `recorder/addon/recording-hub-host.ts` in P2d so both
+* cross-node consumers share ONE resolver.
+*/
+function resolveHubHostname(override, hubUrl) {
+	const trimmedOverride = override?.trim();
+	if (trimmedOverride !== void 0 && trimmedOverride.length > 0) return trimmedOverride;
+	return extractHost(hubUrl);
+}
+/** Extract the bare host from a URL/authority string, scheme + port optional. */
+function extractHost(raw) {
+	const value = raw?.trim();
+	if (value === void 0 || value.length === 0) return void 0;
+	try {
+		const parsed = new URL(value);
+		if (parsed.hostname.length > 0) return parsed.hostname;
+	} catch {}
+	const authority = value.replace(/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//, "").split("/")[0] ?? "";
+	if (authority.startsWith("[")) {
+		const end = authority.indexOf("]");
+		if (end > 0) return authority.slice(0, end + 1);
+	}
+	const host = authority.split(":")[0] ?? "";
+	return host.length > 0 ? host : void 0;
+}
+//#endregion
+export { resolveHubHostname as t };

package/dist/{model-download-service-C-IHWnXx-BnQ_awK4.js → model-download-service-C-IHWnXx-DxM2DSns.js}

@@ -19,12 +19,11 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-//#endregion
+require("node:crypto");
 let node_fs = require("node:fs");
 node_fs = __toESM(node_fs, 1);
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
-require("node:crypto");
 //#region ../system/dist/model-download-service-C-IHWnXx.mjs
 /**
 * Map a rel path to one candidate absolute path PER root, keeping only roots the

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-CE3a05qT.js");
+const require_dist = require("../dist-wzWBZ26C.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { B as BaseAddon, J as hydrateSchema, U as DeviceType, k as motionDetectionCapability, w as evaluateZoneRules } from "../dist-pd_-3C0T.mjs";
+import { A as motionDetectionCapability, T as evaluateZoneRules, V as BaseAddon, W as DeviceType, Y as hydrateSchema } from "../dist-BecXbIzJ.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/pipeline-runner/index.js

@@ -2,7 +2,9 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-CE3a05qT.js");
+const require_dist = require("../dist-wzWBZ26C.js");
+const require_frame_handle_plane = require("../frame-handle-plane-BAKiW6t4.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
 /**
@@ -240,6 +242,26 @@ var INITIAL_SUBSCRIBE_RETRY_BACKOFF_MS = 250;
 */
 var MAX_SUBSCRIBE_RETRY_BACKOFF_MS = 5e3;
 /**
+* The default source: the broker's shm plane over tRPC — today's path. The
+* methods return the underlying client promises DIRECTLY (no async wrapper)
+* so the poller's scheduling is microtask-identical to the pre-seam code.
+*/
+function brokerFrameHandleSource(api, brokerId) {
+	return {
+		subscribe: (input) => api.streamBroker.subscribeFrames.mutate({
+			brokerId,
+			format: input.format,
+			maxFps: input.maxFps,
+			tag: input.tag
+		}),
+		pullHandles: (input) => api.streamBroker.pullFrameHandles.query({
+			subscriptionId: input.subscriptionId,
+			maxCount: input.maxCount
+		}),
+		unsubscribe: (input) => api.streamBroker.unsubscribeFrames.mutate({ subscriptionId: input.subscriptionId }).then(() => void 0)
+	};
+}
+/**
 * Subscribe to a broker's shm frame stream and start the poll loop. Always
 * resolves to a teardown closure — when the broker is not yet registered the
 * closure cancels the ongoing retry loop; when polling is active it stops the
@@ -271,19 +293,19 @@ async function startFrameHandlePoller(options) {
 */
 async function subscribeWithRetry(options, lifecycle) {
 	const { api, brokerId, format, maxFps, tag, logger } = options;
+	const source = options.source ?? brokerFrameHandleSource(api, brokerId);
 	let backoffMs = INITIAL_SUBSCRIBE_RETRY_BACKOFF_MS;
 	let attempt = 0;
 	while (!lifecycle.stopped) {
 		attempt += 1;
 		try {
-			const result = await api.streamBroker.subscribeFrames.mutate({
-				brokerId,
+			const result = await source.subscribe({
 				format,
 				maxFps,
 				tag
 			});
 			if (lifecycle.stopped) {
-				await api.streamBroker.unsubscribeFrames.mutate({ subscriptionId: result.subscriptionId }).catch((err) => {
+				await source.unsubscribe({ subscriptionId: result.subscriptionId }).catch((err) => {
 					logger.warn("frame-handle poller: late unsubscribe failed", { meta: {
 						brokerId,
 						subscriptionId: result.subscriptionId,
@@ -292,7 +314,7 @@ async function subscribeWithRetry(options, lifecycle) {
 				});
 				return;
 			}
-			lifecycle.activeTeardown = startPolling(options, result.subscriptionId, result.maxFps, lifecycle);
+			lifecycle.activeTeardown = startPolling(options, source, result.subscriptionId, result.maxFps, lifecycle);
 			return;
 		} catch (err) {
 			if (lifecycle.stopped) return;
@@ -333,8 +355,8 @@ function sleep(ms, lifecycle) {
 * Returns the teardown closure that stops the loop and releases the
 * subscription.
 */
-function startPolling(options, subscriptionId, resolvedMaxFps, lifecycle) {
-	const { api, brokerId, onFrame, logger, ownNodeId, getRemoteFrame, tag } = options;
+function startPolling(options, source, subscriptionId, resolvedMaxFps, lifecycle) {
+	const { brokerId, onFrame, logger, ownNodeId, getRemoteFrame, tag } = options;
 	const readers = new _camstack_shm_ring.FrameRingReaderCache(logger);
 	const throttle = new ForeignHandleThrottle();
 	const pollIntervalMs = resolvedMaxFps > 0 ? Math.max(MIN_POLL_INTERVAL_MS, Math.round(1e3 / resolvedMaxFps)) : FALLBACK_POLL_INTERVAL_MS;
@@ -342,7 +364,7 @@ function startPolling(options, subscriptionId, resolvedMaxFps, lifecycle) {
 	const tick = async () => {
 		if (lifecycle.stopped) return;
 		try {
-			const handles = await api.streamBroker.pullFrameHandles.query({
+			const handles = await source.pullHandles({
 				subscriptionId,
 				maxCount: PULL_MAX_COUNT
 			});
@@ -374,8 +396,8 @@ function startPolling(options, subscriptionId, resolvedMaxFps, lifecycle) {
 			timer = void 0;
 		}
 		readers.close();
-		api.streamBroker.unsubscribeFrames.mutate({ subscriptionId }).catch((err) => {
-			logger.warn("frame-handle poller: unsubscribeFrames failed", { meta: {
+		source.unsubscribe({ subscriptionId }).catch((err) => {
+			logger.warn("frame-handle poller: unsubscribe failed", { meta: {
 				brokerId,
 				subscriptionId,
 				error: require_dist.errMsg(err)
@@ -384,6 +406,221 @@ function startPolling(options, 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 require_frame_handle_plane.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: require_dist.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: require_dist.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 = require_dist.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
@@ -1157,6 +1394,14 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 	*/
 	onboardAnalyzerTeardownTimers = /* @__PURE__ */ new Map();
 	/**
+	* REMOTE-SOURCE legs (cross-node Phase 2, P2d) — one per attached camera
+	* whose `frameSource.kind === 'remote-restream'`: the owner's compressed
+	* restream + a local satellite frame plane. DORMANT with today's default
+	* payloads (`local-broker` / absent) — the map stays empty and every code
+	* path is identical to pre-Phase-2. Torn down on detach / shutdown.
+	*/
+	remotePlanes = /* @__PURE__ */ new Map();
+	/**
 	* Snapshot-equality cache for metrics-snapshot defer. The runner
 	* fires per-camera metrics every `METRICS_SNAPSHOT_INTERVAL_MS`;
 	* for an idle camera (no inference, queue empty, fps=0) every tick
@@ -1252,6 +1497,9 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 		}
 		this.lastAnalyzerDetected.clear();
 		for (const deviceId of [...this.onboardAnalyzerTeardownTimers.keys(), ...this.onboardAnalyzerSubs.keys()]) this.clearOnboardAnalyzer(deviceId);
+		const remotePlanes = [...this.remotePlanes.values()];
+		this.remotePlanes.clear();
+		await Promise.all(remotePlanes.map((plane) => plane.dispose().catch(() => {})));
 		if (this.runner) {
 			this.runner.stop();
 			this.runner = null;
@@ -1647,6 +1895,16 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 		this.clearOnboardAnalyzer(deviceId);
 		attachment.motionUnsubscribe?.();
 		attachment.detectionUnsubscribe?.();
+		const remotePlane = this.remotePlanes.get(deviceId);
+		if (remotePlane) {
+			this.remotePlanes.delete(deviceId);
+			remotePlane.dispose().catch((err) => {
+				this.ctx?.logger.debug("remote-source plane dispose failed on detach", {
+					tags: { deviceId },
+					meta: { error: require_dist.errMsg(err) }
+				});
+			});
+		}
 		this.attached.delete(deviceId);
 		this.lastMotionAt.delete(deviceId);
 		this.lastEmittedCameraMetrics.delete(deviceId);
@@ -1788,6 +2046,39 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 			timestamp: remote.timestamp
 		};
 	}
+	/**
+	* The remote-source leg for a camera, or `null` for today's co-located
+	* broker path (P2d). Created lazily on the FIRST subscription of a
+	* `remote-restream` camera and shared by its motion + detection pollers;
+	* `detachInternal` / `onShutdown` dispose it. With rollout OFF every
+	* attach payload is `local-broker` (or absent) → always `null` → the
+	* subscribe paths below are byte-identical to pre-Phase-2.
+	*/
+	remoteSourceFor(config) {
+		const frameSource = config.frameSource;
+		if (!isRemoteRestream(frameSource)) return null;
+		const existing = this.remotePlanes.get(config.deviceId);
+		if (existing) return existing;
+		const api = this.ctx.api;
+		if (!api) return null;
+		const hostname = require_hub_hostname.resolveHubHostname(frameSource.hubHostnameOverride, process.env["CAMSTACK_HUB_URL"]);
+		const plane = new RemoteSourcePlane({
+			api,
+			logger: this.ctx.logger,
+			deviceId: config.deviceId,
+			ownNodeId: this.nodeId,
+			hostname
+		});
+		this.ctx.logger.info("remote-source leg armed for camera", {
+			tags: { deviceId: config.deviceId },
+			meta: {
+				ownerNodeId: frameSource.ownerNodeId,
+				hostname: hostname ?? "(unresolved — acquires will fail until set)"
+			}
+		});
+		this.remotePlanes.set(config.deviceId, plane);
+		return plane;
+	}
 	async subscribeMotionFrames(config) {
 		const ctx = this.ctx;
 		const runner = this.runner;
@@ -1798,6 +2089,7 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 			log.warn("subscribeMotionFrames: this.ctx.api not available");
 			return null;
 		}
+		const remote = this.remoteSourceFor(config);
 		return startFrameHandlePoller({
 			api,
 			brokerId: require_dist.makeSourceBrokerId(config.deviceId, config.motionStreamId),
@@ -1807,6 +2099,7 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 			logger: log,
 			ownNodeId: this.nodeId,
 			getRemoteFrame: (handle) => this.getRemoteFrame(handle),
+			...remote ? { source: remote.makeSource(config.motionStreamId) } : {},
 			onFrame: (frame, _handle) => {
 				runner.enqueueMotionFrame(config.deviceId, frame);
 			}
@@ -1883,6 +2176,7 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 			log.warn("subscribeDetectionFrames: this.ctx.api not available");
 			return null;
 		}
+		const remote = this.remoteSourceFor(config);
 		return startFrameHandlePoller({
 			api,
 			brokerId: require_dist.makeSourceBrokerId(config.deviceId, config.detectionStreamId),
@@ -1892,6 +2186,7 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 			logger: log,
 			ownNodeId: this.nodeId,
 			getRemoteFrame: (handle) => this.getRemoteFrame(handle),
+			...remote ? { source: remote.makeSource(config.detectionStreamId) } : {},
 			onFrame: (frame, handle) => {
 				runner.enqueueDetectionFrame(config.deviceId, frame, handle);
 			}