@camstack/addon-pipeline 1.1.25 → 1.1.26

package/dist/audio-analyzer/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-DxM2DSns.js");
-const require_dist = require("../dist-wzWBZ26C.js");
+const require_dist = require("../dist-DAIlCdAx.js");
 let node_fs = require("node:fs");
 node_fs = require_model_download_service_C_IHWnXx.__toESM(node_fs);
 let node_path = require("node:path");

package/dist/audio-analyzer/index.mjs

@@ -1,5 +1,5 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { B as errMsg, D as mapAudioLabelToMacro, V as BaseAddon, Y as hydrateSchema, _ as audioAnalyzerCapability, g as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, o as DEFAULT_AUDIO_ANALYZER_CONFIG, u as HF_BASE_URL } from "../dist-BecXbIzJ.mjs";
+import { B as errMsg, D as mapAudioLabelToMacro, V as BaseAddon, Y as hydrateSchema, _ as audioAnalyzerCapability, g as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, o as DEFAULT_AUDIO_ANALYZER_CONFIG, u as HF_BASE_URL } from "../dist-CgEP_0OL.mjs";
 import { r as downloadFile } from "../model-download-service-C-IHWnXx-BPy6aoAx.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";

package/dist/audio-codec-ffmpeg/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-wzWBZ26C.js");
+const require_dist = require("../dist-DAIlCdAx.js");
 let node_crypto = require("node:crypto");
 let node_child_process = require("node:child_process");
 //#region src/audio-codec-ffmpeg/ffmpeg-audio-process.ts

package/dist/audio-codec-ffmpeg/index.mjs

@@ -1,4 +1,4 @@
-import { B as errMsg, V as BaseAddon, v as audioCodecCapability } from "../dist-BecXbIzJ.mjs";
+import { B as errMsg, V as BaseAddon, v as audioCodecCapability } from "../dist-CgEP_0OL.mjs";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 //#region src/audio-codec-ffmpeg/ffmpeg-audio-process.ts

