@camstack/types 1.1.57 → 1.1.76

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-CF-UWPp0.js");
+const require_sleep = require("./sleep-eVjOy4ev.js");
 const require_event_category = require("./event-category-CGj9fI4L.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -1867,6 +1867,31 @@ var BACKEND_TO_FORMAT = {
 	openvino: "openvino"
 };
 /**
+* DEVICE-POOL backend → model format — the SSOT for the multi-device inference
+* DESCRIPTOR path (Python per-device pools), distinct from {@link BACKEND_TO_FORMAT}
+* above which is the legacy NODE runtime map (where `coreml → onnx` because
+* onnxruntime-node's CoreML EP loads `.onnx`). Here a device pool runs the
+* backend NATIVELY, so `coreml → coreml` and `edgetpu → tflite`. Consumed by
+* `resolveDeviceEngine` (addon-pipeline) and the orchestrator's
+* `parseDeviceKey`/`getNodeInferenceDevices` — the previously-duplicated
+* `BACKEND_FORMAT` maps (R3/node-F2). `cpu`/`cuda` floor to onnx.
+*/
+var DEVICE_BACKEND_TO_FORMAT = {
+	openvino: "openvino",
+	edgetpu: "tflite",
+	coreml: "coreml",
+	onnx: "onnx",
+	cpu: "onnx",
+	cuda: "onnx"
+};
+/**
+* Resolve a DEVICE-POOL backend to its model format via {@link DEVICE_BACKEND_TO_FORMAT},
+* flooring unknown backends to `onnx`. The single entry point both addons call.
+*/
+function deviceBackendToFormat(backend) {
+	return DEVICE_BACKEND_TO_FORMAT[backend] ?? "onnx";
+}
+/**
 * Map DetectionRuntime to ModelFormat.
 * Used when the addon receives an explicit runtime (not 'auto').
 */
