@camstack/addon-pipeline 1.2.128 → 1.2.130

package/dist/detection-pipeline/index.mjs

@@ -1,8 +1,8 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { $ as pickClusterStepModels, D as YAMNET_TO_MACRO, Dt as hydrateSchema, Et as createEvent, Ft as sleep, G as evaluateZoneRules, Gt as string, I as defaultDeviceFor$1, Kt as union, Lt as array, Mt as parseJsonUnknown, St as BaseAddon, Ut as object, V as detectionPipelineCapability, W as enumerateInferenceDevices, Z as overlayClusterStepSettings, c as DEFAULT_CLUSTER_STEP_MODELS, dt as runtimeDevices$1, et as pickClusterStepSettings, gt as errMsg, jt as nodePin, l as DEFAULT_CLUSTER_STEP_SETTINGS, lt as resolvePoolMemoryPolicy, mt as supportedRuntimes$1, p as DEVICE_BACKEND_TO_FORMAT, q as inferModelProvider, qt as EventCategory, rt as pipelineExecutorCapability, st as resolveClusterStepModelId, t as APPLE_SA_TO_MACRO, x as PoolMemoryWatchdog } from "../dist-HLAOw6Pe.mjs";
-import { a as ALL_PIPELINE_STEPS, c as getDefaultModelForFormatFromDef, d as resolveModelForFormat, f as landmarkPrecisionVerdict, l as getStep, n as startEventLoopStallMonitor, o as ALL_STEPS, r as localFrameRegistry, s as getDefaultModelForFormat, u as getStepDefinition } from "../event-loop-stall-monitor-BH-cL_hg.mjs";
+import { $ as pickClusterStepModels, D as YAMNET_TO_MACRO, Dt as hydrateSchema, Et as createEvent, Ft as sleep, G as evaluateZoneRules, Gt as string, I as defaultDeviceFor$1, Kt as union, Lt as array, Mt as parseJsonUnknown, St as BaseAddon, Ut as object, V as detectionPipelineCapability, W as enumerateInferenceDevices, Z as overlayClusterStepSettings, c as DEFAULT_CLUSTER_STEP_MODELS, dt as runtimeDevices$1, et as pickClusterStepSettings, gt as errMsg, jt as nodePin, l as DEFAULT_CLUSTER_STEP_SETTINGS, lt as resolvePoolMemoryPolicy, mt as supportedRuntimes$1, p as DEVICE_BACKEND_TO_FORMAT, q as inferModelProvider, qt as EventCategory, rt as pipelineExecutorCapability, st as resolveClusterStepModelId, t as APPLE_SA_TO_MACRO, x as PoolMemoryWatchdog } from "../dist-Wt81pN5Y.mjs";
+import { a as ALL_PIPELINE_STEPS, c as getDefaultModelForFormatFromDef, d as resolveModelForFormat, f as landmarkPrecisionVerdict, l as getStep, n as startEventLoopStallMonitor, o as ALL_STEPS, r as localFrameRegistry, s as getDefaultModelForFormat, u as getStepDefinition } from "../event-loop-stall-monitor-CtQCOZqm.mjs";
 import { t as getSharp } from "../lazy-sharp-BtT5x-qP.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-CDPRLalN.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-1_D3EZT9.mjs";
 import { a as ensureModel, o as isModelDownloaded, r as deleteModelFromDisk } from "../addon-utils-CgBCF-mE.mjs";
 import sharp from "sharp";
 import { spawn } from "node:child_process";
@@ -228,6 +228,94 @@ function pickBestRuntime(env, bestBackendHint) {
 	};
 }
 //#endregion
