@camstack/addon-pipeline-orchestrator 1.1.57 → 1.1.58

package/dist/{_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_orchestrator_widgets-Q4YOYkCV.mjs → _virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_orchestrator_widgets-BiQO4cUV.mjs}

@@ -18,7 +18,7 @@ var e = {
 	},
 	"@camstack/types": {
 		name: "@camstack/types",
-		version: "1.1.55",
+		version: "1.1.56",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_pipeline_orchestrator_widgets",

package/dist/{hostInit-DMxJQAUo.mjs → hostInit-BtAIIIL1.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.1.55",
+				version: "1.1.56",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

package/dist/index.js

@@ -11929,8 +11929,18 @@ var pipelineExecutorCapability = {
 			*  - `runtime`       — main camera-serving engine (no idle TTL).
 			*  - `warm-override` — benchmark/test override held in the warm
 			*                      cache; auto-disposed after the idle TTL.
+			*  - `device-pool`   — a concurrent per-device pool (Phase 2
+			*                      multi-device, keyed by `deviceKey`) resolved
+			*                      via `resolveDeviceFactory`. Runs alongside the
+			*                      `runtime` engine on a DIFFERENT accelerator
+			*                      (NPU / iGPU / Coral) — this is how the
+			*                      Engines tab shows all pools running at once.
 			*/
-			kind: _enum(["runtime", "warm-override"]),
+			kind: _enum([
+				"runtime",
+				"warm-override",
+				"device-pool"
+			]),
 			/** Native pid of the underlying Python pool (null when no pool). */
 			poolPid: number().nullable(),
 			/** ms since this factory was last used (null when not warm-tracked). */
@@ -17764,7 +17774,17 @@ var AgentPipelineSettingsSchema = object({
 	* it already uses to reach the hub). Set this only when the auto-detected
 	* address is wrong (multi-homed host, NAT, custom interface).
 	*/
-	reachableHost: string().optional()
+	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.
+	*/
+	inferenceDevices: record(string(), object({
+		enabled: boolean(),
+		weight: number().positive().optional()
+	})).optional()
 });
 var CameraPipelineForAgentSchema = object({
 	steps: array(PipelineStepInputSchema).readonly(),
@@ -31437,7 +31457,11 @@ var StoredAgentPipelineSettingsSchema = object({
 	decode: boolean().optional(),
 	audio: boolean().optional(),
 	ingest: boolean().optional(),
-	reachableHost: string().optional()
+	reachableHost: string().optional(),
+	inferenceDevices: record(string(), object({
+		enabled: boolean(),
+		weight: number().positive().optional()
+	})).optional()
 });
 var AgentSettingsMapSchema = record(string(), StoredAgentPipelineSettingsSchema);
 var StoredCameraStepOverridePatchSchema = object({
@@ -32001,6 +32025,20 @@ var PipelineSettingsStore = class PipelineSettingsStore {
 		return weights;
 	}
 	/**
+	* The ENABLED inference devices for a node (Phase 4 multi-device opt-in),
+	* as a `deviceKey → weight` map. Only entries with `enabled:true` are
+	* returned; `weight` defaults to 1. Empty when the node opted into nothing
+	* (or fewer than one device is enabled) — the caller then leaves `deviceKey`
+	* unset and the runner uses its single default accelerator.
+	*/
+	async buildNodeInferenceDevices(nodeId) {
+		const cfg = (await this.agentSettingsState.get())[nodeId]?.inferenceDevices;
+		const out = {};
+		if (!cfg) return out;
+		for (const [deviceKey, entry] of Object.entries(cfg)) if (entry.enabled) out[deviceKey] = entry.weight && entry.weight > 0 ? entry.weight : 1;
+		return out;
+	}
+	/**
 	* Structural runtime check for `CameraPipelineConfig`. Persisted JSON
 	* may be stale or partial across upgrades, so we gate reads on shape
 	* rather than trusting the raw object. False = silently ignore that
@@ -32516,14 +32554,15 @@ var ReconcileController = class ReconcileController {
 //#region src/detection-session-registry.ts
 var DetectionSessionRegistry = class {
 	sessions = /* @__PURE__ */ new Map();
-	register(deviceId, nodeId, startedAt) {
+	register(deviceId, nodeId, startedAt, deviceKey) {
 		const existing = this.sessions.get(deviceId);
 		if (existing?.teardownTimer) clearTimeout(existing.teardownTimer);
 		const session = {
 			deviceId,
 			nodeId,
 			startedAt,
-			teardownTimer: null
+			teardownTimer: null,
+			...deviceKey ? { deviceKey } : {}
 		};
 		this.sessions.set(deviceId, session);
 		return session;
@@ -32565,6 +32604,41 @@ var DetectionSessionRegistry = class {
 	}
 };
 //#endregion
+//#region src/device-balancer.ts
+/**
+* Per-node inference-device balancer (Phase 4 multi-device).
+*
+* Given the ENABLED device pools for a node (deviceKey → relative weight) and
+* the count of ACTIVE detection sessions currently on each pool, pick the pool
+* a NEW session should land on so concurrent sessions spread across the node's
+* accelerators (NPU / iGPU / Coral / additional Corals) proportionally to
+* weight — the classic weighted least-loaded choice used by the node balancer,
+* applied one level down at the device granularity.
+*
+* Returns `null` when fewer than TWO devices are enabled: with zero the caller
+* leaves `deviceKey` unset (the runner's single default accelerator); with
+* exactly one there is nothing to balance and pinning every session to that one
+* key is redundant (the default already serves it). Balancing only earns its
+* keep when there's a real choice.
+*/
+function pickInferenceDevice(enabled, activeCountByDevice) {
+	const keys = Object.keys(enabled);
+	if (keys.length < 2) return null;
+	let best = null;
+	let bestLoad = Number.POSITIVE_INFINITY;
+	let bestWeight = -1;
+	for (const key of keys) {
+		const weight = enabled[key] > 0 ? enabled[key] : 1;
+		const load = (activeCountByDevice[key] ?? 0) / weight;
+		if (load < bestLoad || load === bestLoad && weight > bestWeight) {
+			best = key;
+			bestLoad = load;
+			bestWeight = weight;
+		}
+	}
+	return best;
+}
+//#endregion
 //#region src/session-dispatch-controller.ts
 var SessionDispatchController = class {
 	deps;
@@ -32782,10 +32856,15 @@ var SessionDispatchController = class {
 			return;
 		}
 		const targetNodeId = decision.agentNodeId;
+		const enabledDevices = await this.deps.settingsStore.buildNodeInferenceDevices(targetNodeId);
+		const activeByDevice = {};
+		for (const s of this.sessionRegistry.list()) if (s.nodeId === targetNodeId && s.deviceKey) activeByDevice[s.deviceKey] = (activeByDevice[s.deviceKey] ?? 0) + 1;
+		const deviceKey = pickInferenceDevice(enabledDevices, activeByDevice) ?? void 0;
 		const pipelineConfig = await this.deps.settingsStore.resolvePipelineForDevice(deviceId, targetNodeId);
 		const zones = await this.deps.listZones(deviceId);
 		const sessionConfig = {
 			deviceId,
+			...deviceKey ? { deviceKey } : {},
 			motionCooldownMs: config.motionCooldownMs,
 			motionFps: config.motionFps,
 			detectionFps: config.detectionFps,
@@ -32807,10 +32886,13 @@ var SessionDispatchController = class {
 		try {
 			await this.deps.attachOn(targetNodeId, sessionConfig);
 			this.deps.recordAssignment(deviceId, targetNodeId, decision.reason, decision.reason === "manual");
-			this.sessionRegistry.register(deviceId, targetNodeId, Date.now());
+			this.sessionRegistry.register(deviceId, targetNodeId, Date.now(), deviceKey);
 			log.info("detection session: dispatched on motion", {
 				tags: { nodeId: targetNodeId },
-				meta: { reason: decision.reason }
+				meta: {
+					reason: decision.reason,
+					...deviceKey ? { deviceKey } : {}
+				}
 			});
 		} finally {
 			dispatchGuard.dispose();

package/dist/index.mjs

@@ -11901,8 +11901,18 @@ var pipelineExecutorCapability = {
 			*  - `runtime`       — main camera-serving engine (no idle TTL).
 			*  - `warm-override` — benchmark/test override held in the warm
 			*                      cache; auto-disposed after the idle TTL.
+			*  - `device-pool`   — a concurrent per-device pool (Phase 2
+			*                      multi-device, keyed by `deviceKey`) resolved
+			*                      via `resolveDeviceFactory`. Runs alongside the
+			*                      `runtime` engine on a DIFFERENT accelerator
+			*                      (NPU / iGPU / Coral) — this is how the
+			*                      Engines tab shows all pools running at once.
 			*/
-			kind: _enum(["runtime", "warm-override"]),
+			kind: _enum([
+				"runtime",
+				"warm-override",
+				"device-pool"
+			]),
 			/** Native pid of the underlying Python pool (null when no pool). */
 			poolPid: number().nullable(),
 			/** ms since this factory was last used (null when not warm-tracked). */
@@ -17736,7 +17746,17 @@ var AgentPipelineSettingsSchema = object({
 	* it already uses to reach the hub). Set this only when the auto-detected
 	* address is wrong (multi-homed host, NAT, custom interface).
 	*/
-	reachableHost: string().optional()
+	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.
+	*/
+	inferenceDevices: record(string(), object({
+		enabled: boolean(),
+		weight: number().positive().optional()
+	})).optional()
 });
 var CameraPipelineForAgentSchema = object({
 	steps: array(PipelineStepInputSchema).readonly(),
@@ -31409,7 +31429,11 @@ var StoredAgentPipelineSettingsSchema = object({
 	decode: boolean().optional(),
 	audio: boolean().optional(),
 	ingest: boolean().optional(),
-	reachableHost: string().optional()
+	reachableHost: string().optional(),
+	inferenceDevices: record(string(), object({
+		enabled: boolean(),
+		weight: number().positive().optional()
+	})).optional()
 });
 var AgentSettingsMapSchema = record(string(), StoredAgentPipelineSettingsSchema);
 var StoredCameraStepOverridePatchSchema = object({
@@ -31973,6 +31997,20 @@ var PipelineSettingsStore = class PipelineSettingsStore {
 		return weights;
 	}
 	/**
+	* The ENABLED inference devices for a node (Phase 4 multi-device opt-in),
+	* as a `deviceKey → weight` map. Only entries with `enabled:true` are
+	* returned; `weight` defaults to 1. Empty when the node opted into nothing
+	* (or fewer than one device is enabled) — the caller then leaves `deviceKey`
+	* unset and the runner uses its single default accelerator.
+	*/
+	async buildNodeInferenceDevices(nodeId) {
+		const cfg = (await this.agentSettingsState.get())[nodeId]?.inferenceDevices;
+		const out = {};
+		if (!cfg) return out;
+		for (const [deviceKey, entry] of Object.entries(cfg)) if (entry.enabled) out[deviceKey] = entry.weight && entry.weight > 0 ? entry.weight : 1;
+		return out;
+	}
+	/**
 	* Structural runtime check for `CameraPipelineConfig`. Persisted JSON
 	* may be stale or partial across upgrades, so we gate reads on shape
 	* rather than trusting the raw object. False = silently ignore that
@@ -32488,14 +32526,15 @@ var ReconcileController = class ReconcileController {
 //#region src/detection-session-registry.ts
 var DetectionSessionRegistry = class {
 	sessions = /* @__PURE__ */ new Map();
-	register(deviceId, nodeId, startedAt) {
+	register(deviceId, nodeId, startedAt, deviceKey) {
 		const existing = this.sessions.get(deviceId);
 		if (existing?.teardownTimer) clearTimeout(existing.teardownTimer);
 		const session = {
 			deviceId,
 			nodeId,
 			startedAt,
-			teardownTimer: null
+			teardownTimer: null,
+			...deviceKey ? { deviceKey } : {}
 		};
 		this.sessions.set(deviceId, session);
 		return session;
@@ -32537,6 +32576,41 @@ var DetectionSessionRegistry = class {
 	}
 };
 //#endregion
+//#region src/device-balancer.ts
+/**
+* Per-node inference-device balancer (Phase 4 multi-device).
+*
+* Given the ENABLED device pools for a node (deviceKey → relative weight) and
+* the count of ACTIVE detection sessions currently on each pool, pick the pool
+* a NEW session should land on so concurrent sessions spread across the node's
+* accelerators (NPU / iGPU / Coral / additional Corals) proportionally to
+* weight — the classic weighted least-loaded choice used by the node balancer,
+* applied one level down at the device granularity.
+*
+* Returns `null` when fewer than TWO devices are enabled: with zero the caller
+* leaves `deviceKey` unset (the runner's single default accelerator); with
+* exactly one there is nothing to balance and pinning every session to that one
+* key is redundant (the default already serves it). Balancing only earns its
+* keep when there's a real choice.
+*/
+function pickInferenceDevice(enabled, activeCountByDevice) {
+	const keys = Object.keys(enabled);
+	if (keys.length < 2) return null;
+	let best = null;
+	let bestLoad = Number.POSITIVE_INFINITY;
+	let bestWeight = -1;
+	for (const key of keys) {
+		const weight = enabled[key] > 0 ? enabled[key] : 1;
+		const load = (activeCountByDevice[key] ?? 0) / weight;
+		if (load < bestLoad || load === bestLoad && weight > bestWeight) {
+			best = key;
+			bestLoad = load;
+			bestWeight = weight;
+		}
+	}
+	return best;
+}
+//#endregion
 //#region src/session-dispatch-controller.ts
 var SessionDispatchController = class {
 	deps;
@@ -32754,10 +32828,15 @@ var SessionDispatchController = class {
 			return;
 		}
 		const targetNodeId = decision.agentNodeId;
+		const enabledDevices = await this.deps.settingsStore.buildNodeInferenceDevices(targetNodeId);
+		const activeByDevice = {};
+		for (const s of this.sessionRegistry.list()) if (s.nodeId === targetNodeId && s.deviceKey) activeByDevice[s.deviceKey] = (activeByDevice[s.deviceKey] ?? 0) + 1;
+		const deviceKey = pickInferenceDevice(enabledDevices, activeByDevice) ?? void 0;
 		const pipelineConfig = await this.deps.settingsStore.resolvePipelineForDevice(deviceId, targetNodeId);
 		const zones = await this.deps.listZones(deviceId);
 		const sessionConfig = {
 			deviceId,
+			...deviceKey ? { deviceKey } : {},
 			motionCooldownMs: config.motionCooldownMs,
 			motionFps: config.motionFps,
 			detectionFps: config.detectionFps,
@@ -32779,10 +32858,13 @@ var SessionDispatchController = class {
 		try {
 			await this.deps.attachOn(targetNodeId, sessionConfig);
 			this.deps.recordAssignment(deviceId, targetNodeId, decision.reason, decision.reason === "manual");
-			this.sessionRegistry.register(deviceId, targetNodeId, Date.now());
+			this.sessionRegistry.register(deviceId, targetNodeId, Date.now(), deviceKey);
 			log.info("detection session: dispatched on motion", {
 				tags: { nodeId: targetNodeId },
-				meta: { reason: decision.reason }
+				meta: {
+					reason: decision.reason,
+					...deviceKey ? { deviceKey } : {}
+				}
 			});
 		} finally {
 			dispatchGuard.dispose();

package/dist/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_orchestrator_widgets-Q4YOYkCV.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_orchestrator_widgets-BiQO4cUV.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline-orchestrator",
-  "version": "1.1.57",
+  "version": "1.1.58",
   "description": "Hub-side camera-to-agent load balancer — tracks runner capacity and dispatches attachCamera calls to the optimal pipeline-runner instance",
   "keywords": [
     "camstack",