@camstack/types 1.0.3 → 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
@@ -622,14 +634,15 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["DeviceSleeping"] = "device.sleeping";
 	EventCategory["RetentionCleanup"] = "retention.cleanup";
 	/**
-	* Progress snapshot emitted by `BulkUpdateCoordinator` on every state
-	* transition (item status change, phase change, completion, cancel).
-	* Payload is `BulkUpdateState`. Admin UI subscribes via `useLiveEvent`
-	* to drive the sticky `BulkUpdateBanner` and per-row `AddonRowBadge`.
-	*
-	* Spec: docs/superpowers/specs/2026-05-21-addons-bulk-update-progress-design.md
+	* Legacy bulk-update progress snapshot (payload `BulkUpdateState`). No longer
+	* emitted — F3 removed the coordinator that produced it; "Update all" now runs
+	* as one lifecycle engine job (`AddonsJobProgress`/`AddonsJobLog`). Retained
+	* (with `BulkUpdateState`) only to avoid regenerating the event maps; removed
+	* in F4 once live bulk progress is re-implemented over the engine events.
 	*/
 	EventCategory["AddonsBulkUpdateProgress"] = "addons.bulk-update-progress";
+	EventCategory["AddonsJobProgress"] = "addons.job-progress";
+	EventCategory["AddonsJobLog"] = "addons.job-log";
 	/**
 	* A container's child visibility toggled (hidden/shown). Emitted by the
 	* `accessories` cap when a child device is hidden or revealed.
@@ -8401,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(),
@@ -8500,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()
@@ -12925,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)
@@ -13087,10 +13128,6 @@ function createSystemProxy(api) {
 			listCapabilityProviders: (input) => dispatch("addons", "listCapabilityProviders", "query", input),
 			setCapabilityProviderEnabled: (input) => dispatch("addons", "setCapabilityProviderEnabled", "mutation", input),
 			updateFrameworkPackage: (input) => dispatch("addons", "updateFrameworkPackage", "mutation", input),
-			startBulkUpdate: (input) => dispatch("addons", "startBulkUpdate", "mutation", input),
-			getBulkUpdateState: (input) => dispatch("addons", "getBulkUpdateState", "query", input),
-			cancelBulkUpdate: (input) => dispatch("addons", "cancelBulkUpdate", "mutation", input),
-			listActiveBulkUpdates: (input) => dispatch("addons", "listActiveBulkUpdates", "query", input),
 			getVersions: (input) => dispatch("addons", "getVersions", "query", input),
 			restartAddon: (input) => dispatch("addons", "restartAddon", "mutation", input),
 			retryLoad: (input) => dispatch("addons", "retryLoad", "mutation", input),
@@ -13100,6 +13137,10 @@ function createSystemProxy(api) {
 			setAddonAutoUpdate: (input) => dispatch("addons", "setAddonAutoUpdate", "mutation", input),
 			applyAutoUpdateToAll: (input) => dispatch("addons", "applyAutoUpdateToAll", "mutation", input),
 			custom: (input) => dispatch("addons", "custom", "mutation", input),
+			startJob: (input) => dispatch("addons", "startJob", "mutation", input),
+			getJob: (input) => dispatch("addons", "getJob", "query", input),
+			listJobs: (input) => dispatch("addons", "listJobs", "query", input),
+			cancelJob: (input) => dispatch("addons", "cancelJob", "mutation", input),
 			onAddonLogs: (input, push) => dispatch("addons", "onAddonLogs", "subscription", input, push)
 		},
 		addonSettings: {
@@ -13336,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),
@@ -13379,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),
@@ -16994,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({
@@ -17096,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.
 *
@@ -17272,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. */
@@ -17312,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. */
@@ -22098,6 +22322,71 @@ var integrationsCapability = {
 	}
 };
 //#endregion