package/dist/decoder-ffmpeg/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-wzWBZ26C.js");
+const require_dist = require("../dist-DAIlCdAx.js");
 const require_frame_dropper = require("../frame-dropper-7RTo_YyG.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
 let node_crypto = require("node:crypto");

package/dist/decoder-ffmpeg/index.mjs

@@ -1,4 +1,4 @@
-import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, p as RingBuffer, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-BecXbIzJ.mjs";
+import { B as errMsg, V as BaseAddon, d as HWACCEL_OPTIONS, p as RingBuffer, s as DEFAULT_DECODER_HWACCEL_CONFIG, x as decoderCapability } from "../dist-CgEP_0OL.mjs";
 import { r as logBannerArgs, t as FrameDropper } from "../frame-dropper-CwkBTPGV.mjs";
 import { FrameRingReaderCache, FrameRingWriter, MIN_RING_SLOTS, computeSegmentSize, computeSlotByteLength, createSegment, deriveSlotCount } from "@camstack/shm-ring";
 import { randomUUID } from "node:crypto";

package/dist/detection-pipeline/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-DxM2DSns.js");
-const require_dist = require("../dist-wzWBZ26C.js");
+const require_dist = require("../dist-DAIlCdAx.js");
 let node_fs = require("node:fs");
 node_fs = require_model_download_service_C_IHWnXx.__toESM(node_fs);
 let node_path = require("node:path");
@@ -28,8 +28,12 @@ sharp = require_model_download_service_C_IHWnXx.__toESM(sharp);
 *
 * These three keys are therefore persisted node-scoped as `<key>@<nodeId>`.
 * Everything else in the store stays shared. A legacy un-scoped value (written
-* before this change, or by an older build) is read as a migration fallback and
-* re-persisted under the node-scoped key on the next write.
+* before this change, or by an older build) is read as a migration fallback
+* for the HUB ONLY — the pre-scoping store was only ever written by a
+* hub-only deployment, so serving the bare value to any other node leaks the
+* hub's hardware pick (e.g. `openvino/auto`) onto a node that cannot run it
+* (the CB3 "Mac runs OpenVINO" / N100 AUTO-device bug). A non-hub node with
+* no scoped key reads `undefined`, which drives its own auto-pick.
 */
 var ENGINE_CASCADE_KEYS = [
 	"engineBackend",
@@ -54,11 +58,27 @@ function nodeEngineKey(base, nodeId) {
 }
 /**
 * Read an engine cascade value for a node: the node-scoped key if present,
-* otherwise the legacy un-scoped value (migration), otherwise undefined.
+* otherwise — for the HUB only — the legacy un-scoped value (migration),
+* otherwise undefined. The bare fallback is hub-restricted because only the
+* hub ever wrote the pre-scoping store; serving it to other nodes leaked the
+* hub's engine selection cluster-wide (CB3). A non-hub node with no scoped
+* key gets `undefined` so its own platform-driven auto-pick runs and persists
+* a real per-node selection.
 */
 function readNodeEngineValue(store, base, nodeId) {
 	const scoped = store[nodeEngineKey(base, nodeId)];
-	return scoped !== void 0 ? scoped : store[base];
+	if (scoped !== void 0) return scoped;
+	return normalizeEngineNodeId(nodeId) === "hub" ? store[base] : void 0;
+}
+/**
+* Re-map a UI/settings patch so engine cascade fields persist under the
+* node-scoped key; all other keys pass through unchanged. Used on the write
+* path so a UI save on one node never clobbers another node's engine.
+*/
+function scopeEnginePatch(patch, nodeId) {
+	const out = {};
+	for (const [key, value] of Object.entries(patch)) out[isEngineCascadeKey(key) ? nodeEngineKey(key, nodeId) : key] = value;
+	return out;
 }
 /**
 * Project a raw store onto the plain engine cascade keys for THIS node, so the
@@ -257,6 +277,19 @@ function pickBestRuntime(env, bestBackendHint) {
 }
 //#endregion
 //#region src/detection-pipeline/engine/shared-inference-pool.ts
+/**
+* SharedInferencePool — TypeScript wrapper for inference_pool.py.
+*
+* Multi-process orchestrator. Owns N `PoolWorker` instances, each
+* holding its own Python subprocess + MLModel copy, and round-robins
+* inference dispatches across them. Model management (load/unload/
+* replace) propagates to all workers so every subprocess holds the
+* same model set at the same indices.
+*
+* Wire format (per worker):
+*   Request:  [4B total_len][4B req_id][1B msg_type][payload]
+*   Response: [4B total_len][4B req_id][JSON payload]
+*/
 var MSG_COMMAND = 0;
 var MSG_INFER_JPEG = 1;
 var MSG_INFER_RAW = 2;
@@ -568,6 +601,13 @@ var SharedInferencePool = class {
 	nextDispatchIdx = 0;
 	nextFreeIndex = 0;
 	nextFrameId = 1;
+	/**
+	* Cumulative count of frames the Python pool SHED under overload
+	* (`"dropped": true` responses from the per-model in-flight bound in
+	* inference_pool.py). Without this the shed response is
+	* indistinguishable from a genuine "no detections" result.
+	*/
+	droppedResponseCount = 0;
 	log;
 	concurrency;
 	tuning;
@@ -624,17 +664,28 @@ var SharedInferencePool = class {
 		};
 	}
 	async infer(modelIndex, jpeg) {
-		return this.pickWorker().infer(this.encodeModelByte(modelIndex), jpeg);
+		const w = this.pickWorker();
+		return this.trackDroppedResponse(await w.infer(this.encodeModelByte(modelIndex), jpeg), modelIndex);
 	}
 	async inferRaw(modelIndex, raw, width, height, format) {
-		return this.pickWorker().inferRaw(this.encodeModelByte(modelIndex), raw, width, height, format);
+		const w = this.pickWorker();
+		return this.trackDroppedResponse(await w.inferRaw(this.encodeModelByte(modelIndex), raw, width, height, format), modelIndex);
 	}
 	async inferBatch(modelIndex, items) {
 		if (items.length > 255) throw new Error(`SharedInferencePool.inferBatch: max 255 items per call, got ${items.length}`);
 		return this.pickWorker().inferBatch(this.encodeModelByte(modelIndex), items);
 	}
 	async inferCached(modelIndex, frameId) {
-		return this.pickWorker().inferCached(this.encodeModelByte(modelIndex), frameId);
+		const w = this.pickWorker();
+		return this.trackDroppedResponse(await w.inferCached(this.encodeModelByte(modelIndex), frameId), modelIndex);
+	}
+	/**
+	* Total `"dropped": true` responses seen from the Python pool — frames
+	* shed by the per-model in-flight bound under overload. Diagnostic
+	* counter (monotonic for the pool's lifetime).
+	*/
+	getDroppedResponseCount() {
+		return this.droppedResponseCount;
 	}
 	getHandle(modelIndex) {
 		return new PoolHandle(this, modelIndex);
@@ -695,6 +746,22 @@ var SharedInferencePool = class {
 		this.workers.length = 0;
 		this.log.info("Pool process(es) terminated");
 	}
+	/**
+	* Recognise a Python overload-shed response (`"dropped": true`) on the
+	* single-frame inference paths. Previously indistinguishable from a
+	* genuine empty detection result — now counted + debug-logged so
+	* overload is measurable. The response passes through unchanged.
+	*/
+	trackDroppedResponse(result, modelIndex) {
+		if (result["dropped"] === true) {
+			this.droppedResponseCount++;
+			this.log.debug("Python pool shed frame under overload", { meta: {
+				modelIndex,
+				droppedTotal: this.droppedResponseCount
+			} });
+		}
+		return result;
+	}
 	pickWorker() {
 		if (this.workers.length === 0) throw new Error("SharedInferencePool: not initialized");
 		const idx = this.nextDispatchIdx;
@@ -5433,6 +5500,15 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const priorFactory = this.engineFactory;
 		const priorExecutor = this.executor;
 		if (!override) return () => {};
+		if (!backendPossibleOnPlatform(override.backend)) {
+			this.log.warn("Engine override impossible on this platform — running on own engine", { meta: {
+				override: `${override.runtime}/${override.backend}/${override.device ?? "default"}`,
+				platform: process.platform,
+				arch: process.arch,
+				engine: `${priorEngine.runtime}/${priorEngine.backend}`
+			} });
+			return () => {};
+		}
 		const runEngine = {
 			runtime: override.runtime,
 			backend: override.backend,
@@ -6128,6 +6204,12 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					stored: migratedBackend,
 					fallback: platformDefault.backend
 				} });
+				this.writeStore({
+					[nodeEngineKey("engineBackend", node)]: platformDefault.backend,
+					...platformDefault.device !== void 0 ? { [nodeEngineKey("engineDevice", node)]: platformDefault.device } : {}
+				}).catch((err) => {
+					this.log.warn("Failed to persist platform-default engine after impossible stored pick", { meta: { error: err instanceof Error ? err.message : String(err) } });
+				});
 				return platformDefault;
 			}
 			const device = storedDevice || floor.device;
@@ -6779,7 +6861,9 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	provider = null;
 	/** Last non-null probed hardware PER NODE — reused when the probe transiently
 	*  returns null so offered backends / device lists don't collapse. Keyed by
-	*  node because the hub addon probes other nodes when serving their config. */
+	*  node because the hub addon probes other nodes when serving their config.
+	*  Carries the probed node's platform/arch too, so a transient null probe
+	*  doesn't flip a remote node's env back to the serving hub's platform. */
 	lastGoodHardwareByNode = /* @__PURE__ */ new Map();
 	/** This node's effective engine selection, cached from the node-scoped store
 	*  so the synchronous `resolveBackendTuning` and the reprobe gate don't read
@@ -7086,16 +7170,19 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		const hardware = await this.resolveProbeHardware(node);
 		if (hardware) this.lastGoodHardwareByNode.set(node, hardware);
 		const effective = hardware ?? this.lastGoodHardwareByNode.get(node) ?? null;
+		const useProbedPlatform = node !== this.localNodeId();
 		return {
-			platform: process.platform,
-			arch: process.arch,
+			platform: useProbedPlatform && effective?.platform !== void 0 ? effective.platform : process.platform,
+			arch: useProbedPlatform && effective?.arch !== void 0 ? effective.arch : process.arch,
 			hardware: effective
 		};
 	}
 	/**
 	* Fetch the probed hardware from the platform-probe cap for `nodeId` (default
 	* = self). Returns null when the cap is not reachable (caller falls back to
-	* the registry's safe minimum).
+	* the registry's safe minimum). Carries the probed node's `platform`/`arch`
+	* (from `PlatformCapabilities.hardware`) so `probeHardwareEnv` can build the
+	* env for the TARGET node rather than the serving one.
 	*/
 	async resolveProbeHardware(nodeId) {
 		try {
@@ -7106,7 +7193,9 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 			if (!hw) return null;
 			return {
 				npu: hw.npu ? { type: hw.npu.type } : null,
-				gpu: hw.gpu ? { type: hw.gpu.type } : null
+				gpu: hw.gpu ? { type: hw.gpu.type } : null,
+				platform: hw.platform,
+				arch: hw.arch
 			};
 		} catch {
 			return null;
@@ -7125,6 +7214,34 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		return normalizeEngineNodeId(this.ctxIfReady?.kernel?.localNodeId ?? "hub");
 	}
 	/**
+	* One-time store migration (hub only, F1/CB3): the pre-scoping store
+	* persisted the engine cascade under BARE keys (`engineBackend`, …) that
+	* only the hub ever wrote. `readNodeEngineValue` used to serve those bare
+	* values as a fallback to EVERY node, leaking the hub's engine (e.g.
+	* `openvino/auto`) onto agents with no scoped key. The fallback is now
+	* hub-only (engine-store-keys.ts) and this migration re-homes the bare
+	* values to their `<key>@hub` scoped form and deletes the bare keys so the
+	* legacy values cannot resurface. Guarded: runs only while a bare key is
+	* still present, so post-migration boots are a no-op. Best-effort — an
+	* unreadable store skips the migration (retried on the next boot).
+	*/
+	async migrateLegacyBareEngineKeys() {
+		if (this.localNodeId() !== "hub") return;
+		const store = await this.resolveUiSettingsStore();
+		if (store === null) return;
+		const patch = {};
+		for (const base of ENGINE_CASCADE_KEYS) {
+			const bare = store[base];
+			if (bare === void 0 || bare === null) continue;
+			const scopedKey = nodeEngineKey(base, "hub");
+			if (store[scopedKey] === void 0) patch[scopedKey] = bare;
+			patch[base] = void 0;
+		}
+		if (Object.keys(patch).length === 0) return;
+		await this.ctxIfReady?.settings?.writeAddonStore(patch);
+		this.ctx.logger.info("Migrated legacy bare engine keys to their @hub scoped form", { meta: { keys: Object.keys(patch) } });
+	}
+	/**
 	* Refresh this node's cached engine selection from the node-scoped store.
 	* `resolveBackendTuning` is synchronous and the reprobe gate runs before the
 	* provider exists, so both read these cached fields instead of the
@@ -7146,26 +7263,30 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	* cluster-central store. The hub addon serves writes for every node, so it
 	* scopes by the requested `nodeId` (default self).
 	*
-	* When the target IS this node, `super.updateGlobalSettings` drives the normal
-	* apply path (`resolveConfig` / `onConfigChanged` / `requiresRestart` restart),
-	* and the bare engine keys it writes are shadowed by the node-scoped keys on
-	* read. When the target is a SIBLING node, we persist the scoped engine keys +
-	* the non-engine bare keys but DON'T run this node's restart/reprovision — the
-	* owning node applies its own engine selection on its next (re)start.
+	* The engine cascade keys are NEVER written bare (F1, CB3): the bare keys are
+	* the legacy pre-scoping store whose values used to leak to every node with
+	* no scoped key. When the target IS this node, `super.updateGlobalSettings`
+	* drives the normal apply path (`resolveConfig` / `onConfigChanged` /
+	* `requiresRestart` restart) with the engine keys STRIPPED from its patch —
+	* they were already persisted node-scoped, and `onConfigChanged` re-reads
+	* them from the scoped keys. When the target is a SIBLING node, one scoped
+	* write persists the engine keys under `<key>@<target>` + the non-engine
+	* keys bare, and this node's restart/reprovision is NOT run — the owning
+	* node applies its own engine selection on its next (re)start.
 	*/
 	async updateGlobalSettings(patch, nodeId) {
 		const targetNode = nodeId ? normalizeEngineNodeId(nodeId) : this.localNodeId();
 		const patchRecord = patch;
+		if (targetNode !== this.localNodeId()) {
+			const scoped = scopeEnginePatch(patchRecord, targetNode);
+			if (Object.keys(scoped).length > 0) await this.ctxIfReady?.settings?.writeAddonStore(scoped);
+			return;
+		}
 		const scopedEngine = {};
 		for (const key of ENGINE_CASCADE_KEYS) if (key in patchRecord) scopedEngine[nodeEngineKey(key, targetNode)] = patchRecord[key];
 		if (Object.keys(scopedEngine).length > 0) await this.ctxIfReady?.settings?.writeAddonStore(scopedEngine);
-		if (targetNode === this.localNodeId()) {
-			await super.updateGlobalSettings(patch, nodeId);
-			return;
-		}
-		const sharedPatch = {};
-		for (const [k, v] of Object.entries(patchRecord)) if (!ENGINE_CASCADE_KEYS.includes(k)) sharedPatch[k] = v;
-		if (Object.keys(sharedPatch).length > 0) await this.ctxIfReady?.settings?.writeAddonStore(sharedPatch);
+		const { engineBackend: _engineBackend, engineDevice: _engineDevice, probedBestEngine: _probedBestEngine, ...sharedPatch } = patch;
+		await super.updateGlobalSettings(sharedPatch, nodeId);
 	}
 	/**
 	* Resolve the effective pool tuning for the configured backend.
@@ -7197,6 +7318,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	async onInitialize() {
 		const modelsDir = await this.resolveModelsDir();
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
+		await this.migrateLegacyBareEngineKeys();
 		await this.refreshNodeEngineFromStore();
 		this.pythonAddonDir = resolveAddonPythonDir();
 		const py = await ensurePythonReady(this.ctx.deps, this.ctx.logger);

package/dist/detection-pipeline/index.mjs

@@ -1,5 +1,5 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { B as errMsg, E as hfModelUrl, F as runtimeDevices$1, G as EventCategory, J as createEvent, M as pipelineExecutorCapability, Q as parseJsonUnknown, R as supportedRuntimes$1, S as defaultDeviceFor$1, T as evaluateZoneRules, V as BaseAddon, Y as hydrateSchema, a as COCO_TO_MACRO, i as COCO_80_LABELS, j as nodePin, m as YAMNET_TO_MACRO, r as AUDIO_MACRO_LABELS, t as APPLE_SA_TO_MACRO, tt as sleep, w as detectionPipelineCapability } from "../dist-BecXbIzJ.mjs";
+import { B as errMsg, E as hfModelUrl, F as runtimeDevices$1, G as EventCategory, J as createEvent, M as pipelineExecutorCapability, Q as parseJsonUnknown, R as supportedRuntimes$1, S as defaultDeviceFor$1, T as evaluateZoneRules, V as BaseAddon, Y as hydrateSchema, a as COCO_TO_MACRO, i as COCO_80_LABELS, j as nodePin, m as YAMNET_TO_MACRO, r as AUDIO_MACRO_LABELS, t as APPLE_SA_TO_MACRO, tt as sleep, w as detectionPipelineCapability } from "../dist-CgEP_0OL.mjs";
 import { a as isModelDownloaded, i as ensureModel, n as deleteModelFromDisk } from "../model-download-service-C-IHWnXx-BPy6aoAx.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
@@ -21,8 +21,12 @@ import sharp from "sharp";
 *
 * These three keys are therefore persisted node-scoped as `<key>@<nodeId>`.
 * Everything else in the store stays shared. A legacy un-scoped value (written
-* before this change, or by an older build) is read as a migration fallback and
-* re-persisted under the node-scoped key on the next write.
+* before this change, or by an older build) is read as a migration fallback
+* for the HUB ONLY — the pre-scoping store was only ever written by a
+* hub-only deployment, so serving the bare value to any other node leaks the
+* hub's hardware pick (e.g. `openvino/auto`) onto a node that cannot run it
+* (the CB3 "Mac runs OpenVINO" / N100 AUTO-device bug). A non-hub node with
+* no scoped key reads `undefined`, which drives its own auto-pick.
 */
 var ENGINE_CASCADE_KEYS = [
 	"engineBackend",
@@ -47,11 +51,27 @@ function nodeEngineKey(base, nodeId) {
 }
 /**
 * Read an engine cascade value for a node: the node-scoped key if present,
-* otherwise the legacy un-scoped value (migration), otherwise undefined.
+* otherwise — for the HUB only — the legacy un-scoped value (migration),
+* otherwise undefined. The bare fallback is hub-restricted because only the
+* hub ever wrote the pre-scoping store; serving it to other nodes leaked the
+* hub's engine selection cluster-wide (CB3). A non-hub node with no scoped
+* key gets `undefined` so its own platform-driven auto-pick runs and persists
+* a real per-node selection.
 */
 function readNodeEngineValue(store, base, nodeId) {
 	const scoped = store[nodeEngineKey(base, nodeId)];
-	return scoped !== void 0 ? scoped : store[base];
+	if (scoped !== void 0) return scoped;
+	return normalizeEngineNodeId(nodeId) === "hub" ? store[base] : void 0;
+}
+/**
+* Re-map a UI/settings patch so engine cascade fields persist under the
+* node-scoped key; all other keys pass through unchanged. Used on the write
+* path so a UI save on one node never clobbers another node's engine.
+*/
+function scopeEnginePatch(patch, nodeId) {
+	const out = {};
+	for (const [key, value] of Object.entries(patch)) out[isEngineCascadeKey(key) ? nodeEngineKey(key, nodeId) : key] = value;
+	return out;
 }
 /**
 * Project a raw store onto the plain engine cascade keys for THIS node, so the
@@ -250,6 +270,19 @@ function pickBestRuntime(env, bestBackendHint) {
 }
 //#endregion
 //#region src/detection-pipeline/engine/shared-inference-pool.ts
+/**
+* SharedInferencePool — TypeScript wrapper for inference_pool.py.
+*
+* Multi-process orchestrator. Owns N `PoolWorker` instances, each
+* holding its own Python subprocess + MLModel copy, and round-robins
+* inference dispatches across them. Model management (load/unload/
+* replace) propagates to all workers so every subprocess holds the
+* same model set at the same indices.
+*
+* Wire format (per worker):
+*   Request:  [4B total_len][4B req_id][1B msg_type][payload]
+*   Response: [4B total_len][4B req_id][JSON payload]
+*/
 var MSG_COMMAND = 0;
 var MSG_INFER_JPEG = 1;
 var MSG_INFER_RAW = 2;
@@ -561,6 +594,13 @@ var SharedInferencePool = class {
 	nextDispatchIdx = 0;
 	nextFreeIndex = 0;
 	nextFrameId = 1;
+	/**
+	* Cumulative count of frames the Python pool SHED under overload
+	* (`"dropped": true` responses from the per-model in-flight bound in
+	* inference_pool.py). Without this the shed response is
+	* indistinguishable from a genuine "no detections" result.
+	*/
+	droppedResponseCount = 0;
 	log;
 	concurrency;
 	tuning;
@@ -617,17 +657,28 @@ var SharedInferencePool = class {
 		};
 	}
 	async infer(modelIndex, jpeg) {
-		return this.pickWorker().infer(this.encodeModelByte(modelIndex), jpeg);
+		const w = this.pickWorker();
+		return this.trackDroppedResponse(await w.infer(this.encodeModelByte(modelIndex), jpeg), modelIndex);
 	}
 	async inferRaw(modelIndex, raw, width, height, format) {
-		return this.pickWorker().inferRaw(this.encodeModelByte(modelIndex), raw, width, height, format);
+		const w = this.pickWorker();
+		return this.trackDroppedResponse(await w.inferRaw(this.encodeModelByte(modelIndex), raw, width, height, format), modelIndex);
 	}
 	async inferBatch(modelIndex, items) {
 		if (items.length > 255) throw new Error(`SharedInferencePool.inferBatch: max 255 items per call, got ${items.length}`);
 		return this.pickWorker().inferBatch(this.encodeModelByte(modelIndex), items);
 	}
 	async inferCached(modelIndex, frameId) {
-		return this.pickWorker().inferCached(this.encodeModelByte(modelIndex), frameId);
+		const w = this.pickWorker();
+		return this.trackDroppedResponse(await w.inferCached(this.encodeModelByte(modelIndex), frameId), modelIndex);
+	}
+	/**
+	* Total `"dropped": true` responses seen from the Python pool — frames
+	* shed by the per-model in-flight bound under overload. Diagnostic
+	* counter (monotonic for the pool's lifetime).
+	*/
+	getDroppedResponseCount() {
+		return this.droppedResponseCount;
 	}
 	getHandle(modelIndex) {
 		return new PoolHandle(this, modelIndex);
@@ -688,6 +739,22 @@ var SharedInferencePool = class {
 		this.workers.length = 0;
 		this.log.info("Pool process(es) terminated");
 	}
+	/**
+	* Recognise a Python overload-shed response (`"dropped": true`) on the
+	* single-frame inference paths. Previously indistinguishable from a
+	* genuine empty detection result — now counted + debug-logged so
+	* overload is measurable. The response passes through unchanged.
+	*/
+	trackDroppedResponse(result, modelIndex) {
+		if (result["dropped"] === true) {
+			this.droppedResponseCount++;
+			this.log.debug("Python pool shed frame under overload", { meta: {
+				modelIndex,
+				droppedTotal: this.droppedResponseCount
+			} });
+		}
+		return result;
+	}
 	pickWorker() {
 		if (this.workers.length === 0) throw new Error("SharedInferencePool: not initialized");
 		const idx = this.nextDispatchIdx;
@@ -5426,6 +5493,15 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const priorFactory = this.engineFactory;
 		const priorExecutor = this.executor;
 		if (!override) return () => {};
+		if (!backendPossibleOnPlatform(override.backend)) {
+			this.log.warn("Engine override impossible on this platform — running on own engine", { meta: {
+				override: `${override.runtime}/${override.backend}/${override.device ?? "default"}`,
+				platform: process.platform,
+				arch: process.arch,
+				engine: `${priorEngine.runtime}/${priorEngine.backend}`
+			} });
+			return () => {};
+		}
 		const runEngine = {
 			runtime: override.runtime,
 			backend: override.backend,
@@ -6121,6 +6197,12 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 					stored: migratedBackend,
 					fallback: platformDefault.backend
 				} });
+				this.writeStore({
+					[nodeEngineKey("engineBackend", node)]: platformDefault.backend,
+					...platformDefault.device !== void 0 ? { [nodeEngineKey("engineDevice", node)]: platformDefault.device } : {}
+				}).catch((err) => {
+					this.log.warn("Failed to persist platform-default engine after impossible stored pick", { meta: { error: err instanceof Error ? err.message : String(err) } });
+				});
 				return platformDefault;
 			}
 			const device = storedDevice || floor.device;
@@ -6772,7 +6854,9 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	provider = null;
 	/** Last non-null probed hardware PER NODE — reused when the probe transiently
 	*  returns null so offered backends / device lists don't collapse. Keyed by
-	*  node because the hub addon probes other nodes when serving their config. */
+	*  node because the hub addon probes other nodes when serving their config.
+	*  Carries the probed node's platform/arch too, so a transient null probe
+	*  doesn't flip a remote node's env back to the serving hub's platform. */
 	lastGoodHardwareByNode = /* @__PURE__ */ new Map();
 	/** This node's effective engine selection, cached from the node-scoped store
 	*  so the synchronous `resolveBackendTuning` and the reprobe gate don't read
@@ -7079,16 +7163,19 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		const hardware = await this.resolveProbeHardware(node);
 		if (hardware) this.lastGoodHardwareByNode.set(node, hardware);
 		const effective = hardware ?? this.lastGoodHardwareByNode.get(node) ?? null;
+		const useProbedPlatform = node !== this.localNodeId();
 		return {
-			platform: process.platform,
-			arch: process.arch,
+			platform: useProbedPlatform && effective?.platform !== void 0 ? effective.platform : process.platform,
+			arch: useProbedPlatform && effective?.arch !== void 0 ? effective.arch : process.arch,
 			hardware: effective
 		};
 	}
 	/**
 	* Fetch the probed hardware from the platform-probe cap for `nodeId` (default
 	* = self). Returns null when the cap is not reachable (caller falls back to
-	* the registry's safe minimum).
+	* the registry's safe minimum). Carries the probed node's `platform`/`arch`
+	* (from `PlatformCapabilities.hardware`) so `probeHardwareEnv` can build the
+	* env for the TARGET node rather than the serving one.
 	*/
 	async resolveProbeHardware(nodeId) {
 		try {
@@ -7099,7 +7186,9 @@ var DetectionPipelineAddon = class extends BaseAddon {
 			if (!hw) return null;
 			return {
 				npu: hw.npu ? { type: hw.npu.type } : null,
-				gpu: hw.gpu ? { type: hw.gpu.type } : null
+				gpu: hw.gpu ? { type: hw.gpu.type } : null,
+				platform: hw.platform,
+				arch: hw.arch
 			};
 		} catch {
 			return null;
@@ -7118,6 +7207,34 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		return normalizeEngineNodeId(this.ctxIfReady?.kernel?.localNodeId ?? "hub");
 	}
 	/**
+	* One-time store migration (hub only, F1/CB3): the pre-scoping store
+	* persisted the engine cascade under BARE keys (`engineBackend`, …) that
+	* only the hub ever wrote. `readNodeEngineValue` used to serve those bare
+	* values as a fallback to EVERY node, leaking the hub's engine (e.g.
+	* `openvino/auto`) onto agents with no scoped key. The fallback is now
+	* hub-only (engine-store-keys.ts) and this migration re-homes the bare
+	* values to their `<key>@hub` scoped form and deletes the bare keys so the
+	* legacy values cannot resurface. Guarded: runs only while a bare key is
+	* still present, so post-migration boots are a no-op. Best-effort — an
+	* unreadable store skips the migration (retried on the next boot).
+	*/
+	async migrateLegacyBareEngineKeys() {
+		if (this.localNodeId() !== "hub") return;
+		const store = await this.resolveUiSettingsStore();
+		if (store === null) return;
+		const patch = {};
+		for (const base of ENGINE_CASCADE_KEYS) {
+			const bare = store[base];
+			if (bare === void 0 || bare === null) continue;
+			const scopedKey = nodeEngineKey(base, "hub");
+			if (store[scopedKey] === void 0) patch[scopedKey] = bare;
+			patch[base] = void 0;
+		}
+		if (Object.keys(patch).length === 0) return;
+		await this.ctxIfReady?.settings?.writeAddonStore(patch);
+		this.ctx.logger.info("Migrated legacy bare engine keys to their @hub scoped form", { meta: { keys: Object.keys(patch) } });
+	}
+	/**
 	* Refresh this node's cached engine selection from the node-scoped store.
 	* `resolveBackendTuning` is synchronous and the reprobe gate runs before the
 	* provider exists, so both read these cached fields instead of the
@@ -7139,26 +7256,30 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	* cluster-central store. The hub addon serves writes for every node, so it
 	* scopes by the requested `nodeId` (default self).
 	*
-	* When the target IS this node, `super.updateGlobalSettings` drives the normal
-	* apply path (`resolveConfig` / `onConfigChanged` / `requiresRestart` restart),
-	* and the bare engine keys it writes are shadowed by the node-scoped keys on
-	* read. When the target is a SIBLING node, we persist the scoped engine keys +
-	* the non-engine bare keys but DON'T run this node's restart/reprovision — the
-	* owning node applies its own engine selection on its next (re)start.
+	* The engine cascade keys are NEVER written bare (F1, CB3): the bare keys are
+	* the legacy pre-scoping store whose values used to leak to every node with
+	* no scoped key. When the target IS this node, `super.updateGlobalSettings`
+	* drives the normal apply path (`resolveConfig` / `onConfigChanged` /
+	* `requiresRestart` restart) with the engine keys STRIPPED from its patch —
+	* they were already persisted node-scoped, and `onConfigChanged` re-reads
+	* them from the scoped keys. When the target is a SIBLING node, one scoped
+	* write persists the engine keys under `<key>@<target>` + the non-engine
+	* keys bare, and this node's restart/reprovision is NOT run — the owning
+	* node applies its own engine selection on its next (re)start.
 	*/
 	async updateGlobalSettings(patch, nodeId) {
 		const targetNode = nodeId ? normalizeEngineNodeId(nodeId) : this.localNodeId();
 		const patchRecord = patch;
+		if (targetNode !== this.localNodeId()) {
+			const scoped = scopeEnginePatch(patchRecord, targetNode);
+			if (Object.keys(scoped).length > 0) await this.ctxIfReady?.settings?.writeAddonStore(scoped);
+			return;
+		}
 		const scopedEngine = {};
 		for (const key of ENGINE_CASCADE_KEYS) if (key in patchRecord) scopedEngine[nodeEngineKey(key, targetNode)] = patchRecord[key];
 		if (Object.keys(scopedEngine).length > 0) await this.ctxIfReady?.settings?.writeAddonStore(scopedEngine);
-		if (targetNode === this.localNodeId()) {
-			await super.updateGlobalSettings(patch, nodeId);
-			return;
-		}
-		const sharedPatch = {};
-		for (const [k, v] of Object.entries(patchRecord)) if (!ENGINE_CASCADE_KEYS.includes(k)) sharedPatch[k] = v;
-		if (Object.keys(sharedPatch).length > 0) await this.ctxIfReady?.settings?.writeAddonStore(sharedPatch);
+		const { engineBackend: _engineBackend, engineDevice: _engineDevice, probedBestEngine: _probedBestEngine, ...sharedPatch } = patch;
+		await super.updateGlobalSettings(sharedPatch, nodeId);
 	}
 	/**
 	* Resolve the effective pool tuning for the configured backend.
@@ -7190,6 +7311,7 @@ var DetectionPipelineAddon = class extends BaseAddon {
 	async onInitialize() {
 		const modelsDir = await this.resolveModelsDir();
 		if (!this.ctx.settings) throw new Error("DetectionPipelineAddon: ctx.settings not available");
+		await this.migrateLegacyBareEngineKeys();
 		await this.refreshNodeEngineFromStore();
 		this.pythonAddonDir = resolveAddonPythonDir();
 		const py = await ensurePythonReady(this.ctx.deps, this.ctx.logger);