@camstack/addon-post-analysis 1.2.298 → 1.2.299

package/dist/pipeline-analytics/index.mjs

@@ -1,6 +1,6 @@
-import { $ as NcRuleSchema, $n as string, $t as isSystemEventSummaryRule, A as LockStateSchema, An as evaluateSensorEdge, At as audioMetricsCapability, B as NC_DEFAULT_SNOOZE_MINUTES, Bn as isDeviceScopedCap, Bt as embeddingRefusalOf, C as EMBEDDING_REQUIREMENTS_UNAVAILABLE, Cn as systemEventSummaryScheduleOf, Ct as TimelapseRuleInputSchema, D as FULL_IMAGE_BBOX, Dn as zoneAnalyticsCapability, Dt as addonWidgetsSourceCapability, E as FIRST_LEVEL_MACRO_CLASSES, En as vectorDimFromBase64, Et as TrackSourceSchema, F as MediaFileKindEnum, Fn as CamProfileSchema, Ft as deriveRecordingMode, G as NC_TAXONOMY, Gn as array, Gt as faceGalleryCapability, I as MotionTriggeredBySchema, In as createEvent, It as describeSystemEventDeliveryProblem, J as NcAlarmSettingsPatchSchema, Jn as literal, Jt as isEventOwnerType, K as NC_TEMPLATE_VARS, Kn as boolean, Kt as failureContributionCapability, L as NC_ALARM_SYSTEM_EVENT_KINDS, Ln as customAction, Lt as describeSystemEventFamilyProblem, M as MAX_BIRTH_DECISION_RECORDS, Mn as DeviceType, Mt as buildEventKindDescriptor, Nn as errMsg, Nt as consumableLowPercentOf, O as FailureCounters, Ot as alarmPanelCapability, P as MOTION_CLOSE_AFTER_MS, Pn as BaseAddon, Pt as cosineSimilarity$1, Q as NcRulePatchSchema, Qn as record, Qt as isSystemDelivery, R as NC_CONDITION_CATALOG, Rn as defineCustomActions, S as EMBEDDING_REQUIREMENTS_FAILED, Sn as systemEventFilterApplies, St as TIMELAPSE_DENSE_FLOOR_SEC, T as EVENT_OWNER_TYPES, Tn as templateVarsFor, Tt as TimelapseRuleSchema, U as NC_SYSTEM_EVENT_KIND_GROUP_SPECS, Un as sleep$1, Ut as encodeVectorBase64, V as NC_SENSOR_TRANSITION_KINDS, Vn as nodePin, W as NC_TANK_SYSTEM_EVENT_KINDS, Wn as _enum, Wt as evictionPolicyOfLocation, X as NcConditionsSchema, Xn as object, Xt as isMediaOwnerType, Y as NcConditionDescriptorSchema, Yn as number, Yt as isKnownTemplateVar, Z as NcRuleInputSchema, Zn as partialRecord, Zt as isScheduleActive, _n as servedTemplateVars, a as CLIP_EMBEDDING_STEP_ID, at as NcSnoozeSuppressedSchema, b as DeclaredDevices, bn as systemEventDeliveryProblems, bt as SCENE_DIVERGED, c as resolveClusterModelPin, cn as readDeviceStateFrom, ct as NcTemplatePreviewInputSchema, d as ArchivedDebugNoteSchema, dn as resolveClipSearchMinScore, dt as OpsLogEntrySchema, en as isVectorIndexDimConflict, er as unknown, et as NcRuleTargetSchema, f as BaseDevice, fn as resolveLocationMode, g as DEFAULT_EVENT_COLOR, gn as sensorRaisedOf, gt as RetrainStatusSchema, h as CoverStateSchema, hn as sceneMonitorCapability, ht as RebuildObjectEmbeddingsRefusalSchema, in as occupancyScope, it as NcSnoozeSchema, j as MAX_ARCHIVED_DEBUG_NOTES, jn as isSourceCap, jt as audioModeOf, k as LabelAttributionSchema, kn as canonicalHash, kt as assertTimelapseCadences, l as AUDIO_MACRO_LABELS, ln as readMotionTriggeredBy, lt as NcTemplatePreviewSchema, m as COCO_TO_MACRO, mn as ruleBelongsToAlarm$1, mt as RECORDING_SOURCE_CAMSTACK_ADDON, nn as mayWriteToLocation, nt as NcScheduleSchema, o as FACE_EMBEDDING_STEP_ID, on as pipelineAnalyticsCapability, ot as NcSystemEventKindSchema, p as BirthDecisionRecordSchema, pt as RECORDING_EXPORT_MAX_READ_BYTES, q as NcAlarmConfigSchema, qn as discriminatedUnion, qt as isDetectionMacroClass, rn as notificationRulesCapability, rt as NcSnoozeInputSchema, s as readClusterModelPinStrict, sn as plateGalleryCapability, st as NcTaxonomySchema, t as BUILTIN_CLIP_MODELS, tn as kebabToCamel, tr as EventCategory, tt as NcRuleUpdateInputSchema, u as AlarmArmModeSchema, un as readTimelapseGeneratedAt, ut as NcTemplateVarDescriptorSchema, v as DETECTION_MACRO_CLASSES, vn as storageOccupancyCapability, vt as SCENE_DEFAULT_ANCHOR_THRESHOLD, w as EVENT_KIND_BY_CAP, wn as templateCarriesSummary, wt as TimelapseRulePatchSchema, x as EMBEDDING_MODEL_FAILED, xn as systemEventFamilyProblems, xt as SceneMonitorSchema, yn as subKindsOf, yt as SCENE_DEFAULT_UNCOVERED_POLICY, z as NC_CONSUMABLE_SYSTEM_EVENT_KINDS, zn as hydrateSchema } from "../clip-model-registry-D9WaswEs.mjs";
+import { $ as NcRuleSchema, $n as partialRecord, $t as isScheduleActive, A as LockStateSchema, At as audioMetricsCapability, B as NC_DEFAULT_SNOOZE_MINUTES, Bn as defineCustomActions, Bt as embeddingRefusalOf, C as EMBEDDING_REQUIREMENTS_UNAVAILABLE, Cn as systemEventFamilyProblems, Ct as TimelapseRuleInputSchema, D as FULL_IMAGE_BBOX, Dn as templateVarsFor, Dt as addonWidgetsSourceCapability, E as FIRST_LEVEL_MACRO_CLASSES, En as templateCarriesSummary, Et as TrackSourceSchema, F as MediaFileKindEnum, Fn as errMsg, Ft as deriveRecordingMode, G as NC_TAXONOMY, Gn as sleep$1, Gt as faceGalleryCapability, Hn as isDeviceScopedCap, I as MotionTriggeredBySchema, In as BaseAddon, It as describeSystemEventDeliveryProblem, J as NcAlarmSettingsPatchSchema, Jn as boolean, Jt as gifFromMp4Args, K as NC_TEMPLATE_VARS, Kn as _enum, Kt as failureContributionCapability, L as NC_ALARM_SYSTEM_EVENT_KINDS, Ln as CamProfileSchema, Lt as describeSystemEventFamilyProblem, M as MAX_BIRTH_DECISION_RECORDS, Mn as evaluateSensorEdge, Mt as buildEventKindDescriptor, Nn as isSourceCap, Nt as consumableLowPercentOf, O as FailureCounters, On as vectorDimFromBase64, Ot as alarmPanelCapability, P as MOTION_CLOSE_AFTER_MS, Pn as DeviceType, Pt as cosineSimilarity$1, Q as NcRulePatchSchema, Qn as object, Qt as isMediaOwnerType, R as NC_CONDITION_CATALOG, Rn as createEvent, S as EMBEDDING_REQUIREMENTS_FAILED, Sn as systemEventDeliveryProblems, St as TIMELAPSE_DENSE_FLOOR_SEC, T as EVENT_OWNER_TYPES, Tn as systemEventSummaryScheduleOf, Tt as TimelapseRuleSchema, U as NC_SYSTEM_EVENT_KIND_GROUP_SPECS, Un as nodePin, Ut as encodeVectorBase64, V as NC_SENSOR_TRANSITION_KINDS, Vn as hydrateSchema, W as NC_TANK_SYSTEM_EVENT_KINDS, Wt as evictionPolicyOfLocation, X as NcConditionsSchema, Xn as literal, Xt as isEventOwnerType, Y as NcConditionDescriptorSchema, Yn as discriminatedUnion, Yt as isDetectionMacroClass, Z as NcRuleInputSchema, Zn as number, Zt as isKnownTemplateVar, _n as sceneMonitorCapability, a as CLIP_EMBEDDING_STEP_ID, an as notificationRulesCapability, at as NcSnoozeSuppressedSchema, b as DeclaredDevices, bn as storageOccupancyCapability, bt as SCENE_DIVERGED, c as resolveClusterModelPin, cn as pipelineAnalyticsCapability, ct as NcTemplatePreviewInputSchema, d as ArchivedDebugNoteSchema, dn as readMotionTriggeredBy, dt as OpsLogEntrySchema, en as isSystemDelivery, er as record, et as NcRuleTargetSchema, f as BaseDevice, fn as readTimelapseGeneratedAt, g as DEFAULT_EVENT_COLOR, gn as ruleBelongsToAlarm$1, gt as RetrainStatusSchema, h as CoverStateSchema, ht as RebuildObjectEmbeddingsRefusalSchema, in as mayWriteToLocation, it as NcSnoozeSchema, j as MAX_ARCHIVED_DEBUG_NOTES, jn as canonicalHash, jt as audioModeOf, k as LabelAttributionSchema, kn as zoneAnalyticsCapability, kt as assertTimelapseCadences, l as AUDIO_MACRO_LABELS, ln as plateGalleryCapability, lt as NcTemplatePreviewSchema, m as COCO_TO_MACRO, mn as resolveLocationMode, mt as RECORDING_SOURCE_CAMSTACK_ADDON, nn as isVectorIndexDimConflict, nr as unknown, nt as NcScheduleSchema, o as FACE_EMBEDDING_STEP_ID, on as occupancyScope, ot as NcSystemEventKindSchema, p as BirthDecisionRecordSchema, pn as resolveClipSearchMinScore, pt as RECORDING_EXPORT_MAX_READ_BYTES, q as NcAlarmConfigSchema, qn as array, qt as gifDeriveSpeed, rn as kebabToCamel, rr as EventCategory, rt as NcSnoozeInputSchema, s as readClusterModelPinStrict, st as NcTaxonomySchema, t as BUILTIN_CLIP_MODELS, tn as isSystemEventSummaryRule, tr as string, tt as NcRuleUpdateInputSchema, u as AlarmArmModeSchema, un as readDeviceStateFrom, ut as NcTemplateVarDescriptorSchema, v as DETECTION_MACRO_CLASSES, vn as sensorRaisedOf, vt as SCENE_DEFAULT_ANCHOR_THRESHOLD, w as EVENT_KIND_BY_CAP, wn as systemEventFilterApplies, wt as TimelapseRulePatchSchema, x as EMBEDDING_MODEL_FAILED, xn as subKindsOf, xt as SceneMonitorSchema, yn as servedTemplateVars, yt as SCENE_DEFAULT_UNCOVERED_POLICY, z as NC_CONSUMABLE_SYSTEM_EVENT_KINDS, zn as customAction } from "../clip-model-registry-DCztUu1G.mjs";
 import { t as __exportAll } from "../embedding-encoder/index.mjs";
