@camstack/addon-post-analysis 1.0.0 → 1.0.1

package/dist/embedding-encoder/index.mjs

@@ -1,9 +1,12 @@
-import { a as PYTHON_SCRIPT, f as embeddingEncoderCapability, n as BaseAddon, o as RUNTIME_TO_FORMAT$1, t as BACKEND_TO_FORMAT$1 } from "../dist-4mTLJ7BJ.mjs";
-import sharp from "sharp";
-import { ModelDownloadService } from "@camstack/core";
+import { l as embeddingEncoderCapability, t as BaseAddon } from "../dist-DbD5zJj7.mjs";
+import { createRequire } from "node:module";
 import * as path from "node:path";
 import * as fs from "node:fs";
+import { ModelDownloadService } from "@camstack/core";
 import { spawn } from "node:child_process";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
 //#region src/embedding-encoder/catalogs/embedding-models.ts
 var CLIP_IMAGE_MODELS = [
 	{
@@ -114,359 +117,51 @@ function createNoopLogger() {
 	return logger;
 }
 //#endregion
-//#region src/embedding-encoder/shared/node-raw-tensor-engine.ts
-var BACKEND_TO_DEVICE$1 = {
-	cpu: "cpu",
-	coreml: "gpu-mps",
-	cuda: "gpu-cuda",
-	tensorrt: "tensorrt"
-};
+//#region src/embedding-encoder/shared/python-raw-tensor-engine.ts
 /**
-* Raw tensor engine — runs ONNX inference on pre-processed Float32Array input.
-* Used by addons that handle their own preprocessing (e.g. CLIP embedding encoder).
+* Raw-tensor ONNX engine backed by an embedded-Python subprocess
+* (`raw_tensor_inference.py`). Replaces the Node `onnxruntime-node` raw-tensor
+* engine so the platform ships no Node ONNX runtime. The caller preprocesses to
+* a Float32Array; this engine ships it to Python, which runs onnxruntime and
+* returns the output tensor. Wire protocol = length-prefixed binary frames
+* ([4B LE length][payload]).
 */
-var NodeRawTensorEngine = class {
-	modelPath;
-	backend;
-	runtime = "onnx";
-	device;
-	session = null;
-	log;
-	constructor(modelPath, backend, logger) {
-		this.modelPath = modelPath;
-		this.backend = backend;
-		this.device = BACKEND_TO_DEVICE$1[backend] ?? "cpu";
-		this.log = logger ?? createNoopLogger();
-	}
-	async initialize() {
-		const ort = await import("onnxruntime-node");
-		const provider = this.backend === "coreml" ? "coreml" : this.backend === "cuda" ? "cuda" : "cpu";
-		const absModelPath = path.isAbsolute(this.modelPath) ? this.modelPath : path.resolve(process.cwd(), this.modelPath);
-		this.session = await ort.InferenceSession.create(absModelPath, { executionProviders: [provider] });
-		this.log.info("ONNX session loaded", { meta: {
-			modelPath: absModelPath,
-			backend: this.backend,
-			provider
-		} });
-	}
-	async run(input, inputShape) {
-		if (!this.session) throw new Error("NodeRawTensorEngine: not initialized — call initialize() first");
-		const ort = await import("onnxruntime-node");
-		const sess = this.session;
-		const inputName = sess.inputNames[0];
-		const tensor = new ort.Tensor("float32", input, [...inputShape]);
-		const feeds = { [inputName]: tensor };
-		const start = Date.now();
-		let results;
-		try {
-			results = await sess.run(feeds);
-		} catch (err) {
-			const error = err instanceof Error ? err : new Error(String(err));
-			this.log.error("Inference failed", { meta: { error: error.message } });
-			throw error;
-		}
-		const outputName = sess.outputNames[0];
-		this.log.debug("Inference complete", { meta: {
-			durationMs: Date.now() - start,
-			outputKeys: [outputName],
-			preprocessMode: "raw-tensor"
-		} });
-		return results[outputName].data;
-	}
-	async dispose() {
-		this.session = null;
-		this.log.debug("Session disposed");
-	}
-};
-//#endregion
-//#region src/embedding-encoder/shared/image-utils.ts
-/** Letterbox resize for YOLO: resize preserving aspect ratio, pad to square */
-async function letterbox(jpeg, targetSize) {
-	const meta = await sharp(jpeg).metadata();
-	const originalWidth = meta.width ?? 0;
-	const originalHeight = meta.height ?? 0;
-	const scale = Math.min(targetSize / originalWidth, targetSize / originalHeight);
-	const scaledWidth = Math.round(originalWidth * scale);
-	const scaledHeight = Math.round(originalHeight * scale);
-	const padX = Math.floor((targetSize - scaledWidth) / 2);
-	const padY = Math.floor((targetSize - scaledHeight) / 2);
-	const { data } = await sharp(jpeg).resize(scaledWidth, scaledHeight).extend({
-		top: padY,
-		bottom: targetSize - scaledHeight - padY,
-		left: padX,
-		right: targetSize - scaledWidth - padX,
-		background: {
-			r: 114,
-			g: 114,
-			b: 114
-		}
-	}).removeAlpha().raw().toBuffer({ resolveWithObject: true });
-	const numPixels = targetSize * targetSize;
-	const float32 = new Float32Array(3 * numPixels);
-	for (let i = 0; i < numPixels; i++) {
-		const srcBase = i * 3;
-		float32[0 * numPixels + i] = data[srcBase] / 255;
-		float32[1 * numPixels + i] = data[srcBase + 1] / 255;
-		float32[2 * numPixels + i] = data[srcBase + 2] / 255;
-	}
-	return {
-		data: float32,
-		scale,
-		padX,
-		padY,
-		originalWidth,
-		originalHeight
-	};
-}
-/** Resize and normalize to Float32Array */
-async function resizeAndNormalize(jpeg, targetWidth, targetHeight, normalization, layout) {
-	const { data } = await sharp(jpeg).resize(targetWidth, targetHeight, { fit: "fill" }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
-	const numPixels = targetWidth * targetHeight;
-	const float32 = new Float32Array(3 * numPixels);
-	const mean = [
-		.485,
-		.456,
-		.406
-	];
-	const std = [
-		.229,
-		.224,
-		.225
-	];
-	if (layout === "nchw") for (let i = 0; i < numPixels; i++) {
-		const srcBase = i * 3;
-		for (let c = 0; c < 3; c++) {
-			const raw = data[srcBase + c] / 255;
-			let val;
-			if (normalization === "zero-one") val = raw;
-			else if (normalization === "imagenet") val = (raw - mean[c]) / std[c];
-			else val = data[srcBase + c];
-			float32[c * numPixels + i] = val;
-		}
-	}
-	else for (let i = 0; i < numPixels; i++) {
-		const srcBase = i * 3;
-		for (let c = 0; c < 3; c++) {
-			const raw = data[srcBase + c] / 255;
-			let val;
-			if (normalization === "zero-one") val = raw;
-			else if (normalization === "imagenet") val = (raw - mean[c]) / std[c];
-			else val = data[srcBase + c];
-			float32[i * 3 + c] = val;
-		}
-	}
-	return float32;
-}
-//#endregion
-//#region src/embedding-encoder/shared/node-engine.ts
-var BACKEND_TO_PROVIDER = {
-	cpu: "cpu",
-	coreml: "coreml",
-	cuda: "cuda",
-	tensorrt: "tensorrt",
-	dml: "dml"
-};
-var BACKEND_TO_DEVICE = {
-	cpu: "cpu",
-	coreml: "gpu-mps",
-	cuda: "gpu-cuda",
-	tensorrt: "tensorrt"
-};
-var NodeInferenceEngine = class {
-	modelPath;
-	backend;
-	modelMeta;
-	runtime = "onnx";
-	device;
-	session = null;
-	log;
-	constructor(modelPath, backend, modelMeta, logger) {
-		this.modelPath = modelPath;
-		this.backend = backend;
-		this.modelMeta = modelMeta;
-		this.device = BACKEND_TO_DEVICE[backend] ?? "cpu";
-		this.log = logger ?? createNoopLogger();
-	}
-	async initialize() {
-		const ort = await import("onnxruntime-node");
-		const provider = BACKEND_TO_PROVIDER[this.backend] ?? "cpu";
-		const absModelPath = path.isAbsolute(this.modelPath) ? this.modelPath : path.resolve(process.cwd(), this.modelPath);
-		const sessionOptions = { executionProviders: [provider] };
-		this.session = await ort.InferenceSession.create(absModelPath, sessionOptions);
-		this.log.info("ONNX session loaded", { meta: {
-			modelPath: absModelPath,
-			backend: this.backend,
-			provider
-		} });
-	}
-	async infer(input) {
-		const jpeg = input.kind === "jpeg" ? input.data : await this.encodeRawAsJpeg(input.data, input.width, input.height, input.format);
-		const { data, letterboxMeta } = await this.preprocess(jpeg);
-		const { inputSize } = this.modelMeta;
-		const inputShape = this.modelMeta.preprocessMode === "letterbox" ? [
-			1,
-			3,
-			inputSize.height,
-			inputSize.width
-		] : [
-			1,
-			3,
-			inputSize.height,
-			inputSize.width
-		];
-		const start = Date.now();
-		let result;
-		try {
-			result = await this.runSession(data, inputShape);
-		} catch (err) {
-			const error = err instanceof Error ? err : new Error(String(err));
-			this.log.error("Inference failed", { meta: { error: error.message } });
-			throw error;
-		}
-		const durationMs = Date.now() - start;
-		if ("tensor" in result) {
-			this.log.debug("Inference complete", { meta: {
-				durationMs,
-				outputKeys: ["tensor"],
-				preprocessMode: this.modelMeta.preprocessMode
-			} });
-			return {
-				tensor: result.tensor,
-				letterbox: letterboxMeta,
-				inferenceMs: durationMs
-			};
-		}
-		this.log.debug("Inference complete", { meta: {
-			durationMs,
-			outputKeys: Object.keys(result.tensors),
-			preprocessMode: this.modelMeta.preprocessMode
-		} });
-		return {
-			tensors: result.tensors,
-			letterbox: letterboxMeta,
-			inferenceMs: durationMs
-		};
-	}
-	/** Preprocess JPEG to Float32Array using the configured mode */
-	async preprocess(jpeg) {
-		const { inputSize, inputNormalization, inputLayout, preprocessMode } = this.modelMeta;
-		if (preprocessMode === "letterbox") {
-			const result = await letterbox(jpeg, Math.max(inputSize.width, inputSize.height));
-			const letterboxMeta = {
-				scale: result.scale,
-				padX: result.padX,
-				padY: result.padY,
-				originalWidth: result.originalWidth,
-				originalHeight: result.originalHeight
-			};
-			return {
-				data: result.data,
-				letterboxMeta
-			};
-		}
-		return { data: await resizeAndNormalize(jpeg, inputSize.width, inputSize.height, inputNormalization, inputLayout) };
-	}
-	async encodeRawAsJpeg(raw, width, height, format) {
-		const sharp = (await import("sharp")).default;
-		return sharp(raw, { raw: {
-			width,
-			height,
-			channels: format === "gray" ? 1 : 3
-		} }).jpeg({
-			quality: 80,
-			mozjpeg: false
-		}).toBuffer();
-	}
-	/** Run an ONNX session with a single input, handling both single and multi-output models */
-	async runSession(input, inputShape) {
-		if (!this.session) throw new Error("NodeInferenceEngine: not initialized — call initialize() first");
-		const ort = await import("onnxruntime-node");
-		const sess = this.session;
-		const inputName = sess.inputNames[0];
-		const tensor = new ort.Tensor("float32", input, [...inputShape]);
-		const feeds = { [inputName]: tensor };
-		const results = await sess.run(feeds);
-		const outputNames = sess.outputNames;
-		if (outputNames.length === 1) return { tensor: results[outputNames[0]].data };
-		const tensors = {};
-		for (const name of outputNames) tensors[name] = results[name].data;
-		return { tensors };
-	}
-	async run(input, inputShape) {
-		const result = await this.runSession(input, inputShape);
-		if ("tensor" in result) return result.tensor;
-		const firstKey = Object.keys(result.tensors)[0];
-		return result.tensors[firstKey];
-	}
-	async dispose() {
-		this.session = null;
-		this.log.debug("Session disposed");
-	}
-};
-//#endregion
-//#region src/embedding-encoder/shared/python-engine.ts
-var PythonInferenceEngine = class {
+var PythonRawTensorEngine = class {
 	pythonPath;
 	scriptPath;
 	modelPath;
-	extraArgs;
-	runtime;
-	device;
+	runtime = "onnx";
+	device = "cpu";
 	process = null;
 	receiveBuffer = Buffer.alloc(0);
 	pendingResolve = null;
 	pendingReject = null;
 	log;
-	constructor(pythonPath, scriptPath, runtime, modelPath, extraArgs = [], logger) {
+	constructor(pythonPath, scriptPath, modelPath, logger) {
 		this.pythonPath = pythonPath;
 		this.scriptPath = scriptPath;
 		this.modelPath = modelPath;
-		this.extraArgs = extraArgs;
-		this.runtime = runtime;
-		const runtimeDeviceMap = {
-			onnx: "cpu",
-			coreml: "gpu-mps",
-			pytorch: "cpu",
-			openvino: "cpu",
-			tflite: "cpu"
-		};
-		this.device = runtimeDeviceMap[runtime];
 		this.log = logger ?? createNoopLogger();
 	}
 	async initialize() {
-		const args = [
-			this.scriptPath,
-			this.modelPath,
-			...this.extraArgs
-		];
-		this.process = spawn(this.pythonPath, args, { stdio: [
+		this.process = spawn(this.pythonPath, [this.scriptPath, this.modelPath], { stdio: [
 			"pipe",
 			"pipe",
 			"pipe"
 		] });
-		if (!this.process.stdout || !this.process.stdin) throw new Error("PythonInferenceEngine: failed to create process pipes");
-		this.log.info("Python process started", { meta: {
-			pythonPath: this.pythonPath,
-			scriptPath: this.scriptPath,
-			modelPath: this.modelPath
-		} });
 		this.process.stderr?.on("data", (chunk) => {
-			const lines = chunk.toString().split("\n");
-			for (const line of lines) {
-				const trimmed = line.trim();
-				if (trimmed) this.log.warn(trimmed);
-			}
+			const text = chunk.toString().trim();
+			if (text) this.log.warn(text);
 		});
 		this.process.on("error", (err) => {
-			this.log.error("Process error", { meta: { error: err.message } });
+			this.log.error("Python raw-tensor process error", { meta: { error: err.message } });
 			this.pendingReject?.(err);
 			this.pendingReject = null;
 			this.pendingResolve = null;
 		});
 		this.process.on("exit", (code) => {
-			if (code !== 0) {
-				this.log.error("Process exited", { meta: { code } });
-				const err = /* @__PURE__ */ new Error(`PythonInferenceEngine: process exited with code ${code}`);
+			if (code !== 0 && code !== null) {
+				const err = /* @__PURE__ */ new Error(`PythonRawTensorEngine: process exited with code ${code}`);
 				this.pendingReject?.(err);
 				this.pendingReject = null;
 				this.pendingResolve = null;
@@ -474,70 +169,29 @@ var PythonInferenceEngine = class {
 		});
 		this.process.stdout.on("data", (chunk) => {
 			this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk]);
-			this._tryReceive();
+			this.tryReceive();
 		});
-		await new Promise((resolve, reject) => {
-			const timeout = setTimeout(() => resolve(), 2e3);
-			this.process?.on("error", (err) => {
-				clearTimeout(timeout);
-				reject(err);
-			});
-			this.process?.on("exit", (code) => {
-				clearTimeout(timeout);
-				if (code !== 0) reject(/* @__PURE__ */ new Error(`PythonInferenceEngine: process exited early with code ${code}`));
-			});
-		});
-	}
-	_tryReceive() {
-		if (this.receiveBuffer.length < 4) return;
-		const length = this.receiveBuffer.readUInt32LE(0);
-		if (this.receiveBuffer.length < 4 + length) return;
-		const jsonBytes = this.receiveBuffer.subarray(4, 4 + length);
-		this.receiveBuffer = this.receiveBuffer.subarray(4 + length);
-		const resolve = this.pendingResolve;
-		const reject = this.pendingReject;
-		this.pendingResolve = null;
-		this.pendingReject = null;
-		if (!resolve) return;
-		try {
-			resolve(JSON.parse(jsonBytes.toString("utf8")));
-		} catch (err) {
-			reject?.(err instanceof Error ? err : new Error(String(err)));
-		}
-	}
-	/** Run inference, returning structured detection results. Encodes raw input to JPEG when needed. */
-	async infer(input) {
-		const start = Date.now();
-		const jpeg = input.kind === "jpeg" ? input.data : await this.encodeRawAsJpeg(input.data, input.width, input.height, input.format);
-		const result = await this.sendJpeg(jpeg);
-		const durationMs = Date.now() - start;
-		this.log.debug("Inference complete", { meta: { durationMs } });
-		return {
-			structured: result,
-			inferenceMs: durationMs
-		};
+		const ready = await this.receiveFrame();
+		if (ready.length !== 1 || ready[0] !== 1) throw new Error("PythonRawTensorEngine: unexpected ready frame");
+		this.log.info("ONNX raw-tensor engine ready (embedded Python)", { meta: { modelPath: this.modelPath } });
 	}
-	async encodeRawAsJpeg(raw, width, height, format) {
-		const sharp = (await import("sharp")).default;
-		return sharp(raw, { raw: {
-			width,
-			height,
-			channels: format === "gray" ? 1 : 3
-		} }).jpeg({
-			quality: 80,
-			mozjpeg: false
-		}).toBuffer();
-	}
-	/** Send JPEG buffer via binary IPC, receive JSON detection results */
-	async sendJpeg(jpeg) {
-		if (!this.process?.stdin) throw new Error("PythonInferenceEngine: process not initialized");
-		return new Promise((resolve, reject) => {
-			this.pendingResolve = resolve;
-			this.pendingReject = reject;
-			const lengthBuf = Buffer.allocUnsafe(4);
-			lengthBuf.writeUInt32LE(jpeg.length, 0);
-			this.process.stdin.write(Buffer.concat([lengthBuf, jpeg]));
-		});
+	async run(input, inputShape) {
+		if (!this.process?.stdin) throw new Error("PythonRawTensorEngine: not initialized — call initialize() first");
+		const ndims = inputShape.length;
+		const meta = Buffer.allocUnsafe(1 + ndims * 4);
+		meta.writeUInt8(ndims, 0);
+		for (let i = 0; i < ndims; i++) meta.writeUInt32LE(inputShape[i], 1 + i * 4);
+		const dataBuf = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+		const payload = Buffer.concat([meta, dataBuf]);
+		const lenBuf = Buffer.allocUnsafe(4);
+		lenBuf.writeUInt32LE(payload.length, 0);
+		this.process.stdin.write(Buffer.concat([lenBuf, payload]));
+		const resp = await this.receiveFrame();
+		const floatStart = 1 + resp.readUInt8(0) * 4;
+		const count = (resp.length - floatStart) / 4;
+		const out = new Float32Array(count);
+		for (let i = 0; i < count; i++) out[i] = resp.readFloatLE(floatStart + i * 4);
+		return out;
 	}
 	async dispose() {
 		const proc = this.process;
@@ -545,168 +199,37 @@ var PythonInferenceEngine = class {
 		this.process = null;
 		proc.stdin?.end();
 		proc.kill("SIGTERM");
-		if (!await new Promise((resolve) => {
+		await new Promise((resolve) => {
 			const timer = setTimeout(() => {
-				resolve(false);
+				try {
+					proc.kill("SIGKILL");
+				} catch {}
+				resolve();
 			}, 5e3);
 			proc.once("exit", () => {
 				clearTimeout(timer);
-				resolve(true);
+				resolve();
 			});
-		})) {
-			try {
-				proc.kill("SIGKILL");
-			} catch {}
-			this.log.warn("Python process did not exit gracefully — sent SIGKILL");
-		} else this.log.debug("Python process terminated");
-	}
-};
-//#endregion
-//#region src/embedding-encoder/shared/engine-resolver.ts
-/** Priority order for auto-selection of ONNX backends */
-var AUTO_BACKEND_PRIORITY = [
-	"coreml",
-	"cuda",
-	"tensorrt",
-	"cpu"
-];
-var BACKEND_TO_FORMAT = BACKEND_TO_FORMAT$1;
-var RUNTIME_TO_FORMAT = RUNTIME_TO_FORMAT$1;
-function extractModelMeta(entry) {
-	return {
-		inputSize: entry.inputSize,
-		inputNormalization: entry.inputNormalization ?? "zero-one",
-		inputLayout: entry.inputLayout ?? "nchw",
-		preprocessMode: entry.preprocessMode ?? "letterbox"
-	};
-}
-function modelFilePath(modelsDir, modelEntry, format) {
-	const formatEntry = modelEntry.formats[format];
-	if (!formatEntry) throw new Error(`Model ${modelEntry.id} has no ${format} format`);
-	const urlParts = formatEntry.url.split("/");
-	const filename = urlParts[urlParts.length - 1] ?? `${modelEntry.id}.${format}`;
-	return path.join(modelsDir, filename);
-}
-function modelExists(filePath) {
-	try {
-		return fs.existsSync(filePath);
-	} catch {
-		return false;
-	}
-}
-async function resolveEngine(options) {
-	const { runtime, backend, modelEntry, modelsDir, models } = options;
-	const log = options.logger ?? createNoopLogger();
-	let selectedFormat;
-	let selectedBackend;
-	if (runtime === "auto") {
-		const available = await probeOnnxBackends();
-		let chosen = null;
-		for (const b of AUTO_BACKEND_PRIORITY) {
-			if (!available.includes(b)) continue;
-			const fmt = BACKEND_TO_FORMAT[b];
-			if (!fmt) continue;
-			if (!modelEntry.formats[fmt]) continue;
-			chosen = {
-				backend: b,
-				format: fmt
-			};
-			break;
-		}
-		if (!chosen) throw new Error(`resolveEngine: no compatible backend found for model ${modelEntry.id}. Available backends: ${available.join(", ")}`);
-		selectedFormat = chosen.format;
-		selectedBackend = chosen.backend;
-	} else {
-		const fmt = RUNTIME_TO_FORMAT[runtime];
-		if (!fmt) throw new Error(`resolveEngine: unsupported runtime "${runtime}"`);
-		if (!modelEntry.formats[fmt]) if (fmt !== "onnx" && modelEntry.formats["onnx"]) {
-			selectedFormat = "onnx";
-			selectedBackend = backend || "cpu";
-		} else throw new Error(`resolveEngine: model ${modelEntry.id} has no ${fmt} format for runtime ${runtime}`);
-		else {
-			selectedFormat = fmt;
-			selectedBackend = runtime === "onnx" ? backend || "cpu" : runtime;
-		}
-	}
-	let modelPath;
-	if (models) modelPath = await models.ensure(modelEntry.id, selectedFormat);
-	else {
-		modelPath = modelFilePath(modelsDir, modelEntry, selectedFormat);
-		if (!modelExists(modelPath)) throw new Error(`resolveEngine: model file not found at ${modelPath} and no model service provided`);
-	}
-	log.info("Engine resolved", { meta: {
-		format: selectedFormat,
-		backend: selectedBackend,
-		modelId: modelEntry.id
-	} });
-	if (selectedFormat === "onnx") {
-		const engine = new NodeInferenceEngine(modelPath, selectedBackend, extractModelMeta(modelEntry), options.logger);
-		await engine.initialize();
-		return {
-			engine,
-			format: selectedFormat,
-			modelPath
-		};
-	}
-	const effectiveRuntime = runtime === "auto" ? selectedBackend : runtime;
-	let { pythonPath } = options;
-	if (!pythonPath) {
-		const { execFileSync: efs } = await import("node:child_process");
-		for (const cmd of ["python3", "python"]) try {
-			efs(cmd, ["--version"], {
-				timeout: 3e3,
-				stdio: "ignore"
-			});
-			pythonPath = cmd;
-			break;
-		} catch {}
+		});
 	}
-	const scriptName = PYTHON_SCRIPT[effectiveRuntime];
-	if (scriptName && pythonPath) {
-		const candidates = [
-			path.join(__dirname, "../../python", scriptName),
-			path.join(__dirname, "../python", scriptName),
-			path.join(__dirname, "../../../python", scriptName)
-		];
-		const scriptPath = candidates.find((p) => fs.existsSync(p));
-		if (!scriptPath) throw new Error(`resolveEngine: Python script "${scriptName}" not found. Searched:\n${candidates.join("\n")}`);
-		const inputSize = Math.max(modelEntry.inputSize.width, modelEntry.inputSize.height);
-		const engine = new PythonInferenceEngine(pythonPath, scriptPath, effectiveRuntime, modelPath, [`--input-size=${inputSize}`, `--confidence=0.25`], options.logger);
-		await engine.initialize();
-		return {
-			engine,
-			format: selectedFormat,
-			modelPath
-		};
+	receiveFrame() {
+		return new Promise((resolve, reject) => {
+			this.pendingResolve = resolve;
+			this.pendingReject = reject;
+		});
 	}
-	const fallbackPath = modelFilePath(modelsDir, modelEntry, "onnx");
-	if (modelEntry.formats["onnx"] && modelExists(fallbackPath)) {
-		const engine = new NodeInferenceEngine(fallbackPath, "cpu", extractModelMeta(modelEntry), options.logger);
-		await engine.initialize();
-		return {
-			engine,
-			format: "onnx",
-			modelPath: fallbackPath
-		};
+	tryReceive() {
+		if (this.receiveBuffer.length < 4) return;
+		const length = this.receiveBuffer.readUInt32LE(0);
+		if (this.receiveBuffer.length < 4 + length) return;
+		const payload = Buffer.from(this.receiveBuffer.subarray(4, 4 + length));
+		this.receiveBuffer = this.receiveBuffer.subarray(4 + length);
+		const resolve = this.pendingResolve;
+		this.pendingResolve = null;
+		this.pendingReject = null;
+		resolve?.(payload);
 	}
-	throw new Error(`resolveEngine: format ${selectedFormat} is not yet supported by NodeInferenceEngine, no Python runtime is available, and no ONNX fallback exists`);
-}
-/** Probe which ONNX execution providers are available on this system */
-async function probeOnnxBackends() {
-	const available = ["cpu"];
-	try {
-		const ort = await import("onnxruntime-node");
-		const providers = ort.env?.webgl?.disabled !== void 0 ? ort.InferenceSession.getAvailableProviders?.() ?? [] : [];
-		for (const p of providers) {
-			const normalized = p.toLowerCase().replace("executionprovider", "");
-			if (normalized === "coreml") available.push("coreml");
-			else if (normalized === "cuda") available.push("cuda");
-			else if (normalized === "tensorrt") available.push("tensorrt");
-		}
-	} catch {}
-	if (process.platform === "darwin" && !available.includes("coreml")) available.push("coreml");
-	return [...new Set(available)];
-}
+};
 //#endregion
 //#region src/embedding-encoder/addon/clip-models.ts
 var CLIP_MODEL_META = {
@@ -783,10 +306,7 @@ function l2Normalize(vec) {
 var EmbeddingEncoderAddon = class extends BaseAddon {
 	imageRawEngine = null;
 	textRawEngine = null;
-	imagePythonEngine = null;
-	textPythonEngine = null;
 	models = null;
-	isPython = false;
 	constructor() {
 		super({
 			modelId: DEFAULT_CLIP_MODEL,
@@ -810,19 +330,6 @@ var EmbeddingEncoderAddon = class extends BaseAddon {
 		await this.ensureImageEngine();
 		const meta = getModelMeta(this.config.modelId);
 		const start = Date.now();
-		if (this.isPython && this.imagePythonEngine) {
-			const jpegBuffer = Buffer.isBuffer(crop) ? crop : Buffer.from(crop);
-			const result = await this.imagePythonEngine.infer({
-				kind: "jpeg",
-				data: jpegBuffer
-			});
-			const rawEmbedding = result.structured?.["embedding"];
-			const normalized = l2Normalize(new Float32Array(rawEmbedding));
-			return {
-				embedding: Array.from(normalized),
-				inferenceMs: result.inferenceMs ?? Date.now() - start
-			};
-		}
 		const preprocessed = preprocessForClip(Buffer.isBuffer(crop) ? crop : Buffer.from(crop), width, height, meta.inputSize, meta.inputSize);
 		const output = await this.imageRawEngine.run(preprocessed, [
 			1,
@@ -842,19 +349,6 @@ var EmbeddingEncoderAddon = class extends BaseAddon {
 		await this.ensureTextEngine();
 		const meta = getModelMeta(this.config.modelId);
 		const start = Date.now();
-		if (this.isPython && this.textPythonEngine) {
-			const textBuffer = Buffer.from(JSON.stringify({ text }), "utf-8");
-			const result = await this.textPythonEngine.infer({
-				kind: "jpeg",
-				data: textBuffer
-			});
-			const rawEmbedding = result.structured?.["embedding"];
-			const normalized = l2Normalize(new Float32Array(rawEmbedding));
-			return {
-				embedding: Array.from(normalized),
-				inferenceMs: result.inferenceMs ?? Date.now() - start
-			};
-		}
 		const tokenIds = clipTokenize(text);
 		const inputTensor = new Float32Array(tokenIds);
 		const output = await this.textRawEngine.run(inputTensor, [1, tokenIds.length]);
@@ -870,57 +364,42 @@ var EmbeddingEncoderAddon = class extends BaseAddon {
 		return {
 			modelId: this.config.modelId,
 			embeddingDim: meta.embeddingDim,
-			ready: this.imageRawEngine !== null || this.imagePythonEngine !== null
+			ready: this.imageRawEngine !== null
 		};
 	}
 	async ensureImageEngine() {
-		if (this.imageRawEngine || this.imagePythonEngine) return;
+		if (this.imageRawEngine) return;
 		const meta = getModelMeta(this.config.modelId);
 		const imageEntry = CLIP_IMAGE_MODELS.find((m) => m.id === meta.imageModelId);
 		if (!imageEntry) throw new Error(`EmbeddingEncoderAddon: unknown image model "${meta.imageModelId}"`);
 		await this.resolveForEntry(imageEntry, "image");
 	}
 	async ensureTextEngine() {
-		if (this.textRawEngine || this.textPythonEngine) return;
+		if (this.textRawEngine) return;
 		const meta = getModelMeta(this.config.modelId);
 		const textEntry = CLIP_TEXT_MODELS.find((m) => m.id === meta.textModelId);
 		if (!textEntry) throw new Error(`EmbeddingEncoderAddon: unknown text model "${meta.textModelId}"`);
 		await this.resolveForEntry(textEntry, "text");
 	}
 	async resolveForEntry(entry, target) {
-		const runtime = this.config.runtime === "auto" ? "auto" : this.config.runtime === "node" ? "onnx" : this.config.runtime;
-		const modelsDir = this.models.getModelsDir();
 		const engineLogger = this.ctx.logger.withTags({
 			modelId: entry.id,
 			runtime: this.config.runtime,
 			backend: this.config.backend
 		});
-		await this.models.ensure(entry.id, "onnx");
-		const resolved = await resolveEngine({
-			runtime,
-			backend: this.config.backend,
-			modelEntry: entry,
-			modelsDir,
-			models: this.models ?? void 0,
-			logger: engineLogger
-		});
-		if (resolved.format !== "onnx") {
-			this.isPython = true;
-			if (target === "image") this.imagePythonEngine = resolved.engine;
-			else this.textPythonEngine = resolved.engine;
-		} else {
-			const rawEngine = new NodeRawTensorEngine(resolved.modelPath, this.config.backend, engineLogger);
-			await rawEngine.initialize();
-			await resolved.engine.dispose();
-			if (target === "image") this.imageRawEngine = rawEngine;
-			else this.textRawEngine = rawEngine;
-		}
+		const modelPath = await this.models.ensure(entry.id, "onnx");
+		const pythonPath = await this.ctx.deps.ensurePython();
+		if (!pythonPath) throw new Error("EmbeddingEncoder: embedded Python is unavailable — cannot run ONNX embeddings. ctx.deps.ensurePython() returned null (portable Python download likely failed).");
+		const pythonDir = resolveEmbeddingPythonDir();
+		await this.ctx.deps.installPythonRequirements(path.join(pythonDir, "requirements-embedding.txt"));
+		const rawEngine = new PythonRawTensorEngine(pythonPath, path.join(pythonDir, "raw_tensor_inference.py"), modelPath, engineLogger);
+		await rawEngine.initialize();
+		if (target === "image") this.imageRawEngine = rawEngine;
+		else this.textRawEngine = rawEngine;
 	}
 	async onShutdown() {
 		await this.imageRawEngine?.dispose();
 		await this.textRawEngine?.dispose();
-		await this.imagePythonEngine?.dispose();
-		await this.textPythonEngine?.dispose();
 	}
 	globalSettingsSchema() {
 		return this.schema({ sections: [{
@@ -939,22 +418,15 @@ var EmbeddingEncoderAddon = class extends BaseAddon {
 					type: "select",
 					key: "runtime",
 					label: "Runtime",
-					description: "Inference runtime (auto selects the best available)",
+					description: "Inference runtime — ONNX runs in the embedded Python.",
 					default: "auto",
-					options: [
-						{
-							label: "Auto",
-							value: "auto"
-						},
-						{
-							label: "Node (ONNX)",
-							value: "node"
-						},
-						{
-							label: "Python",
-							value: "python"
-						}
-					]
+					options: [{
+						label: "Auto",
+						value: "auto"
+					}, {
+						label: "Python",
+						value: "python"
+					}]
 				},
 				{
 					type: "select",
@@ -997,5 +469,20 @@ function clipTokenize(text, maxLength = 77) {
 	while (tokens.length < maxLength) tokens.push(0);
 	return tokens;
 }
+/**
+* Locate the addon's bundled `python/` dir (holds `raw_tensor_inference.py` +
+* `requirements-embedding.txt`). Published package first, then `__dirname`
+* candidates for the in-tree dev build.
+*/
+function resolveEmbeddingPythonDir() {
+	const candidates = [];
+	try {
+		const pkgPath = __require.resolve("@camstack/addon-post-analysis/package.json");
+		candidates.push(path.join(path.dirname(pkgPath), "python"));
+	} catch {}
+	candidates.push(path.join(__dirname, "../../python"), path.join(__dirname, "../../../python"), path.join(__dirname, "../python"), path.join(__dirname, "../../../../python"));
+	for (const c of candidates) if (fs.existsSync(path.join(c, "raw_tensor_inference.py"))) return c;
+	throw new Error(`EmbeddingEncoder: python/ dir (raw_tensor_inference.py) not found. Searched:\n${candidates.join("\n")}`);
+}
 //#endregion
 export { EmbeddingEncoderAddon, EmbeddingEncoderAddon as default };