@@ -8072,20 +8097,6 @@ var pipelineExecutorCapability = {
 		getSelectedEngine: require_sleep.method(zod.z.void(), PipelineEngineChoiceSchema),
 		getDefaultSteps: require_sleep.method(PipelineEngineChoiceSchema, zod.z.array(PipelineDefaultStepSchema)),
 		/**
-		* Re-run the platform probe for the inference engine and write the
-		* detected runtime / backend / device back into the addon's own
-		* global settings store. Returns the engine that was picked so the
-		* UI can confirm without a second round-trip. Triggers the standard
-		* `requiresRestart` auto-restart flow because all three fields are
-		* marked restart-required. Replaces the legacy per-agent
-		* `pipeline-orchestrator.reprobeAgentHwAccel` surface for the
-		* engine dimension — each addon now owns its own probe.
-		*/
-		reprobeEngine: require_sleep.method(zod.z.void(), PipelineEngineChoiceSchema, {
-			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
@@ -8877,6 +8888,19 @@ var RunnerLocalLoadSchema = zod.z.object({
 	avgInferenceTimeMs: zod.z.number(),
 	/** Total queue depth across motion + detection queues. */
 	queueDepthTotal: zod.z.number(),
+	/**
+	* Per-inference-device live load (multi-device C4). One entry per deviceKey
+	* this runner currently has attached cameras on, so the orchestrator's second
+	* `balance()` pass (over a node's devices) weights on real per-pool session
+	* counts. Empty on single-device / pre-multi-device runners. `queueDepthTotal`
+	* per device is 0 until the pool backlog gets a public accessor (follow-up).
+	*/
+	devices: zod.z.array(zod.z.object({
+		deviceKey: zod.z.string(),
+		backend: zod.z.string(),
+		attachedCameras: zod.z.number(),
+		queueDepthTotal: zod.z.number()
+	})).default([]),
 	/** Hardware capability flags reported by this node. */
 	hardware: zod.z.object({
 		hasGpu: zod.z.boolean(),
@@ -13416,7 +13440,6 @@ function createSystemProxy(api) {
 			getAvailableEngines: (input) => dispatch("pipelineExecutor", "getAvailableEngines", "query", input),
 			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),
@@ -13460,13 +13483,13 @@ function createSystemProxy(api) {
 			getAudioNodeLoad: (input) => dispatch("pipelineOrchestrator", "getAudioNodeLoad", "query", input),
 			getAgentSettings: (input) => dispatch("pipelineOrchestrator", "getAgentSettings", "query", input),
 			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),
 			setAgentDetectWeight: (input) => dispatch("pipelineOrchestrator", "setAgentDetectWeight", "mutation", input),
 			setAgentCapabilities: (input) => dispatch("pipelineOrchestrator", "setAgentCapabilities", "mutation", input),
 			setAgentReachableHost: (input) => dispatch("pipelineOrchestrator", "setAgentReachableHost", "mutation", input),
 			setAgentInferenceDevices: (input) => dispatch("pipelineOrchestrator", "setAgentInferenceDevices", "mutation", input),
+			getNodeInferenceDevices: (input) => dispatch("pipelineOrchestrator", "getNodeInferenceDevices", "query", input),
 			resetNodePipelineDefaults: (input) => dispatch("pipelineOrchestrator", "resetNodePipelineDefaults", "mutation", input),
 			getCameraStatuses: (input) => dispatch("pipelineOrchestrator", "getCameraStatuses", "query", input),
 			listTemplates: (input) => dispatch("pipelineOrchestrator", "listTemplates", "query", input),
@@ -19544,13 +19567,11 @@ var PipelineTemplateSchema = zod.z.object({
 	createdAt: zod.z.string(),
 	updatedAt: zod.z.string()
 });
-var AgentAddonConfigSchema = zod.z.object({
-	enabled: zod.z.boolean(),
+var DeviceStepConfigSchema = zod.z.object({
 	modelId: zod.z.string().optional(),
-	settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly()
+	settings: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
 var AgentPipelineSettingsSchema = zod.z.object({
-	addonDefaults: zod.z.record(zod.z.string(), AgentAddonConfigSchema).readonly(),
 	maxCameras: zod.z.number().int().nonnegative().nullable().default(null),
 	/** Per-node detection weight (relative share for the quota balancer). */
 	detectWeight: zod.z.number().positive().optional(),
@@ -19577,13 +19598,18 @@ var AgentPipelineSettingsSchema = zod.z.object({
 	reachableHost: zod.z.string().optional(),
 	/**
 	* Multi-device inference opt-in (Phase 4). Per-node map deviceKey → {enabled,
-	* weight}. Absent / all-disabled ⇒ the node's single default accelerator
-	* (safe default); two+ enabled ⇒ the dispatcher balances detection sessions
-	* across them so they run CONCURRENTLY.
+	* weight, steps}. Absent / all-disabled ⇒ the node's single default
+	* accelerator (safe default); two+ enabled ⇒ the dispatcher balances
+	* detection sessions across them so they run CONCURRENTLY. `steps` is the
+	* per-(node,device) BASE provisioning (`stepId → {modelId?, settings?}`) —
+	* the default model/settings for every camera landing on that accelerator;
+	* a stepId absent ⇒ the step uses that device's format default.
 	*/
 	inferenceDevices: zod.z.record(zod.z.string(), zod.z.object({
 		enabled: zod.z.boolean(),
-		weight: zod.z.number().positive().optional()
+		weight: zod.z.number().positive().optional(),
+		maxSessions: zod.z.number().int().positive().optional(),
+		steps: zod.z.record(zod.z.string(), DeviceStepConfigSchema).optional()
 	})).optional()
 });
 var CameraPipelineForAgentSchema = zod.z.object({
@@ -19594,14 +19620,13 @@ var CameraPipelineForAgentSchema = zod.z.object({
 	}).nullable()
 });
 var CameraStepOverridePatchSchema = zod.z.object({
-	enabled: zod.z.boolean().optional(),
 	modelId: zod.z.string().optional(),
 	settings: zod.z.record(zod.z.string(), zod.z.unknown()).readonly().optional()
 });
 var CameraPipelineSettingsSchema = zod.z.object({
 	pinnedAgentNodeId: zod.z.string().optional(),
 	stepToggles: zod.z.record(zod.z.string(), zod.z.boolean()).optional(),
-	stepOverridesByAgent: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), CameraStepOverridePatchSchema)).optional(),
+	stepOverridesByDevice: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: zod.z.record(zod.z.string(), CameraPipelineForAgentSchema).optional()
 });
 /**
@@ -19823,6 +19848,44 @@ var CameraStatusSchema = zod.z.object({
 	/** Unix timestamp (ms) when this snapshot was composed server-side. */
 	fetchedAt: zod.z.number()
 });
+var NodeInferenceDeviceSchema = zod.z.object({
+	/** Stable per-node device key, e.g. `openvino:npu`, `edgetpu:usb`, `cpu`. */
+	key: zod.z.string(),
+	backend: zod.z.string(),
+	device: zod.z.string(),
+	format: zod.z.enum(MODEL_FORMATS),
+	/** Whether the node's live probe reports the device as usable right now. */
+	available: zod.z.boolean(),
+	/**
+	* Whether this device participates in dispatch. AUTO default (spec C2):
+	* accelerators are opt-OUT (a discovered NPU/iGPU/Coral/ANE with no stored
+	* entry is `true`); CPU is opt-IN (`false` by default — the fallback pool,
+	* not a balanced target). An explicit stored value always wins; a stored-only
+	* (unavailable) key keeps its stored value.
+	*/
+	enabled: zod.z.boolean(),
+	/** Relative balancer weight for the enabled device (default 1). */
+	weight: zod.z.number(),
+	/** Per-device concurrent-session cap; null = unlimited (multi-device C4). */
+	maxSessions: zod.z.number().nullable(),
+	/** Object-detection model the executor defaults to for this deviceKey. */
+	defaultModelId: zod.z.string(),
+	/**
+	* Per-(node,device) BASE provisioning (C7.2/C7.4) — the RAW stored
+	* `stepId → {modelId?, settings?}` map from `inferenceDevices[key].steps`.
+	* Absent/empty ⇒ no base (every step uses its device format default). The
+	* UI cross-references `pipelineExecutor.getSchema` for the models actually
+	* available per format; this is the stored selection that becomes the
+	* default for EVERY camera landing on this accelerator.
+	*/
+	steps: zod.z.record(zod.z.string(), DeviceStepConfigSchema).optional()
+});
+var NodeInferenceDevicesSchema = zod.z.object({
+	nodeId: zod.z.string(),
+	/** False when the node's platform-probe was unreachable (no live device set). */
+	reachable: zod.z.boolean(),
+	devices: zod.z.array(NodeInferenceDeviceSchema).readonly()
+});
 /**
 * Pipeline Orchestrator capability — global load balancer + camera dispatcher.
 *
@@ -19872,6 +19935,34 @@ var pipelineOrchestratorCapability = {
 			auth: "admin"
 		}),
 		/**
+		* Pin a camera's detection to a specific INFERENCE DEVICE (accelerator)
+		* within its node — a SOFT L1 device affinity honoured by the per-session
+		* device `balance()` pass (sibling of the node-level `pipelineNodeId` pin;
+		* persisted as `pipelineDeviceKey` in the device store, read by
+		* `readPipelineDevicePin`). `deviceKey` is a concrete key
+		* (`openvino:npu` / `edgetpu:usb` / `cpu`), or the `'auto'` sentinel /
+		* empty string to CLEAR the pin and let the balancer pick the device.
+		*
+		* Applies promptly: the device is chosen per-session at dispatch, so any
+		* running detection session is closed and re-dispatched onto the new pin
+		* (the camera stays on the SAME node — a device pin never moves the camera).
+		* Cameras with no active session pick it up on their next dispatch.
+		*/
+		setPipelineDevicePin: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			deviceKey: zod.z.string()
+		}), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Read a camera's persisted inference-device pin (`pipelineDeviceKey`).
+		* Returns the concrete device key, or `null` when unpinned (auto). Lets the
+		* UI show the current pin alongside the node pin (parity with the node-pin
+		* value carried on the assignment record).
+		*/
+		getPipelineDevicePin: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.object({ deviceKey: zod.z.string().nullable() })),
+		/**
 		* Trigger a full rebalance pass. Iterates over all assigned cameras,
 		* recomputes the optimal agent for each one based on current load +
 		* hardware affinity, and migrates cameras whose current agent is no
@@ -19956,14 +20047,6 @@ var pipelineOrchestratorCapability = {
 			nodeId: zod.z.string(),
 			settings: AgentPipelineSettingsSchema
 		})).readonly()),
-		/** Bulk-replace ALL addon configs on one agent. Used by the agent-level PipelineEditor which emits the full map per edit. Merges on top of existing entries — omitted addonIds are left alone. */
-		setAgentAddonDefaults: require_sleep.method(zod.z.object({
-			agentNodeId: zod.z.string(),
-			defaults: zod.z.record(zod.z.string(), AgentAddonConfigSchema)
-		}), zod.z.object({ success: zod.z.literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
 		/**
 		* Drop a single agent's persisted settings. Used by the cluster
 		* "Offline agents" panel to evict stale entries left behind when an
@@ -20056,21 +20139,40 @@ var pipelineOrchestratorCapability = {
 		* The map REPLACES the node's stored `inferenceDevices` wholesale (pass the
 		* complete desired set; an empty map clears the opt-in → the node reverts to
 		* its single DEFAULT accelerator). `weight` is optional and defaults to 1.
+		* `models` is the optional per-device model override (`stepId → modelId`,
+		* C7.2/C7.4) — a stepId absent ⇒ the step uses that device's default model.
 		* Creates the node's settings entry if absent. Changes take effect on the
 		* next dispatch/rebalance cycle — the dispatcher reads the enabled set via
-		* `PipelineSettingsStore.buildNodeInferenceDevices` when placing sessions.
+		* `PipelineSettingsStore.buildNodeInferenceDevices` when placing sessions
+		* and the per-(node,device) base provisioning via
+		* `buildNodeInferenceDeviceSteps`.
 		*/
 		setAgentInferenceDevices: require_sleep.method(zod.z.object({
 			agentNodeId: zod.z.string(),
 			inferenceDevices: zod.z.record(zod.z.string(), zod.z.object({
 				enabled: zod.z.boolean(),
-				weight: zod.z.number().positive().optional()
+				weight: zod.z.number().positive().optional(),
+				maxSessions: zod.z.number().int().positive().optional(),
+				steps: zod.z.record(zod.z.string(), DeviceStepConfigSchema).optional()
 			}))
 		}), zod.z.object({ success: zod.z.literal(true) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
 		/**
+		* DEVICE-AWARE merged view of ONE node's inference accelerators. Joins each
+		* physical device the node HAS — probed live via a node-pinned
+		* `platformProbe.getCapabilities` (the platform-probe singleton is targeted
+		* by the `nodeId` cap INPUT, since a `nodePin` context is ignored by a
+		* singleton mount) — with its stored opt-in (`enabled`/`weight`) and the
+		* object-detection `defaultModelId` the executor would run for that
+		* deviceKey. Disabled-but-configured keys still appear. An unreachable node
+		* returns `reachable:false` + best-effort stored-only devices (never
+		* throws). Read surface for the cluster/agent multi-device UI — hence a
+		* default (read-level) auth, matching the other `getAgent*` reads.
+		*/
+		getNodeInferenceDevices: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), NodeInferenceDevicesSchema),
+		/**
 		* Reset one node's pipeline to its hardware-aware defaults — the HONEST
 		* reset (replaces the executor's legacy `resetToDefault`, which cleared a
 		* dead persisted step-tree seed nothing in the live path read):
@@ -20109,15 +20211,18 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/** Read every L2.5 override map for a device. Null when device has no overrides. */
-		getCameraStepOverrides: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), CameraStepOverridePatchSchema)).nullable()),
+		/** Read every per-(node,device) override map for a device. Null when device has no overrides. */
+		getCameraStepOverrides: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), CameraStepOverridePatchSchema))).nullable()),
 		/**
-		* Write or clear the L2.5 per-agent override for one addonId on a device.
-		* `patch: null` clears the entry entirely for that (agent, addon) pair.
+		* Write or clear the per-(camera,node,device) override for one addonId.
+		* `patch: null` clears the entry entirely for that (node, deviceKey, addon)
+		* triple (empty parents are pruned). Model/settings only — enablement is
+		* the per-camera `stepToggles` authority.
 		*/
 		setCameraStepOverride: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number(),
 			agentNodeId: zod.z.string(),
