@camstack/addon-pipeline 1.2.293 → 1.2.295

package/dist/detection-pipeline/index.js

@@ -3,11 +3,11 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-Ce8s7XqV.js");
-const require_node = require("../node-DpOrymbW.js");
-const require_default_detection_model = require("../default-detection-model-DTKHLLcC.js");
+const require_dist = require("../dist-BsVcf5wO.js");
+const require_node = require("../node-UFk6I2f6.js");
+const require_default_detection_model = require("../default-detection-model-wNEISVA9.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
-const require_process_memory = require("../process-memory-CBRjuhyg.js");
+const require_process_memory = require("../process-memory-CJV29sPf.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_fs = require("node:fs");
@@ -1703,12 +1703,13 @@ function resolveEffectivePostprocessorForEntry(definition, entry) {
 //#region src/detection-pipeline/registry/model-knob-applicability.ts
 /** Decodes that run NMS in the pipeline (and hence consult `nmsIouThreshold`).
 *  Mirrors the Python postprocessors that read the knob — yolo.py,
-*  yolo_seg.py, rfdetr.py, scrfd.py. */
+*  yolo_seg.py, rfdetr.py, scrfd.py, yunet.py. */
 var NMS_CONSUMING_POSTPROCESSORS = new Set([
 	"yolo",
 	"yolo-seg",
 	"rfdetr",
-	"scrfd"
+	"scrfd",
+	"yunet"
 ]);
 /**
 * Does this decode consult `nmsIouThreshold`?
@@ -3165,6 +3166,52 @@ function createInferenceTimeoutGuard(deps) {
 	};
 }
 //#endregion
+//#region src/detection-pipeline/model-pin.ts
+function requestedModels(steps) {
+	const out = /* @__PURE__ */ new Map();
+	const walk = (nodes) => {
+		for (const step of nodes) {
+			if (!step.enabled) continue;
+			out.set(step.addonId, step.modelId);
+			if (step.children !== void 0) walk(step.children);
+		}
+	};
+	walk(steps);
+	return out;
+}
+function checkReplayPin(input) {
+	if (input.requestedDeviceKey !== void 0 && input.dispatchDeviceKey !== input.requestedDeviceKey) return {
+		kind: "refused",
+		reason: "device-not-servable",
+		detail: `device pool ${input.requestedDeviceKey} cannot run this tree (the capability gate would fall back to ${input.dispatchDeviceKey ?? "the node default"})`
+	};
+	const asked = requestedModels(input.requested);
+	for (const step of input.executing) {
+		const want = asked.get(step.addonId);
+		if (want === void 0 || want.length === 0) return {
+			kind: "refused",
+			reason: "model-not-servable",
+			detail: `${step.addonId}: no model pinned by the caller (would run ${step.modelId}, ${input.format})`
+		};
+		if (want !== step.modelId) return {
+			kind: "refused",
+			reason: "model-not-servable",
+			detail: `${step.addonId}: asked for ${want}, this pool would run ${step.modelId} (${input.format})`
+		};
+	}
+	return { kind: "pinned" };
+}
+var PRIMARY_ROOT_STEP = "object-detection";
+/**
+* The root model a frame result reports: `object-detection` when it runs (it
+* is the detector the tracks come from), else the first enabled video root.
+* `undefined` when no root runs — never a fabricated id.
+*/
+function resolveRootModelId(roots) {
+	const enabled = roots.filter((s) => s.enabled && s.slot !== "audio-classifier");
+	return (enabled.find((s) => s.addonId === PRIMARY_ROOT_STEP) ?? enabled[0])?.modelId;
+}
+//#endregion
 //#region src/detection-pipeline/engine-provisioner.ts
 /** Incremental backoff growing to a ~5 min cap; retries indefinitely at cap. */
 var BACKOFF_SCHEDULE_MS = [
@@ -3435,6 +3482,7 @@ var KNOWN_POSTPROCESSORS = new Set([
 	"rfdetr",
 	"yolo-seg",
 	"scrfd",
+	"yunet",
 	"arcface",
 	"clip",
 	"softmax",
@@ -3536,9 +3584,12 @@ var DropSampler = class {
 	* accumulates and a summary is released once per interval — carrying the
 	* number suppressed, so nothing about the RATE is lost even though the lines
 	* are.
+	*
+	* `channel` separates occasions that share a device — a replay's drops are
+	* sampled apart from the live ones.
 	*/
-	record(deviceId, macroClass) {
-		const key = `${deviceId}:${macroClass}`;
+	record(deviceId, macroClass, channel = "live") {
+		const key = `${channel}:${deviceId}:${macroClass}`;
 		const at = this.now();
 		const prev = this.seen.get(key);
 		if (prev === void 0) {
@@ -5062,7 +5113,8 @@ function buildFrameResult(input) {
 				...embeddingModelId !== void 0 ? { embeddingModelId } : {}
 			} : {},
 			...m.faceAlignedCrop !== void 0 ? { faceAlignedCrop: m.faceAlignedCrop } : {},
-			...m.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: m.nativeFaceShortSidePx } : {}
+			...m.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: m.nativeFaceShortSidePx } : {},
+			...m.landmarks !== void 0 ? { landmarks: m.landmarks } : {}
 		};
 		if (input.debug) {
 			const cleanDebug = pruneUndefined({
@@ -5323,6 +5375,11 @@ var PipelineExecutor = class {
 	async run(tree, rootInput, fullFrameJpegProvider, imageWidth, imageHeight, deviceId, runOpts, nativeCropProvider, cropZoneBbox, rootInputViewProvider) {
 		const startMs = Date.now();
 		const verbosity = runOpts?.traceVerbosity ?? "off";
+		const occasion = runOpts?.occasion ?? "live";
+		const logTags = occasion === "replay" ? {
+			deviceId,
+			occasion
+		} : { deviceId };
 		const traceBuilder = new ExecutionTraceBuilder(verbosity, deviceId, imageWidth, imageHeight, this.opts.engineRuntime);
 		const firstLevel = [];
 		const details = [];
@@ -5338,9 +5395,9 @@ var PipelineExecutor = class {
 			idGen,
 			details,
 			onClassifierClassDropped: (drop) => {
-				const sample = this.classFilterDropSampler.record(deviceId, `${drop.stepId}:${drop.droppedClass}`);
+				const sample = this.classFilterDropSampler.record(deviceId, `${drop.stepId}:${drop.droppedClass}`, occasion);
 				if (sample.logExample) this.opts.logger?.info("classifier winner excluded by class filter — label dropped", {
-					tags: { deviceId },
+					tags: logTags,
 					meta: {
 						step: drop.stepId,
 						model: drop.modelId,
@@ -5351,7 +5408,7 @@ var PipelineExecutor = class {
 					}
 				});
 				if (sample.summaryCount !== null) this.opts.logger?.info("classifier class filter: still dropping", {
-					tags: { deviceId },
+					tags: logTags,
 					meta: {
 						step: drop.stepId,
 						droppedClass: drop.droppedClass,
@@ -5384,7 +5441,7 @@ var PipelineExecutor = class {
 						await this.executeChildren(rootStep.children, mutable, rootView?.jpegProvider ?? fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, deviceId, nativeCropProvider);
 					} catch (err) {
 						this.opts.logger?.warn("Pipeline child execution failed — keeping parent detection", {
-							tags: { deviceId },
+							tags: logTags,
 							meta: {
 								rootStepId: rootStep.stepId,
 								parentClass: mutable.macroClass,
@@ -5438,9 +5495,9 @@ var PipelineExecutor = class {
 				const fullFrameBar = rootStep.settings?.["fullFrameGuardMaxConfidence"];
 				const fullFrameHardArea = rootStep.settings?.["fullFrameGuardHardAreaRatio"];
 				if (isFullFramePhantomDetection(mutable.bbox, imageWidth, imageHeight, mutable.score, typeof fullFrameBar === "number" ? fullFrameBar : void 0, typeof fullFrameHardArea === "number" ? fullFrameHardArea : void 0)) {
-					const sample = this.dropSampler.record(deviceId, String(mutable.macroClass));
+					const sample = this.dropSampler.record(deviceId, String(mutable.macroClass), occasion);
 					if (sample.summaryCount !== null) this.opts.logger?.info("full-frame phantom guard: still dropping", {
-						tags: { deviceId },
+						tags: logTags,
 						meta: {
 							macroClass: mutable.macroClass,
 							suppressed: sample.summaryCount,
@@ -5449,7 +5506,7 @@ var PipelineExecutor = class {
 						}
 					});
 					if (sample.logExample) this.opts.logger?.info("full-frame phantom guard: detection dropped", {
-						tags: { deviceId },
+						tags: logTags,
 						meta: {
 							macroClass: mutable.macroClass,
 							score: mutable.score,
@@ -5475,7 +5532,7 @@ var PipelineExecutor = class {
 					continue;
 				}
 				if (isFullFrameSurvivor(mutable.bbox, imageWidth, imageHeight, mutable.score, typeof fullFrameBar === "number" ? fullFrameBar : void 0)) this.opts.logger?.info("full-frame box SURVIVED the guard on score", {
-					tags: { deviceId },
+					tags: logTags,
 					meta: {
 						macroClass: mutable.macroClass,
 						score: mutable.score,
@@ -5489,7 +5546,7 @@ var PipelineExecutor = class {
 					await this.executeChildren(rootStep.children, mutable, rootView?.jpegProvider ?? fullFrameJpegProvider, imageWidth, imageHeight, traceBuilder, stepTimings, ctx, poolAgg, runOpts?.plane, deviceId, nativeCropProvider);
 				} catch (err) {
 					this.opts.logger?.warn("Pipeline child execution failed — keeping parent detection", {
-						tags: { deviceId },
+						tags: logTags,
 						meta: {
 							rootStepId: rootStep.stepId,
 							parentClass: mutable.macroClass,
@@ -6547,25 +6604,6 @@ var PROBE_READY_TIMEOUT_MS = 12e4;
 * race bound keeps a wedged transport from wedging `setApi`.
 */
 var PROBE_DIRECT_RPC_TIMEOUT_MS = 6e4;
-/**
-* 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
-* instead of duplicated inline.
-*/
-/**
-* Is `backend` even POSSIBLE on this node's OS/arch (ignoring gpu detail)?
-* coreml ⇒ darwin only; openvino ⇒ x64 non-darwin only; onnx ⇒ anywhere. Used to
-* reject a persisted/global engine choice that the node's PLATFORM fundamentally
-* cannot run (e.g. the cluster's OpenVINO default landing on a Mac) — distinct
-* from the gpu-dependent support (linux without a probed Intel iGPU still keeps
-* openvino as a valid platform choice; the device falls back to cpu).
-*/
-function backendPossibleOnPlatform(backend) {
-	if (backend === "coreml") return process.platform === "darwin";
-	if (backend === "openvino") return process.arch === "x64" && process.platform !== "darwin";
-	return true;
-}
 var DetectionPipelineProvider = class DetectionPipelineProvider {
 	modelsDir;
 	eventBus;
@@ -6705,22 +6743,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	needsAutoPick = false;
 	/**
-	* Warm cache for benchmark engine-override runs.
-	*
-	* Each override rebuild costs a full Python pool spin-up (~300-500ms)
-	* plus the per-model load. Benchmark tabs iterate up to 800× against
-	* the same override (e.g. yolov9s / coreml / all) — paying that spin-up
-	* each iteration dwarfs actual inference time.
-	*
-	* When the same override engine is requested within `OVERRIDE_CACHE_TTL_MS`,
-	* we reuse the prior transient factory. Hitting a different override
-	* or exceeding the TTL disposes the cache and spins a new factory.
-	* The prior "main" factory (`priorFactory`) is still restored so
-	* runtime dispatch (camera frames) keeps its own resident engine.
-	*/
-	overrideCache = null;
-	overrideCacheTimer = null;
-	/**
 	* Idle-TTL for a per-device inference pool (multi-device C3). A device pool
 	* with no dispatch for this long is disposed and recreated on next use — the
 	* memory guardrail that keeps `factoriesByDevice` from accumulating warm pools
@@ -6753,7 +6775,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			error: err instanceof Error ? err.message : String(err)
 		} })
 	});
-	static OVERRIDE_CACHE_TTL_MS = 6e4;
 	/**
 	* RSS bound + periodic memory telemetry for the Python inference pools
 	* (2026-08-18 OOM audit: the pools, not the recorder, were the host's OOM
@@ -6890,15 +6911,14 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	/**
 	* Lazy-install the pip requirements file matching `engine.backend` into
 	* the embedded Python before the inference pool spawns. No-op for
-	* `runtime: 'node'`, for backends with no requirements file on disk,
-	* or before the addon context has been wired (warm-pool race window).
+	* backends with no requirements file on disk, or before the addon
+	* context has been wired (warm-pool race window).
 	*
 	* Idempotent — `installPythonRequirements` short-circuits on a hash
 	* marker, so back-to-back EngineFactory rebuilds (benchmark overrides,
 	* tuning respawns) skip the pip subprocess after the first install.
 	*/
 	async ensureBackendDeps(engine) {
-		if (engine.runtime !== "python") return;
 		if (!this.addonCtx) return;
 		const pythonAddonDir = this.executorOptions.pythonAddonDir;
 		if (!pythonAddonDir) return;
@@ -7463,8 +7483,22 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* result with a warning logged, same posture as `recomputeConfigIssues`.
 	*/
 	async validatePipeline(input) {
-		const format = this.currentEngine.format;
+		let format = this.currentEngine.format;
 		try {
+			if (input.deviceKey !== void 0) try {
+				format = resolveDeviceEngine(input.deviceKey).format;
+			} catch (err) {
+				return {
+					ok: false,
+					issues: [{
+						addonId: "*",
+						kind: "unknown-device",
+						detail: require_dist.errMsg(err)
+					}],
+					substitutions: [],
+					format
+				};
+			}
 			const steps = input.steps;
 			const enabledSteps = this.pruneToEnabledSteps(steps);
 			const substitutions = collectSubstitutions(enabledSteps, format);
@@ -7789,7 +7823,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const nodeId = this.addonCtx?.kernel?.localNodeId ?? "hub";
 		const sessionId = input.sessionId ?? `run-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
 		const isRuntime = Boolean(input.frame || input.frameRef);
-		const progressToBus = !isRuntime || input.sessionId !== void 0;
+		const progressToBus = !isRuntime && input.replay !== true || input.sessionId !== void 0;
 		const emit = (message, extra) => {
 			onProgress?.(message);
 			if (!progressToBus) return;
@@ -7931,7 +7965,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const dispatchResolution = this.resolveStepsForDispatch({
 			steps: input.steps,
 			deviceKey: input.deviceKey,
-			engineOverride: input.engine,
 			deviceId: input.deviceId,
 			plane: input.plane
 		});
@@ -7951,322 +7984,150 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}
 		const enabledSteps = flattenSteps(benchmarkSteps);
 		emit(`Pipeline: ${enabledSteps.length} step(s) — ${enabledSteps.map((s) => s.addonId).join(" → ")}`);
-		await this.ensureEngineFactory();
-		const priorEngine = this.currentEngine;
-		const priorFactory = this.engineFactory;
-		const priorExecutor = this.executor;
-		const runEngine = input.engine ? {
-			runtime: input.engine.runtime,
-			backend: input.engine.backend,
-			format: input.engine.format,
-			...input.engine.device || priorEngine.device ? { device: input.engine.device ?? priorEngine.device } : {}
-		} : priorEngine;
-		const differs = input.engine && (priorEngine.runtime !== runEngine.runtime || priorEngine.backend !== runEngine.backend || priorEngine.format !== runEngine.format || (priorEngine.device ?? "") !== (runEngine.device ?? ""));
-		if (differs) if (this.overrideCache && enginesEqual(this.overrideCache.engine, runEngine)) {
-			const cached = this.overrideCache;
-			if (cached.initPromise) await cached.initPromise;
-			this.log.debug("Benchmark: reusing warm override factory", { meta: { engine: `${runEngine.runtime}/${runEngine.backend}/${runEngine.device ?? "default"}` } });
-			this.currentEngine = runEngine;
-			this.engineFactory = cached.factory;
-			this.executor = cached.executor;
-		} else {
-			if (this.overrideCache) {
-				try {
-					await this.overrideCache.factory.dispose();
-				} catch {}
-				this.overrideCache = null;
-			}
-			this.log.info("Benchmark: engine override", { meta: {
-				from: `${priorEngine.runtime}/${priorEngine.backend}`,
-				to: `${runEngine.runtime}/${runEngine.backend}`
-			} });
-			await this.ensureBackendDeps(runEngine);
-			const newFactory = new EngineFactory({
-				engine: runEngine,
-				modelsDir: this.modelsDir,
-				logger: this.log.child("engine-override"),
-				pythonPath: this.executorOptions.pythonPath ?? "",
-				provisioning: this.executorOptions.provisioning,
-				resolveCustomModel: this.customModelResolver
-			});
-			const initPromise = newFactory.initialize([]);
-			this.overrideCache = {
-				engine: runEngine,
-				factory: newFactory,
-				executor: null,
-				lastUsedMs: Date.now(),
-				initPromise
-			};
-			this.scheduleOverrideCacheEviction();
-			try {
-				await initPromise;
-				this.overrideCache.initPromise = null;
-			} catch (err) {
-				this.overrideCache = null;
-				if (this.overrideCacheTimer) {
-					clearTimeout(this.overrideCacheTimer);
-					this.overrideCacheTimer = null;
-				}
-				throw err;
-			}
-			this.currentEngine = runEngine;
-			this.engineFactory = newFactory;
-			this.executor = null;
-		}
-		try {
-			const deviceLabel = runEngine.device ?? "default";
-			emit(`Engine: ${runEngine.runtime}/${runEngine.backend}/${deviceLabel}${input.engine ? " (override)" : ""}`, {
-				step: "engine",
-				engine: {
-					runtime: runEngine.runtime,
-					backend: runEngine.backend,
-					device: deviceLabel
-				}
-			});
-			const runtimeStr = `${runEngine.runtime}+${runEngine.backend}`;
-			const executor = this.executor ?? new PipelineExecutor({
-				engineRuntime: runtimeStr,
-				logger: this.log
+		const rootModelId = resolveRootModelId(benchmarkSteps);
+		const stampRoot = (r) => rootModelId === void 0 ? r : {
+			...r,
+			rootModelId
+		};
+		if (input.replay === true) {
+			const verdict = checkReplayPin({
+				requested: input.steps,
+				executing: input.plane === "frame" ? collectFramePlaneSteps(benchmarkSteps, isDetailPlaneStep) : enabledSteps,
+				requestedDeviceKey: input.deviceKey,
+				dispatchDeviceKey,
+				format: dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey).format : this.currentEngine.format
 			});
-			this.executor = executor;
-			const dispatchEngine = dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey) : runEngine;
-			const dispatchFactory = dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
-			const needed = enabledSteps.filter((s) => dispatchFactory.needsPoolUpdate(s));
-			if (needed.length > 0) {
-				this.log.info("Benchmark: models to load", { meta: {
-					count: needed.length,
-					models: needed.map((s) => `${s.addonId}/${s.modelId}`)
-				} });
-				for (const s of needed) emit(`Loading model: ${s.addonName} (${s.modelId})...`, {
-					step: s.addonId,
-					addonId: s.addonId,
-					modelId: s.modelId
+			if (verdict.kind === "refused") {
+				this.log.warn("replay refused — the node cannot run exactly what was pinned", {
+					...input.deviceId !== void 0 ? { tags: { deviceId: input.deviceId } } : {},
+					meta: {
+						reason: verdict.reason,
+						detail: verdict.detail,
+						deviceKey: input.deviceKey
+					}
 				});
-				await this.ensureModelsForSteps(benchmarkSteps, dispatchFactory, dispatchEngine.format);
-				emit(`All models loaded`);
-			}
-			emit("Running inference...");
-			const tree = buildExecutableTree(benchmarkSteps, (stepId) => dispatchFactory.getEngine(stepId), this.customModelResolver);
-			setupMs = performance.now() - wallT0 - decodeMs;
-			const effectiveDeviceId = input.deviceId ?? 0;
-			const deviceOverrides = effectiveDeviceId > 0 ? await this.deviceOverrides.resolve(effectiveDeviceId) : {};
-			const effectiveTree = Object.keys(deviceOverrides).length > 0 ? applyDeviceOverridesToTree(tree, "object-detection", deviceOverrides) : tree;
-			const nativeCropProvider = this.buildNativeCropProviderFromRef(input.nativeCropRef) ?? this.buildNativeFaceCropProvider(input.frameHandle);
-			let cropZoneBbox;
-			if (isRuntime && effectiveDeviceId > 0 && effectiveTree.roots.some((r) => r.definition.extractMode === "crop-zone")) {
-				await this.ensureDeviceProxy(effectiveDeviceId);
-				const proxy = this.deviceProxies.get(effectiveDeviceId);
-				if (proxy) cropZoneBbox = resolvePackageCropBbox(proxy.state.zones.value?.zones ?? [], proxy.state.zoneRules.value?.package ?? [], imageWidth, imageHeight) ?? void 0;
-			}
-			let frameViewResolver;
-			let rootInputViewProvider;
-			if (runtimeFrameRef) {
-				frameViewResolver = createRootFrameViewResolver(require_default_detection_model.localFrameRegistry, runtimeFrameRef);
-				rootInputViewProvider = async (root, crop) => {
-					const view = await frameViewResolver(root, crop ? {
-						left: crop[0],
-						top: crop[1],
-						width: crop[2] - crop[0],
-						height: crop[3] - crop[1]
-					} : void 0);
-					const data = Buffer.from(view.data.buffer, view.data.byteOffset, view.data.byteLength);
-					return {
-						input: {
-							kind: "jpeg",
-							data
-						},
-						jpegProvider: async () => data,
-						width: view.width,
-						height: view.height,
-						geometry: view.geometry
-					};
-				};
-			}
-			let executionSucceeded = false;
-			let execution;
-			try {
-				execution = await executor.run(effectiveTree, rootInput, jpegProvider, imageWidth, imageHeight, effectiveDeviceId, {
-					traceVerbosity: isRuntime ? this.eventBus ? "summary" : "off" : "full",
-					plane: input.plane
-				}, nativeCropProvider, cropZoneBbox, rootInputViewProvider);
-				executionSucceeded = true;
-			} finally {
-				frameViewResolver?.release(executionSucceeded ? "success" : "error");
-			}
-			const { result, trace } = execution;
-			if (isRuntime) {
-				if (trace && this.eventBus) this.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.PipelineTrace, {
-					type: "device",
-					id: trace.deviceId,
-					nodeId: "hub"
-				}, trace));
-				if (effectiveDeviceId > 0) {
-					await this.ensureDeviceProxy(effectiveDeviceId);
-					return this.gateDetectionsByZoneRules(effectiveDeviceId, result);
-				}
-				return result;
-			}
-			for (const t of result.debug?.stepTimings ?? []) emit(`${t.source}${t.modelId ? ` (${t.modelId})` : ""} → ${t.ms}ms`, {
-				step: t.source,
-				addonId: t.source,
-				modelId: t.modelId ?? void 0,
-				ms: t.ms
-			});
-			emit(`Done — ${result.detections.length} detection(s) in ${result.debug?.totalInferenceMs ?? 0}ms`, { ms: result.debug?.totalInferenceMs });
-			const wallMs = performance.now() - wallT0;
-			const inferMs = result.debug?.totalInferenceMs ?? 0;
-			const overheadMs = Math.max(0, wallMs - decodeMs - setupMs - inferMs);
-			return {
-				...result,
-				debug: {
-					...result.debug,
-					decodeMs: Math.round(decodeMs * 100) / 100,
-					setupMs: Math.round(setupMs * 100) / 100,
-					wallMs: Math.round(wallMs * 100) / 100,
-					overheadMs: Math.round(overheadMs * 100) / 100
-				}
-			};
-		} finally {
-			if (differs && this.overrideCache) {
-				this.overrideCache.executor = this.executor;
-				this.overrideCache.lastUsedMs = Date.now();
-				this.scheduleOverrideCacheEviction();
-			}
-			if (differs) {
-				this.currentEngine = priorEngine;
-				this.engineFactory = priorFactory;
-				this.executor = priorExecutor;
+				throw new Error(`${verdict.reason}: ${verdict.detail}`);
 			}
 		}
-	}
-	/**
-	* Apply a benchmark engine override (mirroring the body of `runPipeline`
-	* lines 863-953). Swaps `currentEngine` / `engineFactory` / `executor`
-	* to the override's warm factory and returns a restore function the
-	* caller MUST invoke in `finally`. When `override` is undefined or
-	* matches the current engine, this is a no-op and the restore function
-	* does nothing — same shape so callers don't need a conditional path.
-	*
-	* Used by both `runPipeline` (single-frame benchmark) and
-	* `runPipelineBatch` (batched fast path). Without this, the batch
-	* path silently ignored `input.engine` and ran the user's override
-	* against the addon's saved engine — making the override matrix in
-	* the bench UI a no-op for batchSize > 1.
-	*/
-	async applyEngineOverride(override) {
-		const priorEngine = this.currentEngine;
-		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,
-			format: override.format,
-			...override.device || priorEngine.device ? { device: override.device ?? priorEngine.device } : {}
-		};
-		if (!(priorEngine.runtime !== runEngine.runtime || priorEngine.backend !== runEngine.backend || priorEngine.format !== runEngine.format || (priorEngine.device ?? "") !== (runEngine.device ?? ""))) return () => {};
-		if (this.overrideCache && enginesEqual(this.overrideCache.engine, runEngine)) {
-			const cached = this.overrideCache;
-			if (cached.initPromise) await cached.initPromise;
-			this.log.debug("Benchmark: reusing warm override factory", { meta: { engine: `${runEngine.runtime}/${runEngine.backend}/${runEngine.device ?? "default"}` } });
-			this.currentEngine = runEngine;
-			this.engineFactory = cached.factory;
-			this.executor = cached.executor;
-		} else {
-			if (this.overrideCache) {
-				try {
-					await this.overrideCache.factory.dispose();
-				} catch {}
-				this.overrideCache = null;
+		const appliesCameraGates = isRuntime || input.replay === true;
+		await this.ensureEngineFactory();
+		const runEngine = this.currentEngine;
+		const deviceLabel = runEngine.device ?? "default";
+		emit(`Engine: ${runEngine.runtime}/${runEngine.backend}/${deviceLabel}`, {
+			step: "engine",
+			engine: {
+				runtime: runEngine.runtime,
+				backend: runEngine.backend,
+				device: deviceLabel
 			}
-			this.log.info("Benchmark: engine override", { meta: {
-				from: `${priorEngine.runtime}/${priorEngine.backend}`,
-				to: `${runEngine.runtime}/${runEngine.backend}`
+		});
+		const runtimeStr = `${runEngine.runtime}+${runEngine.backend}`;
+		const executor = this.executor ?? new PipelineExecutor({
+			engineRuntime: runtimeStr,
+			logger: this.log
+		});
+		this.executor = executor;
+		const dispatchEngine = dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey) : runEngine;
+		const dispatchFactory = dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
+		const needed = enabledSteps.filter((s) => dispatchFactory.needsPoolUpdate(s));
+		if (needed.length > 0) {
+			this.log.info("Benchmark: models to load", { meta: {
+				count: needed.length,
+				models: needed.map((s) => `${s.addonId}/${s.modelId}`)
 			} });
-			await this.ensureBackendDeps(runEngine);
-			const newFactory = new EngineFactory({
-				engine: runEngine,
-				modelsDir: this.modelsDir,
-				logger: this.log.child("engine-override"),
-				pythonPath: this.executorOptions.pythonPath ?? "",
-				provisioning: this.executorOptions.provisioning,
-				resolveCustomModel: this.customModelResolver
+			for (const s of needed) emit(`Loading model: ${s.addonName} (${s.modelId})...`, {
+				step: s.addonId,
+				addonId: s.addonId,
+				modelId: s.modelId
 			});
-			const initPromise = newFactory.initialize([]);
-			this.overrideCache = {
-				engine: runEngine,
-				factory: newFactory,
-				executor: null,
-				lastUsedMs: Date.now(),
-				initPromise
+			await this.ensureModelsForSteps(benchmarkSteps, dispatchFactory, dispatchEngine.format);
+			emit(`All models loaded`);
+		}
+		emit("Running inference...");
+		const tree = buildExecutableTree(benchmarkSteps, (stepId) => dispatchFactory.getEngine(stepId), this.customModelResolver);
+		setupMs = performance.now() - wallT0 - decodeMs;
+		const effectiveDeviceId = input.deviceId ?? 0;
+		const deviceOverrides = effectiveDeviceId > 0 ? await this.deviceOverrides.resolve(effectiveDeviceId) : {};
+		const effectiveTree = Object.keys(deviceOverrides).length > 0 ? applyDeviceOverridesToTree(tree, "object-detection", deviceOverrides) : tree;
+		const nativeCropProvider = this.buildNativeCropProviderFromRef(input.nativeCropRef) ?? this.buildNativeFaceCropProvider(input.frameHandle);
+		let cropZoneBbox;
+		if (appliesCameraGates && effectiveDeviceId > 0 && effectiveTree.roots.some((r) => r.definition.extractMode === "crop-zone")) {
+			await this.ensureDeviceProxy(effectiveDeviceId);
+			const proxy = this.deviceProxies.get(effectiveDeviceId);
+			if (proxy) cropZoneBbox = resolvePackageCropBbox(proxy.state.zones.value?.zones ?? [], proxy.state.zoneRules.value?.package ?? [], imageWidth, imageHeight) ?? void 0;
+		}
+		let frameViewResolver;
+		let rootInputViewProvider;
+		if (runtimeFrameRef) {
+			frameViewResolver = createRootFrameViewResolver(require_default_detection_model.localFrameRegistry, runtimeFrameRef);
+			rootInputViewProvider = async (root, crop) => {
+				const view = await frameViewResolver(root, crop ? {
+					left: crop[0],
+					top: crop[1],
+					width: crop[2] - crop[0],
+					height: crop[3] - crop[1]
+				} : void 0);
+				const data = Buffer.from(view.data.buffer, view.data.byteOffset, view.data.byteLength);
+				return {
+					input: {
+						kind: "jpeg",
+						data
+					},
+					jpegProvider: async () => data,
+					width: view.width,
+					height: view.height,
+					geometry: view.geometry
+				};
 			};
-			this.scheduleOverrideCacheEviction();
-			try {
-				await initPromise;
-				this.overrideCache.initPromise = null;
-			} catch (err) {
-				this.overrideCache = null;
-				if (this.overrideCacheTimer) {
-					clearTimeout(this.overrideCacheTimer);
-					this.overrideCacheTimer = null;
-				}
-				throw err;
+		}
+		let executionSucceeded = false;
+		let execution;
+		try {
+			execution = await executor.run(effectiveTree, rootInput, jpegProvider, imageWidth, imageHeight, effectiveDeviceId, {
+				traceVerbosity: isRuntime ? this.eventBus ? "summary" : "off" : "full",
+				plane: input.plane,
+				occasion: input.replay === true ? "replay" : "live"
+			}, nativeCropProvider, cropZoneBbox, rootInputViewProvider);
+			executionSucceeded = true;
+		} finally {
+			frameViewResolver?.release(executionSucceeded ? "success" : "error");
+		}
+		const { result, trace } = execution;
+		if (isRuntime) {
+			if (trace && this.eventBus) this.eventBus.emit(require_dist.createEvent(require_dist.EventCategory.PipelineTrace, {
+				type: "device",
+				id: trace.deviceId,
+				nodeId: "hub"
+			}, trace));
+			if (effectiveDeviceId > 0) {
+				await this.ensureDeviceProxy(effectiveDeviceId);
+				return stampRoot(this.gateDetectionsByZoneRules(effectiveDeviceId, result));
 			}
-			this.currentEngine = runEngine;
-			this.engineFactory = newFactory;
-			this.executor = null;
+			return stampRoot(result);
 		}
-		return () => {
-			if (this.overrideCache) {
-				this.overrideCache.executor = this.executor;
-				this.overrideCache.lastUsedMs = Date.now();
-				this.scheduleOverrideCacheEviction();
+		for (const t of result.debug?.stepTimings ?? []) emit(`${t.source}${t.modelId ? ` (${t.modelId})` : ""} → ${t.ms}ms`, {
+			step: t.source,
+			addonId: t.source,
+			modelId: t.modelId ?? void 0,
+			ms: t.ms
+		});
+		emit(`Done — ${result.detections.length} detection(s) in ${result.debug?.totalInferenceMs ?? 0}ms`, { ms: result.debug?.totalInferenceMs });
+		const wallMs = performance.now() - wallT0;
+		const inferMs = result.debug?.totalInferenceMs ?? 0;
+		const overheadMs = Math.max(0, wallMs - decodeMs - setupMs - inferMs);
+		const gated = input.replay === true && effectiveDeviceId > 0 ? await this.ensureDeviceProxy(effectiveDeviceId).then(() => this.gateDetectionsByZoneRules(effectiveDeviceId, result)) : result;
+		return {
+			...stampRoot(gated),
+			debug: {
+				...gated.debug,
+				decodeMs: Math.round(decodeMs * 100) / 100,
+				setupMs: Math.round(setupMs * 100) / 100,
+				wallMs: Math.round(wallMs * 100) / 100,
+				overheadMs: Math.round(overheadMs * 100) / 100
 			}
-			this.currentEngine = priorEngine;
-			this.engineFactory = priorFactory;
-			this.executor = priorExecutor;
 		};
 	}
 	/**
-	* Schedule eviction of the override cache after `OVERRIDE_CACHE_TTL_MS`
-	* of idleness. Rescheduling resets the timer so an active benchmark
-	* keeps its warm factory alive until iterations stop arriving.
-	*/
-	scheduleOverrideCacheEviction() {
-		if (this.overrideCacheTimer) clearTimeout(this.overrideCacheTimer);
-		this.overrideCacheTimer = setTimeout(() => {
-			this.evictOverrideCache("idle TTL");
-		}, DetectionPipelineProvider.OVERRIDE_CACHE_TTL_MS);
-	}
-	async evictOverrideCache(reason) {
-		if (!this.overrideCache) return;
-		const entry = this.overrideCache;
-		this.overrideCache = null;
-		if (this.overrideCacheTimer) {
-			clearTimeout(this.overrideCacheTimer);
-			this.overrideCacheTimer = null;
-		}
-		try {
-			await entry.factory.dispose();
-			this.log.info("Override cache evicted", { meta: {
-				reason,
-				engine: `${entry.engine.runtime}/${entry.engine.backend}/${entry.engine.device ?? "default"}`,
-				ageMs: Date.now() - entry.lastUsedMs
-			} });
-		} catch (err) {
-			this.log.warn("Override cache dispose failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-		}
-	}
-	/**
 	* Convert PipelineStepInput[] → PipelineDefaultStep[] by enriching from
 	* StepDefinitions. This is the LIVE per-camera dispatch path — it runs
 	* once per decoded frame (up to detectionFps × N cameras/sec) — so it
@@ -8282,13 +8143,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* `resolveStepModels` (see its doc comment); a second writer here would
 	* corrupt it.
 	*
-	* `format` defaults to `this.currentEngine.format` (the LIVE per-camera
-	* dispatch path never passes it explicitly). Benchmark call sites with a
-	* per-run engine override (`input.engine`) MUST pass the override's format
-	* explicitly — `this.currentEngine` only gets swapped to the override
-	* LATER in `runPipeline`/`runPipelineBatch`, so relying on the default here
-	* would resolve models against the node's persisted format instead of the
-	* format actually being benchmarked.
+	* `format` defaults to `this.currentEngine.format` (the node-default
+	* pool); a `deviceKey` dispatch passes that device's format explicitly.
 	*/
 	inputStepsToPipelineSteps(steps, format = this.currentEngine.format, engine = {
 		backend: this.currentEngine.backend,
@@ -8370,8 +8226,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*    devices — so the whole-tree gate stays.
 	*
 	* Fallback is strictly NODE-LOCAL and ordered: the node's own selected
-	* engine (or the benchmark's explicit `engineOverride`) is the one and only
-	* fallback — frames never migrate to another node from here (that is the
+	* engine is the one and only fallback — frames never migrate to another node from here (that is the
 	* orchestrator's tier). The fallback is logged ONCE per distinct
 	* (deviceKey, steps, format) signature, with `tags: { deviceId }` when the
 	* dispatch is camera-scoped.
@@ -8382,12 +8237,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* configuration must stay loud, not vanish into a silent fallback chain.
 	*/
 	resolveStepsForDispatch(args) {
-		const { deviceKey, engineOverride, deviceId } = args;
-		const nodeFormat = engineOverride?.format ?? this.currentEngine.format;
-		const nodeEngine = engineOverride ? {
-			backend: engineOverride.backend,
-			device: engineOverride.device ?? null
-		} : {
+		const { deviceKey, deviceId } = args;
+		const nodeFormat = this.currentEngine.format;
+		const nodeEngine = {
 			backend: this.currentEngine.backend,
 			device: this.currentEngine.device ?? null
 		};
@@ -8632,12 +8484,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const dispatchResolution = this.resolveStepsForDispatch({
 			steps: input.steps,
 			deviceKey: input.deviceKey,
-			engineOverride: input.engine,
 			deviceId: input.deviceId,
 			plane: void 0
 		});
 		const dispatchDeviceKey = dispatchResolution.deviceKey;
-		const resolveFormat = dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey).format : input.engine?.format ?? this.currentEngine.format;
+		const resolveFormat = dispatchDeviceKey ? resolveDeviceEngine(dispatchDeviceKey).format : this.currentEngine.format;
 		const benchmarkSteps = dispatchResolution.steps;
 		const enabledSteps = flattenEnabledVideoSteps(benchmarkSteps);
 		if (enabledSteps.length === 0) throw new Error("runPipelineBatch: no enabled steps");
@@ -8658,53 +8509,48 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		const uniformDims = input.frames.every((f) => f.width === firstFrame.width && f.height === firstFrame.height);
 		const singleRoot = enabledSteps.length === 1;
 		await this.ensureEngineFactory();
-		const restoreEngine = await this.applyEngineOverride(input.engine);
-		try {
-			const factory = dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
-			if (!factory) throw new Error("runPipelineBatch: factory not initialised");
-			if (enabledSteps.filter((s) => factory.needsPoolUpdate(s)).length > 0) await this.ensureModelsForSteps(benchmarkSteps, factory, resolveFormat);
-			const canFastPath = singleRoot && allRaw && uniformDims && factory.supportsBatch();
-			this.log.info("runPipelineBatch path decision", { meta: {
-				phase: "batch",
-				canFastPath,
-				singleRoot,
-				allRaw,
-				uniformDims,
-				supportsBatch: factory.supportsBatch()
-			} });
-			if (!canFastPath) return { results: await Promise.all(input.frames.map((frame) => this.runPipeline({
-				steps: input.steps,
-				frame,
-				deviceId: input.deviceId,
-				sessionId: input.sessionId,
-				deviceKey: dispatchDeviceKey
-			}))) };
-			const items = input.frames.map((frame) => ({
-				raw: Buffer.from(frame.data),
-				width: frame.width,
-				height: frame.height,
-				format: frame.format
-			}));
-			this.log.info("runPipelineBatch fast path dispatch", { meta: {
-				phase: "batch",
-				stepId: rootStep.addonId,
-				modelId: rootStep.modelId,
-				items: items.length,
-				totalRawBytes: items.reduce((s, it) => s + it.raw.length, 0)
-			} });
-			const start = performance.now();
-			const rawResults = await factory.batchInferRaw(rootStep.addonId, items, rootStep.modelId, input.frameId ?? 0);
-			const totalMs = performance.now() - start;
-			this.log.info("runPipelineBatch fast path returned", { meta: {
-				phase: "batch",
-				resultCount: rawResults.length,
-				ms: Math.round(totalMs)
-			} });
-			const perFrameMs = totalMs / rawResults.length;
-			return { results: rawResults.map((raw, i) => assembleBatchedFrameResult(raw, input.frames[i], rootStep.addonId, input.deviceId ?? 0, perFrameMs, perFrameMs)) };
-		} finally {
-			restoreEngine();
-		}
+		const factory = dispatchDeviceKey ? await this.resolveDeviceFactory(dispatchDeviceKey) : this.engineFactory;
+		if (!factory) throw new Error("runPipelineBatch: factory not initialised");
+		if (enabledSteps.filter((s) => factory.needsPoolUpdate(s)).length > 0) await this.ensureModelsForSteps(benchmarkSteps, factory, resolveFormat);
+		const canFastPath = singleRoot && allRaw && uniformDims && factory.supportsBatch();
+		this.log.info("runPipelineBatch path decision", { meta: {
+			phase: "batch",
+			canFastPath,
+			singleRoot,
+			allRaw,
+			uniformDims,
+			supportsBatch: factory.supportsBatch()
+		} });
+		if (!canFastPath) return { results: await Promise.all(input.frames.map((frame) => this.runPipeline({
+			steps: input.steps,
+			frame,
+			deviceId: input.deviceId,
+			sessionId: input.sessionId,
+			deviceKey: dispatchDeviceKey
+		}))) };
+		const items = input.frames.map((frame) => ({
+			raw: Buffer.from(frame.data),
+			width: frame.width,
+			height: frame.height,
+			format: frame.format
+		}));
+		this.log.info("runPipelineBatch fast path dispatch", { meta: {
+			phase: "batch",
+			stepId: rootStep.addonId,
+			modelId: rootStep.modelId,
+			items: items.length,
+			totalRawBytes: items.reduce((s, it) => s + it.raw.length, 0)
+		} });
+		const start = performance.now();
+		const rawResults = await factory.batchInferRaw(rootStep.addonId, items, rootStep.modelId, input.frameId ?? 0);
+		const totalMs = performance.now() - start;
+		this.log.info("runPipelineBatch fast path returned", { meta: {
+			phase: "batch",
+			resultCount: rawResults.length,
+			ms: Math.round(totalMs)
+		} });
+		const perFrameMs = totalMs / rawResults.length;
+		return { results: rawResults.map((raw, i) => assembleBatchedFrameResult(raw, input.frames[i], rootStep.addonId, input.deviceId ?? 0, perFrameMs, perFrameMs)) };
 	}
 	async listReferenceImages() {
 		const dir = this.resolveRefImagesDir();
@@ -8809,7 +8655,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.poolMemoryGuard = null;
 		this.inferenceTimeoutGuard?.stop();
 		this.inferenceTimeoutGuard = null;
-		await this.evictOverrideCache("shutdown");
 		if (this.engineFactory) {
 			await this.engineFactory.dispose();
 			this.engineFactory = null;
@@ -8891,13 +8736,22 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* own runtime's row, so this is not "the node's tuning" — the per-pool truth
 	* is on each pool's `Python inference pool` log line and in `listLoadedEngines`.
 	*/
-	async getEffectiveTuning() {
-		const p = resolvePoolProvisioning(this.currentEngine, this.executorOptions.provisioning);
+	/**
+	* One pool's provisioning — the device pool named by `deviceKey`, else the
+	* node default. Resolved with the SAME override `resolveDeviceFactory` and
+	* `ensureEngineFactory` build the pool with, so the answer describes the
+	* pool that ran the work (D646).
+	*/
+	async getEffectiveTuning(input = {}) {
+		const p = resolvePoolProvisioning(input.deviceKey !== void 0 ? resolveDeviceEngine(input.deviceKey) : this.currentEngine, this.executorOptions.provisioning);
 		return {
+			deviceKey: input.deviceKey ?? null,
+			runtime: p.runtime,
 			batchMode: p.batchMode,
 			windowMs: p.windowMs,
 			maxBatchSize: p.maxBatchSize,
-			concurrency: p.concurrency
+			concurrency: p.concurrency,
+			numWorkers: p.numWorkers
 		};
 	}
 	/**
@@ -9285,9 +9139,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	async listLoadedEngines() {
 		const out = [];
-		const overrideFactory = this.overrideCache?.factory ?? null;
-		const runtimeFactoryIsOverride = this.engineFactory !== null && this.engineFactory === overrideFactory;
-		if (this.engineFactory && !runtimeFactoryIsOverride) {
+		if (this.engineFactory) {
 			const eng = this.currentEngine;
 			const engineKey = `${eng.runtime}/${eng.backend}/${eng.device ?? "default"}`;
 			const loaded = this.engineFactory.listLoaded();
@@ -9302,22 +9154,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				idleTtlMs: null
 			});
 		}
-		if (this.overrideCache) {
-			const eng = this.overrideCache.engine;
-			const engineKey = `${eng.runtime}/${eng.backend}/${eng.device ?? "default"} (warm)`;
-			const loaded = this.overrideCache.factory.listLoaded();
-			const idleMs = Math.max(0, Date.now() - this.overrideCache.lastUsedMs);
-			if (idleMs <= DetectionPipelineProvider.OVERRIDE_CACHE_TTL_MS) out.push({
-				engineKey,
-				engine: eng,
-				modelsLoaded: loaded.map((l) => `${l.stepId}/${l.modelId}`),
-				inUseByCameras: [],
-				kind: "warm-override",
-				poolPid: this.overrideCache.factory.getPoolPid(),
-				idleMs,
-				idleTtlMs: DetectionPipelineProvider.OVERRIDE_CACHE_TTL_MS
-			});
-		}
 		for (const [deviceKey, factory] of this.factoriesByDevice) {
 			const eng = resolveDeviceEngine(deviceKey);
 			const loaded = factory.listLoaded();
@@ -9346,14 +9182,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		return { success: true };
 	}
 	async killEngine(input) {
-		if (this.overrideCache && enginesEqual(this.overrideCache.engine, input.engine)) {
-			await this.evictOverrideCache("killEngine");
-			this.log.info("Override engine killed", { meta: {
-				...input.engine,
-				force: input.force ?? false
-			} });
-			return { success: true };
-		}
 		if (!this.engineFactory) return {
 			success: false,
 			reason: "not loaded"
@@ -9871,7 +9699,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	/**
 	* Embedded Python path resolved once at boot via
 	* `ctx.deps.ensurePython()`. Empty string means the download failed
-	* or `runtime: 'node'` was selected — the provider's
+	* — the provider's
 	* `ensureBackendDeps` and EngineFactory's `initPythonPool` raise a
 	* clear error in that case.
 	*/