+//#region src/detection-pipeline/engine/pool-provisioning.ts
+/** The fields a {@link PoolProvisioningOverride} may carry, in table order. */
+var OVERRIDABLE_KEYS = [
+	"concurrency",
+	"numWorkers",
+	"batchMode",
+	"windowMs",
+	"maxBatchSize",
+	"numStreams",
+	"intraOpThreads"
+];
+/** Backends that are not a runtime of their own and run on onnxruntime. */
+var BACKEND_TO_RUNTIME = {
+	onnx: "onnx",
+	cpu: "onnx",
+	cuda: "onnx",
+	openvino: "openvino",
+	coreml: "coreml",
+	edgetpu: "edgetpu"
+};
+/**
+* The registry runtime a device-pool backend provisions from. Unknown backends
+* floor to `onnx` — the same floor `resolveDeviceEngine` applies to the model
+* format, so a pool never comes up unprovisioned.
+*/
+function runtimeIdForBackend(backend) {
+	return BACKEND_TO_RUNTIME[backend] ?? "onnx";
+}
+/**
+* Resolve the provisioning for a pool running `engine`, applying the precedence
+* documented at the top of this module. `engine.device` is not consulted today
+* (see the module doc) but is part of the signature so a bench-backed
+* per-device row lands here and nowhere else.
+*/
+function resolvePoolProvisioning(engine, override = {}) {
+	const runtime = runtimeIdForBackend(engine.backend);
+	const profile = tuningFor(runtime);
+	return {
+		runtime,
+		overriddenFields: OVERRIDABLE_KEYS.filter((k) => override[k] !== void 0),
+		concurrency: Math.max(1, override.concurrency ?? profile.concurrency),
+		numWorkers: Math.max(1, override.numWorkers ?? profile.numWorkers),
+		batchMode: override.batchMode ?? profile.batchMode,
+		windowMs: override.windowMs ?? profile.windowMs,
+		maxBatchSize: override.maxBatchSize ?? profile.maxBatchSize,
+		numStreams: override.numStreams ?? profile.numStreams,
+		intraOpThreads: override.intraOpThreads ?? profile.intraOpThreads
+	};
+}
+function positiveNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function batchMode(value) {
+	return value === "none" || value === "list" || value === "window" ? value : void 0;
+}
+/**
+* Read the operator override out of the detection addon's settings. Only a
+* NON-AUTO value counts: the sliders persist `0` and the select persists `''`
+* for "Auto (backend default)", and those must resolve to the runtime's
+* registry value, not to a literal 0 worker threads.
+*
+* The result is deliberately sparse — an empty object means "nothing
+* overridden", which is what lets a per-device pool provision from its own
+* runtime instead of inheriting the node's.
+*/
+function readOperatorOverride(settings) {
+	const override = {};
+	const concurrency = positiveNumber(settings.concurrency);
+	if (concurrency !== void 0) override.concurrency = concurrency;
+	const numWorkers = positiveNumber(settings.numWorkers);
+	if (numWorkers !== void 0) override.numWorkers = numWorkers;
+	const mode = batchMode(settings.batchMode);
+	if (mode !== void 0) override.batchMode = mode;
+	const windowMs = positiveNumber(settings.windowMs);
+	if (windowMs !== void 0) override.windowMs = windowMs;
+	const maxBatchSize = positiveNumber(settings.maxBatchSize);
+	if (maxBatchSize !== void 0) override.maxBatchSize = maxBatchSize;
+	const numStreams = positiveNumber(settings.numStreams);
+	if (numStreams !== void 0) override.numStreams = numStreams;
+	const intraOpThreads = positiveNumber(settings.intraOpThreads);
+	if (intraOpThreads !== void 0) override.intraOpThreads = intraOpThreads;
+	return override;
+}
+/** Two overrides carry the same fields with the same values. */
+function overridesEqual(a, b) {
+	return OVERRIDABLE_KEYS.every((k) => a[k] === b[k]);
+}
+//#endregion
 //#region src/detection-pipeline/engine-store-keys.ts
 /**
 * Node-id normalisation for the detection pipeline.
@@ -438,6 +526,122 @@ function resolveDefaultDetectionModel(backend, device, format, getStepDef = getS
 	return getDefaultModelForFormatFromDef(def, format);
 }
 //#endregion
+//#region src/detection-pipeline/device-override-mirror.ts
+/**
+* The per-device detection overrides, kept fresh OFF the frame path.
+*
+* ## The read this replaces
+*
+* `runPipeline` resolved a device's overrides by calling
+* `settings.readDeviceStore(deviceId)` on **every inference frame**. Measured
+* on the live hub 2026-08-25: `get detection-pipeline:addon-devices`, 1 143
+* calls a minute at 0.44 rows per call — the disk asked, nineteen times a
+* second, whether an operator has ever changed a threshold.
+*
+* ## Why this is not "a cache in the consumer" (D224)
+*
+* D224 forbids a SECOND authority over a fact that belongs to somebody else:
+* the failure it records is a consumer caching a value whose write path does
+* not run through that consumer, so an operator's own change is the one read
+* the cache gets wrong.
+*
+* This addon OWNS the row. `<addonId>:addon-devices` is detection-pipeline's
+* own store, and the only writers are this addon's `updateDeviceSettings` and
+* its `clearDeviceOverrides` — both of which call {@link invalidate}. A write
+* is therefore its own invalidation, exactly as D224 requires, and the window
+* below governs only the case nobody writes through this process.
+*
+* ## The window, declared
+*
+* {@link DEVICE_OVERRIDE_STALE_MS} is what an operator's change costs on a node
+* that did NOT serve the write — this addon runs per node, and a settings write
+* lands on one of them. Thirty seconds is the trade: it removes 99.9% of the
+* reads (one per device per window instead of one per frame) and it is short
+* enough that "I moved the threshold and nothing happened" is not a support
+* question. Ten minutes — {@link OPERATOR_WRITTEN_STALE_MS}, the constant for a
+* cap whose value only an operator changes — is right for a POLLED reader that
+* costs a camera round trip; this read costs one local SQLite `get`, and the
+* cheap read buys a short window.
+*
+* A stale entry is SERVED and revalidated behind the caller, never awaited: a
+* frame that waits for the settings store is a frame the pipeline dropped, and
+* the reader is by definition about to ask again.
+*/
+/**
+* How long a mirrored entry is served before a refresh is started behind the
+* next reader. See the module doc for why it is 30 s and not ten minutes.
+*/
+var DEVICE_OVERRIDE_STALE_MS = 3e4;
+/**
+* How long a FAILED refresh is not retried.
+*
+* A refresh that throws leaves `fetchedAt` where it was, so without a cooldown
+* every subsequent frame would start another one — a broken settings store
+* would be hammered at frame rate by the very mechanism built to stop that.
+*/
+var DEVICE_OVERRIDE_MISS_COOLDOWN_MS = 5e3;
+var DeviceOverrideMirror = class {
+	deps;
+	staleMs;
+	missCooldownMs;
+	entries = /* @__PURE__ */ new Map();
+	/** In-flight reads, so a burst of frames on a cold device costs ONE read and
+	*  not one per frame — the exact failure this class exists to remove. */
+	inFlight = /* @__PURE__ */ new Map();
+	now;
+	constructor(deps, staleMs = DEVICE_OVERRIDE_STALE_MS, missCooldownMs = DEVICE_OVERRIDE_MISS_COOLDOWN_MS) {
+		this.deps = deps;
+		this.staleMs = staleMs;
+		this.missCooldownMs = missCooldownMs;
+		this.now = deps.now ?? (() => Date.now());
+	}
+	/**
+	* The device's overrides.
+	*
+	* COLD awaits — the first frame on a camera has to get the real answer, and a
+	* default is exactly what "the operator lowered this threshold" looks like.
+	* WARM returns immediately, stale or not, and starts the refresh behind the
+	* caller.
+	*/
+	async resolve(deviceId) {
+		const entry = this.entries.get(deviceId);
+		if (entry === void 0) return this.load(deviceId);
+		if (this.now() - entry.fetchedAt >= this.staleMs) this.load(deviceId);
+		return entry.value;
+	}
+	/** Drop a device's entry. Called by every writer in this process, so an
+	*  operator's own change is never served from the mirror. */
+	invalidate(deviceId) {
+		this.entries.delete(deviceId);
+	}
+	invalidateAll() {
+		this.entries.clear();
+	}
+	async load(deviceId) {
+		const pending = this.inFlight.get(deviceId);
+		if (pending !== void 0) return pending;
+		const run = this.deps.read(deviceId).then((value) => {
+			this.entries.set(deviceId, {
+				value,
+				fetchedAt: this.now()
+			});
+			return value;
+		}).catch((err) => {
+			this.deps.onRefreshFailed?.(deviceId, err);
+			const existing = this.entries.get(deviceId);
+			if (existing !== void 0) {
+				existing.fetchedAt = this.now() - this.staleMs + this.missCooldownMs;
+				return existing.value;
+			}
+			return {};
+		}).finally(() => {
+			this.inFlight.delete(deviceId);
+		});
+		this.inFlight.set(deviceId, run);
+		return run;
+	}
+};
+//#endregion
 //#region src/detection-pipeline/engine/shared-inference-pool.ts
 /**
 * SharedInferencePool — TypeScript wrapper for inference_pool.py.
@@ -1980,94 +2184,6 @@ function deviceKeyOf(engine) {
 	return engine.device ? `${engine.backend}:${engine.device}` : engine.backend;
 }
 //#endregion
-//#region src/detection-pipeline/engine/pool-provisioning.ts
-/** The fields a {@link PoolProvisioningOverride} may carry, in table order. */
-var OVERRIDABLE_KEYS = [
-	"concurrency",
-	"numWorkers",
-	"batchMode",
-	"windowMs",
-	"maxBatchSize",
-	"numStreams",
-	"intraOpThreads"
-];
-/** Backends that are not a runtime of their own and run on onnxruntime. */
-var BACKEND_TO_RUNTIME = {
-	onnx: "onnx",
-	cpu: "onnx",
-	cuda: "onnx",
-	openvino: "openvino",
-	coreml: "coreml",
-	edgetpu: "edgetpu"
-};
-/**
-* The registry runtime a device-pool backend provisions from. Unknown backends
-* floor to `onnx` — the same floor `resolveDeviceEngine` applies to the model
-* format, so a pool never comes up unprovisioned.
-*/
-function runtimeIdForBackend(backend) {
-	return BACKEND_TO_RUNTIME[backend] ?? "onnx";
-}
-/**
-* Resolve the provisioning for a pool running `engine`, applying the precedence
-* documented at the top of this module. `engine.device` is not consulted today
-* (see the module doc) but is part of the signature so a bench-backed
-* per-device row lands here and nowhere else.
-*/
-function resolvePoolProvisioning(engine, override = {}) {
-	const runtime = runtimeIdForBackend(engine.backend);
-	const profile = tuningFor(runtime);
-	return {
-		runtime,
-		overriddenFields: OVERRIDABLE_KEYS.filter((k) => override[k] !== void 0),
-		concurrency: Math.max(1, override.concurrency ?? profile.concurrency),
-		numWorkers: Math.max(1, override.numWorkers ?? profile.numWorkers),
-		batchMode: override.batchMode ?? profile.batchMode,
-		windowMs: override.windowMs ?? profile.windowMs,
-		maxBatchSize: override.maxBatchSize ?? profile.maxBatchSize,
-		numStreams: override.numStreams ?? profile.numStreams,
-		intraOpThreads: override.intraOpThreads ?? profile.intraOpThreads
-	};
-}
-function positiveNumber(value) {
-	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
-}
-function batchMode(value) {
-	return value === "none" || value === "list" || value === "window" ? value : void 0;
-}
-/**
-* Read the operator override out of the detection addon's settings. Only a
-* NON-AUTO value counts: the sliders persist `0` and the select persists `''`
-* for "Auto (backend default)", and those must resolve to the runtime's
-* registry value, not to a literal 0 worker threads.
-*
-* The result is deliberately sparse — an empty object means "nothing
-* overridden", which is what lets a per-device pool provision from its own
-* runtime instead of inheriting the node's.
-*/
-function readOperatorOverride(settings) {
-	const override = {};
-	const concurrency = positiveNumber(settings.concurrency);
-	if (concurrency !== void 0) override.concurrency = concurrency;
-	const numWorkers = positiveNumber(settings.numWorkers);
-	if (numWorkers !== void 0) override.numWorkers = numWorkers;
-	const mode = batchMode(settings.batchMode);
-	if (mode !== void 0) override.batchMode = mode;
-	const windowMs = positiveNumber(settings.windowMs);
-	if (windowMs !== void 0) override.windowMs = windowMs;
-	const maxBatchSize = positiveNumber(settings.maxBatchSize);
-	if (maxBatchSize !== void 0) override.maxBatchSize = maxBatchSize;
-	const numStreams = positiveNumber(settings.numStreams);
-	if (numStreams !== void 0) override.numStreams = numStreams;
-	const intraOpThreads = positiveNumber(settings.intraOpThreads);
-	if (intraOpThreads !== void 0) override.intraOpThreads = intraOpThreads;
-	return override;
-}
-/** Two overrides carry the same fields with the same values. */
-function overridesEqual(a, b) {
-	return OVERRIDABLE_KEYS.every((k) => a[k] === b[k]);
-}
-//#endregion
 //#region src/detection-pipeline/engine/engine-factory.ts
 var BACKEND_TO_POOL_RUNTIME = {
 	coreml: "coreml",
@@ -6220,6 +6336,14 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	readDeviceStore;
 	/** Delete all per-device settings for a device (used by `clearDeviceOverrides`). */
 	clearDeviceStore;
+	/**
+	* The per-device overrides the FRAME path reads, kept fresh off that path.
+	*
+	* Public so the addon class can drop a device on its own
+	* `updateDeviceSettings` — the write and the mirror have to be the same
+	* process's, or the mirror becomes the second authority D224 forbids.
+	*/
+	deviceOverrides;
 	constructor(settings, modelsDir, logger, eventBus = null, detectionConfigSchemaSource = null, executorOptions = {}) {
 		this.modelsDir = modelsDir;
 		this.eventBus = eventBus;
@@ -6231,6 +6355,13 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.readDeviceStore = settings.readDeviceStore ?? (async () => ({}));
 		const clearDeviceStore = settings.clearDeviceStore;
 		this.clearDeviceStore = clearDeviceStore ? (deviceId) => clearDeviceStore.call(settings, deviceId) : async () => void 0;
+		this.deviceOverrides = new DeviceOverrideMirror({
+			read: (deviceId) => this.readDeviceStore(deviceId),
+			onRefreshFailed: (deviceId, err) => this.log.warn("per-device detection overrides refresh failed — serving the last value", {
+				tags: { deviceId },
+				meta: { error: errMsg(err) }
+			})
+		});
 		this.currentEngine = ONNX_FLOOR;
 		this.log.info("Engine pick pending (placeholder until probe / persisted selection)", { meta: {
 			runtime: this.currentEngine.runtime,
@@ -7415,7 +7546,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			setupMs = performance.now() - wallT0 - decodeMs;
 			const isRuntime = Boolean(runtimeFrame || runtimeFrameRef);
 			const effectiveDeviceId = input.deviceId ?? 0;
-			const deviceOverrides = effectiveDeviceId > 0 ? await this.readDeviceStore(effectiveDeviceId) : {};
+			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;
@@ -8484,7 +8615,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		if (!api) return 0;
 		let devices = [];
 		try {
-			devices = await api.deviceManager.listAll.query({});
+			devices = await api.deviceManager.listAll.query({ projection: "slim" });
 		} catch (err) {
 			this.log.warn("clearDeviceOverrides: device enumeration failed — skipping per-device clear", { meta: { error: errMsg(err) } });
 			return 0;
@@ -8492,6 +8623,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		let cleared = 0;
 		for (const device of devices) try {
 			await this.clearDeviceStore(device.id);
+			this.deviceOverrides.invalidate(device.id);
 			cleared++;
 		} catch (err) {
 			this.log.warn("clearDeviceOverrides: failed to clear per-device overrides for device", {
@@ -9049,6 +9181,20 @@ function isProfileSliderKey(key) {
 }
 var DetectionPipelineAddon = class extends BaseAddon {
 	provider = null;
+	/**
+	* An operator's own write drops the mirror the frame path reads.
+	*
+	* This override is the half of `device-override-mirror.ts` that keeps it from
+	* being the second authority D224 forbids: `BaseAddon.updateDeviceSettings`
+	* writes THIS addon's `<addonId>:addon-devices` row, so the write and the
+	* mirror are in one process and the write invalidates. Without it the
+	* operator's own change would be the one read the mirror got wrong, which is
+	* the exact failure D224 records.
+	*/
+	async updateDeviceSettings(deviceId, patch) {
+		await super.updateDeviceSettings(deviceId, patch);
+		this.provider?.deviceOverrides.invalidate(deviceId);
+	}
 	/** Last non-null probed hardware PER NODE — reused when the probe transiently
 	*  returns null so offered backends / device lists don't collapse. Keyed by
 	*  node because the hub addon probes other nodes when serving their config.