@camstack/addon-pipeline 0.2.2 → 1.0.1

package/dist/detection-pipeline/index.js

@@ -1963,215 +1963,6 @@ function getDefaultModelForFormat(stepId, format) {
 	})[0].id;
 }
 //#endregion
-//#region src/detection-pipeline/engine/node-engine-manager.ts
-var NodeEngineManager = class {
-	backend;
-	resolveModelPath;
-	createEngine;
-	engines = /* @__PURE__ */ new Map();
-	log;
-	constructor(backend, resolveModelPath, createEngine, logger) {
-		this.backend = backend;
-		this.resolveModelPath = resolveModelPath;
-		this.createEngine = createEngine;
-		this.log = logger;
-	}
-	/**
-	* Apply a new pipeline configuration.
-	* Loads/unloads engines for steps that changed.
-	*/
-	async applyConfig(newSteps) {
-		const enabledSteps = flattenEnabledVideoSteps(newSteps);
-		const desiredMap = /* @__PURE__ */ new Map();
-		for (const step of enabledSteps) desiredMap.set(step.addonId, step);
-		for (const [stepId, loaded] of this.engines) if (!desiredMap.has(stepId)) {
-			this.log.info("Unloading ONNX engine for step", { meta: { step: stepId } });
-			await loaded.engine.dispose();
-			this.engines.delete(stepId);
-		}
-		for (const [stepId, step] of desiredMap) {
-			const existing = this.engines.get(stepId);
-			if (existing && existing.modelId === step.modelId) continue;
-			if (existing) {
-				this.log.info("Replacing ONNX engine for step", { meta: {
-					step: stepId,
-					fromModelId: existing.modelId,
-					toModelId: step.modelId
-				} });
-				await existing.engine.dispose();
-			} else this.log.info("Loading ONNX engine for step", { meta: {
-				step: stepId,
-				modelId: step.modelId
-			} });
-			const modelEntry = getStepDefinition(stepId).models.find((m) => m.id === step.modelId);
-			if (!modelEntry) throw new Error(`Model "${step.modelId}" not found in step "${stepId}" catalog`);
-			const modelPath = this.resolveModelPath(stepId, step.modelId);
-			const meta = {
-				inputSize: modelEntry.inputSize,
-				inputNormalization: modelEntry.inputNormalization ?? "zero-one",
-				inputLayout: modelEntry.inputLayout ?? "nchw",
-				preprocessMode: modelEntry.preprocessMode ?? "letterbox"
-			};
-			const engine = await this.createEngine(modelPath, this.backend, meta, this.log.child(stepId));
-			this.engines.set(stepId, {
-				stepId,
-				modelId: step.modelId,
-				engine
-			});
-		}
-	}
-	/**
-	* Get an IInferenceEngine for a step.
-	* @throws if the step is not loaded.
-	*/
-	getEngine(stepId) {
-		const loaded = this.engines.get(stepId);
-		if (!loaded) throw new Error(`ONNX engine for step "${stepId}" is not loaded`);
-		return loaded.engine;
-	}
-	isLoaded(stepId) {
-		return this.engines.has(stepId);
-	}
-	isLoadedWithModel(stepId, modelId) {
-		const loaded = this.engines.get(stepId);
-		return loaded !== void 0 && loaded.modelId === modelId;
-	}
-	async loadAdditional(steps) {
-		const enabledSteps = flattenEnabledVideoSteps(steps);
-		for (const step of enabledSteps) {
-			const existing = this.engines.get(step.addonId);
-			if (existing && existing.modelId === step.modelId) continue;
-			if (existing) {
-				this.log.info("Replacing ONNX engine for step", { meta: {
-					step: step.addonId,
-					fromModelId: existing.modelId,
-					toModelId: step.modelId
-				} });
-				await existing.engine.dispose();
-			} else this.log.info("Loading additional ONNX engine for step", { meta: {
-				step: step.addonId,
-				modelId: step.modelId
-			} });
-			const modelEntry = getStepDefinition(step.addonId).models.find((m) => m.id === step.modelId);
-			if (!modelEntry) throw new Error(`Model "${step.modelId}" not found in step "${step.addonId}" catalog`);
-			const modelPath = this.resolveModelPath(step.addonId, step.modelId);
-			const meta = {
-				inputSize: modelEntry.inputSize,
-				inputNormalization: modelEntry.inputNormalization ?? "zero-one",
-				inputLayout: modelEntry.inputLayout ?? "nchw",
-				preprocessMode: modelEntry.preprocessMode ?? "letterbox"
-			};
-			const engine = await this.createEngine(modelPath, this.backend, meta, this.log.child(step.addonId));
-			this.engines.set(step.addonId, {
-				stepId: step.addonId,
-				modelId: step.modelId,
-				engine
-			});
-		}
-	}
-	listLoaded() {
-		return [...this.engines.values()].map((l) => ({
-			stepId: l.stepId,
-			modelId: l.modelId
-		}));
-	}
-	async disposeAll() {
-		for (const [, loaded] of this.engines) await loaded.engine.dispose();
-		this.engines.clear();
-	}
-};
-//#endregion
-//#region src/detection-pipeline/engine/model-shape-validator.ts
-/**
-* Runtime input-shape validator for ONNX models.
-*
-* Reads the actual graph input dimensions from a locally-downloaded
-* ONNX model and compares them against the catalog declaration. Used
-* by the engine factory at load time so a converter regression or a
-* stale catalog entry surfaces as a one-line warning rather than
-* silent incorrect inference (preprocess uses one size, the model
-* expects another → garbage detections).
-*
-* Only ONNX is validated here. CoreML and OpenVINO converters in our
-* pipeline derive shape from the same source ONNX, so a passing ONNX
-* check covers all three formats. If they ever diverge, extend with a
-* format-specific reader (Manifest.json for .mlpackage, root <input>
-* tag for OpenVINO XML).
-*/
-/**
-* Probe an ONNX file for its first input's shape. Returns null if the
-* file is missing or unparseable — callers should treat null as
-* "validation skipped" (not a mismatch).
-*
-* Implementation: uses `onnxruntime-node` to create a session and read
-* `inputMetadata`. The session is released immediately after probing.
-*/
-async function readOnnxInputShape(onnxPath) {
-	if (!node_fs.existsSync(onnxPath)) return null;
-	try {
-		const session = await (await import("onnxruntime-node")).InferenceSession.create(onnxPath);
-		const firstInputName = session.inputNames[0];
-		if (!firstInputName) return null;
-		const numeric = (session.inputMetadata?.[firstInputName]?.dimensions ?? []).map((d) => typeof d === "number" ? d : null);
-		let height = null;
-		let width = null;
-		if (numeric.length === 4) {
-			const candidates = numeric.map((v, i) => ({
-				v,
-				i
-			})).filter((e) => typeof e.v === "number" && e.v > 4).toSorted((a, b) => b.v - a.v);
-			if (candidates.length >= 2) {
-				const sorted = candidates.slice(0, 2).toSorted((a, b) => a.i - b.i);
-				height = sorted[0]?.v ?? null;
-				width = sorted[1]?.v ?? null;
-			}
-		}
-		if (typeof session.release === "function") await session.release();
-		return {
-			height,
-			width
-		};
-	} catch {
-		return null;
-	}
-}
-/**
-* Check the catalog `expected` size against the actual ONNX input shape.
-* Returns a ShapeMismatch when the actual shape is known and disagrees;
-* returns null when the file is missing, unparseable, or matches.
-*/
-async function validateOnnxInputShape(opts) {
-	const actual = await readOnnxInputShape(opts.modelPath);
-	if (!actual) return null;
-	const matchesH = actual.height === null || actual.height === opts.expected.height;
-	const matchesW = actual.width === null || actual.width === opts.expected.width;
-	if (matchesH && matchesW) return null;
-	return {
-		modelId: opts.modelId,
-		modelPath: opts.modelPath,
-		expected: opts.expected,
-		actual
-	};
-}
-/**
-* Convenience wrapper: validate, log on mismatch via the supplied
-* logger. Returns true when validation passed (or was skipped) so
-* callers can keep loading; mismatches do not throw — they warn.
-*/
-async function checkAndLogModelShape(opts, logger) {
-	const mismatch = await validateOnnxInputShape(opts);
-	if (!mismatch) return true;
-	logger.warn("Model input shape mismatch — catalog declaration disagrees with model file", { meta: {
-		modelId: mismatch.modelId,
-		expectedWidth: mismatch.expected.width,
-		expectedHeight: mismatch.expected.height,
-		actualWidth: mismatch.actual.width,
-		actualHeight: mismatch.actual.height,
-		modelPath: mismatch.modelPath
-	} });
-	return false;
-}
-//#endregion
 //#region src/detection-pipeline/engine/engine-factory.ts
 var BACKEND_TO_POOL_RUNTIME = {
 	coreml: "coreml",
@@ -2188,32 +1979,29 @@ var RUNTIME_TO_FORMAT = {
 var EngineFactory = class {
 	pool = null;
 	poolManager = null;
-	nodeManager = null;
 	log;
 	opts;
 	constructor(opts) {
 		this.opts = opts;
 		this.log = opts.logger;
 	}
-	/** Whether this factory uses a Python pool (vs Node.js ONNX). */
+	/** Detection always uses the Python pool. */
 	get usesPythonPool() {
-		return this.opts.engine.runtime === "python";
+		return true;
 	}
 	/**
 	* Initialize the engine layer and apply initial pipeline config.
 	*/
 	async initialize(steps) {
-		if (this.usesPythonPool) await this.initPythonPool(steps);
-		else await this.initNodeEngines(steps);
+		await this.initPythonPool(steps);
 	}
 	/**
 	* Apply a new pipeline config (hot swap).
 	* Only loads/unloads models that changed.
 	*/
 	async applyConfig(steps) {
-		if (this.poolManager) await this.poolManager.applyConfig(steps);
-		else if (this.nodeManager) await this.nodeManager.applyConfig(steps);
-		else throw new Error("EngineFactory not initialized");
+		if (!this.poolManager) throw new Error("EngineFactory not initialized");
+		await this.poolManager.applyConfig(steps);
 	}
 	/**
 	* Get an IInferenceEngine for a pipeline step. Without `modelId`,
@@ -2224,49 +2012,35 @@ var EngineFactory = class {
 	* @throws if step not loaded with the requested (or active) model.
 	*/
 	getEngine(stepId, modelId) {
-		if (this.poolManager) return this.poolManager.getHandle(stepId, modelId);
-		if (this.nodeManager) return this.nodeManager.getEngine(stepId);
-		throw new Error("EngineFactory not initialized");
+		if (!this.poolManager) throw new Error("EngineFactory not initialized");
+		return this.poolManager.getHandle(stepId, modelId);
 	}
 	/** Check if a step is loaded (any variant). */
 	isLoaded(stepId) {
-		if (this.poolManager) return this.poolManager.isLoaded(stepId);
-		if (this.nodeManager) return this.nodeManager.isLoaded(stepId);
-		return false;
+		return this.poolManager?.isLoaded(stepId) ?? false;
 	}
 	/** Check if a specific (stepId, modelId) variant is resident. */
 	isLoadedWithModel(stepId, modelId) {
-		if (this.poolManager) return this.poolManager.isLoadedWithModel(stepId, modelId);
-		if (this.nodeManager) return this.nodeManager.isLoadedWithModel(stepId, modelId);
-		return false;
+		return this.poolManager?.isLoadedWithModel(stepId, modelId) ?? false;
 	}
 	/**
-	* List every loaded (stepId, modelId) variant — the pool path
-	* surfaces each warm slot independently (including bench overrides);
-	* the Node path surfaces just the active model per step.
+	* List every loaded (stepId, modelId) variant — the pool surfaces each
+	* warm slot independently (including bench overrides).
 	*/
 	listLoaded() {
-		if (this.poolManager) return this.poolManager.getLoadedSteps().map((l) => ({
+		if (!this.poolManager) return [];
+		return this.poolManager.getLoadedSteps().map((l) => ({
 			stepId: l.stepId,
 			modelId: l.modelId,
 			active: l.active
 		}));
-		if (this.nodeManager) return this.nodeManager.listLoaded().map((l) => ({
-			...l,
-			active: true
-		}));
-		return [];
 	}
 	/** Native pid of the underlying Python pool, if any. */
 	getPoolPid() {
 		return this.pool?.getPid() ?? null;
 	}
 	/**
-	* Whether this factory exposes the batched fast path
-	* (`batchInferRaw`). Only the Python pool path supports it today —
-	* Node.js ONNX engines run one inference per call with their own
-	* thread pool inside InferenceSession, so batching at this layer
-	* would just queue serially.
+	* Whether this factory exposes the batched fast path (`batchInferRaw`).
 	*/
 	supportsBatch() {
 		return this.poolManager !== null;
@@ -2280,7 +2054,7 @@ var EngineFactory = class {
 	* in one IPC round-trip, amortising the per-call envelope overhead.
 	*/
 	async batchInferRaw(stepId, items, modelId) {
-		if (!this.poolManager) throw new Error("EngineFactory.batchInferRaw: pool path not available (Node ONNX factory)");
+		if (!this.poolManager) throw new Error("EngineFactory.batchInferRaw: pool not initialized");
 		const idx = this.poolManager.getPoolIndex(stepId, modelId);
 		if (idx === null) throw new Error(`EngineFactory.batchInferRaw: step "${stepId}"${modelId ? ` (model "${modelId}")` : ""} is not loaded`);
 		return this.poolManager.getPool().inferBatch(idx, items);
@@ -2302,7 +2076,6 @@ var EngineFactory = class {
 	/** Load additional models without unloading existing ones (for benchmark/test). */
 	async loadAdditional(steps) {
 		if (this.poolManager) await this.poolManager.loadAdditional(steps);
-		else if (this.nodeManager) await this.nodeManager.loadAdditional(steps);
 	}
 	/** Shut down all engines and the pool process. */
 	async dispose() {
@@ -2311,14 +2084,10 @@ var EngineFactory = class {
 			this.pool = null;
 			this.poolManager = null;
 		}
-		if (this.nodeManager) {
-			await this.nodeManager.disposeAll();
-			this.nodeManager = null;
-		}
 	}
 	async initPythonPool(steps) {
 		const pythonPath = this.opts.pythonPath;
-		if (!pythonPath) throw new Error("EngineFactory: pythonPath is required for runtime=\"python\" — the addon must call ctx.deps.ensurePython() and pass the result. The embedded portable Python download likely failed; check the addon logs for the download error.");
+		if (!pythonPath) throw new Error("EngineFactory: pythonPath is required — the addon must call ctx.deps.ensurePython() and pass the result. The embedded portable Python download likely failed; check the addon logs for the download error.");
 		const poolRuntime = BACKEND_TO_POOL_RUNTIME[this.opts.engine.backend];
 		if (!poolRuntime) throw new Error(`No pool runtime mapping for backend "${this.opts.engine.backend}"`);
 		const concurrency = this.opts.concurrency ?? {
@@ -2369,16 +2138,6 @@ var EngineFactory = class {
 		const filename = urlParts[urlParts.length - 1] ?? `${modelId}.${format}`;
 		const modelPath = `${this.opts.modelsDir}/${filename}`;
 		const inputSize = Math.max(modelEntry.inputSize.width, modelEntry.inputSize.height);
-		const onnxEntry = modelEntry.formats.onnx;
-		if (onnxEntry) {
-			const onnxUrlParts = onnxEntry.url.split("/");
-			const onnxFilename = onnxUrlParts[onnxUrlParts.length - 1] ?? `${modelId}.onnx`;
-			checkAndLogModelShape({
-				modelId,
-				modelPath: `${this.opts.modelsDir}/${onnxFilename}`,
-				expected: modelEntry.inputSize
-			}, this.log);
-		}
 		let labels = def.labels;
 		if (!labels && modelEntry.extraFiles) {
 			const labelsFile = modelEntry.extraFiles.find((f) => f.filename.endsWith("-labels.json"));
@@ -2405,20 +2164,6 @@ var EngineFactory = class {
 			device: this.opts.engine.device ?? (poolRuntime === "coreml" ? "all" : void 0)
 		};
 	}
-	async initNodeEngines(steps) {
-		if (!this.opts.createNodeEngine) throw new Error("createNodeEngine function required for nodejs+onnx backend");
-		this.nodeManager = new NodeEngineManager(this.opts.engine.backend, (stepId, modelId) => this.resolveOnnxModelPath(stepId, modelId), this.opts.createNodeEngine, this.log.child("onnx-mgr"));
-		await this.nodeManager.applyConfig(steps);
-	}
-	resolveOnnxModelPath(stepId, modelId) {
-		const modelEntry = getStepDefinition(stepId).models.find((m) => m.id === modelId);
-		if (!modelEntry) throw new Error(`Model "${modelId}" not found in step "${stepId}" catalog`);
-		const onnxFormat = modelEntry.formats["onnx"];
-		if (!onnxFormat) throw new Error(`Model "${modelId}" has no ONNX format`);
-		const urlParts = onnxFormat.url.split("/");
-		const filename = urlParts[urlParts.length - 1] ?? `${modelId}.onnx`;
-		return `${this.opts.modelsDir}/${filename}`;
-	}
 };
 //#endregion
 //#region src/detection-pipeline/postprocess/dispatch.ts
@@ -4129,9 +3874,10 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			};
 		} catch {}
 		return {
-			runtime: "node",
-			backend: "cpu",
-			format: "onnx"
+			runtime: "python",
+			backend: "onnx",
+			format: "onnx",
+			device: "cpu"
 		};
 	}
 	/** Store the addon context. ctx.api is a lazy getter resolved at call time. */
@@ -4152,18 +3898,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		return this.getAvailableEnginesWithDevices().map((e) => e.engine);
 	}
 	getAvailableEnginesWithDevices() {
-		const engines = [{
-			engine: {
-				runtime: "node",
-				backend: "cpu",
-				format: "onnx"
-			},
-			devices: [{
-				id: "cpu",
-				label: "CPU"
-			}],
-			defaultDevice: "cpu"
-		}];
+		const engines = [];
 		if (process.platform === "darwin") engines.push({
 			engine: {
 				runtime: "python",
@@ -4216,11 +3951,11 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 				if (audioDef.models.some((m) => m.formats[format])) {
 					const modelId = getDefaultModelForFormat("audio-classifier", format);
 					const audioEngine = modelId === "apple-soundanalysis" ? {
-						runtime: "node",
+						runtime: "python",
 						backend: "coreml",
 						format: "coreml"
 					} : {
-						runtime: "node",
+						runtime: "python",
 						backend: "cpu",
 						format: "onnx"
 					};
@@ -5389,18 +5124,19 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		if (typeof runtime === "string" && typeof backend === "string" && runtime && backend) {
 			const storedDevice = typeof store["engineDevice"] === "string" ? String(store["engineDevice"]) : "";
 			const detected = DetectionPipelineProvider.detectBestEngine();
-			if (runtime === "python" && !DetectionPipelineProvider.isPythonBackendAvailable(backend)) {
+			if (runtime === "python" && !DetectionPipelineProvider.isPythonBackendAvailable(backend, this.executorOptions.pythonPath ?? "")) {
 				this.log.warn("Stored engine backend unavailable on this node — falling back to detected best", { meta: {
 					stored: `${runtime}/${backend}`,
 					fallback: `${detected.runtime}/${detected.backend}`
 				} });
 				return detected;
 			}
+			const migratedBackend = runtime === "node" && backend === "cpu" ? "onnx" : backend;
 			const device = storedDevice || detected.device;
 			return {
-				runtime: runtime === "node" ? "node" : "python",
-				backend,
-				format: backendToFormat(backend),
+				runtime: "python",
+				backend: migratedBackend,
+				format: backendToFormat(migratedBackend),
 				...device ? { device } : {}
 			};
 		}
@@ -5409,13 +5145,21 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	}
 	/**
 	* Synchronous availability probe for a Python inference backend. Runs a
-	* short `python3 -c "import <mod>"` with a 3s timeout. Used at
+	* short `<python> -c "import <mod>"` with a 3s timeout. Used at
 	* `loadEngine` time to reject a persisted backend choice the Python
 	* interpreter on this host can't actually import — without this the
 	* detection-pipeline child process exits with code 1 the moment
 	* `inference_pool.py` hits its `from openvino.runtime import Core`.
+	*
+	* MUST probe the EMBEDDED portable interpreter (`pythonPath`, resolved via
+	* `ctx.deps.ensurePython()`) — that's where `installPythonRequirements`
+	* puts the backend packages and what `SharedInferencePool` actually spawns.
+	* Probing the system `python3` checks the wrong site-packages (and on a
+	* slim container there is no system python3 at all → every backend would
+	* be reported unavailable, silently disabling ML). Falls back to `python3`
+	* only when no embedded interpreter is resolved.
 	*/
-	static isPythonBackendAvailable(backend) {
+	static isPythonBackendAvailable(backend, pythonPath) {
 		const mod = {
 			coreml: "coremltools",
 			openvino: "openvino.runtime",
@@ -5425,7 +5169,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		if (!mod) return false;
 		try {
 			const { execFileSync } = require("node:child_process");
-			execFileSync("python3", ["-c", `import ${mod}`], {
+			execFileSync(pythonPath || "python3", ["-c", `import ${mod}`], {
 				timeout: 3e3,
 				stdio: "pipe"
 			});
@@ -5816,11 +5560,11 @@ function buildDefaultStepTree(format) {
 		makeStep("instance-segmentation", [], { enabled: false })
 	].filter((s) => s !== null));
 	const audioEngine = getDefaultModelForFormat("audio-classifier", format) === "apple-soundanalysis" ? {
-		runtime: "node",
+		runtime: "python",
 		backend: "coreml",
 		format: "coreml"
 	} : {
-		runtime: "node",
+		runtime: "python",
 		backend: "cpu",
 		format: "onnx"
 	};
@@ -5960,30 +5704,21 @@ function resolveAddonPythonDir() {
 var RUNTIMES = [{
 	value: "python",
 	label: "Python (CoreML / OpenVINO / ONNX Runtime)"
-}, {
-	value: "node",
-	label: "Node.js (onnxruntime-node)"
 }];
-var BACKENDS_BY_RUNTIME = {
-	python: [
-		{
-			value: "coreml",
-			label: "CoreML"
-		},
-		{
-			value: "openvino",
-			label: "OpenVINO"
-		},
-		{
-			value: "onnx",
-			label: "ONNX Runtime"
-		}
-	],
-	node: [{
-		value: "cpu",
-		label: "CPU (onnxruntime-node)"
-	}]
-};
+var BACKENDS_BY_RUNTIME = { python: [
+	{
+		value: "coreml",
+		label: "CoreML"
+	},
+	{
+		value: "openvino",
+		label: "OpenVINO"
+	},
+	{
+		value: "onnx",
+		label: "ONNX Runtime"
+	}
+] };
 var DEVICES_BY_BACKEND = {
 	coreml: [
 		{
@@ -6335,7 +6070,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 			...stored,
 			...overlay
 		} : stored;
-		const runtime = merged.engineRuntime === "node" ? "node" : "python";
+		const runtime = "python";
 		const availableBackends = await this.resolveAvailableBackends(ctx, runtime);
 		const runtimeBackends = availableBackends.length > 0 ? BACKENDS_BY_RUNTIME[runtime].filter((b) => availableBackends.includes(b.value)) : BACKENDS_BY_RUNTIME[runtime];
 		const storedBackend = typeof merged.engineBackend === "string" ? merged.engineBackend : "";