@camstack/addon-pipeline 1.1.45 → 1.1.46

package/dist/audio-analyzer/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-CjxqjgEv.js");
+const require_dist = require("../dist-C3CWl8fV.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-BLXzxpRB.js");
 let node_fs = require("node:fs");

package/dist/audio-analyzer/index.mjs

@@ -1,5 +1,5 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { C as mapAudioLabelToMacro, I as errMsg, L as BaseAddon, U as hydrateSchema, h as audioAnalyzerCapability, l as HF_BASE_URL, m as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, o as DEFAULT_AUDIO_ANALYZER_CONFIG } from "../dist-D04numuO.mjs";
+import { C as mapAudioLabelToMacro, I as errMsg, L as BaseAddon, U as hydrateSchema, h as audioAnalyzerCapability, l as HF_BASE_URL, m as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, o as DEFAULT_AUDIO_ANALYZER_CONFIG } from "../dist-Bglbcd7H.mjs";
 import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
 import { r as downloadFile } from "../model-download-service-C-IHWnXx-BPy6aoAx.mjs";
 import * as fs from "node:fs";

package/dist/detection-pipeline/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-CjxqjgEv.js");
+const require_dist = require("../dist-C3CWl8fV.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-BLXzxpRB.js");
 let _camstack_shm_ring = require("@camstack/shm-ring");
@@ -4552,6 +4552,12 @@ function collectUnknownAddonIssues(steps, getStepDef = getStepDefinition) {
 * `PipelineDefaultStep[]` (the catalog-enriched shape the executor consumes),
 * resolving each step's model for `format` via `resolveModelForFormat`.
 *
+* "Auto" model selection (ABSENT `modelId`) is hardware-aware for the
+* object-detection step when `engine` is provided: the default is resolved
+* via `resolveDefaultDetectionModel(engine.backend, engine.device, format)`.
+* A PINNED `modelId` is kept verbatim (subject to the usual format-build
+* substitution); every other step keeps its flat per-format default.
+*
 * Pure and side-effect-free — never throws. This is the seam behind the
 * LIVE per-camera dispatch path (`DetectionPipelineProvider.
 * inputStepsToPipelineSteps`), which runs once per decoded frame (up to
@@ -4562,7 +4568,7 @@ function collectUnknownAddonIssues(steps, getStepDef = getStepDefinition) {
 * `diagnostics.substitutions` instead of happening silently. The caller
 * (the provider) owns logging + dedup for both.
 */
-function resolveInputSteps(steps, format) {
+function resolveInputSteps(steps, format, engine) {
 	const resolvedSteps = [];
 	const unknownAddonIds = [];
 	const substitutions = [];
@@ -4575,14 +4581,14 @@ function resolveInputSteps(steps, format) {
 			continue;
 		}
 		const chosenModelId = s.modelId ?? null;
-		const runningModelId = resolveModelForFormat(s.addonId, chosenModelId, format);
+		const runningModelId = chosenModelId === null && engine !== void 0 && s.addonId === "object-detection" ? resolveDefaultDetectionModel(engine.backend, engine.device, format) : resolveModelForFormat(s.addonId, chosenModelId, format);
 		if (chosenModelId !== null && runningModelId !== chosenModelId) substitutions.push({
 			addonId: s.addonId,
 			chosen: chosenModelId,
 			running: runningModelId,
 			format
 		});
-		const childResult = s.children ? resolveInputSteps(s.children, format) : null;
+		const childResult = s.children ? resolveInputSteps(s.children, format, engine) : null;
 		if (childResult) {
 			unknownAddonIds.push(...childResult.diagnostics.unknownAddonIds);
 			substitutions.push(...childResult.diagnostics.substitutions);
@@ -4615,8 +4621,6 @@ function resolveInputSteps(steps, format) {
 * This is the main provider that consumers (DetectionWiring, Benchmark, tRPC)
 * interact with. It manages the engine factory, pipeline executor, and config persistence.
 */
-var KEY_STEPS = "pipelineSteps";
-var KEY_ENGINE = "pipelineEngine";
 var KEY_TEMPLATES = "pipelineTemplates";
 function pythonModuleForBackend(backend) {
 	switch (backend) {
@@ -4699,14 +4703,6 @@ function readStored(raw, guard) {
 		return null;
 	}
 }
-function isEngineChoice(v) {
-	if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
-	const rec = { ...v };
-	return typeof rec["runtime"] === "string" && typeof rec["backend"] === "string" && typeof rec["format"] === "string";
-}
-function isPipelineStepArray(v) {
-	return Array.isArray(v);
-}
 /**
 * Phase 7 (settings redesign) template migration.
 *
@@ -4923,13 +4919,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	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
-	* surface via the future `isReady()` helper.
-	*/
-	ready = false;
-	/**
 	* Lazy detection-engine runtime provisioner (Phase 2). Owns the
 	* idle → installing → verifying → ready state machine for the
 	* currently-selected engine and is the SOLE authority the inference
@@ -4981,7 +4970,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	writeStore;
 	/** Read per-device settings. */
 	readDeviceStore;
-	/** Delete all per-device settings for a device (used by `resetToDefault`). */
+	/** Delete all per-device settings for a device (used by `clearDeviceOverrides`). */
 	clearDeviceStore;
 	constructor(settings, modelsDir, logger, eventBus = null, detectionConfigSchemaSource = null, executorOptions = {}) {
 		this.modelsDir = modelsDir;
@@ -5056,9 +5045,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}
 		await this.ensureEngineFactory();
 	}
-	/** True when the engine + model pool are fully warmed and inference-ready. */
+	/** True when the engine provisioning machine reports inference-ready. */
 	isReady() {
-		return this.ready;
+		return this.getEngineProvisioning().state === "ready";
 	}
 	/** Store the addon context. ctx.api is a lazy getter resolved at call time. */
 	async setApi(addonCtx) {
@@ -5504,46 +5493,25 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	getActiveModelSubstitutions() {
 		return [...this.modelSubstitutions.values()];
 	}
+	/**
+	* PURE node-default step tree — computed on demand, never persisted.
+	*
+	* The object-detection default is hardware-aware (this node's resolved
+	* backend + device via `resolveDefaultDetectionModel`); every other step
+	* keeps its flat per-format default. The result is cached in
+	* `currentSteps` only as a memo — the cache is dropped whenever the
+	* engine (hence model format) changes, so a re-read always reflects the
+	* live engine. Nothing in the live per-camera dispatch path reads this:
+	* it exists as the benchmark fallback (empty input steps), the Gate-A
+	* config-issue probe, and the "effective post-reset model" probe.
+	*/
 	async getGlobalSteps() {
 		if (this.currentSteps) return this.currentSteps;
-		const raw = (await this.readStore())[KEY_STEPS];
-		if (!raw) {
-			const detectionModelId = resolveDefaultDetectionModel(this.currentEngine.backend, this.currentEngine.device ?? null, this.currentEngine.format);
-			const defaults = buildDefaultStepTree(this.currentEngine.format, detectionModelId);
-			if (defaults.length === 0) return null;
-			this.currentSteps = this.resolveStepModels(defaults);
-			this.writeStore({ [KEY_STEPS]: JSON.stringify(defaults) });
-			this.log.info("Bootstrapped default pipeline — object-detection + face + plate recognition enabled by default", { meta: { rootSteps: defaults.length } });
-			return this.currentSteps;
-		}
-		try {
-			let steps = readStored(raw, isPipelineStepArray) ?? [];
-			if (steps.length === 0) return null;
-			if (!steps.some((s) => s.slot === "audio-classifier")) {
-				const format = this.currentEngine.format;
-				const audioDef = getStepDefinition("audio-classifier");
-				if (audioDef.models.some((m) => m.formats[format])) {
-					const modelId = getDefaultModelForFormat("audio-classifier", format);
-					const audioStep = {
-						addonId: audioDef.id,
-						addonName: audioDef.name,
-						slot: audioDef.slot,
-						inputClasses: audioDef.inputClasses ?? [],
-						outputClasses: audioDef.outputClasses,
-						enabled: true,
-						modelId,
-						children: []
-					};
-					steps = [...steps, audioStep];
-					this.writeStore({ [KEY_STEPS]: JSON.stringify(steps) });
-					this.log.info("Migration: added audio-classifier step to persisted pipeline config");
-				}
-			}
-			this.currentSteps = this.resolveStepModels(steps);
-			return this.currentSteps;
-		} catch {
-			throw new Error(`Failed to parse persisted pipeline steps: corrupt data in key "${KEY_STEPS}"`);
-		}
+		const detectionModelId = resolveDefaultDetectionModel(this.currentEngine.backend, this.currentEngine.device ?? null, this.currentEngine.format);
+		const defaults = buildDefaultStepTree(this.currentEngine.format, detectionModelId);
+		if (defaults.length === 0) return null;
+		this.currentSteps = this.resolveStepModels(defaults);
+		return this.currentSteps;
 	}
 	async getGlobalPipelineConfig() {
 		if (!this.currentSteps) return null;
@@ -5998,7 +5966,14 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		}
 		decodeMs = performance.now() - decodeT0;
 		const resolveFormat = input.engine?.format ?? this.currentEngine.format;
-		const benchmarkSteps = this.inputStepsToPipelineSteps(input.steps, resolveFormat);
+		const resolveEngine = input.engine ? {
+			backend: input.engine.backend,
+			device: input.engine.device ?? null
+		} : {
+			backend: this.currentEngine.backend,
+			device: this.currentEngine.device ?? null
+		};
+		const benchmarkSteps = this.inputStepsToPipelineSteps(input.steps, resolveFormat, resolveEngine);
 		const stepsSignature = JSON.stringify(benchmarkSteps.map((s) => ({
 			id: s.addonId,
 			settings: s.settings ?? {}
@@ -6311,8 +6286,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* would resolve models against the node's persisted format instead of the
 	* format actually being benchmarked.
 	*/
-	inputStepsToPipelineSteps(steps, format = this.currentEngine.format) {
-		const { steps: resolvedSteps, diagnostics } = resolveInputSteps(steps, format);
+	inputStepsToPipelineSteps(steps, format = this.currentEngine.format, engine = {
+		backend: this.currentEngine.backend,
+		device: this.currentEngine.device ?? null
+	}) {
+		const { steps: resolvedSteps, diagnostics } = resolveInputSteps(steps, format, engine);
 		for (const addonId of diagnostics.unknownAddonIds) this.logLiveDispatchIssueOnce(`unknown:${addonId}`, () => this.log.warn("Live pipeline step references an unknown addon — dropping step", { meta: { addonId } }));
 		for (const sub of diagnostics.substitutions) this.logLiveDispatchIssueOnce(`${sub.addonId}|${sub.chosen}|${sub.running}|${sub.format}`, () => this.log.info("Live pipeline step model substituted for engine format (node-local)", { meta: {
 			step: sub.addonId,
@@ -6430,67 +6408,6 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			height: 640
 		};
 	}
-	async detect(input) {
-		const { addonId, frame } = input;
-		const { executor, tree } = await this.ensureExecutor();
-		const data = Buffer.from(frame.data);
-		let rootInput;
-		let jpegProvider;
-		if (frame.format === "jpeg") {
-			rootInput = {
-				kind: "jpeg",
-				data
-			};
-			jpegProvider = async () => data;
-		} else if (frame.format === "rgb" || frame.format === "bgr" || frame.format === "gray") {
-			const channels = frame.format === "gray" ? 1 : 3;
-			const sharp$6 = (await import("sharp")).default;
-			const jpeg = await sharp$6(data, { raw: {
-				width: frame.width,
-				height: frame.height,
-				channels
-			} }).jpeg({
-				quality: 85,
-				mozjpeg: false
-			}).toBuffer();
-			rootInput = {
-				kind: "jpeg",
-				data: jpeg
-			};
-			jpegProvider = async () => jpeg;
-		} else {
-			const sharp$7 = (await import("sharp")).default;
-			const encoded = await sharp$7(data, { raw: {
-				width: frame.width,
-				height: frame.height,
-				channels: 3
-			} }).jpeg({
-				quality: 80,
-				mozjpeg: false
-			}).toBuffer();
-			rootInput = {
-				kind: "jpeg",
-				data: encoded
-			};
-			jpegProvider = async () => encoded;
-		}
-		const { result } = await executor.run(tree, rootInput, jpegProvider, frame.width, frame.height, 0);
-		return {
-			detections: result.detections.filter((d) => d.kind === "first-level").map((d) => ({
-				class: d.macroClass,
-				originalClass: d.debug?.originalClass ?? d.macroClass,
-				score: d.score,
-				bbox: {
-					x: d.bbox.x,
-					y: d.bbox.y,
-					w: d.bbox.width,
-					h: d.bbox.height
-				}
-			})),
-			inferenceMs: result.debug?.totalInferenceMs ?? 0,
-			modelId: addonId
-		};
-	}
 	/**
 	* Batched run — dispatches N raw frames against the same loaded
 	* single-step model in one IPC round-trip via
@@ -6533,7 +6450,14 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async runPipelineBatchImpl(input) {
 		if (input.frames.length === 0) return { results: [] };
 		const resolveFormat = input.engine?.format ?? this.currentEngine.format;
-		const benchmarkSteps = this.inputStepsToPipelineSteps(input.steps, resolveFormat);
+		const resolveEngine = input.engine ? {
+			backend: input.engine.backend,
+			device: input.engine.device ?? null
+		} : {
+			backend: this.currentEngine.backend,
+			device: this.currentEngine.device ?? null
+		};
+		const benchmarkSteps = this.inputStepsToPipelineSteps(input.steps, resolveFormat, resolveEngine);
 		const enabledSteps = flattenEnabledVideoSteps(benchmarkSteps);
 		if (enabledSteps.length === 0) throw new Error("runPipelineBatch: no enabled steps");
 		const rootStep = enabledSteps[0];
@@ -6825,71 +6749,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		});
 		await this.engineFactory.initialize([]);
 	}
-	async ensureExecutor() {
-		if (this.initPromise) await this.initPromise;
-		if (!this.engineFactory) {
-			await this.assertEngineReady();
-			this.initPromise = this.doInitialize();
-			try {
-				await this.initPromise;
-			} finally {
-				this.initPromise = null;
-			}
-		}
-		if (!this.currentSteps) throw new Error("No pipeline steps configured");
-		const tree = buildExecutableTree(this.currentSteps, (stepId) => this.engineFactory.getEngine(stepId));
-		return {
-			executor: this.executor,
-			tree
-		};
-	}
-	/** Actual initialization — download models, create engine, load pool. Called once. */
-	async doInitialize() {
-		const steps = await this.getGlobalSteps();
-		if (!steps) throw new Error("No pipeline steps configured. Use setGlobalSteps() first.");
-		this.log.info("Pipeline initializing — frames will be dropped until ready");
-		const format = this.currentEngine.format;
-		const downloads = [];
-		for (const step of flattenSteps(steps)) {
-			const modelEntry = await this.resolveModelEntry(step.addonId, step.modelId);
-			if (!modelEntry) {
-				this.log.warn("Model not found in step catalog — skipping download", { meta: {
-					modelId: step.modelId,
-					step: step.addonId
-				} });
-				continue;
-			}
-			if (!require_model_download_service_C_IHWnXx.isModelDownloaded(this.modelsDir, modelEntry, format)) this.log.info("Downloading model", { meta: {
-				modelId: step.modelId,
-				format
-			} });
-			downloads.push(require_model_download_service_C_IHWnXx.ensureModel(this.modelsDir, modelEntry, format).then(() => {}));
-		}
-		await Promise.all(downloads);
-		await this.ensureBackendDeps(this.currentEngine);
-		this.engineFactory = new EngineFactory({
-			engine: this.currentEngine,
-			modelsDir: this.modelsDir,
-			logger: this.log.child("engine"),
-			pythonPath: this.executorOptions.pythonPath ?? "",
-			concurrency: this.executorOptions.concurrency,
-			tuning: this.executorOptions.tuning,
-			numWorkers: this.executorOptions.numWorkers
-		});
-		await this.engineFactory.initialize(steps);
-		this.currentSteps = steps;
-		const runtimeStr = `${this.currentEngine.runtime}+${this.currentEngine.backend}`;
-		this.executor = new PipelineExecutor({
-			engineRuntime: runtimeStr,
-			logger: this.log
-		});
-		this.ready = true;
-		this.log.info("Pipeline ready — accepting frames");
-	}
 	/**
 	* Phase 2b — resolve the engine from the addon's new schema-backed
-	* fields (`engineRuntime`, `engineBackend`, `engineDevice`). Fallback
-	* to the legacy `KEY_ENGINE` JSON blob for pre-migration stores.
+	* fields (`engineRuntime`, `engineBackend`, `engineDevice`). The legacy
+	* `pipelineEngine` JSON-blob fallback was removed with the executor seed
+	* (any store predating the per-node cascade simply re-runs auto-pick).
 	*
 	* The `'auto'` sentinel is treated as NO override (returns null) so the
 	* caller re-resolves LIVE via `resolveAutoEngine()` — `'auto'` is the
@@ -6932,8 +6796,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				...device ? { device } : {}
 			};
 		}
-		const raw = store[KEY_ENGINE];
-		return readStored(raw, isEngineChoice);
+		return null;
 	}
 	/**
 	* Re-run the platform probe for the inference engine and persist the
@@ -6983,48 +6846,29 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		return { success: true };
 	}
 	/**
-	* Reset THIS node's detection-pipeline to its factory defaults, forcing
-	* regeneration of the hardware-aware default object-detection model.
+	* Clear THIS node's executor-side PER-DEVICE settings stores — the
+	* per-camera step overrides the object-detection root reads via
+	* `applyDeviceOverridesToTree`.
 	*
 	* Node-routed (the cap's default `nodeIdMode: 'routing'`): the generated
 	* cap-router strips `nodeId` and dispatches to the target node, so this
-	* method runs ON the node being reset and takes no argument.
+	* method runs ON the node being cleared and takes no argument.
 	*
-	* Clears three things:
-	*   1. the persisted GLOBAL pipeline seed (`KEY_STEPS`) — nulled in the
-	*      store AND the in-memory `currentSteps` cache, so the subsequent
-	*      `getGlobalSteps()` re-seeds the hardware-aware default tree fresh
-	*      (`resolveDefaultDetectionModel` against this node's live engine)
-	*      rather than returning the stale cached blob.
-	*   2. the LEGACY engine blob (`KEY_ENGINE`). The per-node engine cascade
-	*      (`engineBackend@<node>` / `engineDevice@<node>`) is intentionally
-	*      left intact — the operator's engine selection is preserved and the
-	*      default is regenerated against it.
-	*   3. every device's PER-CAMERA step overrides (the per-device store the
-	*      object-detection root reads via `applyDeviceOverridesToTree`).
+	* This is the slimmed executor leg of the orchestrator's
+	* `resetNodePipelineDefaults` flow. The legacy `resetToDefault` — which
+	* also reset a persisted GLOBAL step-tree seed nothing in the live
+	* per-camera path read — was removed together with that seed
+	* (`getGlobalSteps` is pure now, so there is nothing node-global left to
+	* reset here).
 	*
-	* Idempotent: a second call re-seeds the identical default and clears
-	* already-empty per-device stores harmlessly. Returns the regenerated
-	* object-detection model id (null when the default tree has no detector
-	* for this node's format).
+	* Idempotent: clearing already-empty per-device stores is a no-op.
 	*/
-	async resetToDefault() {
-		await this.writeStore({
-			[KEY_STEPS]: null,
-			[KEY_ENGINE]: null
-		});
-		this.currentSteps = null;
+	async clearDeviceOverrides() {
 		const clearedDevices = await this.clearAllDeviceOverrides();
-		const regeneratedModelId = ((await this.getGlobalSteps())?.find((s) => s.slot === "detector") ?? null)?.modelId ?? null;
-		this.log.info("pipeline reset to default", { meta: {
-			clearedGlobalSteps: true,
-			clearedEngineBlob: true,
-			clearedDeviceOverrides: clearedDevices,
-			regeneratedModelId
-		} });
+		this.log.info("executor per-device overrides cleared", { meta: { clearedDevices } });
 		return {
 			success: true,
-			regeneratedModelId
+			clearedDevices
 		};
 	}
 	/**
@@ -7034,7 +6878,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* enumerated via the device-manager and cleared one by one
 	* (`clearDeviceStore` is idempotent — a device with no overrides is a
 	* no-op). Never throws: a device-manager outage degrades to "cleared
-	* nothing" so the global reset still completes.
+	* nothing" so the reset flow still completes.
 	*/
 	async clearAllDeviceOverrides() {
 		const api = this.addonCtx?.api;
@@ -7043,7 +6887,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		try {
 			devices = await api.deviceManager.listAll.query({});
 		} catch (err) {
-			this.log.warn("resetToDefault: device enumeration failed — skipping per-device clear", { meta: { error: require_dist.errMsg(err) } });
+			this.log.warn("clearDeviceOverrides: device enumeration failed — skipping per-device clear", { meta: { error: require_dist.errMsg(err) } });
 			return 0;
 		}
 		let cleared = 0;
@@ -7051,10 +6895,13 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			await this.clearDeviceStore(device.id);
 			cleared++;
 		} catch (err) {
-			this.log.warn("resetToDefault: failed to clear per-device overrides for device", { meta: {
-				deviceId: device.id,
-				error: require_dist.errMsg(err)
-			} });
+			this.log.warn("clearDeviceOverrides: failed to clear per-device overrides for device", {
+				tags: { deviceId: device.id },
+				meta: {
+					deviceId: device.id,
+					error: require_dist.errMsg(err)
+				}
+			});
 		}
 		return cleared;
 	}