-import * as fs from "node:fs";
+import * as fs$1 from "node:fs";
 import { promises } from "node:fs";
 import * as path$1 from "node:path";
 import path from "node:path";
@@ -8,6 +8,7 @@ import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from
 import { execFile } from "node:child_process";
 import { startEventLoopStallMonitor } from "@camstack/system/addon-utils";
 import { pipeline } from "node:stream/promises";
+import fs from "node:fs/promises";
 import sharp from "sharp";
 import os from "node:os";
 import { isDeepStrictEqual } from "node:util";
@@ -3152,16 +3153,16 @@ function errnoCode(err) {
 async function writeFileAtomic(filePath, data) {
 	const tmp = path$1.join(path$1.dirname(filePath), `.${path$1.basename(filePath)}.${randomUUID()}.tmp`);
 	try {
-		await fs.promises.writeFile(tmp, data);
+		await fs$1.promises.writeFile(tmp, data);
 		await renameOver(tmp, filePath);
 	} catch (err) {
-		await fs.promises.rm(tmp, { force: true }).catch(() => void 0);
+		await fs$1.promises.rm(tmp, { force: true }).catch(() => void 0);
 		throw err;
 	}
 }
 async function renameOver(tmp, filePath) {
 	for (let attempt = 0;; attempt += 1) try {
-		await fs.promises.rename(tmp, filePath);
+		await fs$1.promises.rename(tmp, filePath);
 		return;
 	} catch (err) {
 		const code = errnoCode(err);
@@ -3170,8 +3171,8 @@ async function renameOver(tmp, filePath) {
 			await new Promise((resolve) => setTimeout(resolve, WINDOWS_RENAME_RETRY_MS));
 			continue;
 		}
-		await fs.promises.copyFile(tmp, filePath);
-		await fs.promises.rm(tmp, { force: true });
+		await fs$1.promises.copyFile(tmp, filePath);
+		await fs$1.promises.rm(tmp, { force: true });
 		return;
 	}
 }
@@ -3246,28 +3247,28 @@ var FilesystemStorageProvider = class {
 			location,
 			relativePath
 		});
