@camstack/system 1.0.2

package/dist/builtins/platform-probe/index.mjs

@@ -0,0 +1,822 @@
+import * as fs from "node:fs";
+import { BaseAddon, EventCategory, errMsg, platformProbeCapability } from "@camstack/types";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import * as os from "node:os";
+//#region src/builtins/platform-probe/platform-scorer.ts
+/**
+* Promisified `execFile`. Used across the scorer so every subprocess
+* spawn yields the event loop — critical at boot because a single sync
+* spawn of a missing Python module hits its 30s timeout and freezes the
+* entire Node process (WS handshakes, tRPC subscriptions, metrics — all
+* stalled). Keeping it async turns the probe into a true background task.
+*/
+var execFileAsync$2 = promisify(execFile);
+/** Minimal no-op logger for default parameter */
+var noopLogger = {
+	debug() {},
+	info() {},
+	warn() {},
+	error() {},
+	child() {
+		return noopLogger;
+	},
+	withTags() {
+		return noopLogger;
+	}
+};
+/**
+* Get reliable "available" RAM in MB, cross-platform.
+* os.freemem() is unreliable on macOS (reports ~200MB on a 36GB system).
+* Uses systeminformation when available, falls back to native commands.
+*/
+async function getAvailableRAM_MB() {
+	try {
+		const mem = await (await import("systeminformation")).mem();
+		return Math.round(mem.available / 1024 / 1024);
+	} catch (err) {
+		console.debug(`systeminformation not available, using platform-specific RAM probe: ${errMsg(err)}`);
+		const platform = os.platform();
+		try {
+			if (platform === "darwin") {
+				const { stdout: output } = await execFileAsync$2("vm_stat", [], {
+					encoding: "utf8",
+					timeout: 3e3
+				});
+				const pageSize = parseInt(output.match(/page size of (\d+)/)?.[1] ?? "16384");
+				const free = parseInt(output.match(/Pages free:\s+(\d+)/)?.[1] ?? "0");
+				const inactive = parseInt(output.match(/Pages inactive:\s+(\d+)/)?.[1] ?? "0");
+				const purgeable = parseInt(output.match(/Pages purgeable:\s+(\d+)/)?.[1] ?? "0");
+				return Math.round((free + inactive + purgeable) * pageSize / 1024 / 1024);
+			} else if (platform === "linux") {
+				const { readFileSync } = await import("node:fs");
+				const match = readFileSync("/proc/meminfo", "utf8").match(/MemAvailable:\s+(\d+)\s+kB/);
+				if (match) return Math.round(parseInt(match[1]) / 1024);
+			}
+		} catch (err) {
+			console.debug(`RAM probe failed, using total RAM fallback: ${errMsg(err)}`);
+		}
+		return Math.round(os.totalmem() / 1024 / 1024);
+	}
+}
+var PlatformScorer = class {
+	cached = null;
+	logger;
+	/**
+	* Path to the embedded portable Python (from `ctx.deps.ensurePython()`).
+	* The Docker hub ships NO system `python3` — inference runs on the
+	* downloaded portable build — so probing system `python3`/`python` would
+	* wrongly report "Python not found" and never surface coreml/openvino
+	* backends. When set, the Python module probes run against THIS binary;
+	* `null` falls back to a system `python3`/`python` lookup (dev / agent
+	* environments where Python is on PATH).
+	*/
+	embeddedPythonPath;
+	constructor(logger = noopLogger, embeddedPythonPath = null) {
+		this.logger = logger;
+		this.embeddedPythonPath = embeddedPythonPath;
+	}
+	/**
+	* Probe hardware + runtimes and score all backend combos.
+	*
+	* An optional `onPhase` callback is invoked at each step so consumers
+	* (e.g. the platform-probe addon) can emit live progress events on
+	* the event bus. The callback takes a phase id + a typed payload; all
+	* phases fire in strict order: `started` → `hardware` → `node-backends`
+	* → `python-backends` → `scored` → `done`. On failure, `error` fires
+	* once with the exception. Cached after first call.
+	*/
+	async probe(onPhase) {
+		if (this.cached) return this.cached;
+		const start = Date.now();
+		onPhase?.("started", {});
+		this.logger.info("Probing hardware...");
+		const hardware = await this.probeHardware();
+		this.logger.info("Hardware detected", { meta: {
+			platform: hardware.platform,
+			arch: hardware.arch,
+			cpuModel: hardware.cpuModel,
+			cpuCores: hardware.cpuCores,
+			ramGB: Math.round(hardware.totalRAM_MB / 1024)
+		} });
+		if (hardware.gpu) this.logger.info("GPU detected", { meta: { name: hardware.gpu.name } });
+		if (hardware.npu) this.logger.info("NPU detected", { meta: { type: hardware.npu.type } });
+		onPhase?.("hardware", { hardware });
+		this.logger.info("Probing Python backends...");
+		const pythonInfo = await this.probePythonBackends();
+		if (pythonInfo.pythonPath) this.logger.info("Python backends detected", { meta: {
+			pythonPath: pythonInfo.pythonPath,
+			backends: pythonInfo.backends.filter((b) => b.available).map((b) => b.id)
+		} });
+		else this.logger.info("Python: not found");
+		onPhase?.("python-backends", {
+			pythonPath: pythonInfo.pythonPath,
+			backends: pythonInfo.backends
+		});
+		const scores = this.scoreBackends(hardware, pythonInfo.backends);
+		const bestScore = scores.find((s) => s.available) ?? scores[scores.length - 1];
+		const elapsed = Date.now() - start;
+		this.logger.info("Scoring complete", { meta: {
+			elapsedMs: elapsed,
+			combos: scores.length
+		} });
+		this.logger.info("Best backend selected", { meta: {
+			runtime: bestScore.runtime,
+			backend: bestScore.backend,
+			format: bestScore.format,
+			reason: bestScore.reason,
+			score: bestScore.score
+		} });
+		for (const s of scores) this.logger.debug("Score entry", { meta: {
+			available: s.available,
+			runtime: s.runtime,
+			backend: s.backend,
+			format: s.format,
+			score: s.score,
+			reason: s.reason
+		} });
+		this.cached = {
+			hardware,
+			scores,
+			bestScore,
+			pythonPath: pythonInfo.pythonPath
+		};
+		onPhase?.("scored", {
+			scores,
+			bestScore,
+			elapsedMs: elapsed
+		});
+		onPhase?.("done", { capabilities: this.cached });
+		return this.cached;
+	}
+	async probeHardware() {
+		const platform = os.platform();
+		const arch = os.arch();
+		const cpus = os.cpus();
+		const cpuModel = cpus[0]?.model ?? "unknown";
+		const cpuCores = cpus.length;
+		const totalRAM_MB = Math.round(os.totalmem() / 1024 / 1024);
+		const availableRAM_MB = await getAvailableRAM_MB();
+		this.logger.debug("RAM probed", { meta: {
+			totalRAM_MB,
+			availableRAM_MB
+		} });
+		let gpu = null;
+		let npu = null;
+		if (platform === "darwin" && arch === "arm64") {
+			gpu = {
+				type: "apple",
+				name: "Apple Silicon GPU"
+			};
+			npu = { type: "apple-ane" };
+		}
+		if (platform === "linux") {
+			try {
+				const { stdout } = await execFileAsync$2("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader"], {
+					encoding: "utf8",
+					timeout: 5e3
+				});
+				const output = stdout.trim();
+				if (output) {
+					const [name, mem] = output.split(",").map((s) => s.trim());
+					gpu = {
+						type: "nvidia",
+						name: name ?? "NVIDIA GPU",
+						memoryMB: parseInt(mem ?? "0")
+					};
+				}
+			} catch (err) {
+				this.logger.debug("NVIDIA GPU detection failed", { meta: { error: errMsg(err) } });
+			}
+			if (!gpu || !npu) {
+				const { classifyIntelAccelerators } = await import("../../intel-accelerators-hGgpZ0pX.mjs");
+				const intel = classifyIntelAccelerators({
+					listRenderNodes: () => {
+						try {
+							return fs.readdirSync("/dev/dri").filter((n) => n.startsWith("renderD")).map((n) => `/dev/dri/${n}`);
+						} catch {
+							return [];
+						}
+					},
+					readVendor: (node) => {
+						try {
+							return fs.readFileSync(`/sys/class/drm/${node.split("/").pop()}/device/vendor`, "utf8");
+						} catch {
+							return "";
+						}
+					},
+					exists: (p) => fs.existsSync(p)
+				});
+				gpu = gpu ?? intel.gpu;
+				npu = npu ?? intel.npu;
+				if (intel.npu) this.logger.info("Intel NPU detected", { meta: { device: "/dev/accel/accel0" } });
+				if (intel.gpu) this.logger.info("Intel iGPU detected", { meta: { name: intel.gpu.name } });
+			}
+		}
+		return {
+			platform,
+			arch,
+			cpuModel,
+			cpuCores,
+			totalRAM_MB,
+			availableRAM_MB,
+			gpu,
+			npu
+		};
+	}
+	async probePythonBackends() {
+		const candidates = [
+			...this.embeddedPythonPath ? [this.embeddedPythonPath] : [],
+			"python3",
+			"python"
+		];
+		let pythonPath = null;
+		for (const cmd of candidates) try {
+			await execFileAsync$2(cmd, ["--version"], { timeout: 5e3 });
+			pythonPath = cmd;
+			break;
+		} catch (err) {
+			console.debug(`Python command "${cmd}" not found: ${errMsg(err)}`);
+		}
+		if (!pythonPath) return {
+			pythonPath: null,
+			backends: []
+		};
+		const results = await Promise.all([
+			[
+				"coremltools",
+				"coreml",
+				"coreml"
+			],
+			[
+				"openvino.runtime",
+				"openvino",
+				"openvino"
+			],
+			[
+				"torch",
+				"pytorch",
+				"onnx"
+			],
+			[
+				"onnxruntime",
+				"onnx-py",
+				"onnx"
+			]
+		].map(async ([mod, id, format]) => {
+			const probeStart = Date.now();
+			let available = false;
+			try {
+				await execFileAsync$2(pythonPath, ["-c", `import ${mod}`], { timeout: 3e4 });
+				available = true;
+				this.logger.info("Python backend confirmed", { meta: {
+					backend: id,
+					module: mod
+				} });
+			} catch (err) {
+				console.debug(`Python module "${mod}" not installed: ${errMsg(err)}`);
+				if (id === "openvino") this.logger.info("Python backend not yet confirmed: openvino (may be pending proactive install on Intel hardware — falling back to onnx-cpu)", { meta: { module: mod } });
+			}
+			const probeMs = Date.now() - probeStart;
+			this.logger.debug("Python module probed", { meta: {
+				module: mod,
+				available,
+				probeMs
+			} });
+			return {
+				mod,
+				id,
+				format,
+				available
+			};
+		}));
+		const backends = [];
+		for (const r of results) if (r.id === "coreml" && os.platform() === "darwin") backends.push({
+			id: r.id,
+			format: r.format,
+			available: r.available
+		});
+		else if (r.available) backends.push({
+			id: r.id,
+			format: r.format,
+			available: r.available
+		});
+		return {
+			pythonPath,
+			backends
+		};
+	}
+	scoreBackends(hardware, pythonBackends) {
+		const scores = [];
+		if (hardware.platform === "darwin" && hardware.arch === "arm64") {
+			const pyCoreMl = pythonBackends.find((b) => b.id === "coreml");
+			if (pyCoreMl) scores.push({
+				runtime: "python",
+				backend: "coreml",
+				format: "coreml",
+				score: 95,
+				reason: "Apple Neural Engine (Python CoreML)",
+				available: pyCoreMl.available
+			});
+		}
+		if (hardware.gpu?.type === "nvidia") scores.push({
+			runtime: "python",
+			backend: "cuda",
+			format: "onnx",
+			score: 85,
+			reason: "NVIDIA CUDA (Python ONNX Runtime)",
+			available: true
+		});
+		const openvino = pythonBackends.find((b) => b.id === "openvino");
+		if (openvino) {
+			const score = hardware.npu?.type === "intel-npu" ? 90 : 80;
+			scores.push({
+				runtime: "python",
+				backend: "openvino",
+				format: "openvino",
+				score,
+				reason: "Intel OpenVINO",
+				available: openvino.available
+			});
+		}
+		scores.push({
+			runtime: "python",
+			backend: "cpu",
+			format: "onnx",
+			score: 50,
+			reason: "CPU (Python ONNX Runtime)",
+			available: true
+		});
+		return scores.toSorted((a, b) => b.score - a.score);
+	}
+};
+//#endregion
+//#region src/builtins/platform-probe/inference-config-resolver.ts
+var InferenceConfigResolver = class {
+	scores;
+	hardware;
+	constructor(scores, hardware) {
+		this.scores = scores;
+		this.hardware = hardware;
+	}
+	/**
+	* Compute accuracy/backend weights based on available system RAM.
+	* availableRAM_MB is now sourced from systeminformation (reliable cross-platform),
+	* not os.freemem() which is broken on macOS.
+	*
+	* - > 16 GB available: prefer larger, more accurate models (accuracy 0.6, backend 0.4)
+	* - > 8 GB available:  balanced (accuracy 0.5, backend 0.5)
+	* - <= 8 GB available: prefer speed (accuracy 0.4, backend 0.6)
+	*/
+	getWeights() {
+		const ramMB = this.hardware.availableRAM_MB;
+		if (ramMB > 16384) return {
+			accuracyWeight: .6,
+			backendWeight: .4
+		};
+		if (ramMB > 8192) return {
+			accuracyWeight: .5,
+			backendWeight: .5
+		};
+		return {
+			accuracyWeight: .4,
+			backendWeight: .6
+		};
+	}
+	/**
+	* Given an addon's model requirements, pick the best model + runtime + backend.
+	*
+	* Algorithm:
+	* 1. Filter models by available RAM (minRAM_MB < 25% of available RAM)
+	* 2. For each remaining model, find the best platform score whose format
+	*    is available in the model's formats
+	* 3. Pick the model with the highest combined score using RAM-adaptive weights:
+	*    - High RAM (>16 GB): accuracy × 0.6 + backend × 0.4  (prefer accuracy)
+	*    - Mid RAM  (>8 GB):  accuracy × 0.5 + backend × 0.5  (balanced)
+	*    - Low RAM  (<=8 GB): accuracy × 0.4 + backend × 0.6  (prefer speed)
+	*/
+	resolve(requirements) {
+		if (requirements.length === 0) return {
+			modelId: "",
+			runtime: "node",
+			backend: "cpu",
+			format: "onnx",
+			reason: "No models declared"
+		};
+		const ramBudget = this.hardware.availableRAM_MB * .25;
+		const { accuracyWeight, backendWeight } = this.getWeights();
+		console.log(`[InferenceConfigResolver] availableRAM: ${this.hardware.availableRAM_MB}MB, budget: ${Math.round(ramBudget)}MB, weights: accuracy=${accuracyWeight}, backend=${backendWeight}`);
+		const fits = requirements.filter((m) => m.minRAM_MB < ramBudget);
+		const candidates = fits.length > 0 ? fits : [requirements[0]];
+		console.log(`[InferenceConfigResolver] ${candidates.length}/${requirements.length} models fit RAM budget`);
+		let bestCombo = null;
+		for (const model of candidates) for (const score of this.scores) {
+			if (!score.available) continue;
+			if (!model.formats.includes(score.format)) continue;
+			const combined = model.accuracyScore * accuracyWeight + score.score * backendWeight;
+			if (!bestCombo || combined > bestCombo.combined) {
+				console.log(`[InferenceConfigResolver] New best: ${model.modelId} (accuracy=${model.accuracyScore}) + ${score.backend}/${score.format} (score=${score.score}) → combined=${Math.round(combined)}`);
+				bestCombo = {
+					model,
+					score,
+					combined
+				};
+			}
+		}
+		if (!bestCombo) return {
+			modelId: candidates[0].modelId,
+			runtime: "node",
+			backend: "cpu",
+			format: "onnx",
+			reason: "No compatible backend — CPU fallback"
+		};
+		return {
+			modelId: bestCombo.model.modelId,
+			runtime: bestCombo.score.runtime,
+			backend: bestCombo.score.backend,
+			format: bestCombo.score.format,
+			reason: `${bestCombo.model.name} on ${bestCombo.score.reason} (score: ${Math.round(bestCombo.combined)})`
+		};
+	}
+};
+//#endregion
+//#region src/builtins/platform-probe/hardware-encoder-probe.ts
+var execFileAsync$1 = promisify(execFile);
+function buildCandidates(hardware) {
+	const out = [];
+	if (hardware.platform === "darwin") {
+		out.push({
+			encoder: "h264_videotoolbox",
+			codec: "H264",
+			family: "videotoolbox"
+		});
+		out.push({
+			encoder: "hevc_videotoolbox",
+			codec: "H265",
+			family: "videotoolbox"
+		});
+	}
+	if (hardware.platform === "linux") {
+		if (hardware.gpu?.type === "nvidia") {
+			out.push({
+				encoder: "h264_nvenc",
+				codec: "H264",
+				family: "nvenc"
+			});
+			out.push({
+				encoder: "hevc_nvenc",
+				codec: "H265",
+				family: "nvenc"
+			});
+		}
+		if (hardware.gpu?.type === "intel" || hardware.gpu?.type === "amd" || !hardware.gpu) {
+			out.push({
+				encoder: "h264_vaapi",
+				codec: "H264",
+				family: "vaapi"
+			});
+			out.push({
+				encoder: "hevc_vaapi",
+				codec: "H265",
+				family: "vaapi"
+			});
+		}
+	}
+	return out;
+}
+async function runTestEncode(candidate, opts) {
+	const ffmpeg = opts.ffmpegPath ?? "ffmpeg";
+	const timeout = opts.timeoutMs ?? 8e3;
+	const nullSink = os.platform() === "win32" ? "NUL" : "/dev/null";
+	const baseArgs = [
+		"-hide_banner",
+		"-loglevel",
+		"error"
+	];
+	const inArgs = [
+		"-f",
+		"lavfi",
+		"-i",
+		"testsrc=duration=0.04:size=16x16:rate=25"
+	];
+	let outArgs;
+	if (candidate.family === "vaapi") outArgs = [
+		"-vaapi_device",
+		"/dev/dri/renderD128",
+		"-vf",
+		"format=nv12,hwupload",
+		"-c:v",
+		candidate.encoder,
+		"-frames:v",
+		"1",
+		"-f",
+		"null",
+		nullSink
+	];
+	else outArgs = [
+		"-c:v",
+		candidate.encoder,
+		"-frames:v",
+		"1",
+		"-f",
+		"null",
+		nullSink
+	];
+	try {
+		await execFileAsync$1(ffmpeg, [
+			...baseArgs,
+			...inArgs,
+			...outArgs
+		], {
+			timeout,
+			encoding: "utf8"
+		});
+		return {
+			encoder: candidate.encoder,
+			codec: candidate.codec,
+			family: candidate.family,
+			available: true
+		};
+	} catch (err) {
+		return {
+			encoder: candidate.encoder,
+			codec: candidate.codec,
+			family: candidate.family,
+			available: false,
+			reason: errMsg(err)
+		};
+	}
+}
+var HardwareEncoderProber = class {
+	cached = null;
+	inflight = null;
+	logger;
+	ffmpegPath;
+	constructor(logger, ffmpegPath = "ffmpeg") {
+		this.logger = logger;
+		this.ffmpegPath = ffmpegPath;
+	}
+	getCached() {
+		return this.cached;
+	}
+	async probe(hardware, options = {}) {
+		if (!options.force && this.cached) return this.cached;
+		if (this.inflight) return this.inflight;
+		this.inflight = this.runProbe(hardware).then((res) => {
+			this.cached = res;
+			this.inflight = null;
+			return res;
+		}).catch((err) => {
+			this.inflight = null;
+			throw err;
+		});
+		return this.inflight;
+	}
+	async runProbe(hardware) {
+		const candidates = buildCandidates(hardware);
+		const start = Date.now();
+		this.logger.info("Probing hardware encoders", { meta: {
+			platform: hardware.platform,
+			arch: hardware.arch,
+			candidates: candidates.length
+		} });
+		const probes = await Promise.all(candidates.map((c) => runTestEncode(c, { ffmpegPath: this.ffmpegPath })));
+		probes.push({
+			encoder: "libx264",
+			codec: "H264",
+			family: "software",
+			available: true
+		});
+		probes.push({
+			encoder: "libx265",
+			codec: "H265",
+			family: "software",
+			available: true
+		});
+		const pickDefault = (codec) => {
+			const hw = probes.find((p) => p.codec === codec && p.available && p.family !== "software");
+			if (hw) return hw.encoder;
+			return codec === "H264" ? "libx264" : "libx265";
+		};
+		const result = {
+			encoders: probes,
+			defaultH264: pickDefault("H264"),
+			defaultH265: pickDefault("H265"),
+			probedAt: Date.now()
+		};
+		const elapsed = Date.now() - start;
+		this.logger.info("Hardware encoder probe complete", { meta: {
+			elapsedMs: elapsed,
+			defaultH264: result.defaultH264,
+			defaultH265: result.defaultH265,
+			availableHw: probes.filter((p) => p.available && p.family !== "software").map((p) => p.encoder)
+		} });
+		return result;
+	}
+};
+//#endregion
+//#region src/builtins/platform-probe/hardware-decode-accel-probe.ts
+var execFileAsync = promisify(execFile);
+var defaultExecFn = async (ffmpegPath, args) => {
+	const { stdout } = await execFileAsync(ffmpegPath, [...args], {
+		timeout: 8e3,
+		encoding: "utf8"
+	});
+	return { stdout };
+};
+/**
+* Parse the output of `ffmpeg -hwaccels`. The listing looks like:
+*
+*   Hardware acceleration methods:
+*   videotoolbox
+*
+* The header line is dropped; remaining non-empty trimmed lines are the
+* method names, lowercased and de-duplicated (order preserved).
+*/
+function parseHwAccelsOutput(stdout) {
+	const seen = /* @__PURE__ */ new Set();
+	const methods = [];
+	for (const raw of stdout.split("\n")) {
+		const line = raw.trim().toLowerCase();
+		if (line.length === 0) continue;
+		if (line.endsWith("methods:")) continue;
+		if (seen.has(line)) continue;
+		seen.add(line);
+		methods.push(line);
+	}
+	return methods;
+}
+/**
+* Probes which `-hwaccel` decode backends the configured ffmpeg binary
+* supports. Mirrors {@link HardwareEncoderProber} (configured binary, cached,
+* single-flight, forceable). Never throws: a probe failure yields an empty
+* method list so callers fall back to software decode.
+*/
+var HardwareDecodeAccelProber = class {
+	cached = null;
+	inflight = null;
+	logger;
+	ffmpegPath;
+	execFn;
+	constructor(logger, ffmpegPath = "ffmpeg", execFn = defaultExecFn) {
+		this.logger = logger;
+		this.ffmpegPath = ffmpegPath;
+		this.execFn = execFn;
+	}
+	getCached() {
+		return this.cached;
+	}
+	async probe(options = {}) {
+		if (!options.force && this.cached) return this.cached;
+		if (this.inflight) return this.inflight;
+		this.inflight = this.runProbe().then((res) => {
+			this.cached = res;
+			this.inflight = null;
+			return res;
+		}).catch((err) => {
+			this.inflight = null;
+			throw err;
+		});
+		return this.inflight;
+	}
+	async runProbe() {
+		try {
+			const { stdout } = await this.execFn(this.ffmpegPath, ["-hide_banner", "-hwaccels"]);
+			const methods = parseHwAccelsOutput(stdout);
+			this.logger.info("Hardware decode-accel probe complete", { meta: { methods } });
+			return {
+				methods,
+				probedAt: Date.now()
+			};
+		} catch (err) {
+			this.logger.warn("Hardware decode-accel probe failed — assuming none available", { meta: { error: errMsg(err) } });
+			return {
+				methods: [],
+				probedAt: Date.now()
+			};
+		}
+	}
+};
+//#endregion
+//#region src/builtins/platform-probe/index.ts
+var PlatformProbeNativeAddon = class extends BaseAddon {
+	scorer = null;
+	encoderProber = null;
+	decodeAccelProber = null;
+	cachedCaps = null;
+	constructor() {
+		super({});
+	}
+	/**
+	* Resolve the ffmpeg binary the encoder probe should test, from the cluster
+	* `ffmpeg` config section (`binaryPath`). The probe MUST exercise the same
+	* binary the broker/recorder spawn, or it may report encoders for a different
+	* ffmpeg. Defaults to PATH `ffmpeg` on any miss.
+	*/
+	async resolveFfmpegBinaryPath() {
+		try {
+			const bp = (await this.ctx.settings?.getSection("ffmpeg") ?? {})["binaryPath"];
+			return typeof bp === "string" && bp.trim().length > 0 ? bp : "ffmpeg";
+		} catch {
+			return "ffmpeg";
+		}
+	}
+	async onInitialize() {
+		const embeddedPython = await this.ctx.deps.ensurePython().catch((err) => {
+			this.ctx.logger.debug("ensurePython unavailable for platform probe", { meta: { error: errMsg(err) } });
+			return null;
+		});
+		this.scorer = new PlatformScorer(this.ctx.logger, embeddedPython);
+		const ffmpegPath = await this.resolveFfmpegBinaryPath();
+		this.encoderProber = new HardwareEncoderProber(this.ctx.logger, ffmpegPath);
+		this.decodeAccelProber = new HardwareDecodeAccelProber(this.ctx.logger, ffmpegPath);
+		const emitPhase = (phase, payload) => {
+			this.ctx.eventBus?.emit({
+				id: `platform-probe-${phase}-${Date.now()}`,
+				timestamp: /* @__PURE__ */ new Date(),
+				source: {
+					type: "core",
+					id: "platform-probe-native"
+				},
+				category: EventCategory.PlatformProbePhase,
+				data: {
+					type: "platform-probe.phase",
+					phase,
+					...payload
+				}
+			});
+		};
+		const probePromise = this.scorer.probe(emitPhase).then((caps) => {
+			this.cachedCaps = caps;
+			this.ctx.logger.info("Platform probe complete", { meta: {
+				cpuModel: caps.hardware.cpuModel,
+				arch: caps.hardware.arch,
+				totalRAM_MB: caps.hardware.totalRAM_MB,
+				gpu: caps.hardware.gpu?.name ?? "none",
+				bestReason: caps.bestScore.reason,
+				bestScore: caps.bestScore.score
+			} });
+			return caps;
+		}).catch((err) => {
+			const msg = errMsg(err);
+			this.ctx.logger.error("Platform probe failed", { meta: { error: msg } });
+			emitPhase("error", { message: msg });
+			throw err;
+		});
+		const getCaps = async () => {
+			return this.cachedCaps ?? probePromise;
+		};
+		return [{
+			capability: platformProbeCapability,
+			provider: {
+				getCapabilities: async () => {
+					return getCaps();
+				},
+				getHardware: async () => {
+					return (await getCaps()).hardware;
+				},
+				resolveInferenceConfig: async (input) => {
+					const caps = await getCaps();
+					return new InferenceConfigResolver(caps.scores, caps.hardware).resolve(input.requirements);
+				},
+				resolveHwAccel: async (input) => {
+					const hwaccel = this.ctx.kernel.hwaccel;
+					if (!hwaccel) return { preferred: [] };
+					return { preferred: (await hwaccel.resolve(input.prefer ?? null)).preferred };
+				},
+				getHardwareEncoders: async () => {
+					const prober = this.encoderProber;
+					if (!prober) throw new Error("Hardware encoder prober not initialized");
+					const cached = prober.getCached();
+					if (cached) return cached;
+					const caps = await getCaps();
+					return prober.probe(caps.hardware);
+				},
+				refreshHardwareEncoders: async () => {
+					const prober = this.encoderProber;
+					if (!prober) throw new Error("Hardware encoder prober not initialized");
+					const caps = await getCaps();
+					return prober.probe(caps.hardware, { force: true });
+				},
+				getHardwareDecodeAccels: async () => {
+					const prober = this.decodeAccelProber;
+					if (!prober) throw new Error("Hardware decode-accel prober not initialized");
+					return prober.probe();
+				},
+				refreshHardwareDecodeAccels: async () => {
+					const prober = this.decodeAccelProber;
+					if (!prober) throw new Error("Hardware decode-accel prober not initialized");
+					return prober.probe({ force: true });
+				}
+			}
+		}];
+	}
+	async onShutdown() {
+		this.scorer = null;
+		this.encoderProber = null;
+		this.decodeAccelProber = null;
+		this.cachedCaps = null;
+	}
+};
+//#endregion
+export { HardwareDecodeAccelProber, HardwareEncoderProber, InferenceConfigResolver, PlatformProbeNativeAddon, PlatformProbeNativeAddon as default, PlatformScorer };