@camstack/addon-post-analysis 1.2.272 → 1.2.273

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-BkBZcyAK.js");
+const require_dist = require("../dist-m5QdWXqR.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -47714,391 +47714,6 @@ async function retentionScopeDeviceIds(deps, onError) {
 	return [...ids];
 }
 //#endregion
-//#region src/pipeline-analytics/videoclip-visits.ts
-/**
-* Videoclip visits — the grain a clip should have on an events-mode camera.
-*
-* Disk writes one fMP4 per ffmpeg roll (~8–12 s). The recorder calendar merges
-* only gaps ≤ 5 s, so a single pantry walk shows up as several availability
-* ranges with ~8 s GOP holes between them. Analytics then mints one 15 s clip
-* per motion heartbeat. A *visit* is the keep-window those fragments belong
-* to: cluster availability with {@link VISIT_MERGE_GAP_MS}, annotate with
-* overlapping events. No second copy of the media; the files stay the source
-* of truth.
-*/
-/** Synthetic event-id slot in `analytics:<start>:<end>:<id>` for a visit clip. */
-var VISIT_EVENT_ID = "visit";
-function clusterFootageVisits(ranges, gapMs = require_dist.VISIT_MERGE_GAP_MS) {
-	if (ranges.length === 0) return [];
-	const sorted = [...ranges].toSorted((a, b) => a.startMs - b.startMs);
-	const visits = [];
-	let pieces = [sorted[0]];
-	let endMs = sorted[0].endMs;
-	for (let i = 1; i < sorted.length; i++) {
-		const next = sorted[i];
-		if (next.startMs <= endMs + gapMs) {
-			pieces.push(next);
-			endMs = Math.max(endMs, next.endMs);
-			continue;
-		}
-		visits.push(finishVisit(pieces, endMs));
-		pieces = [next];
-		endMs = next.endMs;
-	}
-	visits.push(finishVisit(pieces, endMs));
-	return visits;
-}
-function finishVisit(pieces, endMs) {
-	const holes = [];
-	for (let i = 1; i < pieces.length; i++) {
-		const prevEnd = pieces[i - 1].endMs;
-		const nextStart = pieces[i].startMs;
-		if (nextStart > prevEnd) holes.push({
-			startMs: prevEnd,
-			endMs: nextStart
-		});
-	}
-	return {
-		startMs: pieces[0].startMs,
-		endMs,
-		ranges: pieces,
-		holes
-	};
-}
-var KIND_ORDER = [
-	"object",
-	"motion",
-	"audio"
-];
-function eventOverlapsVisit(event, visit, pad) {
-	if (event.timestamp >= visit.startMs && event.timestamp <= visit.endMs) return true;
-	const windowStart = event.timestamp - pad.preMs;
-	const windowEnd = event.timestamp + pad.postMs;
-	return windowStart < visit.endMs && windowEnd > visit.startMs;
-}
-function dominantKind(attached) {
-	for (const kind of KIND_ORDER) if (attached.some((a) => a.kind === kind)) return kind;
-	return "motion";
-}
-/**
-* The instant a recorded still can actually be decoded inside a visit: the
-* midpoint of its LONGEST contiguous range.
-*
-* NOT the midpoint of the visit. A visit spans its holes by construction (it is
-* ranges glued across gaps up to `VISIT_MERGE_GAP_MS`), so the naive midpoint
-* lands in dead air roughly as often as not and the recorder's still route
-* answers 204 for a visit with plenty of footage.
-*/
-function stillInstantMs(ranges) {
-	let best;
-	for (const range of ranges) if (best === void 0 || range.endMs - range.startMs > best.endMs - best.startMs) best = range;
-	if (best === void 0) return void 0;
-	return Math.floor((best.startMs + best.endMs) / 2);
-}
-/**
-* The distinct object classes attached to a visit, most frequent first,
-* capped at {@link MAX_CLIP_LABELS}. Empty when nothing classified overlapped
-* — the caller then omits the field so a motion/audio-only visit keeps its
-* kind label instead of carrying an empty array every consumer length-checks.
-*/
-function dominantLabels(attached) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const a of attached) {
-		if (a.kind !== "object") continue;
-		const name = a.event.className;
-		if (typeof name !== "string" || name.length === 0) continue;
-		counts.set(name, (counts.get(name) ?? 0) + 1);
-	}
-	return [...counts.entries()].toSorted((x, y) => y[1] - x[1]).slice(0, 3).map(([name]) => name);
-}
-function visitsToClips(visits, events, pad, vouched) {
-	const tagged = [
-		...events.object.map((event) => ({
-			kind: "object",
-			event
-		})),
-		...events.motion.map((event) => ({
-			kind: "motion",
-			event
-		})),
-		...events.audio.map((event) => ({
-			kind: "audio",
-			event
-		}))
-	];
-	return visits.map((visit) => {
-		const attached = tagged.filter((t) => eventOverlapsVisit(t.event, visit, pad));
-		const kind = dominantKind(attached);
-		const withThumb = attached.find((a) => a.kind === kind && a.event.mediaUrl && vouched.has(a.event.id)) ?? attached.find((a) => a.event.mediaUrl && vouched.has(a.event.id));
-		const stillAtMs = stillInstantMs(visit.ranges);
-		const labels = dominantLabels(attached);
-		return {
-			id: `analytics:${visit.startMs}:${visit.endMs}:${VISIT_EVENT_ID}`,
-			source: "analytics",
-			kind,
-			timeRange: {
-				startMs: visit.startMs,
-				endMs: visit.endMs
-			},
-			...withThumb?.event.mediaUrl !== void 0 ? { thumbnail: withThumb.event.mediaUrl } : {},
-			...stillAtMs !== void 0 ? { stillAtMs } : {},
-			eventIds: attached.slice(0, 24).map((a) => a.event.id),
-			eventCount: attached.length,
-			holes: [...visit.holes],
-			...labels.length > 0 ? { labels } : {}
-		};
-	}).toSorted((a, b) => b.timeRange.startMs - a.timeRange.startMs);
-}
-//#endregion
-//#region src/pipeline-analytics/videoclips-provider.ts
-/**
-* Default `videoclips` provider — composes recorded footage visits with the
-* analytics event log. A clip is a time-WINDOW over existing footage, never a
-* separate file: `getClipPlayback` resolves to
-* `recording.getPlaybackManifest(startMs, endMs)`.
-*
-* When availability is present the grain is a *visit* (events-mode keep-window
-* clustered at `VISIT_MERGE_GAP_MS`), not one clip per motion heartbeat. The
-* clip id still encodes the window (`analytics:<startMs>:<endMs>:visit`) so
-* playback is self-contained. Without availability (or when that read fails)
-* the provider falls back to per-event padded windows.
-*
-* Pure helpers (`eventsToClips` / `clusterFootageVisits` / `clipIdFor` /
-* `parseClipId`) are unit-tested in isolation; the provider factory wires
-* injected fetch/resolve deps so the compose logic is testable without I/O.
-*/
-var SOURCE = "analytics";
-/** The addon that registers this provider — stamped on its source row. */
-var ANALYTICS_ADDON_ID = "pipeline-analytics";
-/**
-* Backstop on the ANNOTATION read — never on the clip list.
-*
-* A visit is annotated by every event inside it, so the clip `limit` must not
-* reach this fetch (one 615 visit legitimately spans 2 345 motion rows). This
-* bound exists only so a pathological camera-day cannot pull an unbounded page:
-* the store orders `timestamp DESC`, so a truncation drops the OLDEST rows and
-* the EARLIEST visits silently lose their annotations — which is why hitting it
-* is logged, per camera, rather than absorbed.
-*/
-var VISIT_EVENT_FETCH_LIMIT = 5e3;
-function clipIdFor(eventId, startMs, endMs) {
-	return `${SOURCE}:${startMs}:${endMs}:${eventId}`;
-}
-/** Parse a default-provider clip id back into its window + event id. Returns
-*  `null` for any id this provider did not mint (e.g. a native clip id). */
-function parseClipId(clipId) {
-	const parts = clipId.split(":");
-	if (parts.length < 4 || parts[0] !== SOURCE) return null;
-	const startMs = Number(parts[1]);
-	const endMs = Number(parts[2]);
-	if (!Number.isFinite(startMs) || !Number.isFinite(endMs)) return null;
-	const eventId = parts.slice(3).join(":");
-	if (!eventId) return null;
-	return {
-		eventId,
-		startMs,
-		endMs
-	};
-}
-/** Map per-kind events into time-ranged clips, newest-first. Pure. */
-function eventsToClips(events, pad, vouched) {
-	const make = (e, kind) => {
-		const startMs = e.timestamp - pad.preMs;
-		const endMs = e.timestamp + pad.postMs;
-		return {
-			id: clipIdFor(e.id, startMs, endMs),
-			source: SOURCE,
-			kind,
-			timeRange: {
-				startMs,
-				endMs
-			},
-			...e.mediaUrl !== void 0 && vouched.has(e.id) ? { thumbnail: e.mediaUrl } : {}
-		};
-	};
-	return [
-		...events.motion.map((e) => make(e, "motion")),
-		...events.object.map((e) => make(e, "object")),
-		...events.audio.map((e) => make(e, "audio"))
-	].toSorted((a, b) => b.timeRange.startMs - a.timeRange.startMs);
-}
-/** Every id in the three buckets, in the order the composers tag them. */
-function allEventIds(events) {
-	return [
-		...events.motion,
-		...events.object,
-		...events.audio
-	].map((e) => e.id);
-}
-/**
-* Resolve the event ids whose `mediaUrl` is backed by real bytes, mirroring
-* `resolveDefaultEventMedia`: the event's OWN media when it has any, else its
-* owning TRACK's. Up to four batched index reads — one PER EVENT KIND that has
-* any ids (D476: `motion` / `object` / `audio` are separate owner kinds now,
-* so a single combined read can no longer ask "does any of these ids own
-* media" — a motion id and an object id can be the same number post-D474 and
-* are answered by different rows) — plus the track fallback, only over the
-* object events the first pass did not already answer for (motion and audio
-* are trackless roots, so they never need it).
-*
-* THROWS on a failed read. The caller fails closed on the CLAIM and open on the
-* LIST; swallowing here would collapse those two opposite directions into one.
-*/
-async function resolveVouchedEvents(deviceId, events, fetchMediaOwners) {
-	const ownMedia = /* @__PURE__ */ new Set();
-	for (const ownerType of require_dist.EVENT_OWNER_TYPES) {
-		const ownerIds = events[ownerType].map((e) => e.id);
-		if (ownerIds.length === 0) continue;
-		const found = await fetchMediaOwners({
-			deviceId,
-			ownerKind: ownerType,
-			ownerIds
-		});
-		for (const id of found) ownMedia.add(id);
-	}
-	const residualTracks = [];
-	const seenTracks = /* @__PURE__ */ new Set();
-	for (const event of events.object) {
-		const trackId = event.trackId;
-		if (trackId === void 0 || ownMedia.has(event.id) || seenTracks.has(trackId)) continue;
-		seenTracks.add(trackId);
-		residualTracks.push(trackId);
-	}
-	const trackMedia = residualTracks.length === 0 ? /* @__PURE__ */ new Set() : await fetchMediaOwners({
-		deviceId,
-		ownerKind: "track",
-		ownerIds: residualTracks
-	});
-	const vouched = new Set(ownMedia);
-	for (const event of events.object) {
-		const trackId = event.trackId;
-		if (trackId !== void 0 && trackMedia.has(trackId)) vouched.add(event.id);
-	}
-	return vouched;
-}
-/** Keep only clips that actually touch the caller's window. The reads are
-*  widened by {@link leftOverhangMs}; the ANSWER is not. */
-function intersectsWindow(clip, since, until) {
-	return clip.timeRange.startMs < until && clip.timeRange.endMs > since;
-}
-/**
-* How far BEFORE `since` the event + availability reads must reach.
-*
-* A visit straddling `since` keeps its heartbeat rows and loses the transition
-* row — the only one that ever carries a snapshot — so the same visit shows a
-* picture or doesn't depending on where the operator scrolled. One wider range
-* scan on an indexed column buys a list that stops changing under the cursor.
-*/
-function leftOverhangMs(pad) {
-	return require_dist.VISIT_MERGE_GAP_MS + pad.preMs;
-}
-function createVideoclipsProvider(deps) {
-	return {
-		listClips: async ({ deviceId, since, until, limit }) => {
-			const readSince = since - leftOverhangMs(deps.defaultPad);
-			const events = await deps.fetchEvents({
-				deviceId,
-				since: readSince,
-				until,
-				limit: deps.fetchAvailability ? VISIT_EVENT_FETCH_LIMIT : limit
-			});
-			warnOnTruncatedFetch(deps, deviceId, events);
-			let vouched = /* @__PURE__ */ new Set();
-			try {
-				vouched = await resolveVouchedEvents(deviceId, events, deps.fetchMediaOwners);
-			} catch (err) {
-				deps.logWarn?.("videoclips: media presence read failed — listing without thumbnails", {
-					deviceId,
-					events: allEventIds(events).length,
-					error: err instanceof Error ? err.message : String(err)
-				});
-			}
-			let clips = eventsToClips(events, deps.defaultPad, vouched);
-			if (deps.fetchAvailability) try {
-				clips = visitsToClips(clusterFootageVisits(await deps.fetchAvailability({
-					deviceId,
-					since: readSince,
-					until
-				}), require_dist.VISIT_MERGE_GAP_MS), events, deps.defaultPad, vouched);
-			} catch (err) {
-				deps.logWarn?.("videoclips: availability read failed — listing unfiltered", {
-					deviceId,
-					error: err instanceof Error ? err.message : String(err)
-				});
-			}
-			const inWindow = clips.filter((c) => intersectsWindow(c, since, until));
-			const answer = limit != null ? inWindow.slice(0, limit) : inWindow;
-			reportUnvouchedClips(deps, deviceId, answer);
-			return answer;
-		},
-		/**
-		* The one source this provider serves, on every camera: the hub's own
-		* analytics visits over recorded footage.
-		*
-		* Always `ok`, and that is not optimism — this source IS the process
-		* answering the call, so there is no reachability question to report. A
-		* read that fails INSIDE `listClips` degrades that list (and logs it); a
-		* source that cannot be reached at all is reported by the collection
-		* dispatcher, which is the only layer that can tell the difference.
-		* `label` is what the picker draws.
-		*/
-		listSources: async () => [{
-			source: SOURCE,
-			addonId: ANALYTICS_ADDON_ID,
-			label: "CamStack recordings",
-			availability: { state: "ok" }
-		}],
-		getClipPlayback: async ({ deviceId, clipId }) => {
-			const parsed = parseClipId(clipId);
-			if (!parsed) throw new Error(`videoclips: unrecognized clipId "${clipId}"`);
-			return {
-				...await deps.resolvePlayback({
-					deviceId,
-					startMs: parsed.startMs,
-					endMs: parsed.endMs
-				}),
-				format: "hls"
-			};
-		}
-	};
-}
-/** The annotation backstop biting is a SILENT loss of the earliest visits'
-*  events — say so, per camera, instead of shipping a thinner list. */
-function warnOnTruncatedFetch(deps, deviceId, events) {
-	if (!deps.fetchAvailability) return;
-	const truncated = [
-		"motion",
-		"object",
-		"audio"
-	].filter((kind) => events[kind].length >= VISIT_EVENT_FETCH_LIMIT);
-	if (truncated.length === 0) return;
-	deps.logWarn?.("videoclips: annotation fetch truncated — earliest visits lose their events", {
-		deviceId,
-		kinds: truncated,
-		limit: VISIT_EVENT_FETCH_LIMIT
-	});
-}
-/** The operator's acceptance criterion as a number: a rising count on one
-*  camera is its motion-snapshot capturer failing, not a quiet day. */
-function reportUnvouchedClips(deps, deviceId, clips) {
-	const clipsWithoutStill = clips.filter((c) => c.thumbnail === void 0).length;
-	if (clipsWithoutStill === 0) return;
-	deps.logInfo?.("videoclips: visit has no vouched still", {
-		deviceId,
-		clipsWithoutStill,
-		clips: clips.length
-	});
-}
-//#endregion
-//#region src/pipeline-analytics/videoclips-shared.ts
-/** Stringify the numeric event ids of one bucket. Lossless. */
-function toEventLike(events) {
-	return events.map((e) => ({
-		...e,
-		id: String(e.id)
-	}));
-}
-//#endregion
 //#region src/pipeline-analytics/viewer-settings-actions.ts
 /**
 * Viewer settings snapshots — hub-shared named blobs of the viewer's stores.
@@ -78648,7 +78263,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		await step("buildSceneMonitor", () => this.buildSceneMonitor(api, logger));
 		this.startSweepTimers();
 		this.ctx.logger.info("pipeline-analytics subscribers installed");
-		const providers = await step("buildProviderRegistrations", () => this.buildProviderRegistrations(api, stores, capProviders));
+		const providers = await step("buildProviderRegistrations", () => this.buildProviderRegistrations(stores, capProviders));
 		const isHub = ownNodeId === "hub";
 		const ncHandlers = isHub ? this.buildNcActionHandlers(api) : void 0;
 		this.discardJob = createDiscardJob({
@@ -81052,71 +80667,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			});
 		}
 	}
-	buildProviderRegistrations(api, stores, providers) {
+	buildProviderRegistrations(stores, providers) {
 		const widgetsProvider = createAnalyticsWidgetsProvider();
-		const videoclipsProvider = createVideoclipsProvider({
-			defaultPad: require_dist.EVENT_PAD_MS,
-			fetchEvents: async ({ deviceId, since, until, limit }) => {
-				const [motion, object, audio] = await Promise.all([
-					this.getMotionEvents({
-						deviceId,
-						since,
-						until,
-						limit,
-						projection: "slim"
-					}),
-					this.getObjectEvents({
-						deviceId,
-						since,
-						until,
-						limit,
-						projection: "slim"
-					}),
-					this.getAudioEvents({
-						deviceId,
-						since,
-						until,
-						limit,
-						projection: "slim"
-					})
-				]);
-				return {
-					motion: toEventLike(motion),
-					object: toEventLike(object),
-					audio: toEventLike(audio)
-				};
-			},
-			fetchMediaOwners: async ({ deviceId, ownerKind, ownerIds }) => {
-				return stores.mediaStore.ownersWithMedia(ownerKind, ownerIds, deviceId);
-			},
-			fetchAvailability: async ({ deviceId, since, until }) => {
-				return (await api.recording.getAvailability.query({
-					deviceId,
-					fromMs: since,
-					toMs: until
-				})).ranges;
-			},
-			logWarn: (message, meta) => this.ctx.logger.warn(message, {
-				tags: { deviceId: Number(meta["deviceId"]) },
-				meta
-			}),
-			logInfo: (message, meta) => this.ctx.logger.info(message, {
-				tags: { deviceId: Number(meta["deviceId"]) },
-				meta
-			}),
-			resolvePlayback: async ({ deviceId, startMs, endMs }) => {
-				const manifest = await api.recording.getPlaybackManifest.query({
-					deviceId,
-					fromMs: startMs,
-					toMs: endMs
-				});
-				if (manifest.playbackUrl == null) throw new Error(`videoclips: no footage for clip window [${startMs},${endMs}] on device ${deviceId}`);
-				return {
-					playbackUrl: manifest.playbackUrl,
-					playbackEndpoints: manifest.playbackEndpoints
-				};
-			}
-		});
 		const faceGallery = new FaceGalleryProvider({
 			identityStore: stores.identityStore,
 			faceStore: stores.faceStore,
@@ -81179,10 +80731,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				capability: require_dist.addonWidgetsSourceCapability,
 				provider: widgetsProvider
 			},
-			{
-				capability: require_dist.videoclipsCapability,
-				provider: videoclipsProvider
-			},
 			{
 				capability: require_dist.faceGalleryCapability,
 				provider: faceGallery
@@ -85835,6 +85383,24 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		return this.queryFacade.listEventMedia(input);
 	}
 	/**
+	* Which of `ownerIds` hold at least ONE media row — the media-PRESENCE probe,
+	* on the wire because the `videoclips` source lives in the addon that owns
+	* the FOOTAGE now (D560).
+	*
+	* A pass-through to {@link MediaStore.ownersWithMedia}, which batches by
+	* `whereIn` and pages: the N+1 this exists to prevent is one query per owner,
+	* and a process boundary in front of it would multiply that, not absorb it.
+	*
+	* It THROWS rather than answering partially, and the empty ask costs no read
+	* at all — a caller with nothing to probe must not pay a round trip for it.
+	*/
+	async ownersWithMedia(input) {
+		if (input.ownerIds.length === 0) return [];
+		const store = this.mediaStore;
+		if (store === null) throw new Error(`pipelineAnalytics.ownersWithMedia: the media index is not open on this node — refusing rather than answering "these owners have nothing" (device ${String(input.deviceId)})`);
+		return [...await store.ownersWithMedia(input.ownerKind, input.ownerIds, input.deviceId)];
+	}
+	/**
 	* Search object events by text using CLIP cosine similarity.
 	*
 	* Flow: