@camstack/addon-pipeline 1.1.69 → 1.1.71

package/dist/{dist-BT4Ug2Bf.mjs → dist-DyALtmD7.mjs}

@@ -7924,6 +7924,24 @@ function nodePin(nodeId) {
 function hfModelUrl(repo, path) {
 	return `https://huggingface.co/${repo}/resolve/main/${path}`;
 }
+/**
+* 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"
+};
 var COCO_80_LABELS = [
 	{
 		id: "person",
@@ -11941,20 +11959,6 @@ var pipelineExecutorCapability = {
 		getSelectedEngine: method(_void(), PipelineEngineChoiceSchema),
 		getDefaultSteps: method(PipelineEngineChoiceSchema, 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: method(_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
@@ -12585,6 +12589,19 @@ var RunnerLocalLoadSchema = object({
 	avgInferenceTimeMs: number(),
 	/** Total queue depth across motion + detection queues. */
 	queueDepthTotal: 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: array(object({
+		deviceKey: string(),
+		backend: string(),
+		attachedCameras: number(),
+		queueDepthTotal: number()
+	})).default([]),
 	/** Hardware capability flags reported by this node. */
 	hardware: object({
 		hasGpu: boolean(),
@@ -18016,13 +18033,11 @@ var PipelineTemplateSchema = object({
 	createdAt: string(),
 	updatedAt: string()
 });
-var AgentAddonConfigSchema = object({
-	enabled: boolean(),
+var DeviceStepConfigSchema = object({
 	modelId: string().optional(),
-	settings: record(string(), unknown()).readonly()
+	settings: record(string(), unknown()).optional()
 });
 var AgentPipelineSettingsSchema = object({
-	addonDefaults: record(string(), AgentAddonConfigSchema).readonly(),
 	maxCameras: number().int().nonnegative().nullable().default(null),
 	/** Per-node detection weight (relative share for the quota balancer). */
 	detectWeight: number().positive().optional(),
@@ -18049,13 +18064,18 @@ var AgentPipelineSettingsSchema = object({
 	reachableHost: 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: record(string(), object({
 		enabled: boolean(),
-		weight: number().positive().optional()
+		weight: number().positive().optional(),
+		maxSessions: number().int().positive().optional(),
+		steps: record(string(), DeviceStepConfigSchema).optional()
 	})).optional()
 });
 var CameraPipelineForAgentSchema = object({
@@ -18066,14 +18086,13 @@ var CameraPipelineForAgentSchema = object({
 	}).nullable()
 });
 var CameraStepOverridePatchSchema = object({
-	enabled: boolean().optional(),
 	modelId: string().optional(),
 	settings: record(string(), unknown()).readonly().optional()
 });
 var CameraPipelineSettingsSchema = object({
 	pinnedAgentNodeId: string().optional(),
 	stepToggles: record(string(), boolean()).optional(),
-	stepOverridesByAgent: record(string(), record(string(), CameraStepOverridePatchSchema)).optional(),
+	stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
 });
 /**
@@ -18287,6 +18306,44 @@ var CameraStatusSchema = object({
 	/** Unix timestamp (ms) when this snapshot was composed server-side. */
 	fetchedAt: number()
 });
+var NodeInferenceDeviceSchema = object({
+	/** Stable per-node device key, e.g. `openvino:npu`, `edgetpu:usb`, `cpu`. */
+	key: string(),
+	backend: string(),
+	device: string(),
+	format: _enum(MODEL_FORMATS),
+	/** Whether the node's live probe reports the device as usable right now. */
+	available: 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: boolean(),
+	/** Relative balancer weight for the enabled device (default 1). */
+	weight: number(),
+	/** Per-device concurrent-session cap; null = unlimited (multi-device C4). */
+	maxSessions: number().nullable(),
+	/** Object-detection model the executor defaults to for this deviceKey. */
+	defaultModelId: 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: record(string(), DeviceStepConfigSchema).optional()
+});
+var NodeInferenceDevicesSchema = object({
+	nodeId: string(),
+	/** False when the node's platform-probe was unreachable (no live device set). */
+	reachable: boolean(),
+	devices: array(NodeInferenceDeviceSchema).readonly()
+});
 method(object({
 	deviceId: number(),
 	agentNodeId: string()
@@ -18296,7 +18353,13 @@ method(object({
 }), method(object({ deviceId: number() }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), object({ migrated: number() }), {
+}), method(object({
+	deviceId: number(),
+	deviceKey: string()
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number() }), object({ deviceKey: string().nullable() })), method(_void(), object({ migrated: number() }), {
 	kind: "mutation",
 	auth: "admin"
 }), method(_void(), array(PipelineAssignmentSchema).readonly()), method(object({ deviceId: number() }), PipelineAssignmentSchema.nullable()), method(_void(), array(AgentLoadSummarySchema).readonly()), method(_void(), GlobalMetricsSchema), method(object({ deviceId: number() }), CameraMetricsSchema.nullable()), method(object({ nodeId: string() }), CapabilityBindingsSchema), method(object({
@@ -18330,13 +18393,7 @@ method(object({
 }))), method(object({ agentNodeId: string() }), AgentPipelineSettingsSchema.nullable()), method(_void(), array(object({
 	nodeId: string(),
 	settings: AgentPipelineSettingsSchema
-})).readonly()), method(object({
-	agentNodeId: string(),
-	defaults: record(string(), AgentAddonConfigSchema)
-}), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ agentNodeId: string() }), object({
+})).readonly()), method(object({ agentNodeId: string() }), object({
 	success: boolean(),
 	removed: boolean()
 }), {
@@ -18368,7 +18425,18 @@ method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ agentNodeId: string() }), object({
+}), method(object({
+	agentNodeId: string(),
+	inferenceDevices: record(string(), object({
+		enabled: boolean(),
+		weight: number().positive().optional(),
+		maxSessions: number().int().positive().optional(),
+		steps: record(string(), DeviceStepConfigSchema).optional()
+	}))
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ nodeId: string() }), NodeInferenceDevicesSchema), method(object({ agentNodeId: string() }), object({
 	success: literal(true),
 	/** Hardware-aware default detection model now in effect on the node (null when unresolvable). */
 	effectiveModelId: string().nullable(),
@@ -18384,9 +18452,10 @@ method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ deviceId: number() }), record(string(), record(string(), CameraStepOverridePatchSchema)).nullable()), method(object({
+}), method(object({ deviceId: number() }), record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).nullable()), method(object({
 	deviceId: number(),
 	agentNodeId: string(),
+	deviceKey: string(),
 	addonId: string(),
 	patch: CameraStepOverridePatchSchema.nullable()
 }), object({ success: literal(true) }), {
@@ -18538,7 +18607,8 @@ method(_void(), ServerPackageStatusSchema, { auth: "admin" }), method(_void(), S
 /** Explicit target version; omitted = latest from the registry. */
 version: string().optional() }), ServerUpdateActionResultSchema, {
 	kind: "mutation",
-	auth: "admin"
+	auth: "admin",
+	timeoutMs: 16 * 6e4
 }), method(_void(), ServerUpdateActionResultSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -24795,12 +24865,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineExecutor.reprobeEngine": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineExecutor.runAudioTest": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -24951,6 +25015,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getNodeInferenceDevices": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getPipelineAssignment": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -24963,6 +25033,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getPipelineDevicePin": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.listAgentSettings": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -25005,19 +25081,19 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentAddonDefaults": {
+	"pipelineOrchestrator.setAgentCapabilities": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentCapabilities": {
+	"pipelineOrchestrator.setAgentDetectWeight": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentDetectWeight": {
+	"pipelineOrchestrator.setAgentInferenceDevices": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -25059,6 +25135,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setPipelineDevicePin": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.unassignAudio": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -26813,5 +26895,118 @@ function runtimeDevices(id, hw) {
 function defaultDeviceFor(id) {
 	return def(id).defaultDevice;
 }
+/**
+* Scores all applicable inference backends for the given hardware.
+*
+* Rules (hardware-driven only — no Python import probes):
+* - coreml:   score 95, darwin+arm64
+* - cuda:     score 85, nvidia gpu
+* - openvino: score 90 if intel-npu present, else 80 if intel gpu
+* - edgetpu:  score 70, coral usb present
+* - cpu:      score 50 (universal floor, always included)
+*
+* All hardware-matched entries are `available: true`.
+* Scores are sorted descending; `best` is the first available entry
+* (or last entry as fallback).
+*/
+function scoreRuntimes(hw) {
+	const scores = [];
+	if (hw.platform === "darwin" && hw.arch === "arm64") scores.push({
+		runtime: "python",
+		backend: "coreml",
+		format: "coreml",
+		score: 95,
+		reason: "Apple Neural Engine (Python CoreML)",
+		available: true
+	});
+	if (hw.gpu?.type === "nvidia") scores.push({
+		runtime: "python",
+		backend: "cuda",
+		format: "onnx",
+		score: 85,
+		reason: "NVIDIA CUDA (Python ONNX Runtime)",
+		available: true
+	});
+	if (hw.gpu?.type === "intel") {
+		const score = hw.npu?.type === "intel-npu" ? 90 : 80;
+		scores.push({
+			runtime: "python",
+			backend: "openvino",
+			format: "openvino",
+			score,
+			reason: "Intel OpenVINO",
+			available: true
+		});
+	}
+	if (hw.coral != null) scores.push({
+		runtime: "python",
+		backend: "edgetpu",
+		format: "tflite",
+		score: 70,
+		reason: "Coral Edge TPU (Python LiteRT)",
+		available: true
+	});
+	scores.push({
+		runtime: "python",
+		backend: "cpu",
+		format: "onnx",
+		score: 50,
+		reason: "CPU (Python ONNX Runtime)",
+		available: true
+	});
+	const sorted = scores.toSorted((a, b) => b.score - a.score);
+	return {
+		scores: sorted,
+		best: sorted.find((s) => s.available) ?? sorted[sorted.length - 1]
+	};
+}
+var DEVICE_FOR_BACKEND = {
+	cuda: "gpu",
+	edgetpu: "usb",
+	coreml: "all",
+	cpu: "cpu"
+};
+function device(backend, dev, format, score) {
+	return {
+		key: backend === "cpu" ? "cpu" : `${backend}:${dev}`,
+		backend,
+		device: dev,
+		format,
+		runtime: "python",
+		score,
+		available: true
+	};
+}
+/**
+* Enumerate every usable inference device on a node — one descriptor PER PHYSICAL
+* ACCELERATOR, so the orchestrator can run and balance across all of them
+* CONCURRENTLY (each device is its own pool). Critically, OpenVINO is expanded
+* into its distinct devices (NPU / iGPU / CPU) rather than a single AUTO entry:
+* the Intel NPU ("AI Boost") and the iGPU are separate accelerators and run in
+* parallel — collapsing them to AUTO would leave one idle. NPU is scored above
+* the iGPU (faster for int8 detection AND frees the GPU).
+*/
+function enumerateInferenceDevices(hw) {
+	const { scores } = scoreRuntimes(hw);
+	const out = [];
+	for (const s of scores) {
+		if (s.backend === "openvino") {
+			if (hw.npu?.type === "intel-npu") out.push(device("openvino", "npu", s.format, s.score + 2));
+			if (hw.gpu?.type === "intel") out.push(device("openvino", "gpu", s.format, s.score));
+			continue;
+		}
+		if (s.backend === "edgetpu") {
+			const coralCount = Math.max(1, hw.coral?.count ?? 1);
+			for (let i = 0; i < coralCount; i++) {
+				const dev = i === 0 ? "usb" : `usb:${i}`;
+				out.push(device("edgetpu", dev, s.format, s.score));
+			}
+			continue;
+		}
+		const dev = DEVICE_FOR_BACKEND[s.backend] ?? s.backend;
+		out.push(device(s.backend, dev, s.format, s.score));
+	}
+	return out;
+}
 //#endregion
-export { sleep as $, pipelineExecutorCapability as A, errMsg as B, evaluateZoneRules as C, migrateConfigToBands as D, maskUrlCredentials as E, runtimeDevices as F, createEvent as G, CAM_PROFILE_ORDER as H, storageEvictableCapability as I, makeProfileBrokerId as J, hydrateSchema as K, streamBrokerCapability as L, recordingCapability as M, recordingExportCapability as N, motionDetectionCapability as O, resolveScrubThumbnailGeometry as P, selectAssignedProfileSlots as Q, supportedRuntimes as R, detectionPipelineCapability as S, mapAudioLabelToMacro as T, DeviceFeature as U, BaseAddon as V, DeviceType as W, parseJsonUnknown as X, makeSourceBrokerId as Y, parseProfileBrokerId as Z, audioAnalyzerCapability as _, COCO_TO_MACRO as a, literal as at, defaultDeviceFor as b, EncodeProfileSchema as c, record as ct, OpsLogEntrySchema as d, EventCategory as dt, _enum as et, RecordingConfigSchema as f, audioAnalysisCapability as g, addonWidgetsSourceCapability as h, COCO_80_LABELS as i, lazy as it, pipelineRunnerCapability as j, nodePin as k, ExportRecordSchema as l, string as lt, YAMNET_TO_MACRO as m, AUDIO_BACKEND_CHOICES as n, boolean as nt, DEFAULT_AUDIO_ANALYZER_CONFIG as o, number as ot, RingBuffer as p, isEvent as q, AUDIO_MACRO_LABELS as r, discriminatedUnion as rt, EVENT_PAD_MS as s, object as st, APPLE_SA_TO_MACRO as t, array as tt, HF_BASE_URL as u, union as ut, cameraStreamsCapability as v, hfModelUrl as w, defineCustomActions as x, customAction as y, webrtcSessionCapability as z };
+export { parseProfileBrokerId as $, motionDetectionCapability as A, supportedRuntimes as B, detectionPipelineCapability as C, mapAudioLabelToMacro as D, hfModelUrl as E, recordingExportCapability as F, DeviceFeature as G, errMsg as H, resolveScrubThumbnailGeometry as I, hydrateSchema as J, DeviceType as K, runtimeDevices as L, pipelineExecutorCapability as M, pipelineRunnerCapability as N, maskUrlCredentials as O, recordingCapability as P, parseJsonUnknown as Q, storageEvictableCapability as R, defineCustomActions as S, evaluateZoneRules as T, BaseAddon as U, webrtcSessionCapability as V, CAM_PROFILE_ORDER as W, makeProfileBrokerId as X, isEvent as Y, makeSourceBrokerId as Z, audioAnalysisCapability as _, COCO_TO_MACRO as a, discriminatedUnion as at, customAction as b, EVENT_PAD_MS as c, number as ct, HF_BASE_URL as d, string as dt, selectAssignedProfileSlots as et, OpsLogEntrySchema as f, union as ft, addonWidgetsSourceCapability as g, YAMNET_TO_MACRO as h, COCO_80_LABELS as i, boolean as it, nodePin as j, migrateConfigToBands as k, EncodeProfileSchema as l, object as lt, RingBuffer as m, AUDIO_BACKEND_CHOICES as n, _enum as nt, DEFAULT_AUDIO_ANALYZER_CONFIG as o, lazy as ot, RecordingConfigSchema as p, EventCategory as pt, createEvent as q, AUDIO_MACRO_LABELS as r, array as rt, DEVICE_BACKEND_TO_FORMAT as s, literal as st, APPLE_SA_TO_MACRO as t, sleep as tt, ExportRecordSchema as u, record as ut, audioAnalyzerCapability as v, enumerateInferenceDevices as w, defaultDeviceFor as x, cameraStreamsCapability as y, streamBrokerCapability as z };