+			deviceKey: zod.z.string(),
 			addonId: zod.z.string(),
 			patch: CameraStepOverridePatchSchema.nullable()
 		}), zod.z.object({ success: zod.z.literal(true) }), {
@@ -20315,7 +20420,8 @@ var serverManagementCapability = {
 		/** Explicit target version; omitted = latest from the registry. */
 version: zod.z.string().optional() }), ServerUpdateActionResultSchema, {
 			kind: "mutation",
-			auth: "admin"
+			auth: "admin",
+			timeoutMs: 16 * 6e4
 		}),
 		rollbackServerUpdate: require_sleep.method(zod.z.void(), ServerUpdateActionResultSchema, {
 			kind: "mutation",
@@ -28949,12 +29055,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineExecutor.reprobeEngine": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineExecutor.runAudioTest": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -29105,6 +29205,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getNodeInferenceDevices": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getPipelineAssignment": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -29117,6 +29223,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getPipelineDevicePin": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.listAgentSettings": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -29159,12 +29271,6 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentAddonDefaults": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineOrchestrator.setAgentCapabilities": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -29219,6 +29325,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setPipelineDevicePin": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.unassignAudio": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -31767,6 +31879,7 @@ exports.DEFAULT_EVENT_COLOR = DEFAULT_EVENT_COLOR;
 exports.DEFAULT_FEATURES = DEFAULT_FEATURES;
 exports.DEFAULT_RETENTION = DEFAULT_RETENTION;
 exports.DEFAULT_SCRUB_THUMBNAIL_PRESET = DEFAULT_SCRUB_THUMBNAIL_PRESET;
+exports.DEVICE_BACKEND_TO_FORMAT = DEVICE_BACKEND_TO_FORMAT;
 exports.DEVICE_CAP_NAMES = DEVICE_CAP_NAMES;
 exports.DEVICE_PROFILES = DEVICE_PROFILES;
 exports.DEVICE_SETTINGS_CONTRIBUTION_METHODS = require_sleep.DEVICE_SETTINGS_CONTRIBUTION_METHODS;
@@ -32293,6 +32406,7 @@ exports.defineCustomActions = defineCustomActions;
 exports.describeModelVariant = describeModelVariant;
 exports.detectionPipelineCapability = detectionPipelineCapability;
 exports.deviceAdoptionCapability = deviceAdoptionCapability;
+exports.deviceBackendToFormat = deviceBackendToFormat;
 exports.deviceCustomAction = deviceCustomAction;
 exports.deviceDiscoveryCapability = deviceDiscoveryCapability;
 exports.deviceExportCapability = deviceExportCapability;