@camstack/system 1.1.24 → 1.1.26

package/dist/addon-runner.js

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_manifest_python_deps = require("./manifest-python-deps-XWJwKYDx.js");
+const require_manifest_python_deps = require("./manifest-python-deps-CCmnJmNf.js");
 const require_custom_action_registry = require("./custom-action-registry-vLYEFTtv.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);

package/dist/addon-runner.mjs

@@ -1,4 +1,4 @@
-import { I as createUdsLoggerWithControl, L as LocalChildClient, at as setWorkerNativeCapsChangeListener, bt as resolveAddonClass, i as createUdsAddonContext, nt as getWorkerNativeCapProvider, rt as getWorkerNativeCapSnapshot, st as validateProviderRegistrations, t as installManifestPythonDeps, yt as installManifestNativeDeps } from "./manifest-python-deps-CPJXzrZt.mjs";
+import { F as createUdsLoggerWithControl, I as LocalChildClient, i as createUdsAddonContext, it as setWorkerNativeCapsChangeListener, nt as getWorkerNativeCapSnapshot, ot as validateProviderRegistrations, t as installManifestPythonDeps, tt as getWorkerNativeCapProvider, vt as installManifestNativeDeps, yt as resolveAddonClass } from "./manifest-python-deps-DPA7N9UP.mjs";
 import { t as CustomActionRegistry } from "./custom-action-registry-BEXwC-oo.mjs";
 import { register } from "node:module";
 import * as fs from "node:fs";

package/dist/builtins/platform-probe/index.d.ts

@@ -1,21 +1,32 @@
 import { ProviderRegistration, BaseAddon } from '@camstack/types';
 export { PlatformScorer } from './platform-scorer.js';
 export { InferenceConfigResolver } from './inference-config-resolver.js';
-export { HardwareEncoderProber } from './hardware-encoder-probe.js';
-export { HardwareDecodeAccelProber } from './hardware-decode-accel-probe.js';
 export declare class PlatformProbeNativeAddon extends BaseAddon {
     private scorer;
-    private encoderProber;
-    private decodeAccelProber;
     private cachedCaps;
+    /**
+     * Per-boot generation stamp for the manual readiness emissions below.
+     * Constant for the lifetime of this addon instance (== one process boot);
+     * consumer-side registries derive a monotonic epoch from generation
+     * transitions. Mirrors `BaseAddon._readinessGeneration` (private there).
+     */
+    private readonly readinessGeneration;
     constructor();
     /**
-     * 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.
+     * Manual readiness protocol. The provider registers synchronously from
+     * `onInitialize`, but the REAL hardware + EP scoring is the async
+     * `probePromise` (embedded-Python install included). The BaseAddon
+     * auto-emit would flip `ready` at registration time — BEFORE any
+     * accelerator is visible — so probe-gated consumers (detection-pipeline
+     * engine auto-pick) would read accelerator-blind results and stick on
+     * onnx-CPU. Instead: `starting` at init, the single authoritative
+     * `ready` once the probe resolves, `down` on shutdown.
      */
-    private resolveFfmpegBinaryPath;
+    protected get autoEmitReadiness(): boolean;
+    /** Bare cluster node id — readiness is scoped `{type:'node', nodeId}`. */
+    private bareLocalNodeId;
+    /** Emit a `system.ready-state` transition for the platform-probe cap. */
+    private emitProbeReadiness;
     protected onInitialize(): Promise<ProviderRegistration[]>;
     protected onShutdown(): Promise<void>;
 }

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

@@ -18,7 +18,7 @@ node_os = require_chunk.__toESM(node_os);
 * entire Node process (WS handshakes, tRPC subscriptions, metrics — all
 * stalled). Keeping it async turns the probe into a true background task.
 */
-var execFileAsync$2 = (0, node_util.promisify)(node_child_process.execFile);
+var execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
 /** Minimal no-op logger for default parameter */
 var noopLogger = {
 	debug() {},
@@ -46,7 +46,7 @@ async function getAvailableRAM_MB() {
 		const platform = node_os.platform();
 		try {
 			if (platform === "darwin") {
-				const { stdout: output } = await execFileAsync$2("vm_stat", [], {
+				const { stdout: output } = await execFileAsync("vm_stat", [], {
 					encoding: "utf8",
 					timeout: 3e3
 				});
@@ -171,7 +171,7 @@ var PlatformScorer = class {
 		}
 		if (platform === "linux") {
 			try {
-				const { stdout } = await execFileAsync$2("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader"], {
+				const { stdout } = await execFileAsync("nvidia-smi", ["--query-gpu=name,memory.total", "--format=csv,noheader"], {
 					encoding: "utf8",
 					timeout: 5e3
 				});
@@ -237,7 +237,7 @@ var PlatformScorer = class {
 			"python"
 		];
 		for (const cmd of candidates) try {
-			await execFileAsync$2(cmd, ["--version"], { timeout: 5e3 });
+			await execFileAsync(cmd, ["--version"], { timeout: 5e3 });
 			return cmd;
 		} catch (err) {
 			this.logger.debug(`Python command "${cmd}" not found`, { meta: { error: (0, _camstack_types.errMsg)(err) } });
@@ -335,296 +335,91 @@ var InferenceConfigResolver = class {
 	}
 };
 //#endregion
-//#region src/builtins/platform-probe/hardware-encoder-probe.ts
-var execFileAsync$1 = (0, node_util.promisify)(node_child_process.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 = node_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: (0, _camstack_types.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 = (0, node_util.promisify)(node_child_process.execFile);
-var defaultExecFn = async (ffmpegPath, args) => {
-	const { stdout } = await execFileAsync(ffmpegPath, [...args], {
-		timeout: 8e3,
-		encoding: "utf8"
-	});
-	return { stdout };
-};
+//#region src/builtins/platform-probe/index.ts
 /**
-* 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).
+* The decode-hwaccel backends `ctx.kernel.hwaccel.resolve` accepts. The cap
+* input enum is WIDER (it also carries EP-only names — coreml/openvino/… —
+* shared with other probe surfaces), so the provider param must stay
+* `string`-typed to satisfy the `InferProvider` contract. We narrow it here
+* with a type guard instead of a cast: any value that is not a known decode
+* backend (or the `'none'` sentinel) resolves to `null` → auto-probe.
 */
-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;
+var HWACCEL_DECODE_BACKENDS = [
+	"videotoolbox",
+	"cuda",
+	"nvdec",
+	"vaapi",
+	"qsv",
+	"d3d11va",
+	"dxva2",
+	"amf",
+	"vdpau",
+	"drm"
+];
+function isHwAccelBackend(value) {
+	return HWACCEL_DECODE_BACKENDS.includes(value);
+}
+function narrowHwAccelPrefer(value) {
+	if (value === "none") return "none";
+	if (typeof value === "string" && isHwAccelBackend(value)) return value;
+	return null;
 }
-/**
-* 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: (0, _camstack_types.errMsg)(err) } });
-			return {
-				methods: [],
-				probedAt: Date.now()
-			};
-		}
-	}
-};
-//#endregion
-//#region src/builtins/platform-probe/index.ts
 var PlatformProbeNativeAddon = class extends _camstack_types.BaseAddon {
 	scorer = null;
-	encoderProber = null;
-	decodeAccelProber = null;
 	cachedCaps = null;
+	/**
+	* Per-boot generation stamp for the manual readiness emissions below.
+	* Constant for the lifetime of this addon instance (== one process boot);
+	* consumer-side registries derive a monotonic epoch from generation
+	* transitions. Mirrors `BaseAddon._readinessGeneration` (private there).
+	*/
+	readinessGeneration = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).slice(2, 14);
 	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.
+	* Manual readiness protocol. The provider registers synchronously from
+	* `onInitialize`, but the REAL hardware + EP scoring is the async
+	* `probePromise` (embedded-Python install included). The BaseAddon
+	* auto-emit would flip `ready` at registration time — BEFORE any
+	* accelerator is visible — so probe-gated consumers (detection-pipeline
+	* engine auto-pick) would read accelerator-blind results and stick on
+	* onnx-CPU. Instead: `starting` at init, the single authoritative
+	* `ready` once the probe resolves, `down` on shutdown.
 	*/
-	async resolveFfmpegBinaryPath() {
+	get autoEmitReadiness() {
+		return false;
+	}
+	/** Bare cluster node id — readiness is scoped `{type:'node', nodeId}`. */
+	bareLocalNodeId() {
+		const raw = this.ctx.kernel?.localNodeId ?? "hub";
+		return raw.includes("/") ? raw.split("/")[0] : raw;
+	}
+	/** Emit a `system.ready-state` transition for the platform-probe cap. */
+	emitProbeReadiness(state) {
+		const ctx = this.ctxIfReady;
+		if (!ctx) return;
+		const nodeId = this.bareLocalNodeId();
 		try {
-			const bp = (await this.ctx.settings?.getSection("ffmpeg") ?? {})["binaryPath"];
-			return typeof bp === "string" && bp.trim().length > 0 ? bp : "ffmpeg";
-		} catch {
-			return "ffmpeg";
-		}
+			(0, _camstack_types.emitReadiness)(ctx.eventBus, {
+				capName: _camstack_types.platformProbeCapability.name,
+				scope: {
+					type: "node",
+					nodeId
+				},
+				state,
+				generation: this.readinessGeneration,
+				sourceNodeId: nodeId
+			});
+		} catch {}
 	}
 	async onInitialize() {
+		this.emitProbeReadiness("starting");
 		const embeddedPython = await this.ctx.deps.ensurePython().catch((err) => {
 			this.ctx.logger.debug("ensurePython unavailable for platform probe", { meta: { error: (0, _camstack_types.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()}`,
@@ -651,6 +446,7 @@ var PlatformProbeNativeAddon = class extends _camstack_types.BaseAddon {
 				bestReason: caps.bestScore.reason,
 				bestScore: caps.bestScore.score
 			} });
+			this.emitProbeReadiness("ready");
 			return caps;
 		}).catch((err) => {
 			const msg = (0, _camstack_types.errMsg)(err);
@@ -676,46 +472,26 @@ var PlatformProbeNativeAddon = class extends _camstack_types.BaseAddon {
 				},
 				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 });
+					if (!hwaccel) return {
+						preferred: [],
+						rationale: "kernel hwaccel unavailable"
+					};
+					const res = await hwaccel.resolve(narrowHwAccelPrefer(input.prefer));
+					return {
+						preferred: res.preferred,
+						rationale: res.rationale
+					};
 				}
 			}
 		}];
 	}
 	async onShutdown() {
+		this.emitProbeReadiness("down");
 		this.scorer = null;
-		this.encoderProber = null;
-		this.decodeAccelProber = null;
 		this.cachedCaps = null;
 	}
 };
 //#endregion
-exports.HardwareDecodeAccelProber = HardwareDecodeAccelProber;
-exports.HardwareEncoderProber = HardwareEncoderProber;
 exports.InferenceConfigResolver = InferenceConfigResolver;
 exports.PlatformProbeNativeAddon = PlatformProbeNativeAddon;
 exports.default = PlatformProbeNativeAddon;