@camstack/types 1.0.4 → 1.0.5

package/dist/index.js

@@ -473,6 +473,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["PipelineEngineMetricsSnapshot"] = "pipeline.engine-metrics-snapshot";
 	/**
+	* Per-node detection-engine runtime-provisioning transition. Emitted by
+	* the detection-pipeline provider on every state change of its lazy
+	* engine-provisioning machine (idle → installing → verifying → ready,
+	* or → failed with a `nextRetryAt`). Payload is the
+	* `EngineProvisioningState` snapshot; `event.source.nodeId` carries the
+	* node. The Pipeline page subscribes to drive a live "installing
+	* OpenVINO… / ready" indicator per node without polling
+	* `pipelineExecutor.getEngineProvisioning`. Telemetry-grade (D8): the UI
+	* also reads the cap snapshot on mount / reconnect. Phase 2.
+	*/
+	EventCategory["PipelineEngineProvisioning"] = "pipeline.engine-provisioning";
+	/**
 	* Cluster topology snapshot. Carries the same payload returned by
 	* `nodes.topology` (every reachable node + addons + processes).
 	* Emitted by the hub on any agent / addon lifecycle change
@@ -8402,6 +8414,24 @@ var DetectorOutputSchema = zod.z.object({
 	inferenceMs: zod.z.number(),
 	modelId: zod.z.string()
 });
+var EngineProvisioningSchema = zod.z.object({
+	runtimeId: zod.z.enum([
+		"onnx",
+		"openvino",
+		"coreml"
+	]).nullable(),
+	device: zod.z.string().nullable(),
+	state: zod.z.enum([
+		"idle",
+		"installing",
+		"verifying",
+		"ready",
+		"failed"
+	]),
+	progress: zod.z.number().optional(),
+	error: zod.z.string().optional(),
+	nextRetryAt: zod.z.number().optional()
+});
 var PipelineStepInputSchema = zod.z.lazy(() => zod.z.object({
 	addonId: zod.z.string(),
 	modelId: zod.z.string(),
@@ -8501,6 +8531,15 @@ var pipelineExecutorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Per-node detection-engine provisioning snapshot. Returns the live
+		* state of the lazy runtime-provisioning machine on `nodeId`
+		* (idle / installing / verifying / ready / failed). The UI pairs this
+		* one-shot query with the `pipeline.engine-provisioning` live event
+		* (emitted on every transition) to drive a per-node "engine ready?"
+		* indicator without polling. Phase 2.
+		*/
+		getEngineProvisioning: method(zod.z.object({ nodeId: zod.z.string() }), EngineProvisioningSchema),
 		getVideoPipelineSteps: method(zod.z.void(), zod.z.record(zod.z.string(), zod.z.object({
 			modelId: zod.z.string(),
 			settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
@@ -12926,6 +12965,7 @@ function createDeviceProxy(api, binding, opts) {
 			setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
 			setCameraPipelineForAgent: (input) => dispatchSystem("pipelineOrchestrator", "setCameraPipelineForAgent", "mutation", input),
 			resolvePipeline: (input) => dispatchSystem("pipelineOrchestrator", "resolvePipeline", "query", input),
+			getCameraStatus: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStatus", "query", input),
 			getDeviceSettingsContribution: (input) => dispatchSystem("pipelineOrchestrator", "getDeviceSettingsContribution", "query", input),
 			getDeviceLiveContribution: (input) => dispatchSystem("pipelineOrchestrator", "getDeviceLiveContribution", "query", input),
 			applyDeviceSettingsPatch: (input) => dispatchSystem("pipelineOrchestrator", "applyDeviceSettingsPatch", "mutation", input)
@@ -13337,6 +13377,7 @@ function createSystemProxy(api) {
 			getSelectedEngine: (input) => dispatch("pipelineExecutor", "getSelectedEngine", "query", input),
 			getDefaultSteps: (input) => dispatch("pipelineExecutor", "getDefaultSteps", "query", input),
 			reprobeEngine: (input) => dispatch("pipelineExecutor", "reprobeEngine", "mutation", input),
+			getEngineProvisioning: (input) => dispatch("pipelineExecutor", "getEngineProvisioning", "query", input),
 			getVideoPipelineSteps: (input) => dispatch("pipelineExecutor", "getVideoPipelineSteps", "query", input),
 			setVideoPipelineSteps: (input) => dispatch("pipelineExecutor", "setVideoPipelineSteps", "mutation", input),
 			getSchema: (input) => dispatch("pipelineExecutor", "getSchema", "query", input),
@@ -13380,6 +13421,8 @@ function createSystemProxy(api) {
 			listAgentSettings: (input) => dispatch("pipelineOrchestrator", "listAgentSettings", "query", input),
 			setAgentAddonDefaults: (input) => dispatch("pipelineOrchestrator", "setAgentAddonDefaults", "mutation", input),
 			removeAgentSettings: (input) => dispatch("pipelineOrchestrator", "removeAgentSettings", "mutation", input),
+			setAgentMaxCameras: (input) => dispatch("pipelineOrchestrator", "setAgentMaxCameras", "mutation", input),
+			getCameraStatuses: (input) => dispatch("pipelineOrchestrator", "getCameraStatuses", "query", input),
 			listTemplates: (input) => dispatch("pipelineOrchestrator", "listTemplates", "query", input),
 			saveTemplate: (input) => dispatch("pipelineOrchestrator", "saveTemplate", "mutation", input),
 			updateTemplate: (input) => dispatch("pipelineOrchestrator", "updateTemplate", "mutation", input),
@@ -16995,7 +17038,10 @@ var AgentAddonConfigSchema = zod.z.object({
 	modelId: zod.z.string(),
 	settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
 });
-var AgentPipelineSettingsSchema = zod.z.object({ addonDefaults: zod.z.record(zod.z.string(), AgentAddonConfigSchema).readonly() });
+var AgentPipelineSettingsSchema = zod.z.object({
+	addonDefaults: zod.z.record(zod.z.string(), AgentAddonConfigSchema).readonly(),
+	maxCameras: zod.z.number().int().nonnegative().nullable().default(null)
+});
 var CameraPipelineForAgentSchema = zod.z.object({
 	steps: zod.z.array(PipelineStepInputSchema).readonly(),
 	audio: zod.z.object({
@@ -17097,6 +17143,141 @@ var GlobalMetricsSchema = zod.z.object({
 * capability providers.
 */
 var CapabilityBindingsSchema = zod.z.record(zod.z.string(), zod.z.string());
+/** Stream entry surfaced from the stream-catalog for one device. */
+var CameraSourceStreamSchema = zod.z.object({
+	camStreamId: zod.z.string(),
+	codec: zod.z.string(),
+	width: zod.z.number(),
+	height: zod.z.number(),
+	fps: zod.z.number(),
+	kind: zod.z.string()
+});
+/** Source block — always present; derives from the stream catalog. */
+var CameraSourceStatusSchema = zod.z.object({ streams: zod.z.array(CameraSourceStreamSchema).readonly() });
+/** Assignment block — always present (orchestrator-local, no remote call). */
+var CameraAssignmentStatusSchema = zod.z.object({
+	detectionNodeId: zod.z.string().nullable(),
+	decoderNodeId: zod.z.string().nullable(),
+	audioNodeId: zod.z.string().nullable(),
+	pinned: zod.z.object({
+		detection: zod.z.boolean(),
+		decoder: zod.z.boolean(),
+		audio: zod.z.boolean()
+	}),
+	reasons: zod.z.object({
+		detection: zod.z.string().optional(),
+		decoder: zod.z.string().optional(),
+		audio: zod.z.string().optional()
+	})
+});
+/** Broker profile slot entry within the broker block. */
+var CameraBrokerProfileSchema = zod.z.object({
+	profile: zod.z.string(),
+	status: zod.z.string(),
+	codec: zod.z.string(),
+	width: zod.z.number(),
+	height: zod.z.number(),
+	subscribers: zod.z.number(),
+	inFps: zod.z.number(),
+	outFps: zod.z.number()
+});
+/** Broker block — null when the broker stage is unreachable or inactive. */
+var CameraBrokerStatusSchema = zod.z.object({
+	profiles: zod.z.array(CameraBrokerProfileSchema).readonly(),
+	webrtcSessions: zod.z.number(),
+	rtspRestream: zod.z.boolean()
+});
+/** Shared-memory ring statistics within the decoder block. */
+var CameraDecoderShmSchema = zod.z.object({
+	framesWritten: zod.z.number(),
+	getFrameHits: zod.z.number(),
+	getFrameMisses: zod.z.number(),
+	budgetMb: zod.z.number()
+});
+/** Decoder block — null when the decoder stage is unreachable or inactive. */
+var CameraDecoderStatusSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	formats: zod.z.array(zod.z.string()).readonly(),
+	sessionCount: zod.z.number(),
+	shm: CameraDecoderShmSchema
+});
+/** Motion block — null when motion detection is not active for this device. */
+var CameraMotionStatusSchema = zod.z.object({
+	enabled: zod.z.boolean(),
+	fps: zod.z.number()
+});
+/** Detection engine provisioning state (mirrors pipeline-executor provisioning states). */
+var CameraDetectionProvisioningStateSchema = zod.z.enum([
+	"idle",
+	"installing",
+	"verifying",
+	"ready",
+	"failed"
+]);
+/** Detection provisioning sub-block. */
+var CameraDetectionProvisioningSchema = zod.z.object({
+	state: CameraDetectionProvisioningStateSchema,
+	error: zod.z.string().optional()
+});
+/** Detection phase — derived from the runner's engine phase. */
+var CameraDetectionPhaseSchema = zod.z.enum([
+	"idle",
+	"watching",
+	"active"
+]);
+/** Detection block — null when no detection node is assigned or reachable. */
+var CameraDetectionStatusSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	engine: zod.z.object({
+		backend: zod.z.string(),
+		device: zod.z.string()
+	}),
+	phase: CameraDetectionPhaseSchema,
+	configuredFps: zod.z.number(),
+	actualFps: zod.z.number(),
+	queueDepth: zod.z.number(),
+	avgInferenceMs: zod.z.number(),
+	provisioning: CameraDetectionProvisioningSchema
+});
+/** Audio block — null when no audio node is assigned or reachable. */
+var CameraAudioStatusSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	enabled: zod.z.boolean()
+});
+/** Recording mode enum (matches recording cap). */
+var CameraRecordingModeSchema = zod.z.enum([
+	"off",
+	"continuous",
+	"events"
+]);
+/** Recording block — null when no recording cap is active for this device. */
+var CameraRecordingStatusSchema = zod.z.object({
+	mode: CameraRecordingModeSchema,
+	active: zod.z.boolean(),
+	storageBytes: zod.z.number()
+});
+/**
+* Aggregated per-camera pipeline status — server-composed, single call.
+*
+* The `assignment` and `source` blocks are always present.
+* Every other block is `null` when the stage is inactive or unreachable
+* during the bounded parallel fan-out in the orchestrator implementation.
+*
+* See spec: `docs/superpowers/specs/2026-06-24-camera-status-aggregator-cap.md`
+*/
+var CameraStatusSchema = zod.z.object({
+	deviceId: zod.z.number(),
+	assignment: CameraAssignmentStatusSchema,
+	source: CameraSourceStatusSchema,
+	broker: CameraBrokerStatusSchema.nullable(),
+	decoder: CameraDecoderStatusSchema.nullable(),
+	motion: CameraMotionStatusSchema.nullable(),
+	detection: CameraDetectionStatusSchema.nullable(),
+	audio: CameraAudioStatusSchema.nullable(),
+	recording: CameraRecordingStatusSchema.nullable(),
+	/** Unix timestamp (ms) when this snapshot was composed server-side. */
+	fetchedAt: zod.z.number()
+});
 /**
 * Pipeline Orchestrator capability — global load balancer + camera dispatcher.
 *
@@ -17273,6 +17454,25 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Set the per-node camera cap for one agent.
+		*
+		* `maxCameras: 0` and `maxCameras: null` are both treated as unlimited
+		* by the load balancer (0 is stored as-is; the balancer treats ≤0 as
+		* unlimited alongside null). Pass `null` to clear an existing cap.
+		* Note: the admin UI normalises 0→null before calling this method, so
+		* `maxCameras: 0` only reaches the store via direct SDK or CLI calls.
+		* Changes take effect immediately on the next dispatch cycle — cameras
+		* currently assigned over-cap are left in place (no forced eviction),
+		* but new assignments obey the updated cap.
+		*/
+		setAgentMaxCameras: method(zod.z.object({
+			agentNodeId: zod.z.string(),
+			maxCameras: zod.z.number().int().nonnegative().nullable()
+		}), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
 		getCameraSettings: method(zod.z.object({ deviceId: zod.z.number() }), CameraPipelineSettingsSchema.nullable()),
 		/** Set or clear the 3-state toggle for one (camera, addonId). Pass `enabled: null` to clear and revert to agent default. */
@@ -17313,6 +17513,29 @@ var pipelineOrchestratorCapability = {
 			deviceId: zod.z.number(),
 			agentNodeId: zod.z.string().optional()
 		}), CameraPipelineConfigSchema),
+		/**
+		* Server-composed aggregated status for a single camera.
+		*
+		* Fans out in parallel (bounded, per-stage graceful degradation) to
+		* broker / decoder / motion / detection / audio / recording source caps
+		* via `ctx.api`. A stage whose source errors or times out becomes `null`
+		* in the returned payload — one slow agent never breaks the whole call.
+		*
+		* Intended for "on open / on camera select" snapshots. Live deltas
+		* keep arriving from the existing ~1Hz events the UI already subscribes to.
+		*/
+		getCameraStatus: method(zod.z.object({ deviceId: zod.z.number() }), CameraStatusSchema),
+		/**
+		* Server-composed aggregated status for multiple cameras in one call.
+		*
+		* `deviceIds` defaults to all cameras currently tracked by the
+		* orchestrator's assignment map when omitted.
+		*
+		* Runs per-device composition in parallel (bounded). Use this to
+		* populate the cluster assignments table and the pipeline flow overview
+		* rail without issuing N parallel browser round-trips.
+		*/
+		getCameraStatuses: method(zod.z.object({ deviceIds: zod.z.array(zod.z.number()).optional() }), zod.z.array(CameraStatusSchema).readonly()),
 		/** List every template the operator has saved. */
 		listTemplates: method(zod.z.void(), zod.z.array(PipelineTemplateSchema).readonly()),
 		/** Create a new named preset from a given CameraPipelineConfig. */
@@ -26025,6 +26248,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineExecutor.getEngineProvisioning": {
+		capName: "pipeline-executor",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineExecutor.getGlobalPipelineConfig": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -26229,6 +26458,18 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getCameraStatus": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineOrchestrator.getCameraStatuses": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getCameraStepOverrides": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -26313,6 +26554,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setAgentMaxCameras": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setCameraPipelineForAgent": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -28549,10 +28796,26 @@ exports.CamProfileSchema = CamProfileSchema;
 exports.CamStreamDescriptorSchema = CamStreamDescriptorSchema;
 exports.CamStreamKindSchema = CamStreamKindSchema;
 exports.CamStreamResolutionSchema = CamStreamResolutionSchema;
+exports.CameraAssignmentStatusSchema = CameraAssignmentStatusSchema;
+exports.CameraAudioStatusSchema = CameraAudioStatusSchema;
+exports.CameraBrokerProfileSchema = CameraBrokerProfileSchema;
+exports.CameraBrokerStatusSchema = CameraBrokerStatusSchema;
 exports.CameraCredentialsSchema = CameraCredentialsSchema;
 exports.CameraCredentialsStatusSchema = CameraCredentialsStatusSchema;
+exports.CameraDecoderShmSchema = CameraDecoderShmSchema;
+exports.CameraDecoderStatusSchema = CameraDecoderStatusSchema;
+exports.CameraDetectionPhaseSchema = CameraDetectionPhaseSchema;
+exports.CameraDetectionProvisioningSchema = CameraDetectionProvisioningSchema;
+exports.CameraDetectionProvisioningStateSchema = CameraDetectionProvisioningStateSchema;
+exports.CameraDetectionStatusSchema = CameraDetectionStatusSchema;
 exports.CameraMetricsSchema = CameraMetricsSchema;
 exports.CameraMetricsWithDeviceIdSchema = CameraMetricsWithDeviceIdSchema;
+exports.CameraMotionStatusSchema = CameraMotionStatusSchema;
+exports.CameraRecordingModeSchema = CameraRecordingModeSchema;
+exports.CameraRecordingStatusSchema = CameraRecordingStatusSchema;
+exports.CameraSourceStatusSchema = CameraSourceStatusSchema;
+exports.CameraSourceStreamSchema = CameraSourceStreamSchema;
+exports.CameraStatusSchema = CameraStatusSchema;
 exports.CameraStreamSchema = CameraStreamSchema;
 exports.CandidateQueryFilterSchema = CandidateQueryFilterSchema;
 exports.CapScopeSchema = CapScopeSchema;