@camstack/addon-post-analysis 1.2.38 → 1.2.40

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-DQvvZ5_E.js");
+const require_dist = require("../dist-C09kySqI.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
@@ -2255,8 +2255,8 @@ var NcDispatcher = class {
 		try {
 			const points = (await this.deps.getZonePolygons?.(deviceId, zoneIds) ?? []).flat();
 			if (points.length === 0) return null;
-			const { default: sharp$7 } = await import("sharp");
-			const img = sharp$7(Buffer.from(jpeg));
+			const { default: sharp$8 } = await import("sharp");
+			const img = sharp$8(Buffer.from(jpeg));
 			const meta = await img.metadata();
 			const W = meta.width ?? 0;
 			const H = meta.height ?? 0;
@@ -11955,6 +11955,189 @@ var EmbeddingDispatcher = class {
 	}
 };
 //#endregion
+//#region src/pipeline-analytics/pipeline/bbox-pad.ts
+/**
+* Pad a normalized bounding box by a fractional amount relative to its own
+* dimensions. All coordinates remain in the [0, 1] unit-square.
+*
+* Formula (before clamping):
+*   newX = x - padding * w
+*   newW = w + 2 * padding * w  (i.e. w * (1 + 2 * padding))
+*   newY = y - padding * h
+*   newH = h + 2 * padding * h
+*
+* padding === 0 is the identity operation. Pure, immutable — always returns a
+* new object.
+*
+* NOTE: clamping SHIFTS, it does not truncate — a window that overflows a
+* bound slides inward and keeps the extent that was asked for, on either side.
+* It shrinks only when the padded window is larger than the frame itself
+* would (e.g. a left-hugging box gains a bit more right-side context). This is
+* acceptable for detection crops (more context, never out of [0,1]); the
+* downstream `extractCrop` clamps to pixel bounds again regardless.
+*/
+function padBbox(bbox, padding) {
+	const rawX = bbox.x - padding * bbox.w;
+	const rawY = bbox.y - padding * bbox.h;
+	const rawW = bbox.w * (1 + 2 * padding);
+	const rawH = bbox.h * (1 + 2 * padding);
+	const w = Math.min(rawW, 1);
+	const h = Math.min(rawH, 1);
+	return {
+		x: Math.min(Math.max(0, rawX), 1 - w),
+		y: Math.min(Math.max(0, rawY), 1 - h),
+		w,
+		h
+	};
+}
+/**
+* Widen a bbox and optionally square it, staying inside the unit frame.
+*
+* Squaring uses the frame's aspect so the window is square in PIXELS, not in
+* normalised units — those are only the same on a square frame, and no camera
+* produces one.
+*/
+function cropWindow(bbox, frameWidth, frameHeight, options) {
+	const padded = padBbox(bbox, options.margin);
+	if (!options.square) return padded;
+	const pxW = padded.w * frameWidth;
+	const pxH = padded.h * frameHeight;
+	const side = Math.max(pxW, pxH);
+	const w = Math.min(side / frameWidth, 1);
+	const h = Math.min(side / frameHeight, 1);
+	const cx = padded.x + padded.w / 2;
+	const cy = padded.y + padded.h / 2;
+	return {
+		w,
+		h,
+		x: Math.min(Math.max(0, cx - w / 2), 1 - w),
+		y: Math.min(Math.max(0, cy - h / 2), 1 - h)
+	};
+}
+/** Cut a JPEG crop out of a JPEG frame using a normalised window. */
+async function cropFromJpeg(jpeg, window) {
+	const image = (0, sharp.default)(jpeg);
+	const meta = await image.metadata();
+	const frameWidth = meta.width;
+	const frameHeight = meta.height;
+	if (frameWidth === void 0 || frameHeight === void 0) return null;
+	const left = Math.max(0, Math.min(Math.round(window.x * frameWidth), frameWidth - 1));
+	const top = Math.max(0, Math.min(Math.round(window.y * frameHeight), frameHeight - 1));
+	const width = Math.max(1, Math.min(Math.round(window.w * frameWidth), frameWidth - left));
+	const height = Math.max(1, Math.min(Math.round(window.h * frameHeight), frameHeight - top));
+	return {
+		crop: await image.extract({
+			left,
+			top,
+			width,
+			height
+		}).jpeg({ quality: 90 }).toBuffer(),
+		width,
+		height
+	};
+}
+/**
+* Re-embed every listed track from its key frame.
+*
+* Every skip is COUNTED and the counts are returned, because the caller's next
+* decision — whether the index is now consistent enough to trust — depends on
+* knowing how much was not rebuilt, not just how much was.
+*/
+async function rebuildObjectEmbeddings(deps, options = {}) {
+	const margin = options.cropMargin ?? .2;
+	const square = options.square ?? true;
+	const maxTracks = options.maxTracks ?? Number.POSITIVE_INFINITY;
+	const trackIds = await deps.listTrackIds();
+	const considered = trackIds.slice(0, Number.isFinite(maxTracks) ? maxTracks : void 0);
+	let rebuilt = 0;
+	let missingKeyFrame = 0;
+	let missingBbox = 0;
+	let failed = 0;
+	for (const trackId of considered) try {
+		const source = await deps.loadSource(trackId);
+		if (source === null) {
+			missingKeyFrame += 1;
+			continue;
+		}
+		if (source.keyFrame === null) {
+			missingKeyFrame += 1;
+			continue;
+		}
+		if (source.bbox === null || source.bbox.w <= 0 || source.bbox.h <= 0) {
+			missingBbox += 1;
+			continue;
+		}
+		const meta = await (0, sharp.default)(source.keyFrame).metadata();
+		if (meta.width === void 0 || meta.height === void 0) {
+			failed += 1;
+			continue;
+		}
+		const window = cropWindow(source.bbox, meta.width, meta.height, {
+			margin,
+			square
+		});
+		const cut = await cropFromJpeg(source.keyFrame, window);
+		if (cut === null) {
+			failed += 1;
+			continue;
+		}
+		const embedding = await deps.encode(cut.crop, cut.width, cut.height);
+		if (embedding.length === 0) {
+			failed += 1;
+			continue;
+		}
+		await deps.store(source, embedding);
+		rebuilt += 1;
+	} catch (err) {
+		failed += 1;
+		deps.logger.warn("embedding rebuild failed for a track", { meta: {
+			trackId,
+			error: String(err)
+		} });
+	}
+	const complete = considered.length === trackIds.length;
+	deps.logger.info("object embedding rebuild finished", { meta: {
+		scanned: considered.length,
+		rebuilt,
+		missingKeyFrame,
+		missingBbox,
+		failed,
+		complete,
+		cropMargin: margin,
+		square
+	} });
+	return {
+		scanned: considered.length,
+		rebuilt,
+		missingKeyFrame,
+		missingBbox,
+		failed,
+		complete
+	};
+}
+/**
+* Read a normalised bbox off an object event.
+*
+* Events carry the box in FRAME PIXELS alongside `frameWidth`/`frameHeight`,
+* not normalised — normalising here rather than at the call site keeps the
+* conversion in one place, next to the code that consumes it.
+* Returns null when the frame dimensions are missing, because a box without
+* them cannot be placed on a differently-sized key frame.
+*/
+function normaliseEventBbox(event) {
+	const { bbox, frameWidth, frameHeight } = event;
+	if (bbox === void 0) return null;
+	if (frameWidth === void 0 || frameHeight === void 0) return null;
+	if (frameWidth <= 0 || frameHeight <= 0) return null;
+	if (bbox.w <= 0 || bbox.h <= 0) return null;
+	return {
+		x: bbox.x / frameWidth,
+		y: bbox.y / frameHeight,
+		w: bbox.w / frameWidth,
+		h: bbox.h / frameHeight
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/event-media-handler.ts
 var CACHE_CONTROL = "public, max-age=31536000, immutable";
 /** Default / clamp bounds for the `thumb` variant edge (px). Mirrors
@@ -14286,42 +14469,6 @@ async function encodeKeyFrameVariants(native) {
 	};
 }
 //#endregion
-//#region src/pipeline-analytics/pipeline/bbox-pad.ts
-/**
-* Pad a normalized bounding box by a fractional amount relative to its own
-* dimensions. All coordinates remain in the [0, 1] unit-square.
-*
-* Formula (before clamping):
-*   newX = x - padding * w
-*   newW = w + 2 * padding * w  (i.e. w * (1 + 2 * padding))
-*   newY = y - padding * h
-*   newH = h + 2 * padding * h
-*
-* padding === 0 is the identity operation. Pure, immutable — always returns a
-* new object.
-*
-* NOTE: clamping SHIFTS, it does not truncate — a window that overflows a
-* bound slides inward and keeps the extent that was asked for, on either side.
-* It shrinks only when the padded window is larger than the frame itself
-* would (e.g. a left-hugging box gains a bit more right-side context). This is
-* acceptable for detection crops (more context, never out of [0,1]); the
-* downstream `extractCrop` clamps to pixel bounds again regardless.
-*/
-function padBbox(bbox, padding) {
-	const rawX = bbox.x - padding * bbox.w;
-	const rawY = bbox.y - padding * bbox.h;
-	const rawW = bbox.w * (1 + 2 * padding);
-	const rawH = bbox.h * (1 + 2 * padding);
-	const w = Math.min(rawW, 1);
-	const h = Math.min(rawH, 1);
-	return {
-		x: Math.min(Math.max(0, rawX), 1 - w),
-		y: Math.min(Math.max(0, rawY), 1 - h),
-		w,
-		h
-	};
-}
-//#endregion
 //#region src/pipeline-analytics/pipeline/keyframe-crop.ts
 function createKeyFrameCrop(deps) {
 	return async (input) => {
@@ -20430,6 +20577,96 @@ var ObjectEmbeddingStore = class {
 		}
 	}
 	/**
+	* Retention sweep for ONE device.
+	*
+	* Replaces the fleet-global prune this store used to get. Events are evicted
+	* per device at that device's own cutoff, but embeddings were pruned at the
+	* MINIMUM cutoff across the fleet — "never prune anything a longer-retention
+	* device still owns" — which left a short-retention camera with weeks of
+	* vectors whose events were long gone. Measured on device 590: events back
+	* 1.0 day, embeddings back 22.1, and 1,446 of 2,222 rows unrenderable.
+	*
+	* The fleet bound existed because the old store could not filter by device.
+	* `deviceId` is a promoted, indexed column here, so this is one filter.
+	*/
+	async pruneDeviceBefore(deviceId, cutoffMs) {
+		try {
+			return (await this.vectorStore.deleteByFilter.mutate({
+				index: OBJECT_CLIP_INDEX,
+				filter: {
+					equals: { deviceId },
+					between: { timestamp: [0, cutoffMs] }
+				}
+			})).deleted;
+		} catch (err) {
+			this.logger.warn("ObjectEmbeddingStore.pruneDeviceBefore failed", {
+				tags: { deviceId },
+				meta: {
+					cutoffMs,
+					error: String(err)
+				}
+			});
+			return 0;
+		}
+	}
+	/**
+	* Drop every vector whose track no longer exists.
+	*
+	* The cascade already deletes a track's vector when the track is deleted, so
+	* in principle this finds nothing. In practice it found 1,446 orphans on one
+	* camera, because retention pruned by two different rules. A reconcile that
+	* cannot explain how it got work to do is still the right shape — the
+	* alternative is trusting that every deletion path remembered this store,
+	* which is exactly the assumption that failed.
+	*
+	* `liveTrackIds` is the authority. An EMPTY set is refused rather than
+	* treated as "delete everything": a track store that failed to answer would
+	* otherwise wipe the whole index.
+	*/
+	async pruneOrphans(input) {
+		if (input.liveTrackIds.size === 0) {
+			this.logger.warn("ObjectEmbeddingStore.pruneOrphans refused an empty live-track set", { meta: { candidates: input.candidates.length } });
+			return {
+				deleted: 0,
+				refused: true
+			};
+		}
+		const orphans = input.candidates.filter((id) => !input.liveTrackIds.has(id));
+		if (orphans.length === 0) return {
+			deleted: 0,
+			refused: false
+		};
+		await this.deleteByTracks(orphans);
+		this.logger.info("object embedding orphans pruned", { meta: {
+			orphans: orphans.length,
+			candidates: input.candidates.length
+		} });
+		return {
+			deleted: orphans.length,
+			refused: false
+		};
+	}
+	/**
+	* Empty the index completely — the clean slate before a policy change.
+	*
+	* Changing the crop margin or the encoder model leaves two feature spaces in
+	* one index whose cosine scores are not comparable. Wiping first, then
+	* rebuilding, is the only way to be sure every vector means the same thing.
+	*/
+	async wipeAll() {
+		try {
+			const result = await this.vectorStore.deleteByFilter.mutate({
+				index: OBJECT_CLIP_INDEX,
+				filter: { between: { timestamp: [0, Number.MAX_SAFE_INTEGER] } }
+			});
+			this.logger.info("object embedding index wiped", { meta: { deleted: result.deleted } });
+			return result.deleted;
+		} catch (err) {
+			this.logger.warn("ObjectEmbeddingStore.wipeAll failed", { meta: { error: String(err) } });
+			return 0;
+		}
+	}
+	/**
 	* `TrackScopedStore` contract for the retention cascade: delete the per-track
 	* CLIP search vector for the given tracks. Pure EPHEMERAL track state — the
 	* identity MATCHING embeddings (ArcFace) live in a SEPARATE durable store
@@ -22693,6 +22930,15 @@ function buildStationarySnapshot(input) {
 //#region src/pipeline-analytics/index.ts
 /** This addon's manifest id — the owner of the fixed Notification Center
 *  integration and of the alarm device under it. */
+/**
+* How long the active encoder's model id is trusted without re-asking.
+*
+* `embeddingEncoder.getInfo` measured 1.42s on the live hub — a cross-process
+* call into an addon busy with live inference — for a value that changes only
+* when an operator swaps encoders. A minute is short enough that a swap takes
+* effect without a restart and long enough that no search pays for it twice.
+*/
+var ENCODER_INFO_TTL_MS = 6e4;
 var PIPELINE_ANALYTICS_ADDON_ID = "pipeline-analytics";
 /** Operator-visible name of the fixed integration. */
 var NC_INTEGRATION_NAME = "Notification Center";
@@ -22880,6 +23126,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	plateStore = null;
 	plateRecognizer = null;
 	objectEmbeddingStore = null;
+	/** Cached active-encoder model id — see `resolveEncoderModelId`. */
+	encoderInfoCache = null;
 	/** Two-plane detail scheduler/dispatcher: per-track on-demand face/clip/
 	*  classifier/plate enrichment via `pipelineRunner.runDetailSubtree`. Replaces
 	*  the per-frame child consumption the executor no longer emits. */
@@ -23502,7 +23750,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		let storage = this.ctx.kernel.storage;
 		const mediaRoot = process.env.CAMSTACK_MEDIA_ROOT?.trim();
 		if (mediaRoot) {
-			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-CJcK55RY.js"));
+			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-DL2FM8_E.js"));
 			storage = new FilesystemStorageProvider(mediaRoot, { eventMedia: mediaRoot });
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}
@@ -25216,6 +25464,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			});
 			return;
 		}
+		const keyFrameMediaKey = this.residents.keyFrameKey(trackId);
 		await store.upsertIfBetter({
 			trackId,
 			deviceId,
@@ -25223,7 +25472,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			className: detail.className,
 			embedding: decodeEmbeddingBase64(detail.embedding),
 			modelId,
-			confidence: detail.score
+			confidence: detail.score,
+			...keyFrameMediaKey !== void 0 ? { keyFrameMediaKey } : {}
 		});
 	}
 	/** Classifier answer / plate OCR text → the track's enrichment label
@@ -25961,11 +26211,23 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			} catch (err) {
 				this.ctx.logger.debug("plate buffer prune failed", { meta: { error: String(err) } });
 			}
-			if (this.objectEmbeddingStore && Number.isFinite(minObjectCutoffMs)) try {
-				const deletedEmbeddings = await this.objectEmbeddingStore.pruneAll(minObjectCutoffMs);
+			if (this.objectEmbeddingStore) {
+				const embeddingStore = this.objectEmbeddingStore;
+				let deletedEmbeddings = 0;
+				for (const deviceId of deviceIds) {
+					if (this.shuttingDown) return;
+					try {
+						const cutoffs = await this.deviceRetentionCutoffs(deviceId, now);
+						if (cutoffs.objectCutoffMs === null) continue;
+						deletedEmbeddings += await embeddingStore.pruneDeviceBefore(deviceId, cutoffs.objectCutoffMs);
+					} catch (err) {
+						this.ctx.logger.debug("object embedding prune failed", {
+							tags: { deviceId },
+							meta: { error: String(err) }
+						});
+					}
+				}
 				if (deletedEmbeddings > 0) this.ctx.logger.info("object embedding retention prune", { meta: { deleted: deletedEmbeddings } });
-			} catch (err) {
-				this.ctx.logger.debug("object embedding prune failed", { meta: { error: String(err) } });
 			}
 		} catch (err) {
 			this.ctx.logger.debug("sweepRetention failed", { meta: { error: String(err) } });
@@ -26511,6 +26773,129 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	*      with each winner's deviceId + trackId filter) and join score.
 	*   5. Return at most `limit` ScoredObjectEvents sorted descending by score.
 	*/
+	/**
+	* The active encoder's model id, cached for {@link ENCODER_INFO_TTL_MS}.
+	*
+	* Refreshed rather than pinned forever so an operator swapping the encoder
+	* does not need a restart to make search gate on the new model — the window
+	* where the old id is used is bounded by the TTL, and during it a search
+	* simply ranks against the previous model's vectors, which is what it would
+	* have done anyway until the new ones exist.
+	*/
+	async resolveEncoderModelId(api) {
+		const now = Date.now();
+		if (this.encoderInfoCache !== null && now - this.encoderInfoCache.at < ENCODER_INFO_TTL_MS) return this.encoderInfoCache.modelId;
+		const info = await api.embeddingEncoder.getInfo.query().catch((err) => {
+			this.ctx.logger.warn("searchObjectEvents: getInfo failed, proceeding without modelId gate", { meta: { error: String(err) } });
+			return null;
+		});
+		if (info === null) return this.encoderInfoCache?.modelId ?? null;
+		this.encoderInfoCache = {
+			modelId: info.modelId,
+			at: now
+		};
+		return info.modelId;
+	}
+	/**
+	* Empty the CLIP index — the clean slate before a crop-policy or encoder
+	* change, to be followed by {@link rebuildObjectEmbeddings}.
+	*/
+	async wipeObjectEmbeddings() {
+		const store = this.objectEmbeddingStore;
+		if (!store) {
+			this.ctx.logger.warn("wipeObjectEmbeddings: object embedding store unavailable");
+			return { deleted: 0 };
+		}
+		return { deleted: await store.wipeAll() };
+	}
+	/**
+	* Re-embed stored tracks from their key frames — the tool that makes the crop
+	* policy tunable.
+	*
+	* Pixels come from each track's `keyFrame` (the FULL frame at native
+	* resolution, captured at the best detection) plus that detection's bbox, so
+	* the window can be WIDENED. The tight crop originally embedded cannot be
+	* widened after the fact.
+	*/
+	async rebuildObjectEmbeddings(input) {
+		const store = this.objectEmbeddingStore;
+		const trackStore = this.trackStore;
+		const mediaStore = this.mediaStore;
+		const eventStore = this.eventStore;
+		const api = this.ctx.api;
+		const empty = {
+			scanned: 0,
+			rebuilt: 0,
+			missingKeyFrame: 0,
+			missingBbox: 0,
+			failed: 0,
+			complete: true
+		};
+		if (!store || !trackStore || !mediaStore || !eventStore || !api) {
+			this.ctx.logger.warn("rebuildObjectEmbeddings: analytics stores unavailable");
+			return empty;
+		}
+		const modelId = await this.resolveEncoderModelId(api) ?? "unknown";
+		const deviceIds = input.deviceId !== void 0 ? [input.deviceId] : await trackStore.listDeviceIds();
+		return rebuildObjectEmbeddings({
+			listTrackIds: async () => {
+				return (await trackStore.queryRecent({
+					deviceIds,
+					...input.since !== void 0 ? { since: input.since } : {},
+					...input.until !== void 0 ? { until: input.until } : {},
+					limit: input.maxTracks ?? 500
+				})).tracks.map((t) => t.trackId);
+			},
+			loadSource: async (trackId) => {
+				const media = await mediaStore.listByOwner("track", trackId);
+				const keyFrameFile = media.find((m) => m.kind === "keyFrame");
+				const cropFile = media.find((m) => m.kind === "thumbnail");
+				const bestEventId = (await eventStore.peakForTrack(trackId)).bestEventId;
+				const events = await eventStore.queryObjectByTrackIds([trackId]);
+				const best = events.find((e) => e.id === bestEventId) ?? events[0];
+				if (best === void 0) return null;
+				return {
+					trackId,
+					deviceId: best.deviceId,
+					timestamp: best.timestamp,
+					className: best.className,
+					confidence: best.confidence ?? 0,
+					keyFrame: keyFrameFile ? Buffer.from(keyFrameFile.base64, "base64") : null,
+					bbox: normaliseEventBbox(best),
+					...cropFile !== void 0 ? { mediaKey: cropFile.key } : {},
+					...keyFrameFile !== void 0 ? { keyFrameMediaKey: keyFrameFile.key } : {}
+				};
+			},
+			encode: async (crop, width, height) => {
+				return (await api.embeddingEncoder.encode.query({
+					crop: new Uint8Array(crop),
+					width,
+					height
+				})).embedding;
+			},
+			store: async (source, embedding) => {
+				await store.upsertIfBetter({
+					trackId: source.trackId,
+					deviceId: source.deviceId,
+					timestamp: source.timestamp,
+					className: source.className,
+					embedding,
+					modelId,
+					confidence: Number.POSITIVE_INFINITY,
+					...source.mediaKey !== void 0 ? { mediaKey: source.mediaKey } : {},
+					...source.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: source.keyFrameMediaKey } : {}
+				});
+			},
+			logger: {
+				info: (message, extras) => this.ctx.logger.info(message, extras),
+				warn: (message, extras) => this.ctx.logger.warn(message, extras)
+			}
+		}, {
+			...input.cropMargin !== void 0 ? { cropMargin: input.cropMargin } : {},
+			...input.square !== void 0 ? { square: input.square } : {},
+			...input.maxTracks !== void 0 ? { maxTracks: input.maxTracks } : {}
+		});
+	}
 	async searchObjectEvents(input) {
 		const store = this.objectEmbeddingStore;
 		if (!store) return [];
@@ -26522,10 +26907,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		});
 		if (!encodeResult) return [];
 		const queryVec = new Float32Array(encodeResult.embedding);
-		const encoderInfo = await api.embeddingEncoder.getInfo.query().catch((err) => {
-			this.ctx.logger.warn("searchObjectEvents: getInfo failed, proceeding without modelId gate", { meta: { error: String(err) } });
-			return null;
-		});
+		const encoderModelId = await this.resolveEncoderModelId(api);
 		const search = await store.searchByVector({
 			vector: queryVec,
 			limit: input.limit,
@@ -26534,7 +26916,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			...input.since !== void 0 ? { since: input.since } : {},
 			...input.until !== void 0 ? { until: input.until } : {},
 			...input.classFilter !== void 0 ? { className: input.classFilter } : {},
-			...encoderInfo !== null ? { modelId: encoderInfo.modelId } : {}
+			...encoderModelId !== null ? { modelId: encoderModelId } : {}
 		});
 		if (search.truncated) this.ctx.logger.warn("searchObjectEvents: candidate pool truncated", {
 			meta: {