+//#region src/lifecycle/job.ts
+var jobKindSchema = zod.z.enum([
+	"install",
+	"update",
+	"uninstall",
+	"restart"
+]);
+var taskPhaseSchema = zod.z.enum([
+	"queued",
+	"fetching",
+	"staged",
+	"validating",
+	"applying",
+	"restarting",
+	"applied",
+	"done",
+	"failed",
+	"skipped"
+]);
+var taskTargetSchema = zod.z.enum(["framework", "addon"]);
+var taskLogEntrySchema = zod.z.object({
+	tsMs: zod.z.number(),
+	nodeId: zod.z.string(),
+	packageName: zod.z.string(),
+	phase: taskPhaseSchema,
+	message: zod.z.string()
+});
+var lifecycleTaskSchema = zod.z.object({
+	taskId: zod.z.string(),
+	nodeId: zod.z.string(),
+	packageName: zod.z.string(),
+	fromVersion: zod.z.string().nullable(),
+	toVersion: zod.z.string(),
+	target: taskTargetSchema,
+	phase: taskPhaseSchema,
+	stagedPath: zod.z.string().nullable(),
+	attempts: zod.z.number(),
+	steps: zod.z.array(taskLogEntrySchema),
+	error: zod.z.string().nullable(),
+	startedAtMs: zod.z.number().nullable(),
+	finishedAtMs: zod.z.number().nullable()
+});
+var lifecycleJobStateSchema = zod.z.enum([
+	"running",
+	"completed",
+	"failed",
+	"partially-failed",
+	"cancelled"
+]);
+var lifecycleJobScopeSchema = zod.z.enum([
+	"single",
+	"bulk",
+	"cluster"
+]);
+var lifecycleJobSchema = zod.z.object({
+	jobId: zod.z.string(),
+	kind: jobKindSchema,
+	createdAtMs: zod.z.number(),
+	createdBy: zod.z.string(),
+	scope: lifecycleJobScopeSchema,
+	tasks: zod.z.array(lifecycleTaskSchema),
+	state: lifecycleJobStateSchema,
+	schemaVersion: zod.z.literal(1)
+});
+//#endregion
 //#region src/capabilities/addons.cap.ts
 /**
 * addons — system-scoped singleton capability for addon package
@@ -22281,7 +22570,7 @@ var BulkUpdatePhaseSchema = zod.z.enum([
 	"restarting",
 	"finalizing"
 ]);
-var BulkUpdateStateSchema = zod.z.object({
+zod.z.object({
 	id: zod.z.string(),
 	nodeId: zod.z.string(),
 	startedAtMs: zod.z.number(),
@@ -22517,54 +22806,6 @@ var addonsCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/**
-		* Kicks off a server-side bulk update operation and returns the bulk
-		* id immediately. The operation runs asynchronously; observe progress
-		* via the `AddonsBulkUpdateProgress` event or `getBulkUpdateState`.
-		* Items with `isSystem: true` use `deferRestart` — the hub restarts
-		* ONCE at the end of the system phase, after all system packages are
-		* installed.
-		*
-		* `items[].version` is REQUIRED — callers must pass the resolved
-		* version from `listUpdates`. There is no `'latest'` default here
-		* (unlike `updatePackage`) to guarantee deterministic bulk rolls.
-		*/
-		startBulkUpdate: method(zod.z.object({
-			nodeId: zod.z.string(),
-			items: zod.z.array(zod.z.object({
-				name: zod.z.string(),
-				version: zod.z.string(),
-				isSystem: zod.z.boolean()
-			})).readonly()
-		}), zod.z.object({ id: zod.z.string() }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Returns the current state of a bulk update by id.
-		* Returns `null` if the id is unknown or has been auto-cleaned
-		* (5 minutes after `completedAt` the record is evicted from memory).
-		*/
-		getBulkUpdateState: method(zod.z.object({ id: zod.z.string() }), BulkUpdateStateSchema.nullable(), { auth: "admin" }),
-		/**
-		* Cancels an in-flight bulk update. The update loop exits after the
-		* currently-processing item completes — cancellation is not
-		* instantaneous. Has no effect once the `restarting` phase has been
-		* entered (the hub is already shutting down at that point).
-		* Returns `{ cancelled: false }` if the id is unknown, the operation
-		* has already completed, or the `restarting` phase is active.
-		*/
-		cancelBulkUpdate: method(zod.z.object({ id: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Lists all currently active (non-completed) bulk updates.
-		* If `nodeId` is provided, filters to only bulk updates targeting
-		* that node. Useful for restoring an in-progress banner on a fresh
-		* page load when the UI reconnects mid-operation.
-		*/
-		listActiveBulkUpdates: method(zod.z.object({ nodeId: zod.z.string().optional() }), zod.z.array(BulkUpdateStateSchema).readonly(), { auth: "admin" }),
 		getVersions: method(zod.z.object({ name: zod.z.string() }), zod.z.array(PackageVersionInfoSchema).readonly()),
 		restartAddon: method(zod.z.object({ addonId: zod.z.string() }), RestartAddonResultSchema, {
 			kind: "mutation",
@@ -22601,6 +22842,51 @@ var addonsCapability = {
 			auth: "admin"
 		}),
 		custom: method(CustomActionInputSchema, zod.z.unknown(), { kind: "mutation" }),
+		/**
+		* Start a lifecycle job (install / update / uninstall / restart) for one
+		* or more addon packages. Returns the `jobId` immediately — the job runs
+		* asynchronously. Observe progress via `EventCategory.AddonsJobProgress` /
+		* `AddonsJobLog` events or poll `getJob`.
+		*
+		* For a single-addon update on the hub the provider also routes
+		* `updatePackage` through this path so the fast swap + atomic-restart
+		* path (`applyStagedAddonUpdate`) is always used.
+		*/
+		startJob: method(zod.z.object({
+			kind: zod.z.enum([
+				"install",
+				"update",
+				"uninstall",
+				"restart"
+			]),
+			targets: zod.z.array(zod.z.object({
+				name: zod.z.string().min(1),
+				version: zod.z.string().min(1)
+			})).min(1),
+			nodeIds: zod.z.array(zod.z.string()).optional()
+		}), zod.z.object({ jobId: zod.z.string() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Retrieve a lifecycle job by id. Returns `null` when the id is unknown
+		* (e.g. evicted after the retention window).
+		*/
+		getJob: method(zod.z.object({ jobId: zod.z.string() }), lifecycleJobSchema.nullable(), { auth: "admin" }),
+		/**
+		* List lifecycle jobs. When `activeOnly` is true, only jobs still in
+		* `running` state are returned.
+		*/
+		listJobs: method(zod.z.object({ activeOnly: zod.z.boolean().optional() }), zod.z.array(lifecycleJobSchema), { auth: "admin" }),
+		/**
+		* Cancel a lifecycle job that is queued but not yet actively running.
+		* Returns `{ cancelled: false }` if the job is unknown, already in a
+		* terminal state, or actively executing (cannot abort mid-flight).
+		*/
+		cancelJob: method(zod.z.object({ jobId: zod.z.string() }), zod.z.object({ cancelled: zod.z.boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		onAddonLogs: method(zod.z.object({
 			addonId: zod.z.string(),
 			level: LogLevelSchema$1.optional()
@@ -23562,7 +23848,7 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"addons.cancelBulkUpdate": {
+	"addons.cancelJob": {
 		capName: "addons",
 		capScope: "system",
 		addonId: null,
@@ -23592,7 +23878,7 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"addons.getBulkUpdateState": {
+	"addons.getJob": {
 		capName: "addons",
 		capScope: "system",
 		addonId: null,
@@ -23640,19 +23926,19 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"addons.listActiveBulkUpdates": {
+	"addons.listCapabilityProviders": {
 		capName: "addons",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"addons.listCapabilityProviders": {
+	"addons.listFrameworkPackages": {
 		capName: "addons",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"addons.listFrameworkPackages": {
+	"addons.listJobs": {
 		capName: "addons",
 		capScope: "system",
 		addonId: null,
@@ -23736,7 +24022,7 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"addons.startBulkUpdate": {
+	"addons.startJob": {
 		capName: "addons",
 		capScope: "system",
 		addonId: null,
@@ -25962,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",
@@ -26166,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",
@@ -26250,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",
@@ -28023,6 +28333,34 @@ function getCapsByProviderKind(kind) {
 	return out;
 }
 //#endregion
+//#region src/lifecycle/framework-swap.ts
+var frameworkSwapPackageSchema = zod.z.object({
+	name: zod.z.string(),
+	stagedPath: zod.z.string(),
+	backupPath: zod.z.string(),
+	toVersion: zod.z.string(),
+	fromVersion: zod.z.string().nullable()
+});
+var pendingFrameworkSwapSchema = zod.z.object({
+	jobId: zod.z.string(),
+	taskId: zod.z.string(),
+	packages: zod.z.array(frameworkSwapPackageSchema),
+	requestedAtMs: zod.z.number(),
+	schemaVersion: zod.z.literal(1)
+});
+var frameworkSwapConfirmSchema = zod.z.object({
+	jobId: zod.z.string(),
+	taskId: zod.z.string(),
+	backups: zod.z.array(zod.z.object({
+		name: zod.z.string(),
+		backupPath: zod.z.string(),
+		livePath: zod.z.string()
+	})),
+	appliedAtMs: zod.z.number(),
+	bootAttempts: zod.z.number(),
+	schemaVersion: zod.z.literal(1)
+});
+//#endregion
 //#region src/util/location-match.ts
 /**
 * Pure fuzzy matcher for adoption location import. Normalized
@@ -28458,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;
@@ -28914,6 +29268,8 @@ exports.findTimezone = findTimezone;
 exports.floodCapability = floodCapability;
 exports.formatForBackend = formatForBackend;
 exports.formatForRuntime = formatForRuntime;
+exports.frameworkSwapConfirmSchema = frameworkSwapConfirmSchema;
+exports.frameworkSwapPackageSchema = frameworkSwapPackageSchema;
 exports.gasCapability = gasCapability;
 exports.getAudioMacroClassIds = getAudioMacroClassIds;
 exports.getByPath = getByPath;
@@ -28929,7 +29285,12 @@ exports.isAgentOnlyPlacement = isAgentOnlyPlacement;
 exports.isDeployableToAgent = isDeployableToAgent;
 exports.isDeviceConfigCap = isDeviceConfigCap;
 exports.isEvent = isEvent;
+exports.jobKindSchema = jobKindSchema;
 exports.lawnMowerControlCapability = lawnMowerControlCapability;
+exports.lifecycleJobSchema = lifecycleJobSchema;
+exports.lifecycleJobScopeSchema = lifecycleJobScopeSchema;
+exports.lifecycleJobStateSchema = lifecycleJobStateSchema;
+exports.lifecycleTaskSchema = lifecycleTaskSchema;
 exports.localNetworkCapability = localNetworkCapability;
 exports.locationSimilarity = locationSimilarity;
 exports.lockControlCapability = lockControlCapability;
@@ -28966,6 +29327,7 @@ exports.parseJsonObject = parseJsonObject;
 exports.parseJsonUnknown = parseJsonUnknown;
 exports.parseProfileBrokerId = parseProfileBrokerId;
 exports.parseStreamParamsFormPatch = parseStreamParamsFormPatch;
+exports.pendingFrameworkSwapSchema = pendingFrameworkSwapSchema;
 exports.pickPreferredRtspEntry = pickPreferredRtspEntry;
 exports.pipelineAnalyticsCapability = pipelineAnalyticsCapability;
 exports.pipelineExecutorCapability = pipelineExecutorCapability;
@@ -29020,6 +29382,9 @@ exports.switchCapability = switchCapability;
 exports.synthesizeSourceInfo = synthesizeSourceInfo;
 exports.systemCapability = systemCapability;
 exports.tamperCapability = tamperCapability;
+exports.taskLogEntrySchema = taskLogEntrySchema;
+exports.taskPhaseSchema = taskPhaseSchema;
+exports.taskTargetSchema = taskTargetSchema;
 exports.temperatureSensorCapability = temperatureSensorCapability;
 exports.toDeviceSummary = toDeviceSummary;
 exports.toStreamSourceEntry = toStreamSourceEntry;