@camstack/addon-pipeline 1.2.345 → 1.2.346

package/dist/pipeline-runner/index.js

@@ -3,15 +3,19 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-_I6JkuJ8.js");
-const require_node = require("../node-6zL5ddry.js");
-const require_custom_model_catalog = require("../custom-model-catalog-CrEsRBe_.js");
+const require_dist = require("../dist-qBCVRsyf.js");
+const require_node = require("../node-DmCpPH58.js");
+const require_custom_model_catalog = require("../custom-model-catalog-B0QdF7dJ.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
 let node_child_process = require("node:child_process");
 let sharp = require("sharp");
 sharp = require_chunk.__toESM(sharp);
@@ -3181,6 +3185,7 @@ async function executeCapacityRamp(opts) {
 			onMeasureStart: () => {
 				stallStart = opts.stallSnapshot();
 				rssStart = opts.rssMb();
+				opts.onMeasureStartHook?.();
 				opts.onStep?.({
 					stepIndex,
 					cameras,
@@ -3189,15 +3194,25 @@ async function executeCapacityRamp(opts) {
 			}
 		});
 		const stall = diffStallWindow(stallStart, opts.stallSnapshot());
-		const verdict = evaluateCapacityStep(raw, stall, opts.slo);
-		const step = {
+		const evaluated = evaluateCapacityStep(raw, stall, opts.slo);
+		const base = {
 			cameras,
 			raw,
 			stall,
-			verdict,
+			verdict: evaluated,
 			rssStartMb: rssStart,
 			rssEndMb: opts.rssMb()
 		};
+		const extra = opts.extraFailReasons?.(base) ?? [];
+		const verdict = extra.length === 0 ? evaluated : {
+			...evaluated,
+			pass: false,
+			failReasons: [...evaluated.failReasons, ...extra]
+		};
+		const step = {
+			...base,
+			verdict
+		};
 		steps.push(step);
 		firstClass += raw.firstClassShed;
 		fallback += raw.fallbackShed;
@@ -7360,6 +7375,699 @@ async function runStatelessStep(deps, input) {
 		details
 	};
 }
+//#endregion
+//#region src/pipeline-runner/node-bench/bench-frames.ts
+/**
+* The frames a node benchmark runs on (D791), decoded ONCE on the node into
+* RAM at the detection size — never shipped across a process per call (D9).
+*
+* Source, in order:
+*  1. the public bench clip (`camstack-bench-v1`, CC-licensed composite with
+*     a synthetic plate — `docs/benchmarks/bench-clip.md`), downloaded once
+*     into the runner's data dir and accepted ONLY when its sha256 matches
+*     the pinned revision; decoded with the node's pinned ffmpeg;
+*  2. otherwise the executor's reference images (always on the node). The
+*     run says which (`clip.id`), so a result never claims the clip it did
+*     not use.
+*/
+/**
+* The published clip, pinned to the exact build uploaded to the HF dataset
+* repo (`scripts/bench-clip/build-bench-clip.sh` prints the hash). A download
+* that fails (not uploaded yet) or whose bytes differ falls back to the
+* reference images, and the run says so. `sha256: null` disables the clip.
+*/
+var BENCH_CLIP = {
+	id: "camstack-bench-v1",
+	revision: "v1",
+	fileName: "camstack-bench-v1-h264-1080p.mp4",
+	url: "https://huggingface.co/datasets/camstack/camstack-bench-clips/resolve/main/camstack-bench-v1/camstack-bench-v1-h264-1080p.mp4",
+	sha256: "677eea6ccb5711dafe70ac7259aa152b8fad3e5704da1a8a8c66e6b1717f1434"
+};
+async function sha256Of(file) {
+	const hash = (0, node_crypto.createHash)("sha256");
+	for await (const chunk of (0, node_fs.createReadStream)(file)) hash.update(chunk);
+	return hash.digest("hex");
+}
+/** The verified clip on disk, downloading it when absent or wrong. Null when unavailable. */
+async function ensureBenchClip(deps) {
+	const clip = deps.clip ?? BENCH_CLIP;
+	if (clip.sha256 === null) return null;
+	const dir = node_path.default.join(deps.dataDir, "bench");
+	const file = node_path.default.join(dir, clip.fileName);
+	try {
+		if (await sha256Of(file) === clip.sha256) return file;
+	} catch {}
+	await node_fs.promises.mkdir(dir, { recursive: true });
+	const staged = `${file}.downloading`;
+	const res = await deps.fetch(clip.url);
+	if (!res.ok || res.body === null) throw new Error(`bench clip download: HTTP ${res.status}`);
+	await node_fs.promises.writeFile(staged, new Uint8Array(await res.arrayBuffer()));
+	const got = await sha256Of(staged);
+	if (got !== clip.sha256) {
+		await node_fs.promises.rm(staged, { force: true });
+		throw new Error(`bench clip download: sha256 ${got} is not the pinned ${clip.sha256}`);
+	}
+	await node_fs.promises.rename(staged, file);
+	return file;
+}
+/** Decode `count` evenly spread frames of `file` to raw RGB with the node's ffmpeg. */
+async function decodeClipFrames(ffmpeg, file, count) {
+	const frameBytes = 640 * 360 * 3;
+	const args = [
+		"-v",
+		"error",
+		"-i",
+		file,
+		"-vf",
+		`fps=1,scale=640:360`,
+		"-frames:v",
+		String(count),
+		"-pix_fmt",
+		"rgb24",
+		"-f",
+		"rawvideo",
+		"pipe:1"
+	];
+	const chunks = [];
+	const stderr = [];
+	const code = await new Promise((resolve, reject) => {
+		const child = (0, node_child_process.spawn)(ffmpeg, args, { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		child.stdout.on("data", (c) => chunks.push(c));
+		child.stderr.on("data", (c) => stderr.push(c));
+		child.on("error", reject);
+		child.on("close", resolve);
+	});
+	if (code !== 0) throw new Error(`bench clip decode failed (${code}): ${Buffer.concat(stderr).toString().slice(0, 300)}`);
+	const all = Buffer.concat(chunks);
+	const frames = [];
+	for (let off = 0; off + frameBytes <= all.length; off += frameBytes) frames.push({
+		data: new Uint8Array(all.subarray(off, off + frameBytes)),
+		width: 640,
+		height: 360
+	});
+	return frames;
+}
+/** The clip's frames, else the reference images'. Throws only when neither yields a frame. */
+async function loadBenchFrames(deps) {
+	const clip = deps.clip ?? BENCH_CLIP;
+	try {
+		const file = await ensureBenchClip(deps);
+		if (file !== null) {
+			const frames = await decodeClipFrames(await deps.ensureFfmpeg(), file, 120);
+			if (frames.length > 0) return {
+				frames,
+				clip: {
+					id: clip.id,
+					revision: clip.revision,
+					frames: frames.length,
+					width: 640,
+					height: 360
+				}
+			};
+		} else deps.log("bench clip not published yet — measuring on the reference images");
+	} catch (err) {
+		deps.log("bench clip unavailable — measuring on the reference images", { error: err instanceof Error ? err.message : String(err) });
+	}
+	const frames = [];
+	for (const jpeg of await deps.referenceImages()) try {
+		frames.push(await deps.decodeJpeg(jpeg, 640));
+	} catch {}
+	if (frames.length === 0) throw new Error("node bench: neither the bench clip nor a reference image could be decoded");
+	return {
+		frames,
+		clip: {
+			id: "reference-images",
+			revision: null,
+			frames: frames.length,
+			width: frames[0]?.width ?? 0,
+			height: frames[0]?.height ?? 0
+		}
+	};
+}
+var WARMUP_CALLS = 3;
+var DETECTOR_STEP = "object-detection";
+function rootOnly(modelId) {
+	return [{
+		addonId: DETECTOR_STEP,
+		modelId,
+		enabled: true,
+		children: []
+	}];
+}
+/** Which limit a failing step hit first, from its reasons. */
+function limitOf(reasons) {
+	const has = (prefix) => reasons.some((r) => r.startsWith(prefix));
+	if (has("errors") || has("unresolved")) return "errors";
+	if (has("cpu")) return "cpu";
+	if (has("ram")) return "ram";
+	if (has("event-loop")) return "stall";
+	if (has("e2e p95")) return "p95";
+	if (has("dropRatio")) return "drops";
+	return "none";
+}
+function rampStepOf(step, measureSec, system) {
+	return {
+		load: step.cameras,
+		pass: step.verdict.pass,
+		p95Ms: Math.round(step.verdict.e2eMs.p95 * 10) / 10,
+		dropRatio: Math.round(step.verdict.dropRatio * 1e4) / 1e4,
+		fps: Math.round(step.raw.completed / Math.max(measureSec, 1e-9) * 10) / 10,
+		cpuPct: system?.cpuPct ?? null,
+		ramFreePct: system?.ramFreePct ?? null,
+		failReasons: step.verdict.failReasons
+	};
+}
+var NodeBenchDriver = class {
+	deps;
+	frameIndex = 0;
+	cellsDone = 0;
+	cellsTotal;
+	constructor(deps) {
+		this.deps = deps;
+		const { input } = deps;
+		const deviceCells = input.phases.includes("device") ? input.devices.reduce((n, d) => n + d.modelIds.length, 0) : 0;
+		const pipelineCells = input.phases.includes("pipeline") ? input.devices.length : 0;
+		this.cellsTotal = deviceCells + pipelineCells;
+	}
+	nextFrame() {
+		const frames = this.deps.frames;
+		const frame = frames[this.frameIndex % frames.length];
+		this.frameIndex += 1;
+		if (frame === void 0) throw new Error("node bench: no frames");
+		return frame;
+	}
+	progress(p) {
+		this.deps.onProgress({
+			...p,
+			cellsDone: this.cellsDone,
+			cellsTotal: this.cellsTotal
+		});
+	}
+	async warmup(steps, deviceKey, plane) {
+		const t0 = this.deps.now();
+		let firstMs = 0;
+		for (let i = 0; i < WARMUP_CALLS; i++) {
+			const started = this.deps.now();
+			await this.deps.dispatch({
+				steps,
+				deviceKey,
+				plane,
+				frame: this.nextFrame()
+			});
+			if (i === 0) firstMs = this.deps.now() - started;
+		}
+		return Math.max(firstMs, 0) || this.deps.now() - t0;
+	}
+	ramp(opts) {
+		const { input } = this.deps;
+		const frameIntervalMs = 1e3 / input.fpsPerStream;
+		const system = /* @__PURE__ */ new Map();
+		const dispatch = async () => {
+			const r = await this.deps.dispatch({
+				steps: opts.steps,
+				deviceKey: opts.deviceKey,
+				plane: opts.plane,
+				frame: this.nextFrame()
+			});
+			opts.onStepsRan?.(r.stepsRan);
+			if (r.shed) return {
+				kind: "shed",
+				shedSignal: "first-class"
+			};
+			return {
+				kind: "ok",
+				inferMs: r.inferMs,
+				predictMs: r.predictMs,
+				detections: r.detections
+			};
+		};
+		return executeCapacityRamp({
+			ramp: opts.loads,
+			fpsPerCamera: input.fpsPerStream,
+			settleMs: input.settleSec * 1e3,
+			measureMs: input.measureSec * 1e3,
+			drainTimeoutMs: Math.max(5e3, frameIntervalMs * 20),
+			slo: {
+				dropRatioMax: .01,
+				e2eP95MsMax: frameIntervalMs,
+				stallsMax: 0
+			},
+			stopOnFirstFail: true,
+			dispatch,
+			now: this.deps.now,
+			sleepUntil: this.deps.sleepUntil,
+			shouldStop: this.deps.shouldStop,
+			stallSnapshot: this.deps.stallSnapshot,
+			rssMb: this.deps.rssMb,
+			...opts.withSystemGate ? {
+				extraFailReasons: (step) => {
+					const s = this.deps.sampleSystem();
+					system.set(step.cameras, s);
+					const out = [];
+					if (s.cpuPct > 85) out.push(`cpu ${Math.round(s.cpuPct)}% > 85%`);
+					if (s.ramFreePct < 15) out.push(`ram free ${Math.round(s.ramFreePct)}% < 15%`);
+					return out;
+				},
+				onMeasureStartHook: () => {
+					this.deps.sampleSystem();
+				}
+			} : {},
+			onStep: (info) => {
+				if (info.phase === "done") return;
+				this.progress({
+					...opts.label,
+					load: info.cameras,
+					message: `${opts.label.phase === "device" ? "streams" : "sessions"} ${info.cameras} · ${info.phase}`
+				});
+			}
+		}).then((outcome) => ({
+			steps: [...outcome.steps],
+			system,
+			aborted: outcome.aborted
+		}));
+	}
+	/** A cell whose ramp was cut short measured nothing reliable — null. */
+	async measureDevice(deviceKey, modelId) {
+		const steps = rootOnly(modelId);
+		const label = {
+			phase: "device",
+			deviceKey,
+			modelId
+		};
+		this.progress({
+			...label,
+			load: null,
+			message: "loading the model"
+		});
+		const warmupMs = await this.warmup(steps, deviceKey, "frame");
+		const { steps: ramp, aborted } = await this.ramp({
+			loads: require_dist.DEVICE_RAMP,
+			steps,
+			deviceKey,
+			plane: "frame",
+			withSystemGate: false,
+			label
+		});
+		if (aborted) return null;
+		const last = ramp.filter((s) => s.verdict.pass).at(-1);
+		const first = ramp[0];
+		const failed = ramp.find((s) => !s.verdict.pass);
+		const single = first?.raw.e2eMsList ?? [];
+		return {
+			phase: "device",
+			deviceKey,
+			modelId,
+			p50Ms: Math.round(percentile(single, .5) * 10) / 10,
+			p95Ms: Math.round(percentile(single, .95) * 10) / 10,
+			p99Ms: Math.round(percentile(single, .99) * 10) / 10,
+			fps: last === void 0 ? 0 : Math.round(last.raw.completed / this.deps.input.measureSec * 10) / 10,
+			kMax: last?.cameras ?? 0,
+			limitedBy: failed === void 0 ? "none" : limitOf(failed.verdict.failReasons),
+			warmupMs: Math.round(warmupMs),
+			ramp: ramp.map((s) => rampStepOf(s, this.deps.input.measureSec, null))
+		};
+	}
+	async measurePipeline(deviceKey, modelId) {
+		const steps = await this.deps.pipelineSteps(modelId);
+		const label = {
+			phase: "pipeline",
+			deviceKey,
+			modelId
+		};
+		this.progress({
+			...label,
+			load: null,
+			message: "loading the pipeline"
+		});
+		const fired = /* @__PURE__ */ new Set();
+		const warmupMs = await this.warmup(steps, deviceKey, "full");
+		const { steps: ramp, system, aborted } = await this.ramp({
+			loads: require_dist.PIPELINE_RAMP,
+			steps,
+			deviceKey,
+			plane: "full",
+			withSystemGate: true,
+			onStepsRan: (ran) => {
+				for (const s of ran) fired.add(s);
+			},
+			label
+		});
+		if (aborted) return null;
+		const last = ramp.filter((s) => s.verdict.pass).at(-1);
+		const failed = ramp.find((s) => !s.verdict.pass);
+		return {
+			phase: "pipeline",
+			deviceKey,
+			modelId,
+			steps: this.deps.input.steps,
+			maxSessions: last?.cameras ?? 0,
+			limitedBy: failed === void 0 ? "none" : limitOf(failed.verdict.failReasons),
+			stepsFired: this.deps.input.steps.filter((s) => fired.has(s)),
+			warmupMs: Math.round(warmupMs),
+			ramp: ramp.map((s) => rampStepOf(s, this.deps.input.measureSec, system.get(s.cameras) ?? null))
+		};
+	}
+	/** Run every cell the input asks for; stops between steps when told to. */
+	async run() {
+		const { input } = this.deps;
+		if (input.phases.includes("device")) for (const device of input.devices) for (const modelId of device.modelIds) {
+			if (this.deps.shouldStop()) return;
+			const cell = await this.measureDevice(device.deviceKey, modelId);
+			this.cellsDone += 1;
+			if (cell !== null) this.deps.onCell(cell);
+		}
+		if (input.phases.includes("pipeline")) for (const device of input.devices) {
+			const modelId = device.modelIds[0];
+			if (modelId === void 0 || this.deps.shouldStop()) return;
+			const cell = await this.measurePipeline(device.deviceKey, modelId);
+			this.cellsDone += 1;
+			if (cell !== null) this.deps.onCell(cell);
+		}
+	}
+};
+//#endregion
+//#region src/pipeline-runner/node-bench/node-bench-host.ts
+/**
+* The runner side of the node benchmark (D791): one run per node, started
+* by the orchestrator through `nodePin`, answered at once and polled. Holds
+* the run's status in RAM (a restarted runner forgets it — the orchestrator
+* reads that as `runner-lost` and restores the cluster), stops itself at the
+* deadline whatever the hub does, and deletes the models it downloaded that
+* were not installed before (unless told to keep them).
+*/
+/** Node CPU % between two calls (all cores), and free RAM %. */
+function createSystemSampler() {
+	const totals = () => node_os.default.cpus().reduce((acc, c) => {
+		const t = c.times;
+		return {
+			idle: acc.idle + t.idle,
+			total: acc.total + t.user + t.nice + t.sys + t.idle + t.irq
+		};
+	}, {
+		idle: 0,
+		total: 0
+	});
+	let prev = totals();
+	return () => {
+		const now = totals();
+		const total = now.total - prev.total;
+		const idle = now.idle - prev.idle;
+		prev = now;
+		return {
+			cpuPct: total > 0 ? Math.round((1 - idle / total) * 1e3) / 10 : 0,
+			ramFreePct: Math.round(node_os.default.freemem() / node_os.default.totalmem() * 1e3) / 10
+		};
+	};
+}
+/** Runs kept for status reads after they end. */
+var KEEP_FINISHED = 5;
+var NodeBenchHost = class {
+	deps;
+	runs = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	now() {
+		return this.deps.now?.() ?? Date.now();
+	}
+	start(raw) {
+		const input = require_dist.NodeBenchRunnerInputSchema.parse(raw);
+		if (this.runs.get(input.runId) !== void 0) return {
+			accepted: true,
+			runId: input.runId
+		};
+		for (const [id, run] of this.runs) if (run.status.state === "running") throw new Error(`node bench: run ${id} is measuring this node — one at a time`);
+		const state = {
+			stop: false,
+			status: {
+				runId: input.runId,
+				nodeId: this.deps.nodeId,
+				state: "running",
+				progress: null,
+				cells: [],
+				fingerprint: null,
+				clip: null,
+				activeCameraIds: [...this.deps.activeCameraIds()],
+				deletedModels: [],
+				error: null,
+				startedAtMs: this.now(),
+				finishedAtMs: null
+			}
+		};
+		this.runs.set(input.runId, state);
+		this.prune();
+		this.execute(input, state);
+		return {
+			accepted: true,
+			runId: input.runId
+		};
+	}
+	status(runId) {
+		return this.runs.get(runId)?.status ?? null;
+	}
+	abort(runId) {
+		const run = this.runs.get(runId);
+		if (run === void 0 || run.status.state !== "running") return { aborted: false };
+		run.stop = true;
+		return { aborted: true };
+	}
+	prune() {
+		const finished = [...this.runs.values()].filter((r) => r.status.state !== "running").toSorted((a, b) => b.status.startedAtMs - a.status.startedAtMs);
+		for (const old of finished.slice(KEEP_FINISHED)) this.runs.delete(old.status.runId);
+	}
+	patch(state, patch) {
+		state.status = {
+			...state.status,
+			...patch
+		};
+	}
+	noteActiveCameras(state) {
+		const seen = new Set([...state.status.activeCameraIds, ...this.deps.activeCameraIds()]);
+		if (seen.size !== state.status.activeCameraIds.length) this.patch(state, { activeCameraIds: [...seen].toSorted((a, b) => a - b) });
+	}
+	async execute(input, state) {
+		const shouldStop = () => state.stop || this.now() >= input.deadlineAtMs;
+		const sampler = this.deps.startStallSampler();
+		const installedBefore = await this.deps.installedDetectorModels().catch(() => null);
+		try {
+			this.patch(state, { progress: this.preparing(input, "decoding the bench frames") });
+			const deviceKeys = input.devices.map((d) => d.deviceKey);
+			const [frameSet, fingerprint] = await Promise.all([this.deps.loadFrames(), this.deps.fingerprint(deviceKeys).catch(() => null)]);
+			this.patch(state, {
+				clip: frameSet.clip,
+				fingerprint
+			});
+			this.deps.log("info", "node bench start", {
+				runId: input.runId,
+				clip: frameSet.clip.id,
+				frames: frameSet.frames.length,
+				devices: deviceKeys,
+				phases: input.phases
+			});
+			await new NodeBenchDriver({
+				input,
+				frames: frameSet.frames,
+				dispatch: this.deps.dispatch,
+				pipelineSteps: (modelId) => this.deps.pipelineSteps(modelId, input.steps),
+				now: () => this.now(),
+				sleepUntil: this.deps.sleepUntil ?? ((t) => new Promise((resolve) => {
+					setTimeout(resolve, Math.max(0, t - this.now())).unref?.();
+				})),
+				shouldStop,
+				stallSnapshot: sampler.snapshot,
+				rssMb: () => Math.round(process.memoryUsage().rss / 1e6),
+				sampleSystem: this.deps.sampleSystem ?? createSystemSampler(),
+				onProgress: (progress) => {
+					this.noteActiveCameras(state);
+					this.patch(state, { progress });
+				},
+				onCell: (cell) => {
+					this.patch(state, { cells: [...state.status.cells, cell] });
+					this.deps.log("info", "node bench cell", {
+						runId: input.runId,
+						phase: cell.phase,
+						deviceKey: cell.deviceKey,
+						modelId: cell.modelId,
+						...cell.phase === "device" ? {
+							kMax: cell.kMax,
+							fps: cell.fps,
+							p95Ms: cell.p95Ms
+						} : {
+							maxSessions: cell.maxSessions,
+							stepsFired: cell.stepsFired.join(",")
+						},
+						limitedBy: cell.limitedBy
+					});
+				}
+			}).run();
+			this.patch(state, { state: shouldStop() ? "aborted" : "done" });
+		} catch (err) {
+			const error = err instanceof Error ? err.message : String(err);
+			this.deps.log("warn", "node bench failed", {
+				runId: input.runId,
+				error
+			});
+			this.patch(state, {
+				state: "failed",
+				error
+			});
+		} finally {
+			sampler.stop();
+			await this.cleanupModels(input, state, installedBefore);
+			this.patch(state, {
+				finishedAtMs: this.now(),
+				progress: null
+			});
+		}
+	}
+	preparing(input, message) {
+		return {
+			phase: "preparing",
+			deviceKey: null,
+			modelId: null,
+			load: null,
+			cellsDone: 0,
+			cellsTotal: (input.phases.includes("device") ? input.devices.reduce((n, d) => n + d.modelIds.length, 0) : 0) + (input.phases.includes("pipeline") ? input.devices.length : 0),
+			message
+		};
+	}
+	/** Delete the candidate detectors the run fetched that were not installed before. */
+	async cleanupModels(input, state, before) {
+		if (input.keepDownloadedModels || before === null) return;
+		const after = await this.deps.installedDetectorModels().catch(() => null);
+		if (after === null) return;
+		const candidates = new Set(input.devices.flatMap((d) => d.modelIds));
+		const fetched = [...after].filter((key) => candidates.has(key.split("/")[0] ?? "") && !before.has(key));
+		const deleted = [];
+		for (const key of fetched) try {
+			await this.deps.deleteDetectorModel(key);
+			deleted.push(key);
+		} catch (err) {
+			this.deps.log("warn", "node bench: could not delete a downloaded model", {
+				model: key,
+				error: err instanceof Error ? err.message : String(err)
+			});
+		}
+		if (deleted.length > 0) this.patch(state, { deletedModels: deleted });
+	}
+};
+//#endregion
+//#region src/pipeline-runner/node-bench/node-bench-wiring.ts
+/**
+* Binds the node benchmark host (D791) to the runner's in-process executor:
+* every call is pinned to THIS node, so the frame never leaves the process
+* group that owns it (D9) and the numbers are this node's.
+*/
+var DETECTOR_ADDON = "object-detection";
+/** A stall this long fails a ramp step (the frame interval at 4 fps). */
+var BENCH_STALL_MS = 250;
+function isModelFormat(value) {
+	return require_dist.MODEL_FORMATS.includes(value);
+}
+function createNodeBenchHost(deps) {
+	const api = () => {
+		const a = deps.ctx().api;
+		if (!a) throw new Error("node bench: ctx.api unavailable");
+		return a;
+	};
+	const pin = () => require_dist.nodePin(deps.nodeId);
+	const log = deps.ctx().logger;
+	const decodeJpeg = async (jpeg, maxWidth) => {
+		const { data, info } = await (await require_lazy_sharp.getSharp())(Buffer.from(jpeg)).resize({
+			width: maxWidth,
+			withoutEnlargement: true
+		}).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+		return {
+			data: new Uint8Array(data),
+			width: info.width,
+			height: info.height
+		};
+	};
+	return new NodeBenchHost({
+		nodeId: deps.nodeId,
+		loadFrames: () => loadBenchFrames({
+			dataDir: deps.ctx().dataDir,
+			ensureFfmpeg: () => deps.ctx().deps.ensureFfmpeg(),
+			fetch: globalThis.fetch,
+			referenceImages: async () => {
+				const list = await api().pipelineExecutor.listReferenceImages.query(void 0, pin());
+				const out = [];
+				for (const entry of list) {
+					const img = await api().pipelineExecutor.getReferenceImage.query({ filename: entry.filename }, pin());
+					if (img) out.push(new Uint8Array(Buffer.from(img.base64, "base64")));
+				}
+				return out;
+			},
+			decodeJpeg,
+			log: (message, meta) => log.info(message, meta ? { meta } : void 0)
+		}),
+		dispatch: async ({ steps, deviceKey, plane, frame }) => {
+			const result = await api().pipelineExecutor.runPipeline.mutate({
+				steps: [...steps],
+				frame: {
+					data: frame.data,
+					format: "rgb",
+					width: frame.width,
+					height: frame.height,
+					timestamp: Date.now()
+				},
+				plane,
+				deviceKey
+			}, pin());
+			return {
+				shed: result.shed === true,
+				detections: result.detections.length,
+				inferMs: result.debug?.totalInferenceMs ?? 0,
+				predictMs: result.debug?.predictMs ?? 0,
+				stepsRan: [...new Set((result.debug?.stepTimings ?? []).filter((t) => t.ms > 0).map((t) => t.source))]
+			};
+		},
+		pipelineSteps: async (rootModelId, stepIds) => {
+			return require_dist.buildBenchStepTree(await api().pipelineExecutor.getSchema.query(void 0, pin()), rootModelId, stepIds);
+		},
+		fingerprint: async (deviceKeys) => {
+			const pools = {};
+			for (const deviceKey of deviceKeys) try {
+				const t = await api().pipelineExecutor.getEffectiveTuning.query({ deviceKey }, pin());
+				pools[deviceKey] = {
+					runtime: t.runtime,
+					numWorkers: t.numWorkers,
+					concurrency: t.concurrency,
+					batchMode: t.batchMode
+				};
+			} catch {}
+			return {
+				pipelineVersion: deps.pipelineVersion,
+				cpuModel: node_os.default.cpus()[0]?.model?.trim() ?? null,
+				ramGb: Math.round(node_os.default.totalmem() / 1e9),
+				os: `${node_os.default.platform()}-${node_os.default.arch()}`,
+				pools
+			};
+		},
+		installedDetectorModels: async () => {
+			const models = await api().pipelineExecutor.getAddonModels.query({ addonId: DETECTOR_ADDON }, pin());
+			const out = /* @__PURE__ */ new Set();
+			for (const m of models) for (const [format, status] of Object.entries(m.formats)) if (status?.downloaded === true) out.add(`${m.id}/${format}`);
+			return out;
+		},
+		deleteDetectorModel: async (key) => {
+			const [modelId = "", format = ""] = key.split("/");
+			if (!isModelFormat(format)) return;
+			await api().pipelineExecutor.deleteModel.mutate({
+				addonId: DETECTOR_ADDON,
+				modelId,
+				format
+			}, pin());
+		},
+		activeCameraIds: deps.activeCameraIds,
+		startStallSampler: () => startStallSampler({ reportThresholdMs: BENCH_STALL_MS }),
+		log: (level, message, meta) => log[level](message, meta ? { meta } : void 0)
+	});
+}
 /**
 * Normalised boxes for the subjects worth a tile, highest confidence first,
 * capped.
@@ -10010,6 +10718,25 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	* `executionFormat` reports — so the servability check and the dispatch
 	* cannot disagree about which format was verified.
 	*/
+	nodeBenchHost = null;
+	nodeBench() {
+		this.nodeBenchHost ??= createNodeBenchHost({
+			nodeId: this.nodeId,
+			ctx: () => this.ctx,
+			activeCameraIds: () => (this.runner?.getAllCameraMetrics() ?? []).filter((m) => m.phase !== "idle").map((m) => m.deviceId),
+			pipelineVersion: null
+		});
+		return this.nodeBenchHost;
+	}
+	async startNodeBench(input) {
+		return this.nodeBench().start(input);
+	}
+	async getNodeBenchStatus(input) {
+		return this.nodeBench().status(input.runId);
+	}
+	async abortNodeBench(input) {
+		return this.nodeBench().abort(input.runId);
+	}
 	async runStatelessStep(input) {
 		const convention = await this.cropConvention.refresh(this.ctxIfReady?.api);
 		return runStatelessStep({