@camstack/addon-pipeline-orchestrator 1.2.311 → 1.2.312

package/dist/index.js

@@ -5418,7 +5418,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-vWTnHq9G.mjs
+//#region ../types/dist/sleep-B_3F_YwS.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -15021,6 +15021,16 @@ var BrokerClientsSchema = object({
 	/** Total encoded + raw-RTP callback subscriber count (sum of `encoded[].length`). */
 	encodedSubscribers: number()
 });
+/**
+* How many people are watching one camera LIVE right now — see
+* `getLiveViewerCounts`. A camera with nobody watching is absent from the list
+* (so `viewers` is always at least 1): the listing carries the cameras that
+* have viewers, never a row of zeros.
+*/
+var LiveViewerCountSchema = object({
+	deviceId: number().int().nonnegative(),
+	viewers: number().int().positive()
+});
 _enum([
 	"reconnecting",
 	"sleeping",
@@ -15381,7 +15391,7 @@ method(object({
 }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ brokerId: string() }), BrokerClientsSchema), method(object({
+}), method(object({ brokerId: string() }), BrokerClientsSchema), method(_void(), array(LiveViewerCountSchema).readonly()), method(object({
 	brokerId: string(),
 	channel: _enum(["rtsp", "audio"]),
 	handle: string()
@@ -28808,19 +28818,6 @@ var RunnerCameraDeviceUIFields = [
 			label: MOTION_SOURCE_LABELS[value]
 		})
 	},
-	{
-		key: "detectionSources",
-		type: "multiselect",
-		label: "Detection Sources",
-		default: ["pipeline"],
-		options: [{
-			value: "pipeline",
-			label: "This node (ML root step on decoded frames)"
-		}, {
-			value: "onboard",
-			label: "Camera onboard AI (replaces the root step when picked alone)"
-		}]
-	},
 	{
 		key: "motionFps",
 		type: "slider",
@@ -29303,6 +29300,12 @@ var CameraStepOverridePatchSchema = object({
 	settings: record(string(), unknown()).readonly().optional()
 });
 var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
+/** The three root-detector choices a camera has (D507: at most one root). */
+var CameraDetectionSourceSchema = _enum([
+	"pipeline",
+	"onboard",
+	"none"
+]);
 var CameraPipelineSettingsSchema = object({
 	stepToggles: record(string(), boolean()).optional(),
 	stepSettings: CameraStepSettingsSchema.optional(),
@@ -30201,6 +30204,41 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Where this camera's first-level detections come from: this node's own
+		* root step (`pipeline`), the camera's onboard detector alone (`onboard`),
+		* or no root detector (`none`). A camera runs at most one root detector
+		* (D507), so there is no "both". Read from the camera's stored
+		* `detectionSources` — the one authority; `explicit` is false while the
+		* operator has never picked and the default stands.
+		*/
+		getCameraDetectionSource: method(object({ deviceId: number() }), object({
+			source: CameraDetectionSourceSchema,
+			explicit: boolean(),
+			onboard: object({
+				/** The camera has an onboard detector this system can read. */
+				available: boolean(),
+				/** What its detections carry — a camera with no box cannot be a root step. */
+				geometry: _enum([
+					"boxed",
+					"while-streaming",
+					"flag-only",
+					"unknown"
+				])
+			})
+		})),
+		/**
+		* Pick where this camera's detections come from. Writes `detectionSources`
+		* and arms (or disarms) the vendor's boxed sub-stream that the choice
+		* drives. Refuses `onboard` on a camera with no onboard detector.
+		*/
+		setCameraDetectionSource: method(object({
+			deviceId: number(),
+			source: CameraDetectionSourceSchema
+		}), object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Read every per-(node,device) override map for a device. Null when device has no overrides. */
 		getCameraStepOverrides: method(object({ deviceId: number() }), record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).nullable()),
 		/**
@@ -36895,7 +36933,14 @@ var TopologyNodeSchema = object({
 	* completed a mutual-TLS handshake, `clear` otherwise. Absent for the hub,
 	* for offline rows and when the hub cannot tell.
 	*/
-	meshTransport: _enum(["tls", "clear"]).optional()
+	meshTransport: _enum(["tls", "clear"]).optional(),
+	/**
+	* Whether the hub holds this online AGENT's capability registration (its
+	* `registerNode` manifest). `false` = online in the mesh but not ready: the
+	* hub dropped the registration on a disconnect only it saw and the agent has
+	* not re-sent it. Absent for the hub and offline rows.
+	*/
+	capabilitiesRegistered: boolean().optional()
 });
 var CapUsageEdgeSchema = object({
 	callerAddonId: string(),
@@ -47143,6 +47188,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getCameraDetectionSource": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getCameraMetrics": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -47371,6 +47422,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setCameraDetectionSource": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setCameraPipelineForAgent": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -48823,6 +48880,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"streamBroker.getLiveViewerCounts": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"streamBroker.getPreBufferInfo": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -52996,6 +53059,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineOrchestrator.getCameraDetectionSource": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineOrchestrator.getCameraMetrics": [{
 		name: "deviceId",
 		form: "single",
@@ -53056,6 +53124,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineOrchestrator.setCameraDetectionSource": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineOrchestrator.setCameraPipelineForAgent": [{
 		name: "deviceId",
 		form: "single",
@@ -65109,6 +65182,86 @@ function selectedDeviceKey(selection) {
 	return selection.kind === "selected" ? selection.deviceKey : void 0;
 }
 //#endregion
+//#region src/camera-detection-source.ts
+/**
+* The pick a stored list means. A legacy two-root list is truncated to its
+* first element — the same rule the schema applies on the attach path
+* (`DetectionSourcesSchema`), so the UI shows what actually runs. Absent or
+* unreadable is the default, `pipeline`: a value that cannot be read is not an
+* empty pick.
+*/
+function pickFromStored(raw) {
+	if (!Array.isArray(raw)) return {
+		source: "pipeline",
+		explicit: false
+	};
+	const first = raw.find((v) => typeof v === "string");
+	if (first === void 0) return {
+		source: "none",
+		explicit: true
+	};
+	return {
+		source: first === "onboard" ? "onboard" : "pipeline",
+		explicit: true
+	};
+}
+/** The list a pick is stored as. */
+function storedFromPick(source) {
+	return source === "none" ? [] : [source];
+}
+/**
+* What the camera's detections actually CARRY, asked of the cap that knows. A
+* camera whose firmware ships no bounding box cannot be a root step — there is
+* nothing to track — and the operator has to read that BEFORE picking.
+* `unknown` stays unknown: a cap that could not answer is not "flag-only".
+*/
+async function readGeometry(deps, deviceId) {
+	try {
+		const options = await deps.ctx().api?.nativeObjectDetection.getOptions.query({ deviceId });
+		if (options?.geometry === "boxed" || options?.geometry === "while-streaming" || options?.geometry === "flag-only") return options.geometry;
+	} catch {}
+	return "unknown";
+}
+async function readCameraDetectionSource(deps, deviceId) {
+	let raw;
+	try {
+		raw = (await deps.ctx().settings?.readDeviceStore(deviceId))?.["detectionSources"];
+	} catch {}
+	const { source, explicit } = pickFromStored(raw);
+	const available = await deps.deviceHasNativeObjectDetectionCap(deviceId);
+	return {
+		source,
+		explicit,
+		onboard: {
+			available,
+			geometry: available ? await readGeometry(deps, deviceId) : "unknown"
+		}
+	};
+}
+/**
+* Arm (or disarm) the vendor's boxed sub-stream for a camera whose root
+* detector is its own firmware — and stop paying for it on a camera that just
+* stopped being one. A failure is logged and swallowed: the setting still
+* lands, and the sub-stream re-arms on the provider's next login or the
+* orchestrator's forwarding reconcile.
+*/
+async function armOnboardChannel(ctx, deviceId, wantsOnboard) {
+	try {
+		await ctx().api?.nativeObjectDetection.setEnabled.mutate({
+			deviceId,
+			enabled: wantsOnboard
+		});
+	} catch (err) {
+		ctx().logger.warn("failed to arm the onboard detection channel", {
+			tags: { deviceId },
+			meta: {
+				wantsOnboard,
+				error: errMsg$2(err)
+			}
+		});
+	}
+}
+//#endregion
 //#region src/ingest-owner.ts
 /**
 * The cluster's single camera-source owner + its LAN-reachable host, resolved
@@ -65204,48 +65357,7 @@ var DeviceConfigContributions = class {
 				span: 1
 			}]
 		};
-		const hasNativeObjectDetection = await this.deps.deviceHasNativeObjectDetectionCap(input.deviceId);
-		const nativeObjectDetectionSections = [];
-		if (hasNativeObjectDetection) {
-			let currentDetectionSources = ["pipeline"];
-			try {
-				const raw = (await this.deps.ctx().settings?.readDeviceStore(input.deviceId))?.["detectionSources"];
-				if (Array.isArray(raw)) currentDetectionSources = raw.filter((v) => typeof v === "string");
-			} catch {}
-			let geometry = "unknown";
-			try {
-				const options = await this.deps.ctx().api?.nativeObjectDetection.getOptions.query({ deviceId: input.deviceId });
-				if (options?.geometry === "boxed" || options?.geometry === "while-streaming" || options?.geometry === "flag-only") geometry = options.geometry;
-			} catch {}
-			const onboardNote = geometry === "boxed" ? "This camera ships a bounding box with each detection, so picking it alone replaces the ML root step: the accelerator is not asked, and the track still gets its best shot, face, plate and embedding." : geometry === "while-streaming" ? "This is a battery camera: its boxes ride whatever stream is already open rather than a feed of their own, so they cost it nothing — and they exist exactly while it is awake, which is when something is in front of it. Between wake-ups it reports nothing, so pick this alone only if you accept that the camera is the only thing deciding when to look." : geometry === "flag-only" ? "This camera ships the class with NO bounding box. It cannot serve as a root step; its onboard AI is worth what it already is, a wake signal with a class." : "This camera has not said whether its detections carry a bounding box. Without one it cannot serve as a root step.";
-			nativeObjectDetectionSections.push({
-				id: "detection-sources",
-				title: "Detection sources",
-				tab: "detection-pipeline",
-				location: "top-tab",
-				order: 8,
-				fields: [{
-					type: "multiselect",
-					key: "detectionSources",
-					label: "Root detector",
-					description: `Which detector produces this camera's first-level detections. ${onboardNote}`,
-					options: [{
-						value: "pipeline",
-						label: "This node (ML root step on decoded frames)"
-					}, {
-						value: "onboard",
-						label: "Camera onboard AI"
-					}],
-					default: ["pipeline"],
-					value: currentDetectionSources
-				}]
-			});
-		}
-		return { sections: [
-			...baseSections,
-			zonesSection,
-			...nativeObjectDetectionSections
-		] };
+		return { sections: [...baseSections, zonesSection] };
 	}
 	async getDeviceLiveContribution(input) {
 		const assignment = this.deps.getAssignment(input.deviceId);
@@ -65289,6 +65401,23 @@ var DeviceConfigContributions = class {
 			return true;
 		}
 	}
+	/** Where this camera's detections come from, for the Steps editor's first control. */
+	async getCameraDetectionSource(input) {
+		return readCameraDetectionSource(this.deps, input.deviceId);
+	}
+	/**
+	* Pick where this camera's detections come from. Goes through the same write
+	* as every other detection-wiring field (the device store + the settings
+	* event), and arms the vendor sub-stream the pick drives.
+	*/
+	async setCameraDetectionSource(input) {
+		if (input.source === "onboard") {
+			if (!(await readCameraDetectionSource(this.deps, input.deviceId)).onboard.available) throw new Error(`setCameraDetectionSource: device ${String(input.deviceId)} has no onboard detector to use as its root`);
+		}
+		await armOnboardChannel(this.deps.ctx, input.deviceId, input.source === "onboard");
+		await this.writeDeviceOrchestratorSettings(input.deviceId, { detectionSources: storedFromPick(input.source) });
+		return { success: true };
+	}
 	async applyDeviceSettingsPatch(input) {
 		const sensors = validateCameraSensorsPatch(input.patch);
 		if (sensors.kind === "refused") {
@@ -65300,23 +65429,7 @@ var DeviceConfigContributions = class {
 		}
 		const { pipelinePatch, rest } = this.splitPipelinePatch(input.patch);
 		const nextSources = rest["detectionSources"];
-		if (Array.isArray(nextSources)) {
-			const wantsOnboard = nextSources.includes("onboard");
-			try {
-				await this.deps.ctx().api?.nativeObjectDetection.setEnabled.mutate({
-					deviceId: input.deviceId,
-					enabled: wantsOnboard
-				});
-			} catch (err) {
-				this.deps.ctx().logger.warn("failed to arm the onboard detection channel", {
-					tags: { deviceId: input.deviceId },
-					meta: {
-						wantsOnboard,
-						error: err instanceof Error ? err.message : String(err)
-					}
-				});
-			}
-		}
+		if (Array.isArray(nextSources)) await armOnboardChannel(this.deps.ctx, input.deviceId, nextSources.includes("onboard"));
 		const orchestratorRest = sensors.kind === "valid" ? {
 			...rest,
 			[CAMERA_SENSORS_SETTINGS_KEY]: sensors.value
@@ -78528,6 +78641,12 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 	async getDeviceLiveContribution(input) {
 		return this.deviceConfig.getDeviceLiveContribution(input);
 	}
+	async getCameraDetectionSource(input) {
+		return this.deviceConfig.getCameraDetectionSource(input);
+	}
+	async setCameraDetectionSource(input) {
+		return this.deviceConfig.setCameraDetectionSource(input);
+	}
 	async applyDeviceSettingsPatch(input) {
 		return this.deviceConfig.applyDeviceSettingsPatch(input);
 	}