@camstack/addon-post-analysis 1.2.36 → 1.2.37

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-cXcI2z-g.js");
+const require_dist = require("../dist-DQvvZ5_E.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
@@ -14030,41 +14030,6 @@ function shouldSkipDropoutFrame(activeTrackCount, detectionCount, consecutiveSki
 	return consecutiveSkips < cfg.maxSkipFrames;
 }
 //#endregion
-//#region src/pipeline-analytics/pipeline/embedding-search.ts
-/**
-* embedding-search — CLIP text→embedding cosine ranking helper.
-*
-* `rankByText` mirrors `face-matcher.matchEmbedding` with the identity-grouping
-* removed: it compares a single query vector against all rows, enforces the
-* same-modelId/dim gate, and returns the top-N rows above `minScore` sorted
-* descending by cosine similarity.
-*/
-/**
-* Brute-force cosine rank of `rows` against `queryVec`.
-*
-* Gate: same-modelId (when `opts.modelId` is set) AND same dimension as
-* `queryVec.length`. Rows that fail either gate are skipped.
-* Returns at most `opts.limit` rows with `score >= opts.minScore`,
-* ordered descending by score. Immutable — does not modify inputs.
-*/
-function rankByText(queryVec, rows, opts) {
-	const queryDim = queryVec.length;
-	const scored = [];
-	for (const row of rows) {
-		if (opts.modelId !== void 0 && row.modelId !== opts.modelId) continue;
-		if (row.dim !== queryDim) continue;
-		if (row.embedding.length !== queryDim) continue;
-		const score = require_dist.cosineSimilarity(queryVec, new Float32Array(row.embedding));
-		if (score < opts.minScore) continue;
-		scored.push({
-			row,
-			score
-		});
-	}
-	scored.sort((a, b) => b.score - a.score);
-	return scored.slice(0, opts.limit);
-}
-//#endregion
 //#region src/pipeline-analytics/pipeline/event-child-crops.ts
 /**
 * Compute Intersection-over-Union between two (x,y,w,h) bounding boxes.
@@ -20291,50 +20256,35 @@ var IdentityStore = class {
 	}
 };
 //#endregion
-//#region src/pipeline-analytics/store/object-embedding-mirror.ts
+//#region src/pipeline-analytics/store/object-embedding-store.ts
 /**
-* Mirrors per-track object embeddings into the `vector-store` capability.
-*
-* ## Why a mirror and not a swap
+* ObjectEmbeddingStore — per-track CLIP image embeddings, in the `vector-store`
+* capability.
 *
-* The read path (`searchObjectEvents`) is live and, since the whereIn join fix,
-* fast enough to use. Flipping it onto a vector index that has not been
-* backfilled would return an empty search on a hub with 8,455 embeddings — a
-* regression an operator would notice before any benefit landed.
+* ## What this used to be
 *
-* So this writes to BOTH: the existing settings-store collection stays
-* authoritative and the vector index is populated alongside it. Once
-* `vectorStore.stats` reports a count matching the legacy collection on the
-* live hub, the read path can move over in one commit with a real before/after
-* measurement, and this mirror becomes the only writer.
+* Until 2026-08-06 this owned a `pipeline-analytics:object-embeddings` settings
+* collection whose `embedding` column was a JSON array of 512 floats — measured
+* at ~11.7 KB per row on the live hub and `JSON.parse`d 5,000 times on every
+* semantic search. That collection is gone. The vector store is now the only
+* home for these vectors: base64 Float32LE (2,732 bytes for the same 512 dims),
+* with `deviceId` / `timestamp` / `className` / `modelId` promoted to indexed
+* columns so prefilters are pushed into SQL rather than applied after loading.
 *
-* That ordering is deliberate and is written down in `docs/roadmap.md` — the
-* failure this repo keeps repeating is a mechanism that looks finished and is
-* wired to nothing, and a half-migrated store is the same shape.
+* The dual-write mirror and the boot backfill that carried the transition were
+* deleted along with the collection: the index converged (8,467 = 8,467, delta
+* 0) and a migration aid left running is just a second writer nobody reads.
 *
-* ## The index
+* ## What did NOT change
 *
-* One index, `object-clip`, dim taken from the first vector seen. Metadata
-* carries `deviceId` / `timestamp` / `className` / `modelId` (promoted to real
-* columns by the provider, so prefilters are pushed into SQL) plus `trackId`,
-* `confidence` and the two media keys, which ride in the JSON remainder.
+* One row per track, keyed by `trackId`, holding the track's best-confidence
+* detection. The confidence gate lives here rather than in the caller because
+* the in-memory `TrackBestSelector` resets on restart and this is the durable
+* half — see `best-selection-policies.ts`.
 */
-/** The one index this mirror owns. */
+/** The vector-store index this store owns. */
 var OBJECT_CLIP_INDEX = "object-clip";
-/** Build the metadata record for one embedding. Exported for tests. */
-function metadataFor(row) {
-	return {
-		deviceId: row.deviceId,
-		timestamp: row.timestamp,
-		className: row.className,
-		modelId: row.modelId,
-		trackId: row.trackId,
-		confidence: row.confidence,
-		...row.mediaKey !== void 0 ? { mediaKey: row.mediaKey } : {},
-		...row.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: row.keyFrameMediaKey } : {}
-	};
-}
-var ObjectEmbeddingMirror = class {
+var ObjectEmbeddingStore = class {
 	vectorStore;
 	logger;
 	declaredDim = null;
@@ -20343,11 +20293,13 @@ var ObjectEmbeddingMirror = class {
 		this.logger = deps.logger;
 	}
 	/**
-	* Declare the index lazily, on the first vector, because the dimension comes
-	* from the active encoder and is not known at construction time.
+	* Declare the index lazily, on the first vector — its dimension comes from
+	* the active encoder and is not known at construction.
 	*
-	* Returns false when the index could not be declared — the caller must then
-	* skip the write rather than upsert into an index that does not exist.
+	* Returns false when declaration failed, and the caller must then skip the
+	* 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.
 	*/
 	async ensureIndex(dim) {
 		if (this.declaredDim === dim) return true;
@@ -20360,7 +20312,7 @@ var ObjectEmbeddingMirror = class {
 			this.declaredDim = dim;
 			return true;
 		} catch (err) {
-			this.logger.warn("vector-store index declaration failed — mirror disabled for this dim", { meta: {
+			this.logger.warn("object-embedding index declaration failed — writes disabled for this dim", { meta: {
 				index: OBJECT_CLIP_INDEX,
 				dim,
 				error: String(err)
@@ -20368,232 +20320,34 @@ var ObjectEmbeddingMirror = class {
 			return false;
 		}
 	}
-	/** Mirror one embedding. Never throws — the legacy write is authoritative. */
-	async mirror(row) {
-		if (row.embedding.length === 0) return;
-		if (!await this.ensureIndex(row.embedding.length)) return;
+	/**
+	* Upsert the best-confidence embedding for a track. At most ONE row per
+	* track: a write only replaces the stored row when its confidence is
+	* strictly higher, keeping the track's best crop over its lifetime.
+	*/
+	async upsertIfBetter(input) {
+		if (input.embedding.length === 0) return;
+		if (!await this.ensureIndex(input.embedding.length)) return;
 		try {
+			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 ((await this.vectorStore.upsert.mutate({
 				index: "object-clip",
 				items: [{
-					id: row.trackId,
-					vector: require_dist.encodeVectorBase64(row.embedding),
-					metadata: metadataFor(row)
+					id: input.trackId,
+					vector: require_dist.encodeVectorBase64(input.embedding),
+					metadata: metadataFor(input)
 				}]
-			})).rejected > 0) this.logger.warn("vector-store rejected a mirrored embedding", {
-				tags: { deviceId: row.deviceId },
-				meta: {
-					trackId: row.trackId,
-					dim: row.embedding.length
-				}
-			});
-		} catch (err) {
-			this.logger.warn("vector-store mirror failed", {
-				tags: { deviceId: row.deviceId },
+			})).rejected > 0) this.logger.warn("object-embedding upsert rejected", {
+				tags: { deviceId: input.deviceId },
 				meta: {
-					trackId: row.trackId,
-					error: String(err)
+					trackId: input.trackId,
+					dim: input.embedding.length
 				}
 			});
-		}
-	}
-	/** Mirror a page of embeddings — the backfill path. */
-	async mirrorMany(rows) {
-		const usable = rows.filter((r) => r.embedding.length > 0);
-		const first = usable[0];
-		if (first === void 0) return { upserted: 0 };
-		if (!await this.ensureIndex(first.embedding.length)) return { upserted: 0 };
-		const items = usable.filter((r) => r.embedding.length === first.embedding.length).map((r) => ({
-			id: r.trackId,
-			vector: require_dist.encodeVectorBase64(r.embedding),
-			metadata: metadataFor(r)
-		}));
-		const skipped = usable.length - items.length;
-		if (skipped > 0) this.logger.warn("backfill skipped embeddings of a different dimension", { meta: {
-			skipped,
-			expectedDim: first.embedding.length
-		} });
-		try {
-			return { upserted: (await this.vectorStore.upsert.mutate({
-				index: OBJECT_CLIP_INDEX,
-				items
-			})).upserted };
-		} catch (err) {
-			this.logger.warn("vector-store backfill page failed", { meta: {
-				count: items.length,
-				error: String(err)
-			} });
-			return { upserted: 0 };
-		}
-	}
-	/** Keep the index in step with the legacy cascade delete. */
-	async remove(trackIds) {
-		if (trackIds.length === 0) return;
-		try {
-			await this.vectorStore.deleteByIds.mutate({
-				index: OBJECT_CLIP_INDEX,
-				ids: [...trackIds]
-			});
-		} catch (err) {
-			this.logger.warn("vector-store mirror delete failed", { meta: {
-				count: trackIds.length,
-				error: String(err)
-			} });
-		}
-	}
-	/**
-	* How far the mirror has got, for the decision to flip the read path.
-	* Returns null when the index is not reachable or not yet declared.
-	*/
-	async count() {
-		try {
-			return (await this.vectorStore.stats.query({ index: OBJECT_CLIP_INDEX })).count;
-		} catch {
-			return null;
-		}
-	}
-};
-//#endregion
-//#region src/pipeline-analytics/store/object-embedding-store.ts
-var OBJECT_EMBEDDINGS_COLLECTION = "pipeline-analytics:object-embeddings";
-var OBJECT_EMBEDDING_COLUMNS = [
-	{
-		name: "id",
-		type: "TEXT",
-		primaryKey: true,
-		notNull: true
-	},
-	{
-		name: "deviceId",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "trackId",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "timestamp",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "className",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "embedding",
-		type: "JSON",
-		notNull: true
-	},
-	{
-		name: "modelId",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "dim",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "confidence",
-		type: "REAL",
-		notNull: true
-	},
-	{
-		name: "mediaKey",
-		type: "TEXT"
-	},
-	{
-		name: "keyFrameMediaKey",
-		type: "TEXT"
-	}
-];
-/**
-* Ceiling on the CANDIDATE pool a semantic search may load.
-*
-* `query()` was called with no limit at all, so a default search loaded the
-* entire collection — 86.5 MB across 7,375 rows on a live hub, every time,
-* before ranking anything.
-*
-* It cannot simply be the caller's result limit: search RANKS the pool and then
-* takes the top N, so limiting to N up front would return N arbitrary rows
-* instead of the N best. This bounds the pool well above any result count, and
-* `query()` orders by `timestamp` DESC whenever a limit applies so "the pool"
-* means the most recent rows rather than whatever the page order happened to
-* be. The caller logs when the cap is reached — a silently truncated search
-* reads as "nothing older matched".
-*/
-var EMBEDDING_SEARCH_CANDIDATE_CAP = 5e3;
-var ObjectEmbeddingStore = class {
-	store;
-	logger;
-	mirror;
-	constructor(deps) {
-		this.store = deps.store;
-		this.logger = deps.logger;
-		this.mirror = deps.mirror ?? null;
-	}
-	static async declare(store) {
-		await store.declareCollection.mutate({
-			collection: OBJECT_EMBEDDINGS_COLLECTION,
-			columns: [...OBJECT_EMBEDDING_COLUMNS],
-			indexes: [{
-				name: "idx_obj_emb_device_ts",
-				columns: ["deviceId", "timestamp"]
-			}, {
-				name: "idx_obj_emb_track",
-				columns: ["trackId"]
-			}]
-		});
-	}
-	/**
-	* Upsert the best-confidence CLIP embedding for a track. The id is the
-	* trackId so there is at most ONE row per track. An upsert only replaces
-	* the row when the new confidence is strictly higher than the stored value,
-	* keeping the best-crop embedding for the track over its lifetime.
-	*/
-	async upsertIfBetter(input) {
-		const existing = await this.store.get.query({
-			collection: OBJECT_EMBEDDINGS_COLLECTION,
-			key: input.trackId
-		});
-		if (existing !== void 0 && existing !== null) {
-			const storedConf = existing.confidence;
-			if (typeof storedConf === "number" && input.confidence <= storedConf) return;
-		}
-		const record = {
-			deviceId: input.deviceId,
-			trackId: input.trackId,
-			timestamp: input.timestamp,
-			className: input.className,
-			embedding: input.embedding,
-			modelId: input.modelId,
-			dim: input.embedding.length,
-			confidence: input.confidence,
-			...input.mediaKey !== void 0 ? { mediaKey: input.mediaKey } : {},
-			...input.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: input.keyFrameMediaKey } : {}
-		};
-		try {
-			await this.store.set.mutate({
-				collection: OBJECT_EMBEDDINGS_COLLECTION,
-				key: input.trackId,
-				value: record
-			});
-			await this.mirror?.mirror({
-				trackId: input.trackId,
-				deviceId: input.deviceId,
-				timestamp: input.timestamp,
-				className: input.className,
-				embedding: input.embedding,
-				modelId: input.modelId,
-				confidence: input.confidence,
-				...input.mediaKey !== void 0 ? { mediaKey: input.mediaKey } : {},
-				...input.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: input.keyFrameMediaKey } : {}
-			});
 		} catch (err) {
 			this.logger.warn("ObjectEmbeddingStore.upsertIfBetter failed", {
 				tags: { deviceId: input.deviceId },
@@ -20605,93 +20359,141 @@ var ObjectEmbeddingStore = class {
 		}
 	}
 	/**
-	* Load all embeddings for a device within a time range. Applies `modelId`
-	* and `className` filters when provided. Used by `searchObjectEvents`.
-	*/
-	async query(input) {
-		const where = {};
-		if (input.deviceId !== void 0) where["deviceId"] = input.deviceId;
-		if (input.className !== void 0) where["className"] = input.className;
-		if (input.modelId !== void 0) where["modelId"] = input.modelId;
-		const filter = { where };
-		if (input.since !== void 0 || input.until !== void 0) filter["whereBetween"] = { timestamp: [input.since ?? 0, input.until ?? Date.now()] };
-		if (input.limit !== void 0) {
-			filter["limit"] = input.limit;
-			filter["orderBy"] = {
-				field: "timestamp",
-				direction: "desc"
+	* Rank stored embeddings against a query vector.
+	*
+	* Ranking happens in the provider, over compact rows, with the prefilters
+	* pushed into SQL. This used to load every candidate into this process and
+	* cosine them in JS behind a 5,000-row cap.
+	*/
+	async searchByVector(input) {
+		const equals = {};
+		if (input.deviceId !== void 0) equals["deviceId"] = input.deviceId;
+		if (input.className !== void 0) equals["className"] = input.className;
+		if (input.modelId !== void 0) equals["modelId"] = input.modelId;
+		const between = {};
+		if (input.since !== void 0 || input.until !== void 0) between["timestamp"] = [input.since ?? 0, input.until ?? Date.now()];
+		const filter = {
+			...Object.keys(equals).length > 0 ? { equals } : {},
+			...Object.keys(between).length > 0 ? { between } : {}
+		};
+		try {
+			const result = await this.vectorStore.query.query({
+				index: OBJECT_CLIP_INDEX,
+				vector: require_dist.encodeVectorBase64(input.vector),
+				topK: input.limit,
+				...input.minScore !== void 0 ? { minScore: input.minScore } : {},
+				...Object.keys(filter).length > 0 ? { filter } : {}
+			});
+			const hits = [];
+			for (const match of result.matches) {
+				const row = rowFromMetadata(match.id, match.metadata);
+				if (row === null) continue;
+				hits.push({
+					row,
+					score: match.score
+				});
+			}
+			return {
+				hits,
+				scanned: result.scanned,
+				truncated: result.truncated
 			};
-		}
-		return (await this.store.query.query({
-			collection: OBJECT_EMBEDDINGS_COLLECTION,
-			filter
-		})).map((r) => {
-			const data = r.data;
+		} catch (err) {
+			this.logger.warn("ObjectEmbeddingStore.searchByVector failed", {
+				...input.deviceId !== void 0 ? { tags: { deviceId: input.deviceId } } : {},
+				meta: { error: String(err) }
+			});
 			return {
-				id: r.id,
-				...data,
-				mediaKey: data.mediaKey ?? void 0,
-				keyFrameMediaKey: data.keyFrameMediaKey ?? void 0
+				hits: [],
+				scanned: 0,
+				truncated: false
 			};
-		});
+		}
 	}
 	/**
-	* Retention sweep: delete all embeddings whose timestamp < cutoffMs across
-	* every device. Drains fully: loops a page at a time until no stale rows
-	* remain. Returns deleted row ids.
+	* Retention sweep: drop every embedding older than `cutoffMs`, in one
+	* filtered delete rather than the page-and-delete loop the collection needed.
+	* Returns the number removed.
 	*/
 	async pruneAll(cutoffMs) {
-		const ids = [];
-		for (;;) {
-			const rows = await this.store.query.query({
-				collection: OBJECT_EMBEDDINGS_COLLECTION,
-				filter: {
-					whereBetween: { timestamp: [0, cutoffMs] },
-					limit: 500
-				}
-			});
-			if (rows.length === 0) break;
-			let deletedInPage = 0;
-			for (const row of rows) {
-				const id = typeof row.id === "string" ? row.id : void 0;
-				if (!id) continue;
-				try {
-					await this.store.delete.mutate({
-						collection: OBJECT_EMBEDDINGS_COLLECTION,
-						key: id
-					});
-					ids.push(id);
-					deletedInPage++;
-				} catch {}
-			}
-			if (deletedInPage === 0) break;
+		try {
+			return (await this.vectorStore.deleteByFilter.mutate({
+				index: OBJECT_CLIP_INDEX,
+				filter: { between: { timestamp: [0, cutoffMs] } }
+			})).deleted;
+		} catch (err) {
+			this.logger.warn("ObjectEmbeddingStore.pruneAll failed", { meta: {
+				cutoffMs,
+				error: String(err)
+			} });
+			return 0;
 		}
-		await this.mirror?.remove(ids);
-		return ids;
 	}
 	/**
 	* `TrackScopedStore` contract for the retention cascade: delete the per-track
-	* CLIP search vector for the given tracks. The row id IS the trackId (one row
-	* per track), so this deletes by key directly. Pure EPHEMERAL track state —
-	* the identity MATCHING embeddings (ArcFace) live in a SEPARATE durable store
+	* CLIP search vector for the given tracks. Pure EPHEMERAL track state — the
+	* identity MATCHING embeddings (ArcFace) live in a SEPARATE durable store
 	* (`identity-samples`) and are never touched here, so pruning this never
-	* breaks recognition (design §2/§4). Per-track ISOLATED + best-effort.
+	* breaks recognition (design §2/§4).
 	*/
 	async deleteByTracks(trackIds) {
-		await this.mirror?.remove(trackIds);
-		for (const trackId of trackIds) try {
-			await this.store.delete.mutate({
-				collection: OBJECT_EMBEDDINGS_COLLECTION,
-				key: trackId
+		if (trackIds.length === 0) return;
+		try {
+			await this.vectorStore.deleteByIds.mutate({
+				index: OBJECT_CLIP_INDEX,
+				ids: [...trackIds]
 			});
 		} catch (err) {
 			this.logger.warn("ObjectEmbeddingStore.deleteByTracks failed", { meta: {
-				trackId,
+				count: trackIds.length,
 				error: String(err)
 			} });
 		}
 	}
 };
+/** Build the vector-store metadata for one embedding. */
+function metadataFor(input) {
+	return {
+		deviceId: input.deviceId,
+		timestamp: input.timestamp,
+		className: input.className,
+		modelId: input.modelId,
+		trackId: input.trackId,
+		confidence: input.confidence,
+		...input.mediaKey !== void 0 ? { mediaKey: input.mediaKey } : {},
+		...input.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: input.keyFrameMediaKey } : {}
+	};
+}
+/**
+* Rebuild a stored row from vector-store metadata.
+*
+* Returns null when the row lacks its identity fields rather than filling them
+* with defaults: a hit whose `deviceId` silently became 0 would be joined to
+* the wrong camera's events.
+*/
+function rowFromMetadata(id, metadata) {
+	const deviceId = metadata["deviceId"];
+	const timestamp = metadata["timestamp"];
+	const trackId = metadata["trackId"] ?? id;
+	if (typeof deviceId !== "number" || typeof timestamp !== "number") return null;
+	if (typeof trackId !== "string") return null;
+	const className = metadata["className"];
+	const modelId = metadata["modelId"];
+	const confidence = metadata["confidence"];
+	const mediaKey = metadata["mediaKey"];
+	const keyFrameMediaKey = metadata["keyFrameMediaKey"];
+	return {
+		id,
+		trackId,
+		deviceId,
+		timestamp,
+		className: typeof className === "string" ? className : "unknown",
+		modelId: typeof modelId === "string" ? modelId : "unknown",
+		confidence: typeof confidence === "number" ? confidence : 0,
+		...typeof mediaKey === "string" ? { mediaKey } : {},
+		...typeof keyFrameMediaKey === "string" ? { keyFrameMediaKey } : {}
+	};
+}
 //#endregion
 //#region src/pipeline-analytics/store/ops-log-store.ts
 /**
@@ -23686,7 +23488,6 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		await FaceStore.declare(api.settingsStore);
 		await PlateStore.declare(api.settingsStore);
 		await VehicleStore.declare(api.settingsStore);
-		await ObjectEmbeddingStore.declare(api.settingsStore);
 		await StationaryObjectRegistry.declare(api.settingsStore);
 		await OpsLogStore.declare(api.settingsStore);
 		await NotificationCenter.declare(api.settingsStore);
@@ -23701,7 +23502,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-DmmNcR6B.js"));
+			const { FilesystemStorageProvider } = await Promise.resolve().then(() => require("../node-CJcK55RY.js"));
 			storage = new FilesystemStorageProvider(mediaRoot, { eventMedia: mediaRoot });
 			logger.info("pipeline-analytics: event media rooted at CAMSTACK_MEDIA_ROOT", { meta: { mediaRoot } });
 		}
@@ -23945,14 +23746,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		});
 		this.plateRecognizer.refreshGallery();
 		const vectorStore = api.vectorStore;
-		const mirror = vectorStore !== void 0 ? new ObjectEmbeddingMirror({
+		if (vectorStore === void 0) logger.warn("vector-store capability unavailable — CLIP semantic search is disabled", { meta: { addon: "@camstack/addon-vector-store" } });
+		else this.objectEmbeddingStore = new ObjectEmbeddingStore({
 			vectorStore,
-			logger: logger.child("ObjectEmbeddingMirror")
-		}) : void 0;
-		this.objectEmbeddingStore = new ObjectEmbeddingStore({
-			store: api.settingsStore,
-			logger: logger.child("ObjectEmbeddingStore"),
-			...mirror !== void 0 ? { mirror } : {}
+			logger: logger.child("ObjectEmbeddingStore")
 		});
 	}
 	/** Two-plane detail dispatcher: the per-frame executor runs ONLY the root
@@ -26165,8 +25962,8 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				this.ctx.logger.debug("plate buffer prune failed", { meta: { error: String(err) } });
 			}
 			if (this.objectEmbeddingStore && Number.isFinite(minObjectCutoffMs)) try {
-				const deletedEmbIds = await this.objectEmbeddingStore.pruneAll(minObjectCutoffMs);
-				if (deletedEmbIds.length > 0) this.ctx.logger.info("object embedding retention prune", { meta: { deleted: deletedEmbIds.length } });
+				const deletedEmbeddings = await this.objectEmbeddingStore.pruneAll(minObjectCutoffMs);
+				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) } });
 			}
@@ -26707,9 +26504,9 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	*
 	* Flow:
 	*   1. Call `embedding-encoder.encodeText` to embed `text` → `queryVec`.
-	*   2. Query `objectEmbeddingStore` with optional prefilters (deviceId,
-	*      since/until, classFilter, modelId from encoder).
-	*   3. Rank candidates via `rankByText` (same-model/dim gate + cosine).
+	*   2. Resolve the active encoder's modelId (same-model gate).
+	*   3. Rank IN THE VECTOR STORE — prefilters pushed into SQL, cosine over
+	*      compact rows in the provider.
 	*   4. Fetch the corresponding ObjectEvents by trackId (via getObjectEvents
 	*      with each winner's deviceId + trackId filter) and join score.
 	*   5. Return at most `limit` ScoredObjectEvents sorted descending by score.
@@ -26725,39 +26522,37 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		});
 		if (!encodeResult) return [];
 		const queryVec = new Float32Array(encodeResult.embedding);
-		const embeddingRows = await store.query({
-			deviceId: input.deviceId,
-			since: input.since,
-			until: input.until,
-			className: input.classFilter,
-			limit: EMBEDDING_SEARCH_CANDIDATE_CAP
+		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;
 		});
-		if (embeddingRows.length >= 5e3) this.ctx.logger.warn("searchObjectEvents: candidate pool truncated", {
+		const search = await store.searchByVector({
+			vector: queryVec,
+			limit: input.limit,
+			minScore: input.minScore,
+			...input.deviceId !== void 0 ? { deviceId: input.deviceId } : {},
+			...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 } : {}
+		});
+		if (search.truncated) this.ctx.logger.warn("searchObjectEvents: candidate pool truncated", {
 			meta: {
-				cap: EMBEDDING_SEARCH_CANDIDATE_CAP,
+				scanned: search.scanned,
 				since: input.since,
 				until: input.until,
 				className: input.classFilter
 			},
-			tags: input.deviceId !== void 0 ? { deviceId: input.deviceId } : void 0
+			...input.deviceId !== void 0 ? { tags: { deviceId: input.deviceId } } : {}
 		});
-		if (embeddingRows.length === 0) return [];
+		const ranked = search.hits;
+		if (ranked.length === 0) return [];
 		const embeddingMediaKeyByTrackId = /* @__PURE__ */ new Map();
 		const keyFrameKeyByTrackId = /* @__PURE__ */ new Map();
-		for (const row of embeddingRows) {
+		for (const { row } of ranked) {
 			if (row.mediaKey !== void 0) embeddingMediaKeyByTrackId.set(row.trackId, row.mediaKey);
 			if (row.keyFrameMediaKey !== void 0) keyFrameKeyByTrackId.set(row.trackId, row.keyFrameMediaKey);
 		}
-		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 ranked = rankByText(queryVec, embeddingRows, {
-			minScore: input.minScore,
-			limit: input.limit,
-			...encoderInfo !== null ? { modelId: encoderInfo.modelId } : {}
-		});
-		if (ranked.length === 0) return [];
 		const scoreByTrackId = /* @__PURE__ */ new Map();
 		for (const { row, score } of ranked) scoreByTrackId.set(row.trackId, score);
 		const events = await (this.eventStore?.queryObjectByTrackIds([...scoreByTrackId.keys()]) ?? Promise.resolve([]));