@camstack/addon-post-analysis 1.2.45 → 1.2.47

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-QzgUDrwU.js");
+const require_dist = require("../dist-B5O4mNmd.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
@@ -5845,14 +5845,6 @@ function makeNcActionHandlers(deps) {
 var RebuildInputSchema = require_dist.object({
 	/** Restrict to one camera; omit for the whole fleet. */
 	deviceId: require_dist.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.
-	*/
-	cropMargin: require_dist.number().min(0).max(4).optional(),
-	/** Square the window so a tall subject is not squashed into CLIP's input. */
-	square: require_dist.boolean().optional(),
 	/** Stop after this many tracks; the status reports whether more remain. */
 	maxTracks: require_dist.number().int().positive().optional()
 });
@@ -5866,6 +5858,8 @@ var RebuildStatusSchema = require_dist.object({
 	rebuilt: require_dist.number(),
 	missingKeyFrame: require_dist.number(),
 	missingBbox: require_dist.number(),
+	/** Refused by the pipeline (camera detached / step disabled), not broken. */
+	notRunnable: require_dist.number(),
 	failed: require_dist.number(),
 	complete: require_dist.boolean().nullable(),
 	startedAtMs: require_dist.number().nullable(),
@@ -12024,88 +12018,6 @@ 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.
 *
@@ -12114,12 +12026,11 @@ async function cropFromJpeg(jpeg, window) {
 * 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;
 	let rebuilt = 0;
 	let missingKeyFrame = 0;
 	let missingBbox = 0;
+	let notRunnable = 0;
 	let failed = 0;
 	let scanned = 0;
 	let cursor = null;
@@ -12150,27 +12061,41 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 					missingBbox += 1;
 					continue;
 				}
-				const meta = await (0, sharp.default)(source.keyFrame).metadata();
-				if (meta.width === void 0 || meta.height === void 0) {
-					failed += 1;
+				const outcome = await deps.embed(source);
+				if (outcome.kind === "not-runnable") {
+					notRunnable += 1;
+					deps.logger.warn("embedding rebuild: track could not be re-embedded by the pipeline", {
+						tags: { deviceId: source.deviceId },
+						meta: {
+							trackId,
+							reason: outcome.reason
+						}
+					});
 					continue;
 				}
-				const window = cropWindow(source.bbox, meta.width, meta.height, {
-					margin,
-					square
-				});
-				const cut = await cropFromJpeg(source.keyFrame, window);
-				if (cut === null) {
+				if (outcome.kind === "failed") {
 					failed += 1;
+					deps.logger.warn("embedding rebuild: the pipeline returned no vector for a track", {
+						tags: { deviceId: source.deviceId },
+						meta: {
+							trackId,
+							reason: outcome.reason
+						}
+					});
 					continue;
 				}
-				const embedding = await deps.encode(cut.crop, cut.width, cut.height);
-				if (embedding.length === 0) {
+				const written = await deps.store(source, outcome.embeddingBase64);
+				if (written === "persisted") rebuilt += 1;
+				else {
 					failed += 1;
-					continue;
+					deps.logger.warn("embedding rebuild wrote nothing for a track", {
+						tags: { deviceId: source.deviceId },
+						meta: {
+							trackId,
+							outcome: written
+						}
+					});
 				}
-				await deps.store(source, embedding);
-				rebuilt += 1;
 			} catch (err) {
 				failed += 1;
 				deps.logger.warn("embedding rebuild failed for a track", { meta: {
@@ -12183,6 +12108,7 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 				rebuilt,
 				missingKeyFrame,
 				missingBbox,
+				notRunnable,
 				failed
 			});
 		}
@@ -12198,16 +12124,16 @@ async function rebuildObjectEmbeddings(deps, options = {}) {
 		rebuilt,
 		missingKeyFrame,
 		missingBbox,
+		notRunnable,
 		failed,
-		complete,
-		cropMargin: margin,
-		square
+		complete
 	} });
 	return {
 		scanned,
 		rebuilt,
 		missingKeyFrame,
 		missingBbox,
+		notRunnable,
 		failed,
 		complete
 	};
@@ -12375,6 +12301,69 @@ async function resolveDefaultEventMedia(deps) {
 	return pickTrackFallbackMedia(await deps.listTrackMedia(trackId)) ?? null;
 }
 //#endregion
+//#region src/pipeline-analytics/rebuild-detail-request.ts
+/** The one step a rebuild runs. */
+var REBUILD_DETAIL_STEP_ID = "clip-embedding";
+/**
+* Build the `runDetailSubtree` input for one stored track.
+*
+* The box is stored NORMALISED because the key frame is a native-resolution
+* capture while the detection ran on a downscaled analysis frame; the two have
+* different pixel dimensions. `parent.bbox` is frame pixels (the live path's
+* convention), so it is denormalised here against the KEY FRAME's own
+* dimensions — the image the runner is about to cut. This is coordinate
+* mapping, not crop derivation: no padding, no squaring, no rectangle choice.
+*/
+function buildRebuildDetailInput(source, keyFrame) {
+	return {
+		deviceId: source.deviceId,
+		frameJpeg: source.keyFrame.toString("base64"),
+		parent: {
+			bbox: {
+				x: source.bbox.x * keyFrame.width,
+				y: source.bbox.y * keyFrame.height,
+				w: source.bbox.w * keyFrame.width,
+				h: source.bbox.h * keyFrame.height
+			},
+			className: source.className
+		},
+		steps: [REBUILD_DETAIL_STEP_ID]
+	};
+}
+/**
+* Turn one `runDetailSubtree` answer into a rebuild outcome.
+*
+* The three cases lead to three different counters:
+*
+* - `null` — the runner DECLINED: the camera is not attached, `clip-embedding`
+*   is not enabled in its tree, or the frame was unreadable. It logs which,
+*   tagged with the deviceId. That is `not-runnable`, not a failure: the remedy
+*   is a configuration change, and folding it into `failed` would point the
+*   operator at the inference engine instead.
+* - details with no `clip-embedding` embedding — the step RAN and produced
+*   nothing usable. That is a failure.
+* - an embedding — passed through as base64, the form the vector store stores.
+*/
+function readRebuildEmbedding(result) {
+	if (result === null) return {
+		kind: "not-runnable",
+		reason: "the runner returned no result — camera not attached, clip-embedding not enabled for it, or the key frame was unreadable (the runner logged which, tagged with the deviceId)"
+	};
+	const embedding = result.details.find((d) => d.stepId === "clip-embedding" && d.embedding !== void 0)?.embedding;
+	if (embedding === void 0) return {
+		kind: "failed",
+		reason: `the detail subtree ran but returned no ${REBUILD_DETAIL_STEP_ID} embedding (${result.details.length} detail(s))`
+	};
+	return {
+		kind: "embedded",
+		embeddingBase64: embedding
+	};
+}
+/** Narrowing helper — a source without a key frame can never build a request. */
+function hasKeyFrame(source) {
+	return source.keyFrame !== null && source.bbox !== null;
+}
+//#endregion
 //#region src/pipeline-analytics/pipeline/face-matcher.ts
 /**
 * Count enrolled samples per identity for probes of a matching model+dimension.
@@ -14566,6 +14555,42 @@ 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) => {
@@ -18555,30 +18580,18 @@ function buildGlobalSettingsSchema() {
 		{
 			id: "embedding-index",
 			title: "Semantic search index",
-			description: "The CLIP vector index behind text search. Rebuild re-embeds stored tracks from their native key frames — the only way to change what a vector means, since a new crop margin or encoder model leaves two incomparable feature spaces in one index. Vectors live in the vector-store capability, alongside the events they are shown with.",
+			description: "The CLIP vector index behind text search. Rebuild re-embeds stored tracks from their native key frames — the only way to change what a vector means, since a new crop convention or encoder model leaves two incomparable feature spaces in one index. Vectors live in the vector-store capability, alongside the events they are shown with.",
 			columns: 1,
 			fields: [
-				{
-					type: "number",
-					key: "rebuildCropMargin",
-					label: "Rebuild crop margin",
-					description: "Fraction added on EACH side of the detection box when re-embedding. 0.2 gives a 1.4x window: CLIP is trained on natural images WITH surroundings, and a pixel-tight crop removes what it is strongest on. 0 reproduces the tight crop. Only affects Rebuild — it does not change live capture, and the thumbnail is never re-cropped.",
-					default: .2,
-					min: 0,
-					max: 2,
-					step: .1
-				},
 				{
 					type: "addon-action-button",
 					key: "rebuildEmbeddingsButton",
 					label: "Rebuild index",
-					description: "Re-embed every stored track from its key frame, using the margin above. Runs in the background — press Progress to watch it. Tracks whose key frame has aged out cannot be rebuilt and are reported as skipped.",
+					description: "Re-embed every stored track from its key frame, through the detection pipeline, using the cluster Enrichment crop setting — so a rebuilt vector is comparable with a live one. Runs in the background; press Progress to watch it. Tracks whose key frame has aged out, or whose camera is detached, are reported as skipped rather than dropped.",
 					addonId: "pipeline-analytics",
 					action: "embedding.rebuild",
 					buttonLabel: "Rebuild",
 					variant: "primary",
-					paramsFromForm: { cropMargin: "rebuildCropMargin" },
-					paramsStatic: { square: true },
 					successMessage: "Rebuild started — press Progress to follow it."
 				},
 				{
@@ -18589,7 +18602,7 @@ function buildGlobalSettingsSchema() {
 					addonId: "pipeline-analytics",
 					action: "embedding.rebuildStatus",
 					buttonLabel: "Check progress",
-					successMessage: "Indexed {indexed} · scanned {scanned} · rebuilt {rebuilt} · no key frame {missingKeyFrame} · failed {failed}"
+					successMessage: "Indexed {indexed} · scanned {scanned} · rebuilt {rebuilt} · no key frame {missingKeyFrame} · not runnable {notRunnable} · failed {failed}"
 				},
 				{
 					type: "addon-action-button",
@@ -20581,6 +20594,29 @@ var IdentityStore = class {
 */
 /** The vector-store index this store owns. */
 var OBJECT_CLIP_INDEX = "object-clip";
+/**
+* Reduce either input form to the stored form.
+*
+* A base64 payload passes through untouched; its dimension is read from the
+* byte length. A length that is not a whole number of float32s cannot be a
+* vector, and storing it would produce a row whose dimension silently
+* disagrees with the declared index.
+*/
+function resolveVectorPayload(input) {
+	if (input.embeddingBase64 !== void 0) {
+		const byteLength = Buffer.from(input.embeddingBase64, "base64").byteLength;
+		if (byteLength === 0 || byteLength % 4 !== 0) return null;
+		return {
+			base64: input.embeddingBase64,
+			dim: require_dist.vectorDimFromBase64(input.embeddingBase64)
+		};
+	}
+	if (input.embedding.length === 0) return null;
+	return {
+		base64: require_dist.encodeVectorBase64(input.embedding),
+		dim: input.embedding.length
+	};
+}
 var ObjectEmbeddingStore = class {
 	vectorStore;
 	logger;
@@ -20597,6 +20633,14 @@ var ObjectEmbeddingStore = class {
 	* write: the provider rejects an upsert into an index it has never seen. A
 	* dim change against a populated index is REFUSED rather than wiping it, so
 	* this failing is the signal that the encoder model changed.
+	*
+	* `declaredDim` caches the declaration, and that cache is per-PROCESS while
+	* the index lives in whichever addon currently provides `vector-store`. When
+	* the active provider changed under a running hub the cache stayed warm
+	* against an index that no longer existed, and every write from then on threw
+	* `index "object-clip" was never declared` — for hours, until the addon was
+	* restarted by hand. So a failed write clears the cache (see
+	* {@link upsertIfBetter}) and the next one re-declares.
 	*/
 	async ensureIndex(dim) {
 		if (this.declaredDim === dim) return true;
@@ -20628,33 +20672,50 @@ var ObjectEmbeddingStore = class {
 	* short-circuited, and every later pass silently wrote nothing while
 	* reporting hundreds rebuilt. Observed live — 214 "rebuilt" moved the index
 	* by 4 rows.
+	*
+	* ## Why this returns an outcome instead of `void`
+	*
+	* It used to return `void` and turn every failure into a warn. The rebuild
+	* therefore counted a write the instant the call returned, and the second time
+	* this class of bug appeared it produced `rebuilt: 704` against `indexed: 0` —
+	* a progress number that was pure fiction while the real cause sat in a warn
+	* nobody was reading. The caller now has to distinguish "written" from "logged
+	* and dropped", because a counter that cannot reads as verification.
 	*/
 	async upsertIfBetter(input) {
-		if (input.embedding.length === 0) return;
-		if (!await this.ensureIndex(input.embedding.length)) return;
+		const vector = resolveVectorPayload(input);
+		if (vector === null) return "failed";
+		if (!await this.ensureIndex(vector.dim)) return "failed";
 		try {
 			if (input.force !== true) {
 				const stored = (await this.vectorStore.getByIds.query({
 					index: OBJECT_CLIP_INDEX,
 					ids: [input.trackId]
 				})).items[0]?.metadata["confidence"];
-				if (typeof stored === "number" && input.confidence <= stored) return;
+				if (typeof stored === "number" && input.confidence <= stored) return "skipped";
 			}
-			if ((await this.vectorStore.upsert.mutate({
-				index: "object-clip",
+			const result = await this.vectorStore.upsert.mutate({
+				index: OBJECT_CLIP_INDEX,
 				items: [{
 					id: input.trackId,
-					vector: require_dist.encodeVectorBase64(input.embedding),
+					vector: vector.base64,
 					metadata: metadataFor(input)
 				}]
-			})).rejected > 0) this.logger.warn("object-embedding upsert rejected", {
-				tags: { deviceId: input.deviceId },
-				meta: {
-					trackId: input.trackId,
-					dim: input.embedding.length
-				}
 			});
+			if (result.upserted === 0) {
+				this.logger.warn("object-embedding upsert rejected", {
+					tags: { deviceId: input.deviceId },
+					meta: {
+						trackId: input.trackId,
+						dim: vector.dim,
+						rejected: result.rejected
+					}
+				});
+				return "failed";
+			}
+			return "persisted";
 		} catch (err) {
+			this.declaredDim = null;
 			this.logger.warn("ObjectEmbeddingStore.upsertIfBetter failed", {
 				tags: { deviceId: input.deviceId },
 				meta: {
@@ -20662,6 +20723,7 @@ var ObjectEmbeddingStore = class {
 					error: String(err)
 				}
 			});
+			return "failed";
 		}
 	}
 	/**
@@ -23947,7 +24009,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-HrEN5lB7.js"));
+			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-m6HS7TOO.js"));
 			storage = new FilesystemStorageProvider(mediaRoot, { eventMedia: mediaRoot });
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}
@@ -27011,6 +27073,43 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		return info.modelId;
 	}
 	/**
+	* Re-embed ONE stored track by running its `clip-embedding` step through the
+	* camera's runner.
+	*
+	* The whole point: the runner cuts. This method reads the key frame's pixel
+	* dimensions (metadata only — no pixel work, no rectangle chosen here) so the
+	* stored normalised box can be expressed in the key frame's own pixels, ships
+	* the full frame, and reads the vector back. Where the crop boundary falls is
+	* decided inside `runDetailSubtree` by the one cluster-wide convention, the
+	* same call the live detail plane makes.
+	*
+	* NOT node-pinned: `runDetailSubtree` is device-bound, so the cap router
+	* sends it to the runner that owns this camera. A pin would be a guess about
+	* placement that the binding already knows.
+	*/
+	async embedRebuildSourceViaPipeline(source) {
+		if (!hasKeyFrame(source)) return {
+			kind: "failed",
+			reason: "no key frame or no bbox"
+		};
+		const runner = this.ctx.api?.pipelineRunner;
+		if (!runner?.runDetailSubtree) return {
+			kind: "not-runnable",
+			reason: "pipelineRunner.runDetailSubtree is unavailable on this cluster"
+		};
+		const sharp$7 = (await import("sharp")).default;
+		const meta = await sharp$7(source.keyFrame).metadata();
+		if (meta.width === void 0 || meta.height === void 0) return {
+			kind: "failed",
+			reason: "key frame has no readable dimensions"
+		};
+		const input = buildRebuildDetailInput(source, {
+			width: meta.width,
+			height: meta.height
+		});
+		return readRebuildEmbedding(await runner.runDetailSubtree.mutate(input));
+	}
+	/**
 	* Every track id the track store still holds, across the given devices.
 	*
 	* Returned as a Set for the orphan sweep, which REFUSES an empty one — a
@@ -27049,6 +27148,12 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	* 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.
+	*
+	* The frame and the box are shipped to the camera's RUNNER, which cuts and
+	* encodes them through `runDetailSubtree` — the same code path, the same
+	* crop convention and the same step catalog the live detail plane uses. This
+	* side no longer chooses a rectangle, and there is no `cropMargin` argument
+	* to choose one with: see `embedding-rebuild.ts` for what that cost.
 	*/
 	async rebuildObjectEmbeddings(input) {
 		if (this.rebuildState.running) {
@@ -27106,27 +27211,19 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					...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: source.confidence,
-					force: true,
-					...source.mediaKey !== void 0 ? { mediaKey: source.mediaKey } : {},
-					...source.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: source.keyFrameMediaKey } : {}
-				});
-			},
+			embed: (source) => this.embedRebuildSourceViaPipeline(source),
+			store: async (source, embeddingBase64) => store.upsertIfBetter({
+				trackId: source.trackId,
+				deviceId: source.deviceId,
+				timestamp: source.timestamp,
+				className: source.className,
+				embeddingBase64,
+				modelId,
+				confidence: source.confidence,
+				force: true,
+				...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)
@@ -27140,12 +27237,11 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				rebuilt: 0,
 				missingKeyFrame: 0,
 				missingBbox: 0,
+				notRunnable: 0,
 				failed: 0
 			}
 		};
 		rebuildObjectEmbeddings(deps, {
-			...input.cropMargin !== void 0 ? { cropMargin: input.cropMargin } : {},
-			...input.square !== void 0 ? { square: input.square } : {},
 			...input.maxTracks !== void 0 ? { maxTracks: input.maxTracks } : {},
 			onProgress: (progress) => {
 				if (this.rebuildState.running) this.rebuildState.progress = progress;
@@ -27170,7 +27266,6 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		});
 		this.ctx.logger.info("object embedding rebuild started", { meta: {
 			deviceId: input.deviceId ?? "all",
-			cropMargin: input.cropMargin ?? "default",
 			maxTracks: input.maxTracks ?? "unbounded"
 		} });
 		return {
@@ -27212,6 +27307,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			rebuilt: p?.rebuilt ?? 0,
 			missingKeyFrame: p?.missingKeyFrame ?? 0,
 			missingBbox: p?.missingBbox ?? 0,
+			notRunnable: p?.notRunnable ?? 0,
 			failed: p?.failed ?? 0,
 			complete: state.complete ?? null,
 			startedAtMs: state.startedAtMs ?? null,