@camstack/addon-pipeline 1.1.42 → 1.1.44

package/dist/{frame-handle-plane-E_AsR77T.mjs → remote-source-plane-B4hRwchu.mjs}

@@ -1,4 +1,4 @@
-import { I as errMsg, d as RingBuffer } from "./dist-GFd8M6KO.mjs";
+import { D as nodePin, I as errMsg, d as RingBuffer } from "./dist-CgBGV988.mjs";
 import { randomUUID } from "node:crypto";
 //#region src/stream-broker/stream-broker/decoder-session-proxy.ts
 /**
@@ -781,4 +781,221 @@ var FrameHandlePlane = class {
 	}
 };
 //#endregion
-export { DecoderSessionProxy as n, FrameHandlePlane as t };
+//#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;
+	ownerNodeId;
+	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.ownerNodeId = options.ownerNodeId;
+		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, ownerNodeId } = 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(void 0, nodePin(ownerNodeId)), 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}`
+		}, nodePin(ownerNodeId));
+		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 }, nodePin(this.ownerNodeId)).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
+export { DecoderSessionProxy as a, FrameHandlePlane as i, isRemoteRestream as n, profileForStreamId as r, RemoteSourcePlane as t };

package/dist/{frame-handle-plane-B3Fxww8H.js → remote-source-plane-D9m0z1N9.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-NvwN60Fq.js");
+const require_dist = require("./dist-CySHUkXY.js");
 let node_crypto = require("node:crypto");
 //#region src/stream-broker/stream-broker/decoder-session-proxy.ts
 /**
@@ -781,6 +781,223 @@ var FrameHandlePlane = class {
 	}
 };
 //#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;
+	ownerNodeId;
+	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.ownerNodeId = options.ownerNodeId;
+		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, ownerNodeId } = 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(void 0, require_dist.nodePin(ownerNodeId)), 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}`
+		}, require_dist.nodePin(ownerNodeId));
+		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: require_dist.errMsg(err)
+			} });
+		});
+		if (entry.released) return;
+		entry.released = true;
+		await this.api.streamBroker.releaseStreamWithCodec.mutate({ pipelineKey: entry.pipelineKey }, require_dist.nodePin(this.ownerNodeId)).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
 Object.defineProperty(exports, "DecoderSessionProxy", {
 	enumerable: true,
 	get: function() {
@@ -793,3 +1010,21 @@ Object.defineProperty(exports, "FrameHandlePlane", {
 		return FrameHandlePlane;
 	}
 });
+Object.defineProperty(exports, "RemoteSourcePlane", {
+	enumerable: true,
+	get: function() {
+		return RemoteSourcePlane;
+	}
+});
+Object.defineProperty(exports, "isRemoteRestream", {
+	enumerable: true,
+	get: function() {
+		return isRemoteRestream;
+	}
+});
+Object.defineProperty(exports, "profileForStreamId", {
+	enumerable: true,
+	get: function() {
+		return profileForStreamId;
+	}
+});