@camstack/addon-pipeline 1.2.43 → 1.2.44

package/dist/detection-pipeline/index.mjs

@@ -1,6 +1,6 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { A as evaluateZoneRules, K as errMsg, L as pipelineExecutorCapability, O as detectionPipelineCapability, Q as hydrateSchema, V as runtimeDevices$1, W as supportedRuntimes$1, Z as createEvent, _ as YAMNET_TO_MACRO, _t as union, ct as array, gt as string, k as enumerateInferenceDevices, l as DEVICE_BACKEND_TO_FORMAT, mt as object, nt as nodePin, ot as sleep, q as BaseAddon, rt as parseJsonUnknown, t as APPLE_SA_TO_MACRO, vt as EventCategory, w as defaultDeviceFor$1 } from "../dist-B-VVBzrL.mjs";
-import { a as getDefaultModelForFormat, c as getStepDefinition, i as ALL_STEPS, l as resolveModelForFormat, n as startEventLoopStallMonitor, o as getDefaultModelForFormatFromDef, r as ALL_PIPELINE_STEPS, s as getStep } from "../event-loop-stall-monitor-DfKdC7G4.mjs";
+import { A as defaultDeviceFor$1, Dt as string, L as enumerateInferenceDevices, Ot as union, P as detectionPipelineCapability, Q as runtimeDevices$1, R as evaluateZoneRules, S as YAMNET_TO_MACRO, Tt as object, _t as sleep, ct as createEvent, it as BaseAddon, kt as EventCategory, lt as hydrateSchema, mt as parseJsonUnknown, pt as nodePin, q as pipelineExecutorCapability, rt as errMsg, t as APPLE_SA_TO_MACRO, tt as supportedRuntimes$1, u as DEVICE_BACKEND_TO_FORMAT, yt as array } from "../dist-DOu93i_g.mjs";
+import { a as getDefaultModelForFormat, c as getStepDefinition, i as ALL_STEPS, l as resolveModelForFormat, n as startEventLoopStallMonitor, o as getDefaultModelForFormatFromDef, r as ALL_PIPELINE_STEPS, s as getStep } from "../event-loop-stall-monitor-CShgQE6l.mjs";
 import { t as getSharp } from "../lazy-sharp-B-mb8uWx.mjs";
 import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
 import { a as ensureModel, o as isModelDownloaded, r as deleteModelFromDisk } from "../model-download-service-D8B-4ktF-BB7oZL3y.mjs";
