@camstack/addon-pipeline 1.2.293 → 1.2.295

package/dist/motion-wasm/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Ce8s7XqV.js");
+const require_dist = require("../dist-BsVcf5wO.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { Tt as motionDetectionCapability, ct as evaluateZoneRules, gn as hydrateSchema, on as BaseAddon, un as DeviceType } from "../dist-C0Fr4hM5.mjs";
+import { Et as motionDetectionCapability, _n as hydrateSchema, dn as DeviceType, lt as evaluateZoneRules, sn as BaseAddon } from "../dist-CuxSNLKW.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";

package/dist/{node-Xm7amG2e.mjs → node-Cqb1QiXk.mjs}

@@ -1,4 +1,4 @@
-import { $t as errMsg, in as isSoftwareDecode, nn as buildFfmpegArgs, tn as Fmp4BoxSplitter } from "./dist-C0Fr4hM5.mjs";
+import { an as isSoftwareDecode, en as errMsg, nn as Fmp4BoxSplitter, rn as buildFfmpegArgs } from "./dist-CuxSNLKW.mjs";
 import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import path from "node:path";

package/dist/{node-DpOrymbW.js → node-UFk6I2f6.js}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_dist = require("./dist-Ce8s7XqV.js");
+const require_dist = require("./dist-BsVcf5wO.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs, 1);

package/dist/pipeline-runner/index.js

@@ -3,9 +3,9 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-Ce8s7XqV.js");
-const require_node = require("../node-DpOrymbW.js");
-const require_default_detection_model = require("../default-detection-model-DTKHLLcC.js");
+const require_dist = require("../dist-BsVcf5wO.js");
+const require_node = require("../node-UFk6I2f6.js");
+const require_default_detection_model = require("../default-detection-model-wNEISVA9.js");
 const require_worker_protocol = require("../worker-protocol-B2MfQLlu.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
@@ -1024,6 +1024,68 @@ var ParkedFrameStore = class {
 		}
 	}
 };
+/**
+* The key prefix the hub parks a face's SOURCE frame under (D644). The hub
+* owns the key; the runner reads only this prefix, to keep those parcels in
+* their own budget. Mirrors `FACE_SOURCE_PARK_PREFIX` in addon-post-analysis
+* (`runtime/face-source-park-port.ts`) — both specs pin the literal.
+*/
+var FACE_SOURCE_PARCEL_PREFIX = "face-src:";
+/** Is this key a face source parcel? */
+function isFaceSourceParcelKey(trackId) {
+	return trackId.startsWith(FACE_SOURCE_PARCEL_PREFIX);
+}
+/**
+* Track parcels and face source parcels in TWO stores with two budgets (D644).
+*
+* A face source parcel is a full native frame parked on every held best face.
+* In the shared store its eviction took the GLOBALLY oldest parcel — a
+* track's `keyFrame` or `thumbnail` — so a busy face scene could cost a track
+* its best frame (D58: media a later pass depends on must land). Here a face
+* parcel can only ever evict another face parcel.
+*/
+var PartitionedParkedFrameStore = class {
+	track;
+	faceSource;
+	constructor(options = {}) {
+		this.track = new ParkedFrameStore(options.track);
+		this.faceSource = new ParkedFrameStore({
+			budgetBytes: 16 * 1024 * 1024,
+			perDeviceMax: 4,
+			...options.faceSource
+		});
+	}
+	storeFor(trackId) {
+		return isFaceSourceParcelKey(trackId) ? this.faceSource : this.track;
+	}
+	get size() {
+		return this.track.size + this.faceSource.size;
+	}
+	get bytes() {
+		return this.track.bytes + this.faceSource.bytes;
+	}
+	park(deviceId, trackId, kind, frame) {
+		return this.storeFor(trackId).park(deviceId, trackId, kind, frame);
+	}
+	get(deviceId, trackId, kind) {
+		return this.storeFor(trackId).get(deviceId, trackId, kind);
+	}
+	release(deviceId, trackId) {
+		return this.storeFor(trackId).release(deviceId, trackId);
+	}
+	statsByDevice(deviceId) {
+		const a = this.track.statsByDevice(deviceId);
+		const b = this.faceSource.statsByDevice(deviceId);
+		return {
+			parcels: a.parcels + b.parcels,
+			bytes: a.bytes + b.bytes
+		};
+	}
+	clear() {
+		this.track.clear();
+		this.faceSource.clear();
+	}
+};
 /** {@link RETAINED_FRAME_BUDGET_MB} in bytes. */
 var RETAINED_FRAME_BUDGET_BYTES = (() => {
 	const raw = Number(process.env["CAMSTACK_SESSION_RETAIN_MB"]);
@@ -2173,28 +2235,17 @@ function onboardRootDetections(slot, frame, gate) {
 //#endregion
 //#region src/pipeline-runner/bench-step-schema.ts
 /**
-* Shared bench-facing schemas: the minimal recursive step tree and the
-* engine choice. Extracted from `bench-actions.ts` so the capacity-ramp
-* schemas (`capacity/capacity-schemas.ts`) can reuse them without a
-* bench-actions ↔ capacity-schemas import cycle.
-*
-* Local mirror of pipeline-executor's shapes ON PURPOSE (not a cap-package
-* coupling): the shape is fixed by the runtime contract
-* (runtime + backend + format + optional device / addonId + modelId +
-* enabled + children).
-*/
-var BenchEngineChoiceSchema = require_dist.object({
-	runtime: require_dist._enum(["node", "python"]),
-	backend: require_dist.string(),
-	format: require_dist._enum([
-		"onnx",
-		"coreml",
-		"openvino",
-		"tflite",
-		"pt"
-	]),
-	device: require_dist.string().optional()
-});
+* Shared bench-facing schemas: the minimal recursive step tree. Extracted from
+* `bench-actions.ts` so the capacity-ramp schemas (`capacity/capacity-schemas.ts`)
+* can reuse it without a bench-actions ↔ capacity-schemas import cycle.
+*
+* Local mirror of pipeline-executor's step shape ON PURPOSE (not a cap-package
+* coupling): addonId + modelId + enabled + children.
+*
+* There is no engine choice here any more (D646). A bench names the pool it
+* measures by `deviceKey`; the engine override it used to carry was honoured by
+* swapping the executor's shared engine state under live cameras.
+*/
 var BenchStepSchema = require_dist.lazy(() => require_dist.object({
 	addonId: require_dist.string(),
 	modelId: require_dist.string(),
@@ -2230,7 +2281,6 @@ var RunCapacityRampInputSchema = require_dist.object({
 	sessionId: require_dist.string(),
 	nodeId: require_dist.string().optional(),
 	deviceKey: require_dist.string().optional(),
-	engine: BenchEngineChoiceSchema.optional(),
 	slo: CapacitySloSchema.optional(),
 	allowActiveCameras: require_dist.boolean().optional(),
 	drainTimeoutSec: require_dist.number().min(1).max(300).optional()
@@ -2419,16 +2469,15 @@ var CacheBenchFrameResultSchema = require_dist.object({
 });
 var ReleaseBenchFrameInputSchema = require_dist.object({ frameId: require_dist.string() });
 var ReleaseBenchFrameResultSchema = require_dist.object({ released: require_dist.boolean() });
-var RunSyntheticBenchInputSchema = require_dist.object({
+var StartSyntheticBenchInputSchema = require_dist.object({
 	frameId: require_dist.string(),
 	steps: require_dist.array(BenchStepSchema).min(1),
 	parallel: require_dist.number().int().min(1).max(32),
 	iterations: require_dist.number().int().min(1).max(1e4),
 	warmup: require_dist.number().int().min(0).max(100).optional(),
-	sessionId: require_dist.string().optional(),
+	sessionId: require_dist.string().min(1),
 	simulatePipeline: require_dist.boolean().optional(),
 	nodeId: require_dist.string().optional(),
-	engine: BenchEngineChoiceSchema.optional(),
 	deviceKey: require_dist.string().optional(),
 	plane: require_dist._enum(["full", "frame"]).optional()
 });
@@ -2438,7 +2487,16 @@ var TimingSplitSchema = require_dist.object({
 	p95: require_dist.number(),
 	p99: require_dist.number()
 });
-var RunSyntheticBenchResultSchema = require_dist.object({
+var BenchPoolSchema = require_dist.object({
+	nodeId: require_dist.string(),
+	deviceKey: require_dist.string().nullable(),
+	runtime: require_dist.string().nullable(),
+	numWorkers: require_dist.number().nullable(),
+	concurrency: require_dist.number().nullable(),
+	batchMode: require_dist.string().nullable(),
+	maxBatchSize: require_dist.number().nullable()
+});
+var SyntheticBenchResultSchema = require_dist.object({
 	runs: require_dist.number(),
 	wallSec: require_dist.number(),
 	fps: require_dist.number(),
@@ -2450,23 +2508,52 @@ var RunSyntheticBenchResultSchema = require_dist.object({
 	predictMs: require_dist.number(),
 	batchSizeMean: require_dist.number(),
 	batchSizeMax: require_dist.number(),
-	engine: require_dist.object({
-		runtime: require_dist.string(),
-		backend: require_dist.string(),
-		device: require_dist.string().optional()
-	}).optional(),
-	tuning: require_dist.object({
-		batchMode: require_dist.string(),
-		windowMs: require_dist.number(),
-		maxBatchSize: require_dist.number(),
-		concurrency: require_dist.number()
-	}).optional(),
-	path: require_dist.string().optional()
+	pool: BenchPoolSchema,
+	path: require_dist.string()
+});
+/** `startSyntheticBench` answers at once; the run continues in the background. */
+var StartSyntheticBenchAcceptedSchema = require_dist.object({
+	accepted: require_dist.literal(true),
+	sessionId: require_dist.string()
 });
+var SyntheticBenchKeySchema = require_dist.object({ sessionId: require_dist.string() });
+var SyntheticBenchStatusSchema = require_dist.object({
+	sessionId: require_dist.string(),
+	state: require_dist._enum([
+		"running",
+		"done",
+		"failed",
+		"aborted"
+	]),
+	startedAtMs: require_dist.number(),
+	finishedAtMs: require_dist.number().nullable(),
+	progress: require_dist.object({
+		runs: require_dist.number(),
+		totalRuns: require_dist.number()
+	}).nullable(),
+	result: SyntheticBenchResultSchema.nullable(),
+	error: require_dist.string().nullable()
+}).nullable();
 var pipelineRunnerBenchActions = require_dist.defineCustomActions({
 	cacheBenchFrame: require_dist.customAction(CacheBenchFrameInputSchema, CacheBenchFrameResultSchema, { kind: "mutation" }),
 	releaseBenchFrame: require_dist.customAction(ReleaseBenchFrameInputSchema, ReleaseBenchFrameResultSchema, { kind: "mutation" }),
-	runSyntheticBench: require_dist.customAction(RunSyntheticBenchInputSchema, RunSyntheticBenchResultSchema, { kind: "mutation" }),
+	/**
+	* START a synthetic bench and return at once (D646). Up to 32 parallel ×
+	* 10 000 iterations does not fit the UDS addon-call plane's 60 s request
+	* timeout, and a synchronous call was abandoned by its caller while it kept
+	* loading the node. Poll `getSyntheticBenchStatus {sessionId}`; stop early
+	* with `abortSyntheticBench {sessionId}`. One bench per runner at a time —
+	* the measurement owns the pool.
+	*/
+	startSyntheticBench: require_dist.customAction(StartSyntheticBenchInputSchema, StartSyntheticBenchAcceptedSchema, {
+		kind: "mutation",
+		auth: "admin"
+	}),
+	getSyntheticBenchStatus: require_dist.customAction(SyntheticBenchKeySchema, SyntheticBenchStatusSchema),
+	abortSyntheticBench: require_dist.customAction(SyntheticBenchKeySchema, require_dist.object({ aborted: require_dist.boolean() }), {
+		kind: "mutation",
+		auth: "admin"
+	}),
 	/**
 	* OPEN-loop capacity ramp (spec `2026-08-02-capacity-test-design.md` §4):
 	* paced N×`fpsPerCamera` single-frame `runPipeline` calls with raw RGB —
@@ -2531,12 +2618,24 @@ function buildBenchRunPipelineInput(req) {
 	return {
 		steps: [...req.steps],
 		frame: req.frame,
-		...req.engine ? { engine: req.engine } : {},
 		...req.deviceKey ? { deviceKey: req.deviceKey } : {},
 		...req.plane ? { plane: req.plane } : {}
 	};
 }
 /**
+* The tuning query for the pool a bench MEASURED (D646). It asked the node
+* default of whatever node answered first, so an NPU run was recorded beside
+* the onnx pool's `concurrency: 4`. Absent `deviceKey`, never
+* present-and-undefined, for the same `.loose()` reason as
+* {@link buildBenchRunPipelineInput}.
+*/
+function buildBenchTuningQuery(target) {
+	return {
+		nodeId: target.nodeId,
+		input: target.deviceKey ? { deviceKey: target.deviceKey } : {}
+	};
+}
+/**
 * How long a box stays "seen".
 *
 * Sized on the gate's own clock, not on a guess: `maxDeferralMs` defaults to
@@ -3298,7 +3397,14 @@ function toDetailResult(detection, stepId, crop) {
 			...label.modelId !== void 0 ? { labelModelId: label.modelId } : {}
 		} : {},
 		...detection.faceAlignedCrop !== void 0 ? { alignedCropJpeg: detection.faceAlignedCrop } : {},
-		...detection.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: detection.nativeFaceShortSidePx } : {}
+		...detection.nativeFaceShortSidePx !== void 0 ? { nativeFaceShortSidePx: detection.nativeFaceShortSidePx } : {},
+		...detection.landmarks !== void 0 ? { landmarks: detection.landmarks.map((p) => mapPointToFrameSpace(p, crop)) } : {}
+	};
+}
+function mapPointToFrameSpace(point, crop) {
+	return {
+		x: crop.frameSpace.x + point.x * (crop.frameSpace.w / crop.width),
+		y: crop.frameSpace.y + point.y * (crop.frameSpace.h / crop.height)
 	};
 }
 /**
@@ -6605,6 +6711,7 @@ var PipelineRunner = class {
 //#endregion
 //#region src/pipeline-runner/stateless-step.ts
 function modelServability(step, modelId, format) {
+	if (require_default_detection_model.RETIRED_MODEL_IDS[step.id]?.includes(modelId) === true) return { kind: "retired" };
 	const entry = step.models.find((m) => m.id === modelId);
 	if (entry === void 0) return { kind: "custom-model" };
 	if (entry.formats[format] !== void 0) return { kind: "catalog-build" };
@@ -6649,6 +6756,7 @@ async function runStatelessStep(deps, input) {
 	const format = await deps.executionFormat();
 	if (format === null) return refuse(deps, input, "model-not-servable", "this node could not report the engine format it would dispatch on, so the model pin cannot be verified — running anyway would risk a silent format substitution");
 	const servability = modelServability(definition, input.modelId, format);
+	if (servability.kind === "retired") return refuse(deps, input, "model-not-servable", `model "${input.modelId}" was retired from the ${definition.id} catalog — this node would have substituted the step default`);
 	if (servability.kind === "no-build") return refuse(deps, input, "model-not-servable", `model "${input.modelId}" has no ${format} build (catalog ships: ${servability.availableFormats.join(", ") || "none"}) — this node would have substituted the ${format} default`);
 	let decodeError = null;
 	const crop = await cutFromFullFrame(input.frameJpeg, {
@@ -7504,6 +7612,26 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	benchFrameCache = /* @__PURE__ */ new Map();
 	benchFrameSweeper = null;
 	/**
+	* Synthetic benches, start-then-poll (D646). One at a time on this runner —
+	* the measurement owns the pool — and the last few finished ones kept for a
+	* late poll. In RAM: a bench belongs to this process.
+	*/
+	syntheticBenches = new require_dist.BackgroundRunRegistry({
+		maxConcurrent: 1,
+		keepFinished: 5,
+		onSettled: (status) => {
+			const line = { meta: {
+				sessionId: status.runId,
+				state: status.state,
+				error: status.error,
+				runs: status.result?.runs ?? null,
+				fps: status.result?.fps ?? null
+			} };
+			if (status.state === "failed") this.ctx.logger.warn("synthetic bench failed", line);
+			else this.ctx.logger.info("synthetic bench finished", line);
+		}
+	});
+	/**
 	* In-flight + recent capacity-ramp runs, keyed by sessionId. The ramp is
 	* fire-and-poll (a full run outlives the UDS addon-call 60s timeout), so
 	* completed results are kept here for `getCapacityRampStatus` to collect;
@@ -7582,7 +7710,11 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			nodeId: this.nodeId,
 			continuousRetain: isContinuousRetainEnabled()
 		});
-		this.parkedFrames = new ParkedFrameStore({ onEvict: (eviction) => this.noteParkedEviction(eviction.deviceId, eviction.cause) });
+		const onEvict = (eviction) => this.noteParkedEviction(eviction.deviceId, eviction.cause);
+		this.parkedFrames = new PartitionedParkedFrameStore({
+			track: { onEvict },
+			faceSource: { onEvict }
+		});
 		this.runner = new PipelineRunner({
 			maxQueueDepth: this.config.maxQueueDepth,
 			maxConcurrentInferences: this.config.maxConcurrentInferences,
@@ -7700,7 +7832,9 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			actionHandlers: {
 				cacheBenchFrame: async (input) => this.cacheBenchFrame(input),
 				releaseBenchFrame: async (input) => this.releaseBenchFrame(input),
-				runSyntheticBench: async (input) => this.runSyntheticBench(input),
+				startSyntheticBench: async (input) => this.startSyntheticBench(input),
+				getSyntheticBenchStatus: async (input) => this.getSyntheticBenchStatus(input.sessionId),
+				abortSyntheticBench: async (input) => ({ aborted: this.syntheticBenches.abort(input.sessionId) }),
 				runCapacityRamp: async (input) => this.runCapacityRampAction(input),
 				getCapacityRampStatus: async (input) => this.getCapacityRampStatusAction(input),
 				listCapacityRamps: async () => this.listCapacityRampsAction(),
@@ -7722,6 +7856,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			this.benchFrameSweeper = null;
 		}
 		this.benchFrameCache.clear();
+		this.syntheticBenches.abortAll();
 		for (const entry of this.capacityRuns.values()) entry.abortFlag.aborted = true;
 		this.capacityRuns.clear();
 		if (this.unsubMotionEvents) {
@@ -7801,7 +7936,34 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		const now = Date.now();
 		for (const [id, entry] of this.benchFrameCache) if (entry.expiresAt < now) this.benchFrameCache.delete(id);
 	}
-	async runSyntheticBench(input) {
+	/**
+	* Validate the cheap preconditions synchronously (so a bad frame id is a
+	* refusal the caller sees at once), then run the bench in the background
+	* and answer with the receipt (D646).
+	*/
+	startSyntheticBench(input) {
+		if (!this.ctx.api) throw new Error("startSyntheticBench: ctx.api unavailable");
+		if (!this.benchFrameCache.has(input.frameId)) throw new Error(`startSyntheticBench: frameId ${input.frameId} not cached (call cacheBenchFrame first)`);
+		this.syntheticBenches.start(input.sessionId, (run) => this.runSyntheticBench(input, run));
+		return {
+			accepted: true,
+			sessionId: input.sessionId
+		};
+	}
+	getSyntheticBenchStatus(sessionId) {
+		const status = this.syntheticBenches.status(sessionId);
+		if (status === null) return null;
+		return {
+			sessionId: status.runId,
+			state: status.state,
+			startedAtMs: status.startedAtMs,
+			finishedAtMs: status.finishedAtMs,
+			progress: status.progress,
+			result: status.result,
+			error: status.error
+		};
+	}
+	async runSyntheticBench(input, run) {
 		const ctx = this.ctx;
 		const api = ctx.api;
 		if (!api) throw new Error("runSyntheticBench: ctx.api unavailable");
@@ -7851,8 +8013,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			}, pin)).frameId;
 			await api.pipelineExecutor.runPipeline.mutate({ ...buildBenchRunPipelineInput({
 				steps: stepsToRun,
-				frame: sharedFrame,
-				...input.engine ? { engine: input.engine } : {}
+				frame: sharedFrame
 			}) }, pin);
 			const warmupCount = input.warmup ?? 1;
 			for (let w = 0; w < warmupCount; w++) await api.pipelineExecutor.inferCached.mutate({
@@ -7866,11 +8027,12 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			const batchSizes = [];
 			const detCounts = [];
 			let _n = 0;
-			const sessionId = input.sessionId ?? `synth-${Date.now().toString(36)}`;
+			const sessionId = input.sessionId;
 			const totalRuns = input.parallel * input.iterations;
 			const wallStart = performance.now();
 			const worker = async () => {
 				for (let i = 0; i < input.iterations; i++) {
+					if (run.signal.aborted) break;
 					const t0 = performance.now();
 					const result = await api.pipelineExecutor.inferCached.mutate({
 						stepId: rootStep.addonId,
@@ -7890,6 +8052,10 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 					batchSizes.push(bs);
 					detCounts.push(dets);
 					const n = ++_n;
+					run.report({
+						runs: n,
+						totalRuns
+					});
 					if (n <= 20) ctx.logger.info("bench call trace (cached)", { meta: {
 						n,
 						wallMs: Math.round(wallMs),
@@ -7942,7 +8108,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			await Promise.all(Array.from({ length: input.parallel }, () => worker()));
 			const wallSec = (performance.now() - wallStart) / 1e3;
 			await api.pipelineExecutor.uncacheFrame.mutate({ frameId: poolFrameId }, pin).catch(() => {});
-			return this.buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, "cached");
+			return this.buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, "cached", { nodeId: benchNode });
 		}
 		ctx.logger.info("synthetic bench: using full runPipeline path", { meta: {
 			steps: enabledSteps.length,
@@ -7956,7 +8122,6 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			const result = await api.pipelineExecutor.runPipeline.mutate({ ...buildBenchRunPipelineInput({
 				steps: stepsToRun,
 				frame: sharedFrame,
-				...input.engine ? { engine: input.engine } : {},
 				...input.deviceKey ? { deviceKey: input.deviceKey } : {},
 				...input.plane ? { plane: input.plane } : {}
 			}) }, pin);
@@ -7984,11 +8149,12 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		const predictTimings = [];
 		const batchSizes = [];
 		const detCounts = [];
-		const sessionId = input.sessionId ?? `synth-${Date.now().toString(36)}`;
+		const sessionId = input.sessionId;
 		const totalRuns = input.parallel * input.iterations;
 		const wallStart = performance.now();
 		const worker = async () => {
 			for (let i = 0; i < input.iterations; i++) {
+				if (run.signal.aborted) break;
 				const { wallMs, result } = await callOnce();
 				wallTimings.push(wallMs);
 				serverWallTimings.push(result.debug?.wallMs ?? 0);
@@ -7998,6 +8164,10 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				batchSizes.push(result.debug?.batchSize ?? 1);
 				detCounts.push(result.detections?.length ?? 0);
 				const n = wallTimings.length;
+				run.report({
+					runs: n,
+					totalRuns
+				});
 				if (n % Math.max(1, input.parallel) === 0 && ctx.eventBus) {
 					const elapsed = (performance.now() - wallStart) / 1e3;
 					const fps = elapsed > 0 ? n / elapsed : 0;
@@ -8038,9 +8208,12 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		};
 		await Promise.all(Array.from({ length: input.parallel }, () => worker()));
 		const wallSec = (performance.now() - wallStart) / 1e3;
-		return this.buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, "pipeline");
+		return this.buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, "pipeline", {
+			nodeId: benchNode,
+			...input.deviceKey ? { deviceKey: input.deviceKey } : {}
+		});
 	}
-	async buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, path) {
+	async buildBenchResult(wallTimings, inferTimings, preprocessTimings, predictTimings, batchSizes, detCounts, wallSec, path, target) {
 		const meanOfArr = (xs) => xs.length > 0 ? xs.reduce((s, v) => s + v, 0) / xs.length : 0;
 		this.ctx.logger.info("synthetic bench summary", { meta: {
 			runs: wallTimings.length,
@@ -8076,24 +8249,47 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			batchSizeMean: Math.round(meanOf(batchSizes) * 100) / 100,
 			batchSizeMax: batchSizes.length > 0 ? Math.max(...batchSizes) : 0,
 			path,
-			...await this.getEngineAndTuning()
+			pool: await this.readBenchPool(target)
 		};
 	}
-	async getEngineAndTuning() {
+	/**
+	* The pool a bench measured, and its provisioning — asked of the node it
+	* was pinned to, for the device pool it named (D646). It used to ask the
+	* node DEFAULT of whichever node answered, so an NPU bench was recorded
+	* beside the onnx pool's tuning. A failed read is `null` fields and a line,
+	* never a default (D393).
+	*/
+	async readBenchPool(target) {
+		const unknown = {
+			nodeId: target.nodeId,
+			deviceKey: target.deviceKey ?? null,
+			runtime: null,
+			numWorkers: null,
+			concurrency: null,
+			batchMode: null,
+			maxBatchSize: null
+		};
+		const api = this.ctx.api;
+		if (!api) return unknown;
+		const query = buildBenchTuningQuery(target);
 		try {
-			const api = this.ctx.api;
-			if (!api) return {};
-			const [eng, tuning] = await Promise.all([api.pipelineExecutor.getSelectedEngine.query(), api.pipelineExecutor.getEffectiveTuning.query()]);
+			const tuning = await api.pipelineExecutor.getEffectiveTuning.query({ ...query.input }, require_dist.nodePin(query.nodeId));
 			return {
-				engine: eng ? {
-					runtime: eng.runtime,
-					backend: eng.backend,
-					device: eng.device
-				} : void 0,
-				tuning: tuning ?? void 0
+				nodeId: target.nodeId,
+				deviceKey: tuning.deviceKey,
+				runtime: tuning.runtime,
+				numWorkers: tuning.numWorkers,
+				concurrency: tuning.concurrency,
+				batchMode: tuning.batchMode,
+				maxBatchSize: tuning.maxBatchSize
 			};
-		} catch {
-			return {};
+		} catch (err) {
+			this.ctx.logger.warn("synthetic bench: pool tuning read failed — reported as unknown", { meta: {
+				nodeId: target.nodeId,
+				deviceKey: target.deviceKey ?? null,
+				error: require_dist.errMsg(err)
+			} });
+			return unknown;
 		}
 	}
 	/**
@@ -8216,7 +8412,6 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 			settleSec,
 			measureSec,
 			deviceKey: input.deviceKey ?? null,
-			engine: input.engine ?? null,
 			contaminatedByActiveCameras,
 			steps: stepsToRun.map((s) => `${s.addonId}/${s.modelId}${s.enabled ? "" : "[off]"}`)
 		} });
@@ -8233,8 +8428,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				},
 				plane: "frame",
 				sessionId,
-				...input.deviceKey ? { deviceKey: input.deviceKey } : {},
-				...input.engine ? { engine: input.engine } : {}
+				...input.deviceKey ? { deviceKey: input.deviceKey } : {}
 			}, pin);
 			if (result.debug?.engine !== void 0) engineLabel = result.debug.engine;
 			if (result.shed === true) return {