@camstack/addon-post-analysis 1.2.38 → 1.2.39

package/dist/{dist-BdBTDQxw.mjs → dist-BlnI3F_z.mjs}

@@ -15472,6 +15472,42 @@ var EventPruneCountsSchema = object({
 	object: number().int(),
 	audio: number().int()
 });
+/**
+* Re-embed stored tracks from their key frames.
+*
+* The reason this is an operator-callable method and not a migration script:
+* every knob that decides what a vector MEANS — encoder model, crop margin,
+* squaring — is only changeable if the existing vectors can be regenerated.
+* Mixing feature spaces in one index makes cosine scores incomparable, and the
+* symptom is a quality regression with no visible cause.
+*/
+var RebuildObjectEmbeddingsInput = object({
+	/** Restrict to one camera. Omit for the whole fleet. */
+	deviceId: number().optional(),
+	since: number().optional(),
+	until: number().optional(),
+	/**
+	* Fraction added on EACH side of the detection box before cropping.
+	* ~0.2 (a 1.4x window) gives CLIP the surroundings it is trained on; 0 is
+	* the pixel-tight crop the first implementation used.
+	*/
+	cropMargin: number().min(0).max(4).optional(),
+	/** Square the window before extracting, so a tall subject is not squashed. */
+	square: boolean().optional(),
+	/** Stop after this many tracks; the result reports whether more remain. */
+	maxTracks: number().int().positive().optional()
+});
+var RebuildObjectEmbeddingsResultSchema = object({
+	scanned: number(),
+	rebuilt: number(),
+	/** Tracks whose key frame is gone — nothing to re-embed from. */
+	missingKeyFrame: number(),
+	/** Tracks with no usable detection box. */
+	missingBbox: number(),
+	failed: number(),
+	/** False when the pass stopped at `maxTracks` with tracks left. */
+	complete: boolean()
+});
 var pipelineAnalyticsCapability = {
 	name: "pipeline-analytics",
 	scope: "device",
@@ -15744,7 +15780,12 @@ var pipelineAnalyticsCapability = {
 		* ObjectEvents by trackId. Returns up to `limit` events scored ≥
 		* `minScore`, sorted descending by score.
 		*/
-		searchObjectEvents: method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly())
+		searchObjectEvents: method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()),
+		rebuildObjectEmbeddings: method(RebuildObjectEmbeddingsInput, RebuildObjectEmbeddingsResultSchema, {
+			kind: "mutation",
+			auth: "admin",
+			timeoutMs: 30 * 6e4
+		})
 	},
 	events: {
 		/**
@@ -29018,6 +29059,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.rebuildObjectEmbeddings": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.relocateMedia": {
 		capName: "pipeline-analytics",
 		capScope: "device",

package/dist/{dist-DQvvZ5_E.js → dist-z5sH8cjz.js}

@@ -15494,6 +15494,42 @@ var EventPruneCountsSchema = object({
 	object: number().int(),
 	audio: number().int()
 });
+/**
+* Re-embed stored tracks from their key frames.
+*
+* The reason this is an operator-callable method and not a migration script:
+* every knob that decides what a vector MEANS — encoder model, crop margin,
+* squaring — is only changeable if the existing vectors can be regenerated.
+* Mixing feature spaces in one index makes cosine scores incomparable, and the
+* symptom is a quality regression with no visible cause.
+*/
+var RebuildObjectEmbeddingsInput = object({
+	/** Restrict to one camera. Omit for the whole fleet. */
+	deviceId: number().optional(),
+	since: number().optional(),
+	until: number().optional(),
+	/**
+	* Fraction added on EACH side of the detection box before cropping.
+	* ~0.2 (a 1.4x window) gives CLIP the surroundings it is trained on; 0 is
+	* the pixel-tight crop the first implementation used.
+	*/
+	cropMargin: number().min(0).max(4).optional(),
+	/** Square the window before extracting, so a tall subject is not squashed. */
+	square: boolean().optional(),
+	/** Stop after this many tracks; the result reports whether more remain. */
+	maxTracks: number().int().positive().optional()
+});
+var RebuildObjectEmbeddingsResultSchema = object({
+	scanned: number(),
+	rebuilt: number(),
+	/** Tracks whose key frame is gone — nothing to re-embed from. */
+	missingKeyFrame: number(),
+	/** Tracks with no usable detection box. */
+	missingBbox: number(),
+	failed: number(),
+	/** False when the pass stopped at `maxTracks` with tracks left. */
+	complete: boolean()
+});
 var pipelineAnalyticsCapability = {
 	name: "pipeline-analytics",
 	scope: "device",
@@ -15766,7 +15802,12 @@ var pipelineAnalyticsCapability = {
 		* ObjectEvents by trackId. Returns up to `limit` events scored ≥
 		* `minScore`, sorted descending by score.
 		*/
-		searchObjectEvents: method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly())
+		searchObjectEvents: method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()),
+		rebuildObjectEmbeddings: method(RebuildObjectEmbeddingsInput, RebuildObjectEmbeddingsResultSchema, {
+			kind: "mutation",
+			auth: "admin",
+			timeoutMs: 30 * 6e4
+		})
 	},
 	events: {
 		/**
@@ -29040,6 +29081,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.rebuildObjectEmbeddings": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.relocateMedia": {
 		capName: "pipeline-analytics",
 		capScope: "device",

package/dist/embedding-encoder/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-z5sH8cjz.js");
 let node_fs = require("node:fs");
 let node_fs$1 = require_dist.__toESM(node_fs, 1);
 node_fs = require_dist.__toESM(node_fs);

package/dist/embedding-encoder/index.mjs

@@ -1,4 +1,4 @@
-import { E as embeddingEncoderCapability, k as hfModelUrl, z as BaseAddon } from "../dist-BdBTDQxw.mjs";
+import { E as embeddingEncoderCapability, k as hfModelUrl, z as BaseAddon } from "../dist-BlnI3F_z.mjs";
 import { createRequire } from "node:module";
 import * as fs from "node:fs";
 import "node:fs";

package/dist/{node-CJcK55RY.js → node-BKP-AAun.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-DQvvZ5_E.js");
+const require_dist = require("./dist-z5sH8cjz.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");

package/dist/pipeline-analytics/{_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-DrKQwfNe.mjs → _virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-CVOC4n3K.mjs}

@@ -18,7 +18,7 @@ var e = {
 	},
 	"@camstack/types": {
 		name: "@camstack/types",
-		version: "1.2.36",
+		version: "1.2.37",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_pipeline_analytics_widgets",

package/dist/pipeline-analytics/{hostInit-DyfCBQE8.mjs → hostInit-D5ShhMc1.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.36",
+				version: "1.2.37",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

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-z5sH8cjz.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) => {
@@ -22693,6 +22840,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 +23036,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 +23660,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-BKP-AAun.js"));
 			storage = new FilesystemStorageProvider(mediaRoot, { eventMedia: mediaRoot });
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}
@@ -26511,6 +26669,117 @@ 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;
+	}
+	/**
+	* 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 +26791,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 +26800,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: {

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { $ as unknown, A as kebabToCamel, B as DeviceType, C as cosineSimilarity, D as encodeVectorBase64, F as subKindsOf, G as _enum, H as hydrateSchema, I as videoclipsCapability, J as literal, K as array, L as zoneAnalyticsCapability, M as pipelineAnalyticsCapability, N as plateGalleryCapability, O as faceGalleryCapability, P as readDeviceStateFrom, Q as string, R as errMsg, S as buildEventKindDescriptor, T as defineCustomActions, U as isDeviceScopedCap, V as createEvent, W as nodePin, X as object, Y as number, Z as record, _ as TimelapseRuleInputSchema, a as MACRO_LABELS, b as alarmPanelCapability, c as NcConditionDescriptorSchema, d as NcRuleSchema, et as EventCategory, f as NcSnoozeInputSchema, g as OpsLogEntrySchema, h as NcTaxonomySchema, i as EVENT_PAD_MS, j as notificationRulesCapability, l as NcRuleInputSchema, m as NcSnoozeSuppressedSchema, n as DEFAULT_EVENT_COLOR, o as NC_CONDITION_CATALOG, p as NcSnoozeSchema, q as boolean, r as EVENT_KIND_BY_CAP, s as NC_TAXONOMY, t as BaseDevice, u as NcRulePatchSchema, v as TimelapseRuleSchema, w as customAction, x as audioMetricsCapability, y as addonWidgetsSourceCapability, z as BaseAddon } from "../dist-BdBTDQxw.mjs";
+import { $ as unknown, A as kebabToCamel, B as DeviceType, C as cosineSimilarity, D as encodeVectorBase64, F as subKindsOf, G as _enum, H as hydrateSchema, I as videoclipsCapability, J as literal, K as array, L as zoneAnalyticsCapability, M as pipelineAnalyticsCapability, N as plateGalleryCapability, O as faceGalleryCapability, P as readDeviceStateFrom, Q as string, R as errMsg, S as buildEventKindDescriptor, T as defineCustomActions, U as isDeviceScopedCap, V as createEvent, W as nodePin, X as object, Y as number, Z as record, _ as TimelapseRuleInputSchema, a as MACRO_LABELS, b as alarmPanelCapability, c as NcConditionDescriptorSchema, d as NcRuleSchema, et as EventCategory, f as NcSnoozeInputSchema, g as OpsLogEntrySchema, h as NcTaxonomySchema, i as EVENT_PAD_MS, j as notificationRulesCapability, l as NcRuleInputSchema, m as NcSnoozeSuppressedSchema, n as DEFAULT_EVENT_COLOR, o as NC_CONDITION_CATALOG, p as NcSnoozeSchema, q as boolean, r as EVENT_KIND_BY_CAP, s as NC_TAXONOMY, t as BaseDevice, u as NcRulePatchSchema, v as TimelapseRuleSchema, w as customAction, x as audioMetricsCapability, y as addonWidgetsSourceCapability, z as BaseAddon } from "../dist-BlnI3F_z.mjs";
 import { promises } from "node:fs";
 import path from "node:path";
 import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
@@ -11949,6 +11949,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 = sharp(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 sharp(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
@@ -14280,42 +14463,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) => {
@@ -22687,6 +22834,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";
@@ -22874,6 +23030,8 @@ var PipelineAnalyticsAddon = class extends 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. */
@@ -26505,6 +26663,117 @@ var PipelineAnalyticsAddon = class extends 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;
+	}
+	/**
+	* 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 [];
@@ -26516,10 +26785,7 @@ var PipelineAnalyticsAddon = class extends 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,
@@ -26528,7 +26794,7 @@ var PipelineAnalyticsAddon = class extends 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: {

package/dist/pipeline-analytics/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-DrKQwfNe.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-CVOC4n3K.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-post-analysis",
-  "version": "1.2.38",
+  "version": "1.2.39",
   "description": "Post-Analysis bundle — enrichment, embedding-encoder, pipeline-analytics. Multi-entry npm package shipping addons that consume pipeline output.",
   "keywords": [
     "camstack",