@@ -246,7 +246,7 @@ function normalizeEngineNodeId(rawNodeId) {
 //#endregion
 //#region src/detection-pipeline/default-detection-model.ts
 /** The object-detection step id — the only slot this resolver applies to. */
-var OBJECT_DETECTION_STEP_ID$1 = "object-detection";
+var OBJECT_DETECTION_STEP_ID = "object-detection";
 /**
 * Balanced default object-detection model per accelerator class. `'cpu'` maps to
 * `null` → the caller substitutes the step's own `defaultModelId` (`yolo26n`).
@@ -308,7 +308,7 @@ function classifyAccelerator(backend, device) {
 function resolveDefaultDetectionModel(backend, device, format, getStepDef = getStepDefinition) {
 	let def;
 	try {
-		def = getStepDef(OBJECT_DETECTION_STEP_ID$1);
+		def = getStepDef(OBJECT_DETECTION_STEP_ID);
 	} catch {
 		return "yolo26n";
 	}
@@ -434,7 +434,7 @@ var PoolHandle = class {
 	}
 	async infer(input) {
 		const start = performance.now();
-		return poolResultToEngineOutput(input.kind === "raw" ? await this.pool.inferRaw(this.modelIndex, input.data, input.width, input.height, input.format) : await this.pool.infer(this.modelIndex, input.data), performance.now() - start);
+		return poolResultToEngineOutput(input.kind === "raw" ? await this.pool.inferRaw(this.modelIndex, input.data, input.width, input.height, input.format, input.deviceId) : await this.pool.infer(this.modelIndex, input.data, input.deviceId), performance.now() - start);
 	}
 	/**
 	* Inference on a frame previously cached in the Python pool via
@@ -638,12 +638,12 @@ var PoolWorker = class {
 			});
 		});
 	}
-	async infer(modelByte, jpeg) {
+	async infer(modelByte, jpeg, deviceId) {
 		this.ensureReady();
 		const payload = Buffer.concat([Buffer.from([modelByte]), jpeg]);
-		return this.dispatch(MSG_INFER_JPEG, payload);
+		return this.dispatch(MSG_INFER_JPEG, payload, deviceId);
 	}
-	async inferRaw(modelByte, raw, width, height, format) {
+	async inferRaw(modelByte, raw, width, height, format, deviceId) {
 		this.ensureReady();
 		const fmtCode = RAW_FMT_CODE[format];
 		const rawHeader = Buffer.allocUnsafe(10);
@@ -651,7 +651,7 @@ var PoolWorker = class {
 		rawHeader.writeUInt32LE(width, 1);
 		rawHeader.writeUInt32LE(height, 5);
 		rawHeader[9] = fmtCode;
-		return this.dispatchMulti(MSG_INFER_RAW, rawHeader.length + raw.length, [rawHeader, raw]);
+		return this.dispatchMulti(MSG_INFER_RAW, rawHeader.length + raw.length, [rawHeader, raw], deviceId);
 	}
 	async inferBatch(modelByte, items, frameId = 0) {
 		this.ensureReady();
@@ -689,12 +689,12 @@ var PoolWorker = class {
 		const result = await this.dispatchMulti(MSG_CACHE_FRAME, payloadLen, [header, raw]);
 		if (result["error"]) throw new Error(String(result["error"]));
 	}
-	async inferCached(modelByte, frameId) {
+	async inferCached(modelByte, frameId, deviceId) {
 		this.ensureReady();
 		const payload = Buffer.allocUnsafe(5);
 		payload[0] = modelByte;
 		payload.writeUInt32LE(frameId, 1);
-		return this.dispatch(MSG_INFER_CACHED, payload);
+		return this.dispatch(MSG_INFER_CACHED, payload, deviceId);
 	}
 	async sendCommand(cmd) {
 		this.ensureReady();
@@ -718,7 +718,7 @@ var PoolWorker = class {
 	* raise — but logging none is how a camera went dark for 52 minutes looking
 	* like a quiet afternoon.
 	*/
-	shedIfSaturated(msgType) {
+	shedIfSaturated(msgType, deviceId) {
 		if (!SHEDDABLE_MSG_TYPES.has(msgType)) return null;
 		if (this.pending.size < POOL_MAX_IN_FLIGHT) {
 			this.shedding = false;
@@ -726,15 +726,18 @@ var PoolWorker = class {
 		}
 		if (!this.shedding) {
 			this.shedding = true;
-			this.log.warn("worker saturated — shedding inference until it catches up", { meta: {
-				worker: this.opts.workerLabel,
-				pid: this.getPid(),
-				runtime: this.opts.poolRuntime,
-				device: this.opts.device ?? "default",
-				inFlight: this.pending.size,
-				cap: POOL_MAX_IN_FLIGHT,
-				deadlineMs: POOL_LIVE_INFER_TIMEOUT_MS
-			} });
+			this.log.warn("worker saturated — shedding inference until it catches up", {
+				...deviceId !== void 0 ? { tags: { deviceId } } : {},
+				meta: {
+					worker: this.opts.workerLabel,
+					pid: this.getPid(),
+					runtime: this.opts.poolRuntime,
+					device: this.opts.device ?? "default",
+					inFlight: this.pending.size,
+					cap: POOL_MAX_IN_FLIGHT,
+					deadlineMs: POOL_LIVE_INFER_TIMEOUT_MS
+				}
+			});
 		}
 		this.shedCount++;
 		return {
@@ -747,12 +750,12 @@ var PoolWorker = class {
 	deadlineFor(msgType) {
 		return SHEDDABLE_MSG_TYPES.has(msgType) ? POOL_LIVE_INFER_TIMEOUT_MS : POOL_INFER_TIMEOUT_MS;
 	}
-	dispatch(msgType, payload) {
-		const shed = this.shedIfSaturated(msgType);
+	dispatch(msgType, payload, deviceId) {
+		const shed = this.shedIfSaturated(msgType, deviceId);
 		if (shed) return Promise.resolve(shed);
 		const reqId = this.allocRequestId();
 		return new Promise((resolve, reject) => {
-			const timer = this.armRequestTimeout(reqId, reject, this.deadlineFor(msgType));
+			const timer = this.armRequestTimeout(reqId, reject, this.deadlineFor(msgType), deviceId);
 			this.pending.set(reqId, {
 				resolve,
 				reject,
@@ -772,30 +775,33 @@ var PoolWorker = class {
 	* `POOL_INFER_TIMEOUT_MS`. `unref` so it never keeps the event loop alive.
 	* The normal response + `rejectAll` paths clear it via `PendingRequest.timer`.
 	*/
-	armRequestTimeout(reqId, reject, timeoutMs) {
+	armRequestTimeout(reqId, reject, timeoutMs, deviceId) {
 		const timer = setTimeout(() => {
 			if (this.pending.delete(reqId)) {
-				this.log.error("inference request timed out", { meta: {
-					worker: this.opts.workerLabel,
-					pid: this.getPid(),
-					runtime: this.opts.poolRuntime,
-					device: this.opts.device ?? "default",
-					inFlight: this.pending.size,
-					reqId,
-					timeoutMs
-				} });
+				this.log.error("inference request timed out", {
+					...deviceId !== void 0 ? { tags: { deviceId } } : {},
+					meta: {
+						worker: this.opts.workerLabel,
+						pid: this.getPid(),
+						runtime: this.opts.poolRuntime,
+						device: this.opts.device ?? "default",
+						inFlight: this.pending.size,
+						reqId,
+						timeoutMs
+					}
+				});
 				reject(/* @__PURE__ */ new Error(`PoolWorker[${this.opts.workerLabel}]: inference request ${reqId} timed out after ${timeoutMs}ms (worker alive, no reply)`));
 			}
 		}, timeoutMs);
 		timer.unref?.();
 		return timer;
 	}
-	dispatchMulti(msgType, payloadLen, parts) {
-		const shed = this.shedIfSaturated(msgType);
+	dispatchMulti(msgType, payloadLen, parts, deviceId) {
+		const shed = this.shedIfSaturated(msgType, deviceId);
 		if (shed) return Promise.resolve(shed);
 		const reqId = this.allocRequestId();
 		return new Promise((resolve, reject) => {
-			const timer = this.armRequestTimeout(reqId, reject, this.deadlineFor(msgType));
+			const timer = this.armRequestTimeout(reqId, reject, this.deadlineFor(msgType), deviceId);
 			this.pending.set(reqId, {
 				resolve,
 				reject,
@@ -991,21 +997,21 @@ var SharedInferencePool = class {
 			workers: this.numWorkers
 		};
 	}
-	async infer(modelIndex, jpeg) {
+	async infer(modelIndex, jpeg, deviceId) {
 		const w = this.pickWorker();
-		return this.trackDroppedResponse(await w.infer(this.encodeModelByte(modelIndex), jpeg), modelIndex);
+		return this.trackDroppedResponse(await w.infer(this.encodeModelByte(modelIndex), jpeg, deviceId), modelIndex);
 	}
-	async inferRaw(modelIndex, raw, width, height, format) {
+	async inferRaw(modelIndex, raw, width, height, format, deviceId) {
 		const w = this.pickWorker();
-		return this.trackDroppedResponse(await w.inferRaw(this.encodeModelByte(modelIndex), raw, width, height, format), modelIndex);
+		return this.trackDroppedResponse(await w.inferRaw(this.encodeModelByte(modelIndex), raw, width, height, format, deviceId), modelIndex);
 	}
 	async inferBatch(modelIndex, items, frameId = 0) {
 		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, frameId);
 	}
-	async inferCached(modelIndex, frameId) {
+	async inferCached(modelIndex, frameId, deviceId) {
 		const w = this.pickWorker();
-		return this.trackDroppedResponse(await w.inferCached(this.encodeModelByte(modelIndex), frameId), modelIndex);
+		return this.trackDroppedResponse(await w.inferCached(this.encodeModelByte(modelIndex), frameId, deviceId), modelIndex);
 	}
 	/**
 	* Total `"dropped": true` responses seen from the Python pool — frames
@@ -1631,12 +1637,24 @@ var RUNTIME_TO_FORMAT = {
 	onnxruntime: "onnx",
 	edgetpu: "tflite"
 };
-/** The step whose detections are re-filtered downstream by the executor's
-*  per-macro `minConfidence*` sliders (`macroFilterVerdict`). Its pool-side
-*  floor must stay BELOW those sliders or it silently pre-empts them. */
-var OBJECT_DETECTION_STEP_ID = "object-detection";
 /**
-* Pool-side confidence FLOOR for the object-detection step (#4 foot-gun fix).
+* Steps whose detections are re-filtered downstream by the executor's per-macro
+* `minConfidence*` sliders (`macroFilterVerdict` runs on EVERY root, keyed by
+* the detection's macro class). Their pool-side floor must stay BELOW those
+* sliders or it silently pre-empts them.
+*
+* `package-detection` joined on 2026-08-07, when it gained a
+* `minConfidencePackage` slider: while it kept `defaultConfidence` (0.5) as its
+* pool floor, every sub-0.5 position of that brand-new slider was dead on
+* arrival — the same foot-gun this constant was introduced to remove for
+* object-detection. A step with NO operator-facing threshold keeps its own
+* `def.defaultConfidence`; adding one without adding the id here ships a
+* control that lies below its default.
+*/
+var PER_MACRO_REFILTERED_STEP_IDS = new Set(["object-detection", "package-detection"]);
+/**
+* Pool-side confidence FLOOR for a step the executor re-filters (#4 foot-gun
+* fix).
 *
 * The pool used to receive `def.defaultConfidence` (0.5) as its floor and drop
 * every box < 0.5 BEFORE the executor's per-macro `minConfidence*` sliders run —
@@ -1644,17 +1662,17 @@ var OBJECT_DETECTION_STEP_ID = "object-detection";
 * constant so the operator-visible per-macro sliders are the authoritative
 * filter across their full 0–1 range. The per-macro slider DEFAULTS stay at 0.5
 * (see `step-definitions.ts` getConfigSchema), so default UI behaviour is
-* unchanged; only sub-0.5 sliders start having an effect. Non-object-detection
-* steps keep their own `def.defaultConfidence` floor (no per-macro re-filter). */
-var OBJECT_DETECTION_POOL_CONFIDENCE_FLOOR = .05;
+* unchanged; only sub-0.5 sliders start having an effect. */
+var PER_MACRO_POOL_CONFIDENCE_FLOOR = .05;
 /**
-* Resolve the pool-side confidence FLOOR for a step (#4). The object-detection
-* step gets the small {@link OBJECT_DETECTION_POOL_CONFIDENCE_FLOOR} so its
-* per-macro `minConfidence*` sliders (applied downstream by the executor) are
-* the authoritative filter; every other step keeps its own `defaultConfidence`.
+* Resolve the pool-side confidence FLOOR for a step (#4). A step in
+* {@link PER_MACRO_REFILTERED_STEP_IDS} gets the small
+* {@link PER_MACRO_POOL_CONFIDENCE_FLOOR} so its per-macro `minConfidence*`
+* slider (applied downstream by the executor) is the authoritative filter;
+* every other step keeps its own `defaultConfidence`.
 */
 function resolvePoolConfidenceFloor(stepId, defaultConfidence) {
-	return stepId === OBJECT_DETECTION_STEP_ID ? OBJECT_DETECTION_POOL_CONFIDENCE_FLOOR : defaultConfidence;
+	return PER_MACRO_REFILTERED_STEP_IDS.has(stepId) ? PER_MACRO_POOL_CONFIDENCE_FLOOR : defaultConfidence;
 }
 /**
 * Load a model's runtime label list from its `-labels.json` extraFile, if any.
@@ -3482,6 +3500,21 @@ function isEnrichmentOutput(output) {
 	return output.kind === "classifications" || output.kind === "embedding" || output.kind === "text";
 }
 /**
+* Stamp the camera onto an inference input so a failure inside the SHARED pool
+* can name it (`InferenceInput.deviceId` — diagnostic only, it selects
+* nothing). Immutable, and a no-op for a caller with no real camera: the
+* benchmark and the reference runs pass `deviceId: 0`, and a fabricated `0` in
+* a log tag is worse than no tag.
+*/
+function withInferenceDeviceId(input, deviceId) {
+	if (!Number.isFinite(deviceId) || deviceId <= 0) return input;
+	if (input.deviceId === deviceId) return input;
+	return {
+		...input,
+		deviceId
+	};
+}
+/**
 * Re-project a `crop-zone` root's detections from crop-relative coordinates
 * back to full-frame image space by the crop's origin — the root analogue of
 * the crop-roi child re-projection (`transformBboxToImageSpace`). Landmarks (if
@@ -3585,7 +3618,7 @@ var PipelineExecutor = class {
 			if (debug) console.log(`[executor] rootStep=${rootStep.stepId} settings=${JSON.stringify(rootStep.settings ?? {})}`);
 			const cropPrep = rootStep.definition.extractMode === "crop-zone" && cropZoneBbox !== void 0 ? await this.prepareCropZoneInput(cropZoneBbox, fullFrameJpegProvider, imageWidth, imageHeight, deviceId) : null;
 			const rootStart = Date.now();
-			const rawRootOutput = await this.executeStep(rootStep, cropPrep?.input ?? rootInput, cropPrep?.width ?? imageWidth, cropPrep?.height ?? imageHeight, "full-frame", void 0, void 0, traceBuilder, stepTimings, poolAgg, rootShed);
+			const rawRootOutput = await this.executeStep(rootStep, cropPrep?.input ?? withInferenceDeviceId(rootInput, deviceId), cropPrep?.width ?? imageWidth, cropPrep?.height ?? imageHeight, "full-frame", void 0, void 0, traceBuilder, stepTimings, poolAgg, rootShed);
 			const rootMs = Date.now() - rootStart;
 			if (rawRootOutput === null) continue;
 			const rootOutput = cropPrep && rawRootOutput.kind === "detections" ? reprojectCropZoneDetections(rawRootOutput, cropPrep.origin) : rawRootOutput;
@@ -3776,10 +3809,10 @@ var PipelineExecutor = class {
 			const ox = Math.max(0, Math.round(cropZoneBbox[0]));
 			const oy = Math.max(0, Math.round(cropZoneBbox[1]));
 			return {
-				input: {
+				input: withInferenceDeviceId({
 					kind: "jpeg",
 					data: crop.jpeg
-				},
+				}, deviceId),
 				width: crop.width,
 				height: crop.height,
 				origin: [
@@ -4005,10 +4038,10 @@ var PipelineExecutor = class {
 						}
 					} catch {}
 				}
-				const childOutput = await this.executeStep(child, {
+				const childOutput = await this.executeStep(child, withInferenceDeviceId({
 					kind: "jpeg",
 					data: cropJpegBuf
-				}, cropW, cropH, "crop-roi", parentDetection.bbox, parentDetection.macroClass, traceBuilder, stepTimings, poolAgg);
+				}, deviceId), cropW, cropH, "crop-roi", parentDetection.bbox, parentDetection.macroClass, traceBuilder, stepTimings, poolAgg);
 				const childMs = Date.now() - childStart;
 				if (childOutput === null) continue;
 				const detailsBefore = ctx.details.length;
@@ -4651,8 +4684,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	deviceProxies = /* @__PURE__ */ new Map();
 	proxyUnsubs = /* @__PURE__ */ new Map();
-	/** Initialization lock — ensures only one init runs at a time; concurrent callers await the same promise */
-	initPromise = null;
 	/**
 	* Last logged "step configured" signature — used to dedupe the
 	* per-step debug trail so it only fires on actual config CHANGE
@@ -6693,20 +6724,66 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* If global steps exist, initializes with them. Otherwise, creates an empty pool.
 	*/
 	async ensureEngineFactory() {
-		if (this.initPromise) await this.initPromise;
 		if (this.engineFactory) return;
-		await this.assertEngineReady();
-		await this.ensureBackendDeps(this.currentEngine);
-		this.engineFactory = new EngineFactory({
-			engine: this.currentEngine,
-			modelsDir: this.modelsDir,
-			logger: this.log.child("engine"),
-			pythonPath: this.executorOptions.pythonPath ?? "",
-			provisioning: this.executorOptions.provisioning
-		});
-		await this.engineFactory.initialize([]);
+		const inflight = this.engineFactoryInflight;
+		if (inflight) {
+			await inflight;
+			return;
+		}
+		const creation = (async () => {
+			await this.assertEngineReady();
+			await this.ensureBackendDeps(this.currentEngine);
+			const factory = new EngineFactory({
+				engine: this.currentEngine,
+				modelsDir: this.modelsDir,
+				logger: this.log.child("engine"),
+				pythonPath: this.executorOptions.pythonPath ?? "",
+				provisioning: this.executorOptions.provisioning
+			});
+			try {
+				await factory.initialize([]);
+			} catch (err) {
+				await factory.dispose().catch(() => void 0);
+				this.log.error("Node-default pool failed to initialize", { meta: {
+					deviceKey: deviceKeyOf(this.currentEngine),
+					backend: this.currentEngine.backend,
+					device: this.currentEngine.device ?? null,
+					error: errMsg(err)
+				} });
+				throw err;
+			}
+			this.engineFactory = factory;
+			return factory;
+		})();
+		this.engineFactoryInflight = creation;
+		try {
+			await creation;
+		} finally {
+			this.engineFactoryInflight = null;
+		}
 	}
 	/**
+	* In-flight node-default pool creation. Single-flights
+	* {@link ensureEngineFactory} exactly as `deviceFactoryInflight` does for the
+	* per-device pools.
+	*
+	* Its absence was the chronic `PoolWorker[w0]: not initialized` storm
+	* (1263 lines / 24 h, 2026-08-07): `this.engineFactory` was assigned BEFORE
+	* `initialize()` was awaited, so every caller arriving during the 1-3.5 s
+	* Python spawn took the early-exit and dispatched into a worker whose ready
+	* handshake had not landed. The frames were logged as ERRORs and lost.
+	*
+	* The same bug was found and fixed twice before in this file — once for the
+	* benchmark override cache (whose comment describes it verbatim) and once for
+	* `resolveDeviceFactory` — which is why no `not initialized` line ever
+	* carried a NON-default deviceKey. This is the third and last copy.
+	*
+	* It replaces a `private initPromise` field that was read here and assigned
+	* NOWHERE: a dead lock that read, for as long as it existed, as if this path
+	* were already guarded.
+	*/
+	engineFactoryInflight = null;
+	/**
 	* Get (or lazily build) the inference-pool factory for an explicit device
 	* (`<backend>:<device>`, e.g. `openvino:npu`, `edgetpu:usb`) — Phase 2
 	* multi-device. Each device runs its OWN pool concurrently. Never mutates
@@ -7716,13 +7793,12 @@ var DetectionPipelineAddon = class extends BaseAddon {
 		}
 	}
 	/**
-	* Bare node id used to scope the engine cascade in the shared store. MUST
-	* match the provider's `localProbeNodeId()` (kernel.localNodeId, default
-	* 'hub') so the UI write path (this) and the provider read/write path
-	* (loadEngine / autoPick / reprobe) target the SAME `<key>@<nodeId>`. The old
-	* `?? this.ctx.id` fallback resolved to the ADDON id ('detection-pipeline')
-	* when kernel.localNodeId was absent, so UI saves landed on a key the
-	* provider never read — silently losing the per-node selection.
+	* Bare node id for this instance. MUST match the provider's
+	* `localProbeNodeId()` (kernel.localNodeId, default 'hub') so the per-node
+	* settings projection here and the provider's own node targeting agree. The
+	* old `?? this.ctx.id` fallback resolved to the ADDON id
+	* ('detection-pipeline') when kernel.localNodeId was absent, so UI saves
+	* landed on a key the provider never read.
 	*/
 	localNodeId() {
 		return normalizeEngineNodeId(this.ctxIfReady?.kernel?.localNodeId ?? "hub");