-		await fs.promises.mkdir(path$1.dirname(filePath), { recursive: true });
+		await fs$1.promises.mkdir(path$1.dirname(filePath), { recursive: true });
 		if (Buffer.isBuffer(data)) await writeFileAtomic(filePath, data);
 		else {
 			const tmp = path$1.join(path$1.dirname(filePath), `.${path$1.basename(filePath)}.${randomUUID()}.tmp`);
 			try {
-				await pipeline(data, fs.createWriteStream(tmp));
-				await fs.promises.rename(tmp, filePath);
+				await pipeline(data, fs$1.createWriteStream(tmp));
+				await fs$1.promises.rename(tmp, filePath);
 			} catch (err) {
-				await fs.promises.rm(tmp, { force: true }).catch(() => void 0);
+				await fs$1.promises.rm(tmp, { force: true }).catch(() => void 0);
 				throw err;
 			}
 		}
 	}
 	async read({ location, relativePath }) {
-		return fs.promises.readFile(await this.resolve({
+		return fs$1.promises.readFile(await this.resolve({
 			location,
 			relativePath
 		}));
 	}
 	async exists({ location, relativePath }) {
 		try {
-			await fs.promises.access(await this.resolve({
+			await fs$1.promises.access(await this.resolve({
 				location,
 				relativePath
 			}));
@@ -3281,7 +3282,7 @@ var FilesystemStorageProvider = class {
 		if (!base) return [];
 		const dir = prefix ? path$1.join(base, prefix) : base;
 		try {
-			return (await fs.promises.readdir(dir, { withFileTypes: true })).map((e) => prefix ? `${prefix}/${e.name}` : e.name);
+			return (await fs$1.promises.readdir(dir, { withFileTypes: true })).map((e) => prefix ? `${prefix}/${e.name}` : e.name);
 		} catch {
 			return [];
 		}
@@ -3291,19 +3292,19 @@ var FilesystemStorageProvider = class {
 			location,
 			relativePath
 		});
-		await fs.promises.rm(filePath, { force: true });
+		await fs$1.promises.rm(filePath, { force: true });
 	}
 	async getAvailableSpace({ location }) {
 		const base = this.locationPaths.get(location);
 		if (!base) return null;
 		try {
 			let target = base;
-			while (!fs.existsSync(target)) {
+			while (!fs$1.existsSync(target)) {
 				const parent = path$1.dirname(target);
 				if (!parent || parent === target) return null;
 				target = parent;
 			}
-			const stats = await fs.promises.statfs(target);
+			const stats = await fs$1.promises.statfs(target);
 			return stats.bavail * stats.bsize;
 		} catch {
 			return null;
@@ -9973,14 +9974,25 @@ function occupancySubjectFromEdge(edge) {
 		threshold: edge.threshold
 	};
 }
-/** Build the subject for a `package-event` evaluation (a persisted `package`
-*  object-event; `phase` derives from the event `state` at the call site). */
+/**
+* Build the subject for a `package-event` evaluation (a persisted `package`
+* object-event; `phase` derives from the event `state` at the call site).
+*
+* `observedAt` (D682, D684): a pick-up row's `timestamp` is when the departure
+* was CONCLUDED — five minutes of unseen observed time after the parcel went —
+* so the detector STORES the instant it happened on the row, and the footage is
+* cut around that (`media-anchor.ts`). Read from the row HERE, the one place
+* every path builds a package subject (live hook, boot reconcile, dry-run), so
+* none of them can anchor differently. `timestamp` keeps its meaning; a row
+* written before D684 has none, which the anchor reads as unknown, out loud.
+*/
 function subjectFromPackageEvent(ev, phase) {
 	return {
 		kind: "package-event",
 		recordId: String(ev.id),
 		deviceId: ev.deviceId,
 		timestamp: ev.timestamp,
+		...ev.observedAt !== void 0 ? { observedAt: ev.observedAt } : {},
 		classNames: [ev.className],
 		...displayLabel(ev) !== void 0 ? { label: displayLabel(ev) } : {},
 		...recognitionPatch(ev.subLabelMeta),
@@ -10911,7 +10923,11 @@ function incomingFromAudioEvent(event, stillOwnerId) {
 		})
 	};
 }
-/** Package object-event persist (delivered / picked-up). */
+/**
+* Package object-event persist (delivered / picked-up) — the live hook and the
+* boot reconcile alike. A pick-up's instant is read from the row
+* (`event.observedAt`, D684) inside `subjectFromPackageEvent`.
+*/
 function incomingFromPackageEvent(event, phase) {
 	return {
 		subject: subjectFromPackageEvent(event, phase),
@@ -10921,7 +10937,8 @@ function incomingFromPackageEvent(event, phase) {
 			tags: { deviceId: event.deviceId },
 			meta: {
 				eventId: event.id,
-				phase
+				phase,
+				...event.observedAt !== void 0 ? { observedAt: event.observedAt } : {}
 			}
 		})
 	};
@@ -19314,9 +19331,14 @@ function mediaAnchor(subject) {
 		lagMs: subject.timestamp - observedAt
 	};
 }
+function selfDatingKindOf(subject) {
+	if (subject.occupancy !== void 0) return "occupancy";
+	if (subject.packagePhase === "picked-up") return "package pick-up";
+	return null;
+}
 /**
 * True when this anchor is the conclusion instant AND the subject was one that
-* should have been able to date itself — today, an occupancy row.
+* should have been able to date itself — see {@link selfDatingKindOf}.
 *
 * Split from {@link mediaAnchor} because the anchor must stay pure of any
 * notion of subject KIND, while the log line that matters is exactly the one
@@ -20420,7 +20442,8 @@ var NcDispatcher = class {
 		};
 		const preRollSec = entry.payload.mediaClipPreRollSec ?? 4;
 		const anchor = mediaAnchor(entry.payload.subject);
-		if (anchorFellBack(anchor, entry.payload.subject.occupancy !== void 0)) this.deps.logger.warn("occupancy footage anchored on the conclusion — moment unknown", {
+		const selfDating = selfDatingKindOf(entry.payload.subject);
+		if (anchorFellBack(anchor, selfDating !== null)) this.deps.logger.warn(`${selfDating ?? "occupancy"} footage anchored on the conclusion — moment unknown`, {
 			tags: { deviceId: entry.payload.subject.deviceId },
 			meta: {
 				ruleId: entry.ruleId,
@@ -20448,7 +20471,7 @@ var NcDispatcher = class {
 					preRollSec,
 					retentionSec: this.ringRetentionSec(entry.payload.subject.deviceId),
 					wanted: [...wantGif ? ["gif"] : [], ...wantMp4 ? ["video"] : []],
-					next: this.deps.cutRecordedClip !== void 0 ? "recorded-clip-follow-up" : "no-clip"
+					next: this.recordedFollowUp(entry).kinds.length > 0 ? "recorded-clip-follow-up" : "no-clip"
 				}
 			});
 			return {
@@ -20502,6 +20525,13 @@ var NcDispatcher = class {
 	* alert for a complete one, which is precisely the wrong trade for the
 	* notification that tells an operator someone is at the door.
 	*
+	* A GIF rule is served here too (D682): a package pick-up is concluded five
+	* minutes after it happened, so a gif anchored on the pick-up is always
+	* outside the ring. The gif is derived from THIS cut's bytes
+	* (`deriveGifFromClip`) — one cut, never a second renderer — and a moment the
+	* recordings cannot serve ships NO gif, by named reason, rather than a gif of
+	* the wrong time.
+	*
 	* So the alert's latency is UNCHANGED, and **the clip is attached later**, as
 	* a follow-up send to the same target carrying the same `tag` — a phone
 	* collapses the two, so what the operator sees is the notification gaining
@@ -20524,7 +20554,9 @@ var NcDispatcher = class {
 	*/
 	startRecordedFootage(entry, target, notification) {
 		const cut = this.deps.cutRecordedClip;
-		if (cut === void 0 || entry.payload.mediaClip !== true) return;
+		const plan = this.recordedFollowUp(entry);
+		const wanted = plan.kinds;
+		if (cut === void 0 || wanted.length === 0 && plan.gifRefused === void 0 && plan.videoRefused === void 0) return;
 		const preRollSec = entry.payload.mediaClipPreRollSec ?? 4;
 		const anchor = mediaAnchor(entry.payload.subject);
 		if (footageSourceFor({
@@ -20534,34 +20566,70 @@ var NcDispatcher = class {
 			ringRetentionSec: this.ringRetentionSec(entry.payload.subject.deviceId)
 		}) !== "recordings") return;
 		const deviceId = entry.payload.subject.deviceId;
+		if (plan.gifRefused !== void 0) this.deps.logger.info("recorded gif follow-up: none — the gif is not cut from the recordings", {
+			tags: { deviceId },
+			meta: {
+				ruleId: entry.ruleId,
+				eventId: entry.recordId,
+				targetId: target.id,
+				reason: plan.gifRefused,
+				anchoredOn: anchor.source,
+				...anchor.fallback !== void 0 ? { anchorFallback: anchor.fallback } : {},
+				next: wanted
+			}
+		});
+		if (plan.videoRefused !== void 0) this.deps.logger.info("recorded video follow-up: none — the video is not cut from the recordings", {
+			tags: { deviceId },
+			meta: {
+				ruleId: entry.ruleId,
+				eventId: entry.recordId,
+				targetId: target.id,
+				reason: plan.videoRefused,
+				anchoredOn: anchor.source,
+				...anchor.fallback !== void 0 ? { anchorFallback: anchor.fallback } : {},
+				next: wanted
+			}
+		});
+		if (wanted.length === 0) return;
+		const videoSpeed = entry.payload.mediaClipSpeed;
 		const pending = (async () => {
 			const result = await cut({
 				deviceId,
 				aroundMs: anchor.atMs,
 				preRollSec,
 				postRollSec: entry.payload.mediaClipPostRollSec ?? 6,
-				...entry.payload.mediaClipSpeed !== void 0 ? { speed: entry.payload.mediaClipSpeed } : {},
+				...videoSpeed !== void 0 ? { speed: videoSpeed } : {},
 				ruleId: entry.ruleId,
 				recordId: entry.recordId
 			});
 			if (!result.ok) {
-				this.deps.logger.info("recorded clip follow-up: none — this delivery keeps no clip", {
+				this.deps.logger.info("recorded footage follow-up: none — the recorded cut failed", {
 					tags: { deviceId },
 					meta: {
 						ruleId: entry.ruleId,
 						eventId: entry.recordId,
 						targetId: target.id,
-						reason: result.reason
+						reason: result.reason,
+						wanted
 					}
 				});
 				return;
 			}
-			const withUrls = await this.withArtifactUrls(entry, [{
-				mediaType: "video",
-				bytes: result.mp4,
-				mime: "video/mp4",
-				name: "event.mp4"
-			}]);
+			const attachments = await this.recordedAttachments(entry, wanted, result.mp4);
+			if (attachments.length === 0) {
+				this.deps.logger.info("recorded clip follow-up: none — the gif could not be derived", {
+					tags: { deviceId },
+					meta: {
+						ruleId: entry.ruleId,
+						eventId: entry.recordId,
+						targetId: target.id,
+						reason: "gif-derive-failed",
+						wanted
+					}
+				});
+				return;
+			}
+			const withUrls = await this.withArtifactUrls(entry, attachments);
 			const sent = await this.deps.send({
 				addonId: target.addonId,
 				targetId: target.id,
@@ -20590,6 +20658,8 @@ var NcDispatcher = class {
 					target: target.name,
 					profile: result.profile,
 					bytes: result.mp4.byteLength,
+					attachments: attachments.map((a) => a.mediaType),
+					anchoredOn: anchor.source,
 					lagMs: this.now() - entry.updatedAt
 				}
 			});
@@ -20609,6 +20679,84 @@ var NcDispatcher = class {
 		});
 	}
 	/**
+	* What a recorded follow-up for this row would CARRY — the one answer both
+	* the refusal line (`next`) and the follow-up read, so the log cannot promise
+	* a follow-up the dispatcher will not send.
+	*
+	* A video when the rule asked for one. A gif only for a package PICK-UP
+	* whose moment is KNOWN (D682): the gif is derived from the recorded cut's
+	* own bytes, the same way the broker derives it from a ring cut — one cut,
+	* two containers, never a second renderer.
+	*
+	* Narrow on purpose. A pick-up is the one kind whose moment is ALWAYS outside
+	* the ring; every other kind keeps the gif behaviour it had (the ring's, or
+	* none) rather than silently gaining a recorder export per notification. And
+	* a pick-up that fell back to its conclusion gets no recorded footage at all,
+	* gif OR video — cutting the recordings there is exactly the doormat D682
+	* removed (see {@link NcRecordedGifRefusal}, {@link NcRecordedVideoRefusal}).
+	*/
+	recordedFollowUp(entry) {
+		if (this.deps.cutRecordedClip === void 0) return { kinds: [] };
+		const gifRefused = this.recordedGifRefusal(entry);
+		const videoRefused = this.recordedVideoRefusal(entry);
+		const kinds = [];
+		if (entry.payload.mediaGif === true && gifRefused === void 0) kinds.push("gif");
+		if (entry.payload.mediaClip === true && videoRefused === void 0) kinds.push("video");
+		return {
+			kinds,
+			...gifRefused !== void 0 ? { gifRefused } : {},
+			...videoRefused !== void 0 ? { videoRefused } : {}
+		};
+	}
+	/** Why this row's video is not cut from the recordings, or `undefined` when
+	*  it is (or when the rule asked for no video). */
+	recordedVideoRefusal(entry) {
+		if (entry.payload.mediaClip !== true) return void 0;
+		const subject = entry.payload.subject;
+		if (selfDatingKindOf(subject) !== "package pick-up") return void 0;
+		if (anchorFellBack(mediaAnchor(subject), true)) return "moment-unknown";
+	}
+	/** Why this row's gif is not cut from the recordings, or `undefined` when it
+	*  is (or when the rule asked for no gif). */
+	recordedGifRefusal(entry) {
+		if (entry.payload.mediaGif !== true) return void 0;
+		if (this.deps.deriveGifFromClip === void 0) return "no-derive";
+		const subject = entry.payload.subject;
+		if (selfDatingKindOf(subject) !== "package pick-up") return "not-a-pick-up";
+		if (anchorFellBack(mediaAnchor(subject), true)) return "moment-unknown";
+	}
+	/**
+	* The follow-up's attachments, gif first and video second — the order the
+	* ring path ships them in. A gif that could not be derived is left out (its
+	* reason already logged); the video, when asked for, still ships.
+	*/
+	async recordedAttachments(entry, wanted, mp4) {
+		const out = [];
+		const derive = this.deps.deriveGifFromClip;
+		if (wanted.includes("gif") && derive !== void 0) {
+			const gif = await derive({
+				deviceId: entry.payload.subject.deviceId,
+				mp4,
+				...entry.payload.mediaClipSpeed !== void 0 ? { videoSpeed: entry.payload.mediaClipSpeed } : {},
+				ruleId: entry.ruleId,
+				recordId: entry.recordId
+			});
+			if (gif.ok) out.push({
+				mediaType: "gif",
+				bytes: gif.gif,
+				mime: "image/gif",
+				name: "event.gif"
+			});
+		}
+		if (wanted.includes("video")) out.push({
+			mediaType: "video",
+			bytes: mp4,
+			mime: "video/mp4",
+			name: "event.mp4"
+		});
+		return out;
+	}
+	/**
 	* Settle every recorded-clip follow-up this dispatcher has in flight.
 	*
 	* A TEST SEAM, and the honest kind: the follow-up is detached by design, so
@@ -32536,6 +32684,9 @@ var NotificationCenter = class NotificationCenter {
 	* delivered/picked-up), in the SAME moment as the durable insert. Feeds the
 	* `package-event` trigger. Package events ARE object-event rows, so the boot
 	* crash-gap reconcile re-covers them (routed by className in {@link reconcile}).
+	*
+	* When a pick-up HAPPENED is on the row (`event.observedAt`, D684), so this
+	* hook and the reconcile read it from the same place.
 	*/
 	onPackageEventPersisted(event, phase) {
 		this.consumeEvent(incomingFromPackageEvent(event, phase));
@@ -53030,7 +53181,9 @@ var MOTION_EVENTS_COLLECTION = "pipeline-analytics:motion-events";
 * @durable class=ledger owner=pipeline-analytics
 *   write="one row per detected object per processed frame — every tracked
 *     detection the frame processor emits, plus the appearance events and the
-*     synthetic package-drop events. Every row carries the trackId it belongs to."
+*     synthetic package-drop events. Every row carries the trackId it belongs to.
+*     A package PICK-UP row also carries observedAt, when the parcel went,
+*     beside its timestamp, when the departure was concluded (D684)."
 *   retention="TRACK-OWNED: it has no clock of its own. Rows go only when their
 *     track goes, through EventStore.deleteByTracks — which folds in the deletion
 *     of the event's child crops so a caller cannot take the events and leave the
@@ -53237,7 +53390,21 @@ var OBJECT_COLUMNS = [
 	{
 		name: "importance",
 		type: "REAL"
-	}
+	},
+	(
+	/**
+	* When a package PICK-UP happened, beside `timestamp` (when it was
+	* CONCLUDED, five minutes later) — see `ObjectEvent.observedAt` (D684).
+	*
+	* DECLARED, or the backend drops it on write (see `frameId`). Additive: the
+	* collection gains the column in place (`ALTER TABLE … ADD COLUMN`), and every
+	* row written before it reads SQL NULL → absent after `stripNulls`, which is
+	* the truth about it: the moment is unknown. Only the package detector sets it.
+	*/
+	{
+		name: "observedAt",
+		type: "INTEGER"
+	})
 ];
 var AUDIO_COLUMNS = [
 	...COMMON_BASE_COLUMNS,
@@ -59025,6 +59192,180 @@ function decodeBase64(base64) {
 	}
 }
 //#endregion
+//#region src/notification-center/recorded-gif.ts
+/**
+* The notification GIF for a moment only the RECORDINGS still hold — derived
+* from the recorded clip's own bytes (D682).
+*
+* ## Why this exists
+*
+* A package pick-up is concluded five minutes after the parcel went
+* (`PACKAGE_STILLNESS_TTL_MS`). Once its footage is anchored on the pick-up
+* itself rather than on the conclusion (`media-anchor.ts`), the window is far
+* older than any clip ring (≤ 60 s, `NC_CLIP_RETENTION_MAX_SEC`), so the ring
+* refuses it. A gif-only rule then had NOTHING: the recorded follow-up served
+* only a rule that asked for a video. The honest fix for "the gif shows the
+* empty doormat" is not "no gif" — it is the gif of the pick-up, from the
+* recordings.
+*
+* ## One cut, and the gif is DERIVED from it
+*
+* The recorded clip (`recorded-clip.ts`, one `recordingExport` render) is the
+* only cut. The gif is derived from ITS bytes with the SAME filter chain the
+* broker uses on a ring cut (`gifFromMp4Args` in `@camstack/types`), so a gif
+* of an old moment and a gif of a live one look the same, and a rule that asks
+* for both a gif and a video gets two containers of ONE window — the guarantee
+* `NcEventMediaRequest` exists for.
+*
+* ## Never throws, every miss named
+*
+* `derive-failed` (ffmpeg could not produce it) and `stage-failed` (the clip
+* could not be written where ffmpeg can read it) are logged with
+* `tags: { deviceId }` (D400: a missing attachment names its reason).
+*/
+/** Bound on one derive: a ~10 s window encodes in well under a second; a
+*  derive that has not finished in 20 s is wedged. Same bound as the broker's. */
+var NC_RECORDED_GIF_TIMEOUT_MS = 2e4;
+/** A notification gif is a few hundred KB; this is headroom, not a budget. */
+var RECORDED_GIF_MAX_BUFFER = 32 * 1024 * 1024;
+/**
+* Derive the gif. Never throws; every `ok: false` has logged its reason.
+*/
+async function deriveRecordedGif(ports, req) {
+	const tags = { deviceId: req.deviceId };
+	const common = {
+		ruleId: req.ruleId,
+		eventId: req.recordId,
+		sourceBytes: req.mp4.byteLength
+	};
+	let file;
+	try {
+		file = await ports.writeTemp(req.mp4);
+	} catch (err) {
+		ports.logger.warn("recorded gif: could not stage the recorded clip — no gif", {
+			tags,
+			meta: {
+				...common,
+				reason: "stage-failed",
+				error: String(err)
+			}
+		});
+		return {
+			ok: false,
+			reason: "stage-failed"
+		};
+	}
+	try {
+		const speed = gifDeriveSpeed(4, req.videoSpeed ?? 1);
+		const args = gifFromMp4Args({
+			maxWidth: 640,
+			fps: 12,
+			speed,
+			input: file
+		});
+		const startedAt = Date.now();
+		let ran;
+		try {
+			ran = await ports.run(await ports.resolveFfmpeg(), args);
+		} catch (err) {
+			ran = {
+				ok: false,
+				error: String(err)
+			};
+		}
+		const out = ran.ok ? ran.stdout : null;
+		if (out === null || out.byteLength === 0) {
+			ports.logger.warn("recorded gif: the derive failed — the follow-up carries no gif", {
+				tags,
+				meta: {
+					...common,
+					reason: "derive-failed",
+					error: ran.ok ? "ffmpeg produced no bytes" : ran.error.slice(-400)
+				}
+			});
+			return {
+				ok: false,
+				reason: "derive-failed"
+			};
+		}
+		const gif = new Uint8Array(new ArrayBuffer(out.byteLength));
+		gif.set(out);
+		ports.logger.info("recorded gif: derived from the recorded clip", {
+			tags,
+			meta: {
+				...common,
+				gifBytes: gif.byteLength,
+				width: 640,
+				fps: 12,
+				speed,
+				encodeMs: Date.now() - startedAt
+			}
+		});
+		return {
+			ok: true,
+			gif
+		};
+	} finally {
+		await ports.removeTemp(file).catch((err) => {
+			ports.logger.warn("recorded gif: could not remove the staged clip", {
+				tags,
+				meta: {
+					...common,
+					file,
+					error: String(err)
+				}
+			});
+		});
+	}
+}
+/** The production ports: the pinned ffmpeg, a temp file, a bounded child. */
+function buildRecordedGifPorts(input) {
+	return {
+		logger: input.logger,
+		resolveFfmpeg: input.resolveFfmpeg,
+		run: (cmd, args) => new Promise((resolve) => {
+			execFile(cmd, [...args], {
+				encoding: "buffer",
+				maxBuffer: RECORDED_GIF_MAX_BUFFER,
+				timeout: NC_RECORDED_GIF_TIMEOUT_MS,
+				killSignal: "SIGKILL"
+			}, (err, stdout) => resolve(err !== null ? {
+				ok: false,
+				error: String(err)
+			} : {
+				ok: true,
+				stdout
+			}));
+		}),
+		writeTemp: (bytes) => stageTempClip(path.join(os.tmpdir(), `camstack-nc-gif-${randomUUID()}.mp4`), bytes, {
+			write: (file, data) => fs.writeFile(file, data),
+			remove: (file) => fs.rm(file, { force: true })
+		}),
+		removeTemp: (file) => fs.rm(file, { force: true })
+	};
+}
+/**
+* Write the clip to `file`, and on a failed write remove whatever landed.
+*
+* The path is named BEFORE the write, because a write can create the file and
+* then fail (ENOSPC half-way): the caller's `finally` only knows a path the
+* write RETURNED, so a partial `camstack-nc-gif-*.mp4` used to stay in the temp
+* directory for good. The write's error is re-thrown — the caller names it
+* (`stage-failed`, tagged per camera). A removal that ALSO fails is a real leak
+* and rides in that same error's message, so it reaches that one line rather
+* than a second, untagged one.
+*/
+async function stageTempClip(file, bytes, io) {
+	try {
+		await io.write(file, bytes);
+		return file;
+	} catch (err) {
+		const leaked = await io.remove(file).then(() => null, (removeErr) => String(removeErr));
+		if (leaked === null) throw err;
+		throw new Error(`${String(err)}; the partial file ${file} was NOT removed: ${leaked}`);
+	}
+}
+//#endregion
 //#region src/shared/frame/crop-extractor.ts
 /**
 * The ONE reading of a normalized box against a frame: round, then clamp so
@@ -70498,10 +70839,12 @@ var PackageDropDetector = class {
 				pickupAt: entry.lastConfirmedAt
 			}
 		});
+		const observedAt = collector?.observedAt ?? pickupInstantOf(entry);
 		const draft = {
 			kind: "object",
 			deviceId: entry.deviceId,
 			timestamp,
+			observedAt,
 			source: "pipeline",
 			idempotencyKey: pickedUpKey,
 			trackId: mediaTrackId,
@@ -70553,6 +70896,8 @@ var PackageDropDetector = class {
 				idempotencyKey: pickedUpKey,
 				deliveredEventId: delivered.id,
 				mediaTrackId,
+				observedAt,
+				concludedLagMs: timestamp - observedAt,
 				...collector !== void 0 ? {
 					collectorTrackId: collector.trackId,
 					collectorClassName: collector.className,
@@ -89067,6 +89412,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends BaseAddon {
 					readExportBytes: (input) => api.recordingExport.readExportBytes.query(input),
 					deleteExport: (input) => api.recordingExport.deleteExport.mutate(input)
 				}, req),
+				deriveGifFromClip: (req) => deriveRecordedGif(buildRecordedGifPorts({
+					logger: logger.child("RecordedGif"),
+					resolveFfmpeg: () => this.ctx.deps.ensureFfmpeg()
+				}), req),
 				publishArtifact: async (bytes, mime, deviceId) => await this.ncArtifactPlane?.publish(bytes, mime, deviceId) ?? null,
 				viewerUrlBase: async () => pickArtifactBaseUrl(await this.ncEndpoints()),
 				indexArtifact: async (bytes, mime, meta) => await this.ncArtifactPlane?.publishIndexed(bytes, mime, 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-Bk7ACano.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-thT_ff8Z.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

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