@camstack/addon-pipeline 1.1.27 → 1.1.28

package/dist/detection-pipeline/index.js

@@ -3,7 +3,9 @@ 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-DAIlCdAx.js");
+const require_dist = require("../dist-Biq62zt4.js");
+const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
+let _camstack_shm_ring = require("@camstack/shm-ring");
 let node_fs = require("node:fs");
 node_fs = require_model_download_service_C_IHWnXx.__toESM(node_fs);
 let node_path = require("node:path");
@@ -27,13 +29,15 @@ sharp = require_model_download_service_C_IHWnXx.__toESM(sharp);
 * another node that has no NPU.
 *
 * 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
-* 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.
+* Everything else in the store stays shared. There is NO fallback to a legacy
+* un-scoped value for ANY node (the hub included) and no in-code migration: a
+* bare key (written before scoping, or by an older build) is inert — invisible
+* to every node. A node with no scoped key reads `undefined`, which drives its
+* OWN platform auto-pick (`autoPickAndPersist` / `reprobeEngine` persist the
+* node's own probe under `<key>@<node>`). Serving a bare value to any node
+* would leak one node's hardware pick (e.g. `openvino/auto`) onto a node that
+* cannot run it (the CB3 "Mac runs OpenVINO" / N100 AUTO-device bug). This
+* mirrors the decoder's `readNodeDecoderBackend` no-fallback rule.
 */
 var ENGINE_CASCADE_KEYS = [
 	"engineBackend",
@@ -58,27 +62,14 @@ function nodeEngineKey(base, nodeId) {
 }
 /**
 * Read an engine cascade value for a node: the node-scoped key if present,
-* 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.
+* otherwise `undefined` — for EVERY node, the hub included. There is no
+* fallback to the legacy un-scoped key: a bare value in the store is inert.
+* A node with no scoped key gets `undefined` so its own platform-driven
+* auto-pick runs and persists a real per-node selection under `<key>@<node>`.
+* (A bare fallback would leak one node's engine selection cluster-wide — CB3.)
 */
 function readNodeEngineValue(store, base, nodeId) {
-	const scoped = store[nodeEngineKey(base, nodeId)];
-	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;
+	return store[nodeEngineKey(base, nodeId)];
 }
 /**
 * Project a raw store onto the plain engine cascade keys for THIS node, so the
@@ -4348,6 +4339,15 @@ var ONNX_FLOOR = {
 	device: "cpu"
 };
 /**
+* How long the first-boot pick waits for the node's `platform-probe` to flip
+* `ready` (= its FULL async probe done, embedded-Python install included).
+* MUST stay finite — `readinessRegistry.awaitReady` defaults to Infinity,
+* which would wedge `setApi` (and the addon's onInitialize) forever on a
+* node whose probe never completes. On timeout the pick proceeds
+* conservatively (platform floor, never persisted when non-authoritative).
+*/
+var PROBE_READY_TIMEOUT_MS = 12e4;
+/**
 * Build the onnx-cpu floor pick using `pickBestRuntime` with a null hardware
 * env.  Used wherever the old `detectBestEngine()` sync probe fell back — the
 * result is identical (onnx / cpu) but is now derived through the shared rules
@@ -4426,6 +4426,16 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	lastStepsSignature = null;
 	/**
+	* CB5 shm passthrough — the process-local, LONG-LIVED reader cache for
+	* `runPipeline({ frameHandle })`. Opens each named shm segment ONCE and
+	* reuses the mapping for every later handle on the same ring (never
+	* open/close per-call). Lazily created on first handle, unmapped in
+	* {@link shutdown}. The executor and the runner are both hub-local
+	* processes sharing `/dev/shm`, so a LOCAL handle resolves to a zero-copy
+	* read here.
+	*/
+	frameHandleReaders = null;
+	/**
 	* True once the engine + models are fully ready for inference. No
 	* longer gates runtime dispatch (Phase 4 removed the legacy `runFrame`
 	* which read this flag); kept as a diagnostic the admin UI / tests
@@ -4451,13 +4461,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	needsAutoPick = false;
 	/**
-	* Unsubscribe handle for the deferred-auto-pick `platform-probe` ready
-	* listener (armed in `setApi` when the probe isn't ready yet). Cleared once
-	* the engine is resolved — either by the listener firing or by the boot
-	* safety-net `ensureBootEngineProvisioned`.
-	*/
-	deferredAutoPickUnsub = null;
-	/**
 	* Warm cache for benchmark engine-override runs.
 	*
 	* Each override rebuild costs a full Python pool spin-up (~300-500ms)
@@ -4558,60 +4561,26 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	/** Store the addon context. ctx.api is a lazy getter resolved at call time. */
 	async setApi(addonCtx) {
 		this.addonCtx = addonCtx;
-		if (this.needsAutoPick) if (this.addonCtx.useCapability("platform-probe").isReady) {
-			await this.autoPickAndPersist();
-			this.needsAutoPick = false;
+		if (!this.needsAutoPick) {
 			this.startProvisioningForCurrentEngine();
-		} else {
-			const unsubscribe = this.addonCtx.onCapabilityStateChange("platform-probe", { type: "global" }, (state) => {
-				if (state !== "ready") return;
-				this.cancelDeferredAutoPick();
-				if (!this.needsAutoPick) return;
-				this.autoPickAndPersist().then(() => {
-					this.needsAutoPick = false;
-					this.startProvisioningForCurrentEngine();
-				});
-			});
-			this.deferredAutoPickUnsub = unsubscribe;
-			this.addonCtx.addDisposer(() => this.cancelDeferredAutoPick());
+			return;
 		}
-		else this.startProvisioningForCurrentEngine();
-	}
-	/** Tear down the deferred-auto-pick probe listener, if still armed. */
-	cancelDeferredAutoPick() {
-		if (this.deferredAutoPickUnsub) {
-			this.deferredAutoPickUnsub();
-			this.deferredAutoPickUnsub = null;
+		const nodeId = this.localProbeNodeId();
+		const registry = this.addonCtx.kernel?.readinessRegistry;
+		if (registry) try {
+			await registry.awaitReady("platform-probe", {
+				type: "node",
+				nodeId
+			}, { timeoutMs: PROBE_READY_TIMEOUT_MS });
+		} catch (err) {
+			this.log.warn("platform-probe readiness gate timed out — conservative engine pick (floor is not persisted)", { meta: {
+				nodeId,
+				timeoutMs: PROBE_READY_TIMEOUT_MS,
+				error: require_dist.errMsg(err)
+			} });
 		}
-	}
-	/**
-	* Boot safety-net: deterministically provision the hardware-probed engine.
-	*
-	* Called from the addon's `onInitialize` right after `reprobeEngine` has
-	* written this node's probe-driven selection (e.g. `engineBackend=openvino`)
-	* to the store. When first-boot auto-pick was DEFERRED (probe not ready at
-	* `setApi`), the engine would otherwise stay `idle` — selected but never
-	* provisioned — because the `onCapabilityStateChange('platform-probe')` ready
-	* edge can be missed when the cap is already 'ready' by the time we subscribe
-	* (the old eager-onnx-floor masked this; removing it surfaced a node that
-	* boots with no engine at all). This loads the now-persisted selection and
-	* starts provisioning it, so the node reliably comes up on its real best
-	* engine (openvino on Intel) with no onnx floor and no missed boot. No-op
-	* when provisioning already started (persisted-engine path / listener fired)
-	* or when nothing has been selected yet.
-	*/
-	async ensureBootEngineProvisioned() {
-		if (this.getEngineProvisioning().state !== "idle") return;
-		const stored = await this.loadEngine();
-		if (!stored) return;
-		this.currentEngine = stored;
+		await this.autoPickAndPersist();
 		this.needsAutoPick = false;
-		this.cancelDeferredAutoPick();
-		this.log.info("Boot engine provisioning from probed selection", { meta: {
-			runtime: stored.runtime,
-			backend: stored.backend,
-			device: stored.device ?? null
-		} });
 		this.startProvisioningForCurrentEngine();
 	}
 	/**
@@ -4643,7 +4612,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		};
 		this.currentEngine = engine;
 		if (!(pick.runtimeId !== "onnx" || hardware !== null)) {
-			this.log.info("Auto-pick: onnx floor pending gpu probe — NOT persisting (re-pick on done)", { meta: {
+			this.log.info("Auto-pick: onnx floor pending gpu probe — NOT persisting (next boot retries)", { meta: {
 				backend: pick.runtimeId,
 				device: pick.device
 			} });
@@ -5194,6 +5163,53 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		} });
 		return { success: true };
 	}
+	/** This executor's cluster node id (suffix-stripped, matching the runner). */
+	ownNodeId() {
+		const raw = this.addonCtx?.kernel?.localNodeId ?? "hub";
+		return raw.includes("/") ? raw.split("/")[0] : raw;
+	}
+	/**
+	* CB5 — resolve a shm `FrameHandle` to pixels zero-copy. Returns `null`
+	* when:
+	*  - the handle is FOREIGN (its segment lives on another node — a local
+	*    `shm_open` would flood ENOENT; the runner only sends LOCAL handles, so
+	*    this is a defensive guard against an unexpected topology);
+	*  - the ring slot was recycled before the read (latest-wins drop) or the
+	*    segment could not be mapped.
+	* A `null` degrades the caller to an empty `FrameResult` — the runner ships
+	* pixels via `frame` as the fallback.
+	*/
+	resolveFrameHandle(handle) {
+		if (handle.nodeId !== this.ownNodeId()) return null;
+		if (!this.frameHandleReaders) this.frameHandleReaders = new _camstack_shm_ring.FrameRingReaderCache(this.log);
+		const decoded = this.frameHandleReaders.read(handle);
+		if (!decoded) return null;
+		return {
+			data: decoded.data,
+			width: decoded.width,
+			height: decoded.height,
+			format: decoded.format,
+			timestamp: decoded.timestamp
+		};
+	}
+	/**
+	* Minimal detection-free `FrameResult` returned when a `frameHandle` read
+	* misses (recycled slot / foreign / unmappable). Shape-identical to a
+	* zero-detection runtime result so downstream consumers treat it as a
+	* dropped frame, not an error.
+	*/
+	emptyFrameHandleResult(input) {
+		return {
+			kind: "frame",
+			frameId: `run-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+			deviceId: input.deviceId ?? 0,
+			timestamp: Date.now(),
+			width: input.frameHandle?.width ?? 0,
+			height: input.frameHandle?.height ?? 0,
+			detections: [],
+			debug: { totalInferenceMs: 0 }
+		};
+	}
 	async runPipeline(input, onProgress) {
 		const nodeId = this.addonCtx?.kernel?.localNodeId ?? "hub";
 		const sessionId = input.sessionId ?? `run-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
@@ -5229,15 +5245,22 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		let jpegProvider;
 		const sources = [
 			input.frame ? "frame" : null,
+			input.frameHandle ? "frameHandle" : null,
 			input.image ? "image" : null,
 			input.imageBase64 ? "imageBase64" : null,
 			input.referenceImage ? "referenceImage" : null
 		].filter((s) => s !== null);
-		if (sources.length === 0) throw new Error("runPipeline requires exactly one of: frame, image, imageBase64, referenceImage");
+		if (sources.length === 0) throw new Error("runPipeline requires exactly one of: frame, frameHandle, image, imageBase64, referenceImage");
 		if (sources.length > 1) throw new Error(`runPipeline received conflicting image sources: ${sources.join(", ")}`);
+		let handleFrame = null;
+		if (input.frameHandle) {
+			handleFrame = this.resolveFrameHandle(input.frameHandle);
+			if (!handleFrame) return this.emptyFrameHandleResult(input);
+		}
+		const runtimeFrame = input.frame ?? handleFrame ?? void 0;
 		const decodeT0 = performance.now();
-		if (input.frame) {
-			const frame = input.frame;
+		if (runtimeFrame) {
+			const frame = runtimeFrame;
 			imageWidth = frame.width;
 			imageHeight = frame.height;
 			const data = Buffer.from(frame.data.buffer, frame.data.byteOffset, frame.data.byteLength);
@@ -5431,7 +5454,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			emit("Running inference...");
 			const tree = buildExecutableTree(benchmarkSteps, (stepId) => this.engineFactory.getEngine(stepId));
 			setupMs = performance.now() - wallT0 - decodeMs;
-			const isRuntime = Boolean(input.frame);
+			const isRuntime = Boolean(runtimeFrame);
 			const effectiveDeviceId = input.deviceId ?? 0;
 			const deviceOverrides = effectiveDeviceId > 0 ? await this.readDeviceStore(effectiveDeviceId) : {};
 			const effectiveTree = Object.keys(deviceOverrides).length > 0 ? applyDeviceOverridesToTree(tree, "object-detection", deviceOverrides) : tree;
@@ -6002,6 +6025,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			this.executor = null;
 		}
 		for (const id of Array.from(this.deviceProxies.keys())) this.releaseDeviceProxy(id);
+		this.frameHandleReaders?.close();
+		this.frameHandleReaders = null;
 	}
 	/**
 	* Resolve and cache a {@link DeviceProxy} for the given camera. Pins
@@ -6371,37 +6396,12 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				device: best.device ?? null,
 				probedBestEngine: probedLabel
 			} });
-		} else this.log.info("Re-probe: onnx floor pending gpu probe — NOT persisting (re-pick on done)", { meta: {
+		} else this.log.info("Re-probe: onnx floor pending gpu probe — NOT persisting (next boot retries)", { meta: {
 			backend: best.backend,
 			device: best.device ?? null
 		} });
 		return best;
 	}
-	/**
-	* Re-pick the engine when the platform-probe finishes its async hardware +
-	* Python detection (the `platform-probe.phase` `done` event). At boot the
-	* probe's accelerator result may not be ready yet, so the engine floored to
-	* onnx; once the probe answers (e.g. a Mac's CoreML/ANE surfaces after the
-	* embedded Python is installed) this re-runs the probe-driven pick and
-	* re-provisions. Idempotent: `startProvisioningForCurrentEngine` skips a
-	* no-op when the selection is unchanged.
-	*/
-	async repickEngineOnProbeReady() {
-		const before = `${this.currentEngine.backend}/${this.currentEngine.device ?? "default"}`;
-		await this.reprobeEngine();
-		const stored = await this.loadEngine();
-		if (stored) {
-			this.currentEngine = stored;
-			this.needsAutoPick = false;
-			this.cancelDeferredAutoPick();
-		}
-		const after = `${this.currentEngine.backend}/${this.currentEngine.device ?? "default"}`;
-		if (before !== after) this.log.info("Engine re-picked after platform-probe completed", { meta: {
-			before,
-			after
-		} });
-		this.startProvisioningForCurrentEngine();
-	}
 	async getReferenceAudioFiles() {
 		const dir = resolveReferenceAudioDir();
 		if (!dir) return [];
@@ -6843,6 +6843,15 @@ function stableEngineKey(engines) {
 	return JSON.stringify(stripped);
 }
 /**
+* Narrow a topology-reported platform string to the runtime-relevant
+* `NodeJS.Platform` values the engine cascade branches on (darwin/linux/win32).
+* A type guard, not a cast; any other value → undefined so the caller floors to
+* `process.platform`. These three match `HardwarePlatformSchema` in the cap.
+*/
+function toNodePlatform(value) {
+	return value === "darwin" || value === "linux" || value === "win32" ? value : void 0;
+}
+/**
 * Tuning fields that bind into the Python pool at construction. Any
 * change requires a pool respawn to take effect (the executor caches
 * `tuning` at engine-factory build time). `onConfigChanged` watches
@@ -6865,13 +6874,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	*  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
-	*  the cluster-shared bare keys. Refreshed at init + on every config change. */
-	nodeEngineBackend = DEFAULT_CONFIG.engineBackend;
-	nodeProbedBestEngine = "";
 	engineMetricsTimer = null;
-	probePhaseUnsub = null;
 	/** Snapshot-equality cache for engine-metrics emit. Most ticks
 	*  the engine inventory is unchanged (no model load/unload), so
 	*  we skip the bus emit and let the heartbeat re-emit at
@@ -6919,6 +6922,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 					description: "Auto-detected best engine for this host (format: provider/device, e.g. \"openvino/npu\"). Click the refresh icon to re-run the probe — the detected provider and hardware device are written back into the two fields below, overwriting any manual override.",
 					readonlyField: true,
 					default: "",
+					perNode: true,
 					actions: [{
 						action: "reprobe-engine",
 						icon: "refresh-cw",
@@ -6939,7 +6943,8 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 					label: "Execution provider",
 					options: [...STATIC_BACKEND_OPTIONS],
 					default: DEFAULT_CONFIG.engineBackend,
-					immediate: true
+					immediate: true,
+					perNode: true
 				}),
 				this.field({
 					type: "select",
@@ -6947,7 +6952,8 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 					label: "Hardware device",
 					options: [...STATIC_DEFAULT_DEVICE_OPTIONS],
 					default: DEFAULT_CONFIG.engineDevice,
-					immediate: true
+					immediate: true,
+					perNode: true
 				})
 			]
 		}, {
@@ -7170,14 +7176,37 @@ 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();
+		const isRemote = node !== this.localNodeId();
+		const topo = isRemote ? await this.resolveTopologyPlatform(node) : null;
 		return {
-			platform: useProbedPlatform && effective?.platform !== void 0 ? effective.platform : process.platform,
-			arch: useProbedPlatform && effective?.arch !== void 0 ? effective.arch : process.arch,
+			platform: (isRemote ? topo?.platform ?? effective?.platform : void 0) ?? process.platform,
+			arch: (isRemote ? topo?.arch ?? effective?.arch : void 0) ?? process.arch,
 			hardware: effective
 		};
 	}
 	/**
+	* Read the TARGET node's platform/arch from cluster topology — the
+	* registration self-report (`nodes.topology`), which is hub-local and
+	* available immediately, independent of the node's async accelerator probe.
+	* Mirrors the audio analyzer's `resolveNodePlatform` (the D6 reference
+	* pattern) so detection + audio share ONE topology-read path. Returns null
+	* when topology is unreachable (caller falls back to the probe report, then
+	* `process.platform`). Narrows the reported platform to the runtime-relevant
+	* `NodeJS.Platform` values via a type guard (no cast); any other value is
+	* dropped so the caller floors safely.
+	*/
+	async resolveTopologyPlatform(nodeId) {
+		try {
+			const picked = require_node_topology_platform.pickNodePlatformArch(await this.ctxIfReady?.api?.nodes?.topology.query(), nodeId);
+			return {
+				platform: toNodePlatform(picked.platform),
+				arch: picked.arch
+			};
+		} catch {
+			return null;
+		}
+	}
+	/**
 	* 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). Carries the probed node's `platform`/`arch`
@@ -7214,81 +7243,6 @@ 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
-	* cluster-shared bare keys (which belong to no single node). Best-effort: a
-	* transiently-unreadable store leaves the last cached values in place.
-	*/
-	async refreshNodeEngineFromStore() {
-		const store = await this.resolveUiSettingsStore();
-		if (store === null) return;
-		const node = this.localNodeId();
-		const backend = readNodeEngineValue(store, "engineBackend", node);
-		if (typeof backend === "string" && backend !== "") this.nodeEngineBackend = backend;
-		const probed = readNodeEngineValue(store, "probedBestEngine", node);
-		this.nodeProbedBestEngine = typeof probed === "string" ? probed : "";
-	}
-	/**
-	* Persist a settings patch, mirroring the engine cascade fields to the TARGET
-	* node's scoped keys so each node keeps an INDEPENDENT engine selection in the
-	* cluster-central store. The hub addon serves writes for every node, so it
-	* scopes by the requested `nodeId` (default self).
-	*
-	* 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);
-		const { engineBackend: _engineBackend, engineDevice: _engineDevice, probedBestEngine: _probedBestEngine, ...sharedPatch } = patch;
-		await super.updateGlobalSettings(sharedPatch, nodeId);
-	}
-	/**
 	* Resolve the effective pool tuning for the configured backend.
 	*
 	* Reads the registry's `tuningFor(backend)` and ignores any persisted
@@ -7302,7 +7256,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	* a reason to disagree.
 	*/
 	resolveBackendTuning() {
-		const t = tuningFor(toRuntimeId(this.nodeEngineBackend ?? DEFAULT_CONFIG.engineBackend));
+		const t = tuningFor(toRuntimeId(this.config.engineBackend));
 		const num = (v, dflt) => typeof v === "number" && v > 0 ? v : dflt;
 		const batch = (v, dflt) => v === "none" || v === "list" || v === "window" ? v : dflt;
 		return {
@@ -7318,8 +7272,6 @@ 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);
 		if (py.ok && py.pythonPath) this.pythonPath = py.pythonPath;
@@ -7341,18 +7293,9 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		});
 		await this.provider.init();
 		await this.provider.setApi(this.ctx);
-		if (!this.nodeProbedBestEngine) await this.provider.reprobeEngine().catch((err) => {
+		if (!this.config.probedBestEngine) await this.provider.reprobeEngine().catch((err) => {
 			this.ctx.logger.warn("auto-reprobe engine failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
-		await this.provider.ensureBootEngineProvisioned().catch((err) => {
-			this.ctx.logger.warn("ensureBootEngineProvisioned failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-		});
-		this.probePhaseUnsub = this.ctx.eventBus?.subscribe({ category: require_dist.EventCategory.PlatformProbePhase }, (event) => {
-			if (event.data?.phase !== "done") return;
-			this.provider?.repickEngineOnProbeReady().catch((err) => {
-				this.ctx.logger.warn("repick on platform-probe done failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-			});
-		}) ?? null;
 		await this.provider.warmPool();
 		this.engineMetricsTimer = setInterval(() => this.emitEngineMetricsSnapshot(), ENGINE_METRICS_SNAPSHOT_INTERVAL_MS);
 		this.lastAppliedPoolConfig = this.snapshotPoolConfig();
@@ -7426,10 +7369,6 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 		}
 	}
 	async onShutdown() {
-		if (this.probePhaseUnsub) {
-			this.probePhaseUnsub();
-			this.probePhaseUnsub = null;
-		}
 		if (this.engineMetricsTimer) {
 			clearInterval(this.engineMetricsTimer);
 			this.engineMetricsTimer = null;
@@ -7477,7 +7416,6 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	* re-spin, frames are dropped (never crashed), no addon bounce.
 	*/
 	async onConfigChanged() {
-		await this.refreshNodeEngineFromStore();
 		if (this.provider) await this.provider.onEngineSelectionChanged().catch((err) => {
 			this.ctx.logger.warn("engine provisioning re-select failed on config change", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});