@camstack/addon-post-analysis 1.2.224 → 1.2.226

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-iJA2F7_d.js");
+const require_dist = require("../dist-BypQW8jz.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -16,6 +16,7 @@ sharp = require_dist.__toESM(sharp);
 let node_os = require("node:os");
 node_os = require_dist.__toESM(node_os);
 let node_buffer = require("node:buffer");
+let node_zlib = require("node:zlib");
 //#region src/pipeline-analytics/media-occupancy.ts
 /** The bare type ref legacy NULL-stamped media rows belong to. */
 var LEGACY_MEDIA_TYPE = "eventMedia";
@@ -55,6 +56,183 @@ function mediaOccupancyReports(footprint, locationIds, measuredAtMs) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/motion-episode.ts
+/**
+* Decide what one `(detected, timestamp)` observation does to the episode
+* state for one `(deviceId, source)` key. `prior` is `undefined` the first
+* time this key is ever observed (fresh process, or a key never seen).
+*/
+function decideMotionSignal(prior, detected, timestamp) {
+	if (!detected) {
+		if (prior === void 0) return { kind: "noop" };
+		return { kind: "observed-off" };
+	}
+	if (prior?.episode == null) return { kind: "open-episode" };
+	const isNewEdge = prior.lastDetected === false;
+	const edgeOffsetsMs = isNewEdge ? [...prior.episode.edgeOffsetsMs, timestamp - prior.episode.startedAt] : prior.episode.edgeOffsetsMs;
+	return {
+		kind: "extend-episode",
+		next: {
+			...prior.episode,
+			lastOnAt: timestamp,
+			edgeOffsetsMs
+		},
+		isNewEdge
+	};
+}
+/** `lastOnAt - startedAt` — see the module doc for why not `closedAt - startedAt`. */
+function motionEpisodeDurationMs(state) {
+	return state.lastOnAt - state.startedAt;
+}
+//#endregion
+//#region src/pipeline-analytics/motion-episode-tracker.ts
+function keyOf(deviceId, source) {
+	return `${deviceId}:${source}`;
+}
+var MotionEpisodeTracker = class {
+	deps;
+	signals = /* @__PURE__ */ new Map();
+	timers = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/**
+	* One `(detected, timestamp)` observation for one `(deviceId, source)` key.
+	* `regionData` is read only if this observation OPENS a new episode — see
+	* {@link MotionEpisodeInsertInput}.
+	*/
+	async observe(deviceId, source, detected, timestamp, regionData) {
+		const key = keyOf(deviceId, source);
+		const prior = this.signals.get(key);
+		const decision = decideMotionSignal(prior, detected, timestamp);
+		switch (decision.kind) {
+			case "noop": return;
+			case "observed-off":
+				this.setSignal(key, deviceId, source, false, prior?.episode ?? null);
+				return;
+			case "open-episode": {
+				const eventId = await this.deps.insertRow({
+					deviceId,
+					source,
+					timestamp,
+					regionData
+				});
+				if (eventId === null) {
+					this.deps.logger.warn("motion episode open failed — insert did not land", {
+						tags: { deviceId },
+						meta: {
+							source,
+							timestamp
+						}
+					});
+					this.setSignal(key, deviceId, source, true, null);
+					return;
+				}
+				const episode = {
+					eventId,
+					startedAt: timestamp,
+					lastOnAt: timestamp,
+					edgeOffsetsMs: [0]
+				};
+				this.setSignal(key, deviceId, source, true, episode);
+				this.armCloseTimer(key);
+				this.deps.onNewEdge?.({
+					deviceId,
+					source,
+					timestamp,
+					eventId,
+					isFirst: true
+				});
+				this.deps.onTick?.({
+					deviceId,
+					source,
+					timestamp
+				});
+				return;
+			}
+			case "extend-episode":
+				this.setSignal(key, deviceId, source, true, decision.next);
+				this.armCloseTimer(key);
+				if (decision.isNewEdge) this.deps.onNewEdge?.({
+					deviceId,
+					source,
+					timestamp,
+					eventId: decision.next.eventId,
+					isFirst: false
+				});
+				this.deps.onTick?.({
+					deviceId,
+					source,
+					timestamp
+				});
+				return;
+		}
+	}
+	/**
+	* Close every currently-open episode immediately, without waiting out the
+	* quiet window — used at addon shutdown so a row never sits with
+	* `durationMs: null` forever because the process that would have closed it
+	* is gone. Each close is logged with `reason` so an operator reading the
+	* row's neighbours understands why it stopped short of a natural close.
+	*/
+	async closeAll(reason) {
+		const keys = [...this.signals.keys()];
+		for (const key of keys) {
+			const signal = this.signals.get(key);
+			if (!signal?.episode) continue;
+			await this.closeNow(key, signal, reason);
+		}
+	}
+	setSignal(key, deviceId, source, lastDetected, episode) {
+		this.signals.set(key, {
+			deviceId,
+			source,
+			lastDetected,
+			episode
+		});
+	}
+	armCloseTimer(key) {
+		const existing = this.timers.get(key);
+		if (existing !== void 0) clearTimeout(existing);
+		const timer = setTimeout(() => {
+			this.fireClose(key);
+		}, this.deps.closeAfterMs);
+		timer.unref?.();
+		this.timers.set(key, timer);
+	}
+	async fireClose(key) {
+		this.timers.delete(key);
+		const signal = this.signals.get(key);
+		if (!signal?.episode) return;
+		await this.closeNow(key, signal, "quiet-window-elapsed");
+	}
+	async closeNow(key, signal, reason) {
+		const episode = signal.episode;
+		if (!episode) return;
+		const timer = this.timers.get(key);
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			this.timers.delete(key);
+		}
+		signal.episode = null;
+		const durationMs = motionEpisodeDurationMs(episode);
+		if (!await this.deps.closeRow({
+			deviceId: signal.deviceId,
+			source: signal.source,
+			eventId: episode.eventId,
+			durationMs,
+			edges: episode.edgeOffsetsMs
+		})) this.deps.logger.warn("motion episode close failed — row keeps durationMs: null", {
+			tags: { deviceId: signal.deviceId },
+			meta: {
+				source: signal.source,
+				eventId: episode.eventId,
+				reason
+			}
+		});
+	}
+};
+//#endregion
 //#region src/notification-center/action-token.ts
 /**
 * The authority behind a notification button.
@@ -6757,7 +6935,7 @@ function normalizeBbox(bbox, frameWidth, frameHeight) {
 function subjectFromObjectEvent(ev) {
 	return {
 		kind: "object-event",
-		recordId: ev.id,
+		recordId: String(ev.id),
 		deviceId: ev.deviceId,
 		timestamp: ev.timestamp,
 		classNames: [ev.className],
@@ -6825,7 +7003,7 @@ function subjectFromSensorEvent(ev, markerTrackId) {
 	const eventType = readSensorEventType(ev.value);
 	return {
 		kind: "device-event",
-		recordId: ev.id,
+		recordId: String(ev.id),
 		deviceId: ev.deviceId,
 		...markerTrackId !== void 0 ? { trackId: markerTrackId } : {},
 		...ev.sourceDeviceId !== ev.deviceId ? { sourceDeviceId: ev.sourceDeviceId } : {},
@@ -6862,7 +7040,7 @@ function subjectFromAudioEvent(ev, stillOwnerId) {
 	const macro = ev.classification?.className;
 	return {
 		kind: "audio-event",
-		recordId: ev.id,
+		recordId: String(ev.id),
 		deviceId: ev.deviceId,
 		timestamp: ev.timestamp,
 		classNames: macro !== void 0 ? [`audio-${macro}`] : [],
@@ -6992,7 +7170,7 @@ function occupancySubjectFromEdge(edge) {
 function subjectFromPackageEvent(ev, phase) {
 	return {
 		kind: "package-event",
-		recordId: ev.id,
+		recordId: String(ev.id),
 		deviceId: ev.deviceId,
 		timestamp: ev.timestamp,
 		classNames: [ev.className],
@@ -11674,7 +11852,7 @@ var NcDispatcher = class {
 				recordId: entry.recordId,
 				policy: entry.payload.media,
 				...entry.payload.mediaFrame !== void 0 ? { frame: entry.payload.mediaFrame } : {},
-				owners: [...entry.payload.subject.eventId !== void 0 ? [`event:${entry.payload.subject.eventId}`] : [], ...entry.payload.subject.trackId !== void 0 ? [`track:${entry.payload.subject.trackId}`] : []]
+				owners: [...entry.payload.subject.eventId !== void 0 ? [`object:${entry.payload.subject.eventId}`] : [], ...entry.payload.subject.trackId !== void 0 ? [`track:${entry.payload.subject.trackId}`] : []]
 			}
 		});
 		out.push(...footage.attachments);
@@ -11981,7 +12159,7 @@ var NcDispatcher = class {
 		const signal = policy === "best-matching" ? matchSignal(entry.payload.matchedOn) : null;
 		const owners = [];
 		if (subject.eventId !== void 0) owners.push({
-			kind: "event",
+			kind: "object",
 			id: subject.eventId
 		});
 		if (subject.trackId !== void 0) owners.push({
@@ -28216,16 +28394,28 @@ var StoragePressureTracker = class {
 * operator-captured reference picture as collectable. It is the same class of
 * mistake `identity` and `vehicle` are exempt for: a blob the OPERATOR curated,
 * which nothing else can regenerate and no cascade owns.
+*
+* `event` was DROPPED and replaced by `motion` / `object` / `audio` (D476).
+* `event` used to cover all three event tables under one owner kind, which was
+* safe while event ids were UUIDs (unique across tables). D474 made an event
+* id a per-table SQLite rowid alias, so `event:5` stopped naming one row —
+* three different rows, one per table, can all be `5`. This is the AUTHORITY
+* on what may own media; `MEDIA_OWNER_TYPES` in
+* `@camstack/types/media/media-owner-key.ts` must cover every member here —
+* `scripts` / `__tests__/owner-kinds-authority.spec.ts` guards the two lists
+* staying married.
 */
 var OWNER_KINDS = [
-	"event",
 	"track",
 	"summary",
 	"face",
 	"identity",
 	"plate",
 	"vehicle",
-	"scene"
+	"scene",
+	"motion",
+	"object",
+	"audio"
 ];
 /**
 * Owner kinds that NOTHING may write any more, but whose rows can still be on
@@ -28622,7 +28812,12 @@ function mediaRowLocation(data) {
 	return typeof id === "string" && id.length > 0 ? id : DEFAULT_MEDIA_LOCATION;
 }
 function buildKey(params) {
-	return isSingleInstanceKind(params.kind) ? `${params.ownerKind}:${params.ownerId}:${params.kind}` : `${params.ownerKind}:${params.ownerId}:${params.kind}:${params.timestamp}`;
+	return require_dist.formatMediaOwnerKey({
+		ownerType: params.ownerKind,
+		ownerId: params.ownerId,
+		fileKind: params.kind,
+		...isSingleInstanceKind(params.kind) ? {} : { timestampMs: params.timestamp }
+	});
 }
 function buildPath(params) {
 	const base = `${params.deviceId}/events/${params.ownerKind}/${params.ownerId}`;
@@ -29537,9 +29732,27 @@ var MediaStore = class {
 		}
 		return newKey;
 	}
-	/** Back-compat: existing retention path deletes media for evicted events. */
-	async deleteForEvents(eventIds) {
-		return this.deleteForOwner("event", eventIds);
+	/**
+	* Delete event-owned media for evicted events, GROUPED by the table each id
+	* came from (D476).
+	*
+	* There is no honest single-kind signature any more: `deleteForOwner` needs
+	* ONE owner kind per call, and a flat id list can no longer say which of
+	* `motion` / `object` / `audio` an id names — D474 made event ids per-table
+	* rowids, so `motion:5` and `object:5` are different rows that both spell
+	* `5`. Every caller (the retention cascade's per-track object-event sweep,
+	* the trackless motion/audio sweep, the operator prune) already KNOWS which
+	* table produced each id before it reaches here — the old flat signature
+	* just threw that fact away. `ids` is a partial record so a caller supplies
+	* only the kinds it actually collected.
+	*/
+	async deleteForEvents(ids) {
+		let total = 0;
+		for (const ownerType of require_dist.EVENT_OWNER_TYPES) {
+			const kindIds = ids[ownerType];
+			if (kindIds !== void 0 && kindIds.length > 0) total += await this.deleteForOwner(ownerType, kindIds);
+		}
+		return total;
 	}
 	/** Delete all media owned by these tracks (keyFrame/snapshot/thumbnail). */
 	async deleteForTracks(trackIds) {
@@ -29554,8 +29767,9 @@ var MediaStore = class {
 	* ENROLLED face/plate has its crop REOWNED to `identity`/`vehicle` at
 	* assignment, so deleting only the `'face'`/`'plate'` owner removes unassigned
 	* crops and leaves the enrolled gallery intact. Event-owned media
-	* (`ownerKind:'event'`) is handled by `EventStore` (which holds the eventId
-	* set). `deleteForOwner` is best-effort per row, so one bad row can't abort the
+	* (`ownerKind:'motion'` / `'object'` / `'audio'`) is handled by `EventStore`
+	* (which holds the per-kind event id sets — see {@link deleteForEvents}).
+	* `deleteForOwner` is best-effort per row, so one bad row can't abort the
 	* batch.
 	*/
 	async deleteByTracks(trackIds) {
@@ -36421,23 +36635,6 @@ function ruleApplies(resolved, det, className, maskInfo, _zones, frameWidth, fra
 }
 //#endregion
 //#region src/pipeline-analytics/pipeline/frame-processor.ts
-/**
-* FrameProcessor — per-device pipeline stage runner.
-*
-* Consumes a raw `PipelineInferenceResult` payload and runs:
-*   1. Flatten first-level detections
-*   2. Zone filter (ZoneEngine)
-*   3. Tracking (SortTracker)
-*   4. State analysis (StateAnalyzer)
-*   5. Event emission (DetectionEventEmitter)
-*
-* Returns a structured result the addon uses to:
-*   - upsert TrackStore
-*   - insert ObjectEvent rows into the declared collection
-*   - emit onFrameTracked / onDetectionEvent on the bus
-*
-* One FrameProcessor per device — lifecycle managed by DeviceRegistry.
-*/
 /** Shared empty — a fold is rare and every other frame would allocate. */
 var EMPTY_RIDER_FOLDS = [];
 /** Mapping from StateAnalyzer's `ObjectState.state` values to the
@@ -37173,7 +37370,6 @@ var FrameProcessor = class {
 			const crossing = crossingOf(e);
 			const labelPatch = labelPatchByTrack.get(e.detection.trackId) ?? knownTrackLabelPatch(this.trackLabelState?.(e.detection.trackId));
 			return {
-				id: (0, node_crypto.randomUUID)(),
 				deviceId: this.deviceId,
 				timestamp,
 				kind: "object",
@@ -37910,7 +38106,7 @@ async function cascadeDeleteTrack(stores, trackId) {
 		for (const id of ids) {
 			const eventIds = await stores.eventStore.deleteByTrack(id);
 			events += eventIds.length;
-			if (eventIds.length > 0) media += await stores.mediaStore.deleteForEvents([...eventIds]);
+			if (eventIds.length > 0) media += await stores.mediaStore.deleteForEvents({ object: [...eventIds] });
 		}
 		return [{
 			family: "events",
@@ -39867,6 +40063,11 @@ function runFrameProcessorPass(input) {
 * remaining blob are dropped — including snapshot-less rows. Enrolled gallery
 * media (`identity` / `vehicle` / `scene`) is never probed.
 */
+/** Is this an event-owned media row — `motion` / `object` / `audio` (D476;
+*  `event` used to cover all three under one owner kind). */
+function isEventOwnedMediaRow(ownerKind) {
+	return require_dist.EVENT_OWNER_TYPES.includes(ownerKind);
+}
 function shouldProbeMediaRow(ownerKind) {
 	if (!isMediaOwnerKind(ownerKind)) return true;
 	return !isRetentionExemptOwnerKind(ownerKind);
@@ -39897,7 +40098,7 @@ async function reconcileDeviceFromDisk(deps, deviceId) {
 			if (row.path.length === 0 ? false : await deps.blobExists(row.location, row.path)) {
 				const trackId = trackIdFromMediaOwner(row.ownerKind, row.ownerId);
 				if (trackId !== null) tracksWithMedia.add(trackId);
-				if (row.ownerKind === "event") eventsWithMedia.add(row.ownerId);
+				if (isEventOwnedMediaRow(row.ownerKind)) eventsWithMedia.add(row.ownerId);
 				continue;
 			}
 			missingKeys.push(row.key);
@@ -39958,6 +40159,191 @@ var locationDiscardActions = require_dist.defineCustomActions({
 	"storage.discardLocationCancel": require_dist.customAction(require_dist.object({}), DiscardCancel, { auth: "admin" })
 });
 //#endregion
+//#region src/pipeline-analytics/store/motion-edge-codec.ts
+/**
+* How a motion episode's rising-edge offsets become bytes, and back (D475).
+*
+* A motion episode row (`durationMs` + `edges`) records every distinct
+* off→on transition the camera reported while the episode stayed open — "ogni
+* evento on si deve salvare" (the operator's words). `edges` holds those
+* instants as **ms offsets from the episode's `timestamp`** (its first rising
+* edge, so the first entry is always `0`), never as absolute epochs — an
+* epoch is ~13 digits per entry; an offset into a 40 s episode is 1–5.
+*
+* Mirrors `position-codec.ts` (D471) on purpose: same discipline, different
+* shape. A MALFORMED stored value decodes to an empty array, never a throw —
+* one row's garbage `edges` column must not take out the whole event read
+* path, and a legacy row (written before this column existed) has no `edges`
+* at all, which decodes to `[]` exactly like garbage does. The open/closed
+* question is answered by `durationMs` being `null` vs a number vs absent —
+* never by this column, so an empty `edges` array must never be read as "no
+* episode" or "still open".
+*/
+/**
+* Marks a value this module wrote. A distinct namespace from
+* `position-codec.ts`'s `z1:` — different column, different shape, so a
+* value from one can never be mistaken for the other's.
+*/
+var ENCODED_PREFIX$1 = "me1:";
+/** Round-trip a sequence of rising-edge offsets (ms, from the episode start)
+*  through gzip + base64 — the same trade `position-codec.ts` made: base64
+*  because the settings-store column types have no BLOB, gzip because the
+*  repeated small integers compress well. */
+function encodeMotionEdges(edgesMs) {
+	const json = JSON.stringify(edgesMs);
+	return ENCODED_PREFIX$1 + (0, node_zlib.gzipSync)(Buffer.from(json, "utf8"), { level: 6 }).toString("base64");
+}
+/**
+* Read a stored `edges` value. Two shapes reach here: a `me1:` string this
+* module wrote, and a plain array (the store parsed the JSON column for us,
+* or a caller handed one straight through — the codec should not be the
+* reason a valid in-memory array fails to read back). Anything else —
+* `undefined` (legacy row, or an episode that never closed), a garbage
+* string, a number — answers `[]`.
+*/
+function decodeMotionEdges(value) {
+	if (Array.isArray(value)) return value.filter(isFiniteNumber);
+	if (typeof value !== "string") return [];
+	if (value.startsWith(ENCODED_PREFIX$1)) try {
+		const raw = (0, node_zlib.gunzipSync)(Buffer.from(value.slice(4), "base64")).toString("utf8");
+		const parsed = JSON.parse(raw);
+		return Array.isArray(parsed) ? parsed.filter(isFiniteNumber) : [];
+	} catch {
+		return [];
+	}
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed.filter(isFiniteNumber) : [];
+	} catch {
+		return [];
+	}
+}
+function isFiniteNumber(v) {
+	return typeof v === "number" && Number.isFinite(v);
+}
+//#endregion
+//#region src/pipeline-analytics/store/position-codec.ts
+/**
+* How a track's `positions[]` becomes bytes, and back (D471).
+*
+* `positions` was 94.9 % of the `tracks` table and 17 % of the whole settings
+* database — 186.5 MB — and most of that was not information. See
+* `__tests__/position-codec.spec.ts` for the measurement and for why rounding
+* is safe only since D399.
+*
+* Pure on purpose: what a MALFORMED stored value decodes to is the decision
+* worth pinning in a test, and it is "an empty trail", never a throw.
+*/
+/**
+* Marks a value this module wrote. Chosen so it cannot collide with the plain
+* JSON array every pre-D471 row holds: that always starts `[`.
+*/
+var ENCODED_PREFIX = "z1:";
+/** Pixels are integers. The float tail is representation noise, not precision. */
+function roundPosition(p) {
+	return {
+		...p,
+		x: Math.round(p.x),
+		y: Math.round(p.y),
+		bbox: {
+			...p.bbox,
+			x: Math.round(p.bbox.x),
+			y: Math.round(p.bbox.y),
+			w: Math.round(p.bbox.w),
+			h: Math.round(p.bbox.h)
+		}
+	};
+}
+/** Round, serialise, gzip, base64 — in that order, so the compressor sees the
+*  smaller text and the repeated field names it compresses best. */
+function encodePositions(positions) {
+	const json = JSON.stringify(positions.map(roundPosition));
+	return ENCODED_PREFIX + (0, node_zlib.gzipSync)(Buffer.from(json, "utf8"), { level: 6 }).toString("base64");
+}
+/**
+* Read a stored value, whichever era wrote it.
+*
+* THREE shapes reach here and all three are ordinary, which is what makes a
+* migration unnecessary: a `z1:` string this module wrote, a plain array (the
+* store parsed the JSON column for us), and a plain JSON string (it did not).
+* Anything else is a row we cannot read, and the answer is an empty trail —
+* the timeline then draws a track with no path, which an operator can SEE,
+* instead of failing the page, which they cannot.
+*/
+function decodePositions(value) {
+	if (Array.isArray(value)) return value.filter(isPosition);
+	if (typeof value !== "string") return [];
+	if (value.startsWith(ENCODED_PREFIX)) try {
+		const raw = (0, node_zlib.gunzipSync)(Buffer.from(value.slice(3), "base64")).toString("utf8");
+		const parsed = JSON.parse(raw);
+		return Array.isArray(parsed) ? parsed.filter(isPosition) : [];
+	} catch {
+		return [];
+	}
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed.filter(isPosition) : [];
+	} catch {
+		return [];
+	}
+}
+function isPosition(v) {
+	if (typeof v !== "object" || v === null) return false;
+	const p = { ...v };
+	return typeof p["x"] === "number" && typeof p["y"] === "number" && typeof p["bbox"] === "object";
+}
+/**
+* A trajectory reduced to the ONLY thing a zone-filtered reader uses (D471).
+*
+* The client's `parsePositionBoxes` walks `positions[]` and keeps `p.bbox`,
+* discarding `x`, `y`, `timestamp` and `source` the moment they arrive. On the
+* zone path — the one path that ships positions at all — that is **59 % of the
+* payload thrown away by the receiver**: 162 B per position sent, 66 B used.
+*
+* Measured on 20 130 real positions. This is the reduction, applied server-side
+* so the bytes are never spent.
+*
+* NOT applied to any other read: a caller that asked for a full trajectory gets
+* one. This is narrowing on the request that already narrowed.
+*/
+function geometryOnlyPositions(positions) {
+	return positions.map((p) => ({
+		x: p.bbox.x,
+		y: p.bbox.y,
+		timestamp: 0,
+		bbox: p.bbox
+	}));
+}
+/**
+* A detection box with integer pixel coordinates (D471).
+*
+* `object-events.bbox` carries the same float tail as `positions` did —
+* `{"w":1089.6000000000001,"h":398.40000000000003}` — and is 18 % of a 30 MB
+* table. Same cause: a pixel scaled by the analysis raster ratio, serialised
+* with every digit JavaScript can print.
+*
+* Returns the input unchanged when there is nothing to round, so a legacy row
+* with no bbox stays exactly what it was.
+*/
+function roundBbox(bbox) {
+	if (typeof bbox !== "object" || bbox === null) return bbox;
+	const b = { ...bbox };
+	let touched = false;
+	for (const k of [
+		"x",
+		"y",
+		"w",
+		"h"
+	]) {
+		const v = b[k];
+		if (typeof v === "number" && Number.isFinite(v)) {
+			b[k] = Math.round(v);
+			touched = true;
+		}
+	}
+	return touched ? b : bbox;
+}
+//#endregion
 //#region src/pipeline-analytics/store/tiered-label-columns.ts
 /**
 * The six tiered-label columns, read and written in ONE place (roadmap 4g).
@@ -40078,12 +40464,17 @@ function audioDbfsByBucket(events, since, bucketMs) {
 //#region src/pipeline-analytics/store/event-store.ts
 /**
 * @durable class=ledger owner=pipeline-analytics
-*   write="one row when a camera's motion goes off→on, then one more every 5 s
-*     (MOTION_EVENT_HEARTBEAT_MS) while it stays on. The analyzer path and the
-*     onboard-firmware path share that throttle, so a camera cannot double-count.
-*     Measured at ~7,200 rows/day/camera."
+*   write="one row per motion EPISODE, keyed per (deviceId, source) so the
+*     analyzer and a firmware/device-activity sensor on the SAME camera never
+*     share one episode (D475). INSERT on a rising edge with no episode open
+*     (durationMs: null, edges: [0]); a further rising edge inside the open
+*     episode does NOT insert — it extends the in-memory episode and re-arms
+*     the MOTION_CLOSE_AFTER_MS close timer. One UPDATE at close writes the
+*     final durationMs (lastOnAt - startedAt) and the encoded edges array.
+*     Replaces the pre-D475 scheme (one row off→on, then a heartbeat row
+*     every 5 s while motion stayed on) — MOTION_EVENT_HEARTBEAT_MS is gone."
 *   retention="a TERMINAL age-keyed root — no trackId. A motion row may own a
-*     still (`ownerKind: 'event'`, `kind: 'snapshot'`) captured on the off→on
+*     still (`ownerKind: 'motion'`, `kind: 'snapshot'`) captured on the off→on
 *     visit so events-mode recordings have a videoclip thumbnail. Deleted by
 *     EventStore.evictTracklessBefore on the DEVICE's one retention window
 *     (follow-recordings horizon, or trackRetentionDays, default 7), which
@@ -40118,7 +40509,7 @@ var AUDIO_EVENTS_COLLECTION = "pipeline-analytics:audio-events";
 var COMMON_BASE_COLUMNS = [
 	{
 		name: "id",
-		type: "TEXT",
+		type: "INTEGER",
 		primaryKey: true,
 		notNull: true
 	},
@@ -40151,7 +40542,31 @@ var MOTION_COLUMNS = [
 	{
 		name: "frameHeight",
 		type: "INTEGER"
-	}
+	},
+	(
+	/**
+	* `null` while the episode this row represents is still open; the final
+	* `lastOnAt - startedAt` once closed (D475). DECLARED, not merely stamped —
+	* the sqlite backend silently drops an undeclared key on every write, which
+	* is exactly how `frameId` was written into the void for years (see
+	* `OBJECT_COLUMNS.frameId`). Absent on a row written before D475: that
+	* means "closed the old way", never "open" — only an explicit `null` here
+	* means open.
+	*/
+	{
+		name: "durationMs",
+		type: "INTEGER"
+	}),
+	(
+	/**
+	* Encoded rising-edge offsets for the episode — see `motion-edge-codec.ts`.
+	* Written once, in the same UPDATE as `durationMs`, at close; a legacy or
+	* still-open row has no value here, which the codec reads as `[]`.
+	*/
+	{
+		name: "edges",
+		type: "TEXT"
+	})
 ];
 var OBJECT_COLUMNS = [
 	...COMMON_BASE_COLUMNS,
@@ -40177,6 +40592,18 @@ var OBJECT_COLUMNS = [
 		name: "frameId",
 		type: "TEXT"
 	}),
+	(
+	/**
+	* The producer's own idempotence key (D474) — see `ObjectEvent.idempotencyKey`.
+	*
+	* DECLARED, not merely stamped: the sqlite backend drops an undeclared key
+	* without error, which is exactly how `frameId` was written into the void on
+	* every row ever persisted. Nullable — only the package detector sets it.
+	*/
+	{
+		name: "idempotencyKey",
+		type: "TEXT"
+	}),
 	{
 		name: "trackId",
 		type: "TEXT",
@@ -40310,6 +40737,42 @@ var COMMON_INDEXES = (prefix) => [{
 	name: `idx_${prefix}_device_ts`,
 	columns: ["deviceId", "timestamp"]
 }];
+/**
+* The wire value `durationMs` carries for an OPEN episode (D475).
+*
+* The app-level contract is "`null` = open, a number = closed, absent = a
+* row from before this column existed" — but SQL has no way to tell "this
+* column was never given a value because the row predates it" from
+* "explicitly set to NULL": `declareCollection` adds the column via ALTER
+* TABLE, which backfills every existing row's `durationMs` with a real SQL
+* NULL, bit-for-bit the same NULL an open episode would write. Writing an
+* actual NULL for "open" would therefore make a brand-new open episode
+* indistinguishable from a five-year-old legacy row — exactly the failure
+* mode this constant exists to avoid. `insertMotion` writes this in place of
+* `null`; `queryMotion` translates it back to `null` on the way out, so
+* nothing outside this file ever sees the sentinel. `-1` is safe because a
+* real duration is never negative.
+*/
+var OPEN_EPISODE_SENTINEL = -1;
+/**
+* The key `insert` reports, narrowed to the ROWID these three collections use.
+*
+* `settingsStore.insert` answers `string | number` because the SAME method
+* serves TEXT-keyed collections, where it mints a UUID (D474). On the event
+* collections the primary key is an `INTEGER` rowid alias, so a string here is
+* not an event id at all — it means the table in front of us still has the old
+* TEXT key. Returning `null` says "no id", which is what every caller already
+* handles; the WARN says why, because a silent null would read as a failed
+* write (D474).
+*/
+function eventRowId(logger, operation, deviceId, key) {
+	if (typeof key === "number") return key;
+	logger.warn(`${operation}: event key is not an INTEGER rowid`, {
+		tags: { deviceId },
+		meta: { returnedId: key }
+	});
+	return null;
+}
 var EventStore = class {
 	store;
 	logger;
@@ -40348,65 +40811,129 @@ var EventStore = class {
 			indexes: COMMON_INDEXES("audio")
 		});
 	}
+	/**
+	* Returns the ROWID SQLite assigned, or `null` when the write failed (D474).
+	*
+	* The caller needs it on the very next line — the notification centre reads
+	* it and the marker-still path builds a media key from it — and with an
+	* auto-assigned key the insert is the ONLY place it is knowable. A
+	* placeholder would reach the event bus and the media keys.
+	*/
 	async insertMotion(ev) {
 		this.onMotionSample?.(ev.deviceId, ev.regionCount, ev.timestamp);
+		const record = { ...ev };
+		if (ev.durationMs === null) record["durationMs"] = OPEN_EPISODE_SENTINEL;
 		try {
-			const { id, ...rest } = ev;
-			await this.store.insert.mutate({
+			const inserted = await this.store.insert.mutate({
 				collection: MOTION_EVENTS_COLLECTION,
-				record: {
-					id,
-					data: rest
-				}
+				record: { data: record }
 			});
+			return eventRowId(this.logger, "insertMotion", ev.deviceId, inserted.id);
 		} catch (err) {
 			this.logger.warn("insertMotion failed", {
 				tags: { deviceId: ev.deviceId },
 				meta: {
-					eventId: ev.id,
+					timestamp: ev.timestamp,
+					error: String(err)
+				}
+			});
+			return null;
+		}
+	}
+	/**
+	* The one place a motion EPISODE row is closed (D475). Writes `durationMs`
+	* and the encoded `edges` in a single UPDATE — a row never gets a second
+	* write after this one. Returns whether it landed; the caller
+	* (`MotionEpisodeTracker`) logs the failure with the episode's `deviceId`
+	* tag, because a `durationMs: null` row that never gets a reason is exactly
+	* the silent-forever-open shape D475 exists to prevent.
+	*/
+	async updateMotion(eventId, deviceId, patch) {
+		try {
+			await this.store.update.mutate({
+				collection: MOTION_EVENTS_COLLECTION,
+				id: String(eventId),
+				data: {
+					durationMs: patch.durationMs,
+					edges: encodeMotionEdges(patch.edges)
+				}
+			});
+			return true;
+		} catch (err) {
+			this.logger.warn("updateMotion (episode close) failed", {
+				tags: { deviceId },
+				meta: {
+					eventId,
 					error: String(err)
 				}
 			});
+			return false;
 		}
 	}
+	/**
+	* The motion-activity LTS tap, exposed for a caller that extends an
+	* already-open episode without inserting a new row (D475) — `insertMotion`
+	* fires it on OPEN; this fires it on every further tick, so a long
+	* continuous episode still samples activity at the same density the
+	* pre-D475 heartbeat gave the aggregator, rather than once per episode.
+	*/
+	noteMotionSample(deviceId, regionCount, at) {
+		this.onMotionSample?.(deviceId, regionCount, at);
+	}
+	/**
+	* Returns the ROWID SQLite assigned, or `null` when the write failed (D474).
+	*
+	* The caller needs it on the very next line — the notification centre reads
+	* it and the marker-still path builds a media key from it — and with an
+	* auto-assigned key the insert is the ONLY place it is knowable. A
+	* placeholder would reach the event bus and the media keys.
+	*/
 	async insertObject(ev) {
 		try {
-			const { id, ...rest } = ev;
-			await this.store.insert.mutate({
+			const rounded = "bbox" in ev ? {
+				...ev,
+				bbox: roundBbox(ev.bbox)
+			} : ev;
+			const inserted = await this.store.insert.mutate({
 				collection: OBJECT_EVENTS_COLLECTION,
-				record: {
-					id,
-					data: rest
-				}
+				record: { data: rounded }
 			});
+			return eventRowId(this.logger, "insertObject", ev.deviceId, inserted.id);
 		} catch (err) {
 			this.logger.warn("insertObject failed", {
 				tags: { deviceId: ev.deviceId },
 				meta: {
-					eventId: ev.id,
+					timestamp: ev.timestamp,
 					error: String(err)
 				}
 			});
+			return null;
 		}
 	}
+	/**
+	* Returns the ROWID SQLite assigned, or `null` when the write failed (D474).
+	*
+	* The caller needs it on the very next line — the notification centre reads
+	* it and the marker-still path builds a media key from it — and with an
+	* auto-assigned key the insert is the ONLY place it is knowable. A
+	* placeholder would reach the event bus and the media keys.
+	*/
 	async insertAudio(ev) {
 		try {
-			const { id, ...rest } = ev;
-			await this.store.insert.mutate({
+			const inserted = await this.store.insert.mutate({
 				collection: AUDIO_EVENTS_COLLECTION,
-				record: {
-					id,
-					data: rest
-				}
+				record: { data: ev }
 			});
+			return eventRowId(this.logger, "insertAudio", ev.deviceId, inserted.id);
 		} catch (err) {
 			this.logger.warn("insertAudio failed", {
 				tags: { deviceId: ev.deviceId },
 				meta: {
-					eventId: ev.id,
+					timestamp: ev.timestamp,
 					error: String(err)
 				}
 			});
+			return null;
 		}
 	}
 	/**
@@ -40520,12 +41047,15 @@ var EventStore = class {
 			filter: this.buildFilter(q),
 			...this.slimColumns(q.projection, SLIM_MOTION_COLUMNS)
 		});
-		if (q.projection === "slim") return rows.map((r) => slimMotion(r.id, stripNulls$1(r.data)));
+		if (q.projection === "slim") return rows.map((r) => slimMotion(Number(r.id), stripNulls$1(r.data)));
 		return rows.map((r) => {
+			const { edges: rawEdges, durationMs: rawDurationMs, ...data } = stripNulls$1(r.data);
 			return {
-				id: r.id,
+				id: Number(r.id),
 				kind: "motion",
-				...stripNulls$1(r.data)
+				...data,
+				...rawDurationMs !== void 0 ? { durationMs: rawDurationMs === OPEN_EPISODE_SENTINEL ? null : rawDurationMs } : {},
+				...rawEdges !== void 0 ? { edges: decodeMotionEdges(rawEdges) } : {}
 			};
 		});
 	}
@@ -40572,7 +41102,7 @@ var EventStore = class {
 			});
 			if (rows.length === 0) break;
 			for (const r of rows) out.push({
-				id: r.id,
+				id: Number(r.id),
 				kind: "object",
 				...stripNulls$1(r.data)
 			});
@@ -40591,10 +41121,10 @@ var EventStore = class {
 			filter,
 			...this.slimColumns(q.projection, SLIM_OBJECT_COLUMNS)
 		});
-		if (q.projection === "slim") return rows.map((r) => slimObject(r.id, stripNulls$1(r.data)));
+		if (q.projection === "slim") return rows.map((r) => slimObject(Number(r.id), stripNulls$1(r.data)));
 		return rows.map((r) => {
 			return {
-				id: r.id,
+				id: Number(r.id),
 				kind: "object",
 				...stripNulls$1(r.data)
 			};
@@ -40619,7 +41149,7 @@ var EventStore = class {
 			}
 		})).map((r) => {
 			return {
-				id: r.id,
+				id: Number(r.id),
 				kind: "object",
 				...stripNulls$1(r.data)
 			};
@@ -40630,10 +41160,10 @@ var EventStore = class {
 			collection: AUDIO_EVENTS_COLLECTION,
 			filter: this.buildFilter(q)
 		});
-		if (q.projection === "slim") return rows.map((r) => slimAudio(r.id, stripNulls$1(r.data)));
+		if (q.projection === "slim") return rows.map((r) => slimAudio(Number(r.id), stripNulls$1(r.data)));
 		return rows.map((r) => {
 			return {
-				id: r.id,
+				id: Number(r.id),
 				kind: "audio",
 				...stripNulls$1(r.data)
 			};
@@ -40644,9 +41174,28 @@ var EventStore = class {
 	* resolver's track fallback: a new-style object event owns no crop, so its
 	* `mediaUrl` degrades to the track's cadence media, addressed by this id.
 	* Returns `null` when the id is not a persisted object event (e.g. a KeyEvent
-	* whose id is already a track id, or a motion/audio event) — best-effort.
-	*/
-	async getTrackIdForEvent(eventId) {
+	* whose id is already a track id) — best-effort.
+	*
+	* **D476: only an OBJECT event has a `trackId` at all** — motion and audio
+	* rows carry no such column, so this probes `OBJECT_EVENTS_COLLECTION`
+	* only, never the other two. That was already true structurally, but before
+	* D474 an id that MISSED here was safely "not an object event" because
+	* every id was a UUID, unique across all three tables. D474 made event ids
+	* per-table rowid aliases, so a motion id can now coincide with an
+	* UNRELATED object row of the same number — a probe that HITS is no longer
+	* proof the caller's id names that object row.
+	*
+	* `ownerType`, when the caller already knows it (a `motion:`/`audio:`/
+	* `object:` key was parsed rather than a bare legacy id), short-circuits to
+	* `null` without querying for anything but `'object'` — the caller's one
+	* remaining lever against the collision, since this method has nothing left
+	* to guess once the kind is in the key. Its only caller today
+	* (`readEventThumbnail` in `index.ts`) still reaches this with a bare,
+	* kind-less id from a URL and cannot supply it — see the D476 ADR for why
+	* that residual ambiguity is accepted rather than fixed here.
+	*/
+	async getTrackIdForEvent(eventId, ownerType) {
+		if (ownerType !== void 0 && ownerType !== "object") return null;
 		try {
 			const row = await this.store.get.query({
 				collection: OBJECT_EVENTS_COLLECTION,
@@ -40999,9 +41548,11 @@ var EventStore = class {
 		});
 		const motion = await batch(MOTION_EVENTS_COLLECTION);
 		const audio = await batch(AUDIO_EVENTS_COLLECTION);
-		const ids = [...motion, ...audio];
-		if (ids.length > 0 && this.media !== void 0) try {
-			await this.media.deleteForEvents(ids);
+		if ((motion.length > 0 || audio.length > 0) && this.media !== void 0) try {
+			await this.media.deleteForEvents({
+				motion,
+				audio
+			});
 		} catch (err) {
 			this.logger.warn("EventStore.evictTracklessBefore: event media delete failed", { meta: { error: String(err) } });
 		}
@@ -41067,7 +41618,7 @@ var EventStore = class {
 	* {@link existingEventIds} answers "is this event alive", which is the
 	* orphan audit's question. The media reclaim asks a narrower one: *is this
 	* event-owned snapshot a MOTION-VISIT still* — because the selection shape
-	* (`ownerKind: 'event', kind: 'snapshot'`) is not itself a guarantee.
+	* (`ownerKind: 'motion', kind: 'snapshot'`) is not itself a guarantee.
 	* Nothing structurally prevents another writer landing an event-owned
 	* snapshot on an object or audio row, and the reclaim must not be the place
 	* that discovers it. A per-page indexed `whereIn` on one table is cheap
@@ -41134,7 +41685,12 @@ var EventStore = class {
 				...motionIds,
 				...objectIds,
 				...audioIds
-			]
+			],
+			byKind: {
+				motion: motionIds,
+				object: objectIds,
+				audio: audioIds
+			}
 		};
 	}
 	/**
@@ -41199,7 +41755,7 @@ var EventStore = class {
 		}
 		let mediaRows = 0;
 		if (eventIds.length > 0 && this.media !== void 0) try {
-			mediaRows = await this.media.deleteForEvents(eventIds);
+			mediaRows = await this.media.deleteForEvents({ object: eventIds });
 		} catch (err) {
 			this.logger.warn("EventStore.deleteByTracks: event media delete failed", { meta: { error: String(err) } });
 		}
@@ -41529,8 +42085,8 @@ function rowMatchesZone(data, zone) {
 	const fw = data["frameWidth"];
 	const fh = data["frameHeight"];
 	if (typeof fw !== "number" || typeof fh !== "number") return true;
-	const positions = data["positions"];
-	if (!Array.isArray(positions)) return true;
+	const positions = decodePositions(data["positions"]);
+	if (positions.length === 0) return true;
 	const positionRows = [];
 	for (const p of positions) {
 		if (p === null || typeof p !== "object") continue;
@@ -43105,7 +43661,13 @@ var TrackStore = class {
 			data
 		});
 		matched.sort((a, b) => Number(b.data["firstSeen"] ?? 0) - Number(a.data["firstSeen"] ?? 0));
-		return matched.slice(0, limit).map((r) => this.rowToTrack(r.id, r.data, params.projection));
+		return matched.slice(0, limit).map((r) => {
+			const track = this.rowToTrack(r.id, r.data, params.projection);
+			return {
+				...track,
+				positions: geometryOnlyPositions(track.positions)
+			};
+		});
 	}
 	/**
 	* Batched multi-device recent-tracks page (`listRecentTracks`): the
@@ -43360,7 +43922,7 @@ var TrackStore = class {
 				...t.producingDeviceName !== void 0 ? { producingDeviceName: t.producingDeviceName } : {},
 				firstSeen: t.firstSeen,
 				lastSeen: t.lastSeen,
-				positions: [...t.positions],
+				positions: encodePositions(t.positions),
 				observations: t.positions.length,
 				snapshots: [...t.snapshots],
 				zonesVisited: [...t.zonesVisited],
@@ -43389,7 +43951,7 @@ var TrackStore = class {
 				...t.source !== void 0 ? { source: t.source } : {},
 				firstSeen: t.firstSeen,
 				lastSeen: t.lastSeen,
-				positions: [...t.positions],
+				positions: encodePositions(t.positions),
 				observations: t.positions.length,
 				snapshots: [...t.snapshots],
 				zonesVisited: [...t.zonesVisited],
@@ -43429,7 +43991,7 @@ var TrackStore = class {
 	*/
 	rowToTrack(id, data, projection) {
 		const slim = projection === "slim";
-		const storedPositions = slim ? [] : data["positions"] ?? [];
+		const storedPositions = slim ? [] : decodePositions(data["positions"]);
 		/**
 		* The stored count first, the blob only as a fallback — never `0` for a
 		* column that was not read.
@@ -44396,7 +44958,7 @@ function createDiscardJob(deps) {
 					collection: TRACKS_COLLECTION,
 					key: owner.ownerId
 				});
-			} else if (owner.ownerKind === "event") await deps.store.delete.mutate({
+			} else if (owner.ownerKind === "object") await deps.store.delete.mutate({
 				collection: OBJECT_EVENTS_COLLECTION,
 				key: owner.ownerId
 			});
@@ -45074,21 +45636,29 @@ function allEventIds(events) {
 /**
 * 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. Two batched index reads at most, and the second only over the
-* object events the first did not already answer for — motion and audio are
-* trackless roots, so they never need it.
+* 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 eventIds = allEventIds(events);
-	if (eventIds.length === 0) return /* @__PURE__ */ new Set();
-	const ownMedia = await fetchMediaOwners({
-		deviceId,
-		ownerKind: "event",
-		ownerIds: eventIds
-	});
+	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) {
@@ -45203,6 +45773,15 @@ function reportUnvouchedClips(deps, deviceId, clips) {
 	});
 }
 //#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.
@@ -46258,7 +46837,13 @@ var AnalyticsQueryFacade = class {
 		const store = this.deps.mediaStore();
 		if (store === null) return [];
 		const prefix = this.deps.eventMediaPathPrefix();
-		return (await store.listByOwner("event", input.eventId, input.deviceId, input.kind === void 0 ? void 0 : [input.kind])).map((row) => toWireMediaFile(row, prefix));
+		const kinds = input.kind === void 0 ? void 0 : [input.kind];
+		let rows = [];
+		for (const ownerType of require_dist.EVENT_OWNER_TYPES) {
+			rows = await store.listByOwner(ownerType, input.eventId, input.deviceId, kinds);
+			if (rows.length > 0) break;
+		}
+		return rows.map((row) => toWireMediaFile(row, prefix));
 	}
 	/**
 	* A track's media WITH the bytes, restricted to `kinds` when given.
@@ -46300,7 +46885,12 @@ var AnalyticsQueryFacade = class {
 		const store = this.deps.mediaStore();
 		if (store === null) return [];
 		const prefix = this.deps.eventMediaPathPrefix();
-		return (await store.listInfoByOwner("event", input.eventId, input.deviceId)).map((row) => toWireMediaFileInfo(row, prefix));
+		let rows = [];
+		for (const ownerType of require_dist.EVENT_OWNER_TYPES) {
+			rows = await store.listInfoByOwner(ownerType, input.eventId, input.deviceId);
+			if (rows.length > 0) break;
+		}
+		return rows.map((row) => toWireMediaFileInfo(row, prefix));
 	}
 	/**
 	* A track's media WITHOUT the bytes.
@@ -46334,9 +46924,9 @@ var AnalyticsQueryFacade = class {
 			object: 0,
 			audio: 0
 		};
-		const { counts, ids } = await eventStore.pruneBefore(input);
+		const { counts, ids, byKind } = await eventStore.pruneBefore(input);
 		const mediaStore = this.deps.mediaStore();
-		if (ids.length > 0 && mediaStore) await mediaStore.deleteForEvents([...ids]);
+		if (ids.length > 0 && mediaStore) await mediaStore.deleteForEvents(byKind);
 		const { motion, object, audio } = counts;
 		if (motion + object + audio > 0) this.deps.logger().info("analytics event eviction (floor)", {
 			tags: { deviceId: input.deviceId },
@@ -46458,7 +47048,11 @@ var AnalyticsQueryFacade = class {
 			...evicted.audio
 		];
 		const mediaStore = this.deps.mediaStore();
-		if (ids.length > 0 && mediaStore) await mediaStore.deleteForEvents(ids);
+		if (ids.length > 0 && mediaStore) await mediaStore.deleteForEvents({
+			motion: evicted.motion,
+			object: objectIds,
+			audio: evicted.audio
+		});
 		const counts = {
 			motion: evicted.motion.length,
 			object: objectIds.length,
@@ -49297,9 +49891,13 @@ function resolveCropForcedMedia(files, pickClean, detailFiles = []) {
 * Event + track media (the body/scene) and face/plate media (the detail
 * crops). Face rows live under `face-${trackId}`; a track can close with
 * `hasEmbeddedFace` and ZERO track files (0e343f86).
+*
+* `eventFiles` is the event's OWN media, already fetched by the caller (the
+* same rows the default path reuses via {@link collectDefaultEventMedia}) —
+* this function no longer lists by owner kind `'event'` itself (D476; see
+* {@link CropForcedOwnerKind}).
 */
-async function collectCropForcedMedia(source, id) {
-	const eventFiles = await source.listByOwner("event", id);
+async function collectCropForcedMedia(source, id, eventFiles) {
 	const trackFiles = await source.listByOwner("track", id);
 	const ownerTrackId = trackFiles.length === 0 ? await source.getTrackIdForEvent(id) : null;
 	const owningTrackFiles = ownerTrackId === null ? [] : await source.listByOwner("track", ownerTrackId);
@@ -56253,11 +56851,23 @@ var PACKAGE_IMPORTANCE = 1;
 *  stay `getObjectEvents`-output-valid. */
 var DELIVERED_STATE = "idle";
 var PICKED_UP_STATE = "left";
-/** Deterministic durable-event ids keyed on the stationary entry id. */
-function deliveredEventId(entryId) {
+/**
+* Deterministic IDEMPOTENCE keys, one per (stationary entry, phase).
+*
+* These were the event ids until D474 made an event id the SQLite rowid, which
+* the database assigns and a producer cannot choose. They kept their exact
+* spelling and moved to `ObjectEvent.idempotencyKey`: the gates below are the
+* only reason a restart does not re-deliver every parcel, and the strings are
+* on 2.1 million existing rows' primary key, so a row written before the
+* rebuild is still recognisable by the same text.
+*
+* They are NOT event ids any more. `eventId` on the emitted payload and in
+* every log line is the row's real id.
+*/
+function deliveredIdempotencyKey(entryId) {
 	return `pa-pkg-${entryId}-delivered`;
 }
-function pickedUpEventId(entryId) {
+function pickedUpIdempotencyKey(entryId) {
 	return `pa-pkg-${entryId}-pickedup`;
 }
 var PackageDropDetector = class {
@@ -56395,26 +57005,28 @@ var PackageDropDetector = class {
 			});
 			return;
 		}
-		const eventId = deliveredEventId(entry.id);
-		if ((await this.deps.events.queryObject({
+		const idempotencyKey = deliveredIdempotencyKey(entry.id);
+		const alreadyDelivered = (await this.deps.events.queryObject({
 			deviceId: entry.deviceId,
-			classFilter: "package"
-		})).some((e) => e.id === eventId)) {
+			classFilter: PACKAGE_EVENT_CLASS
+		})).find((e) => e.idempotencyKey === idempotencyKey || String(e.id) === idempotencyKey);
+		if (alreadyDelivered !== void 0) {
 			this.deps.logger.info("package gate 5/5 idempotence — delivery already recorded", {
 				tags,
 				meta: {
 					entryId: entry.id,
-					eventId
+					idempotencyKey,
+					eventId: alreadyDelivered.id
 				}
 			});
 			return;
 		}
-		const ev = {
-			id: eventId,
+		const draft = {
 			kind: "object",
 			deviceId: entry.deviceId,
 			timestamp,
 			source: "pipeline",
+			idempotencyKey,
 			trackId: entry.sourceTrackId ?? entry.id,
 			className: PACKAGE_EVENT_CLASS,
 			...entry.label !== void 0 ? { label: entry.label } : {},
@@ -56432,12 +57044,26 @@ var PackageDropDetector = class {
 			...entry.keyFrameMediaKey !== void 0 ? { mediaKey: entry.keyFrameMediaKey } : {},
 			importance: PACKAGE_IMPORTANCE
 		};
-		await this.deps.events.insertObject(ev);
+		const rowId = await this.deps.events.insertObject(draft);
+		if (rowId === null) {
+			this.deps.logger.warn("package delivery NOT emitted — the event row did not persist", {
+				tags,
+				meta: {
+					entryId: entry.id,
+					idempotencyKey
+				}
+			});
+			return;
+		}
+		const ev = {
+			...draft,
+			id: rowId
+		};
 		this.deps.onPersisted?.(ev, "delivered");
 		this.deps.emit.delivered({
 			deviceId: entry.deviceId,
 			entryId: entry.id,
-			eventId,
+			eventId: String(rowId),
 			className: entry.className,
 			zoneIds: hitZones,
 			...entry.keyFrameMediaKey !== void 0 ? { keyFrameMediaKey: entry.keyFrameMediaKey } : {},
@@ -56453,7 +57079,8 @@ var PackageDropDetector = class {
 			tags: { deviceId: entry.deviceId },
 			meta: {
 				entryId: entry.id,
-				eventId,
+				eventId: rowId,
+				idempotencyKey,
 				zoneIds: hitZones,
 				dwellMs,
 				areaFrac: Number(areaFrac.toFixed(5)),
@@ -56471,13 +57098,14 @@ var PackageDropDetector = class {
 			});
 			return;
 		}
-		const deliveredId = deliveredEventId(entry.id);
-		const pickedUpId = pickedUpEventId(entry.id);
+		const deliveredKey = deliveredIdempotencyKey(entry.id);
+		const pickedUpKey = pickedUpIdempotencyKey(entry.id);
 		const rows = await this.deps.events.queryObject({
 			deviceId: entry.deviceId,
 			classFilter: PACKAGE_EVENT_CLASS
 		});
-		const delivered = rows.find((e) => e.id === deliveredId);
+		const matchesKey = (e, key) => e.idempotencyKey === key || String(e.id) === key;
+		const delivered = rows.find((e) => matchesKey(e, deliveredKey));
 		if (delivered === void 0) {
 			this.deps.logger.debug("package pick-up skipped — no delivery row for this entry", {
 				tags: { deviceId: entry.deviceId },
@@ -56488,12 +57116,14 @@ var PackageDropDetector = class {
 			});
 			return;
 		}
-		if (rows.some((e) => e.id === pickedUpId)) {
+		const alreadyPickedUp = rows.find((e) => matchesKey(e, pickedUpKey));
+		if (alreadyPickedUp !== void 0) {
 			this.deps.logger.info("package pick-up skipped — already recorded", {
 				tags: { deviceId: entry.deviceId },
 				meta: {
 					entryId: entry.id,
-					eventId: pickedUpId
+					eventId: alreadyPickedUp.id,
+					idempotencyKey: pickedUpKey
 				}
 			});
 			return;
@@ -56505,17 +57135,17 @@ var PackageDropDetector = class {
 			tags: { deviceId: entry.deviceId },
 			meta: {
 				entryId: entry.id,
-				eventId: pickedUpId,
+				idempotencyKey: pickedUpKey,
 				packageTrackId,
 				pickupAt: entry.lastConfirmedAt
 			}
 		});
-		const ev = {
-			id: pickedUpId,
+		const draft = {
 			kind: "object",
 			deviceId: entry.deviceId,
 			timestamp,
 			source: "pipeline",
+			idempotencyKey: pickedUpKey,
 			trackId: mediaTrackId,
 			className: PACKAGE_EVENT_CLASS,
 			...entry.label !== void 0 ? { label: entry.label } : {},
@@ -56533,12 +57163,26 @@ var PackageDropDetector = class {
 			...collector?.keyFrameMediaKey !== void 0 ? { mediaKey: collector.keyFrameMediaKey } : {},
 			importance: PACKAGE_IMPORTANCE
 		};
-		await this.deps.events.insertObject(ev);
+		const rowId = await this.deps.events.insertObject(draft);
+		if (rowId === null) {
+			this.deps.logger.warn("package pick-up NOT emitted — the event row did not persist", {
+				tags: { deviceId: entry.deviceId },
+				meta: {
+					entryId: entry.id,
+					idempotencyKey: pickedUpKey
+				}
+			});
+			return;
+		}
+		const ev = {
+			...draft,
+			id: rowId
+		};
 		this.deps.onPersisted?.(ev, "picked-up");
 		this.deps.emit.pickedUp({
 			deviceId: entry.deviceId,
 			entryId: entry.id,
-			deliveredEventId: deliveredId,
+			deliveredEventId: String(delivered.id),
 			className: entry.className,
 			...collector !== void 0 ? { collectorTrackId: collector.trackId } : {},
 			timestamp
@@ -56547,8 +57191,9 @@ var PackageDropDetector = class {
 			tags: { deviceId: entry.deviceId },
 			meta: {
 				entryId: entry.id,
-				eventId: pickedUpId,
-				deliveredEventId: deliveredId,
+				eventId: rowId,
+				idempotencyKey: pickedUpKey,
+				deliveredEventId: delivered.id,
 				mediaTrackId,
 				...collector !== void 0 ? {
 					collectorTrackId: collector.trackId,
@@ -58983,7 +59628,7 @@ async function loadRebuildSource(deps, trackId) {
 	const cropInfo = media.find((m) => m.kind === "thumbnail");
 	const peak = await deps.events.peakForTrack(trackId);
 	const events = await deps.events.queryObjectByTrackIds([trackId]);
-	const best = events.find((e) => e.id === peak.bestEventId) ?? events[0];
+	const best = events.find((e) => String(e.id) === peak.bestEventId) ?? events[0];
 	if (best === void 0) return null;
 	const common = {
 		trackId,
@@ -62876,7 +63521,7 @@ var ANALYTICS_COLLECTIONS = [
 		classification: {
 			kind: "owner-indirection",
 			derivation: "explicit",
-			why: "(ownerKind, ownerId) means a different entity per kind — a trackId for 'track', a PREFIXED trackId for 'face'/'plate', an eventId for 'event', and an enrolled gallery row for 'identity'/'vehicle' that retention must never touch. A RETIRED ownerKind (the deleted group entity) resolves to an owner that can never exist again and is always an orphan. The mapping is `resolveMediaOwner` in orphan-audit.ts."
+			why: "(ownerKind, ownerId) means a different entity per kind — a trackId for 'track', a PREFIXED trackId for 'face'/'plate', an eventId for 'motion'/'object'/'audio' (D476 split 'event' into the three tables it used to cover), and an enrolled gallery row for 'identity'/'vehicle' that retention must never touch. A RETIRED ownerKind (the deleted group entity) resolves to an owner that can never exist again and is always an orphan. The mapping is `resolveMediaOwner` in orphan-audit.ts."
 		}
 	},
 	{
@@ -63090,7 +63735,9 @@ function resolveMediaOwner(row) {
 			kind: "track",
 			trackId: ownerId
 		};
-		case "event": return {
+		case "motion":
+		case "object":
+		case "audio": return {
 			kind: "event",
 			eventId: ownerId
 		};
@@ -64359,8 +65006,21 @@ var FULL_FRAME_BBOX = {
 	w: 1,
 	h: 1
 };
+/** The same classification the RUNNER applies to decide "full frame" from the
+*  bbox (`getNativeCrop`), restated here so the two cannot drift. */
+function isFullFrameBbox(bbox) {
+	return bbox.x <= .001 && bbox.y <= .001 && bbox.w >= .999 && bbox.h >= .999;
+}
 /** Throttle for the native-crop HIT/FALLBACK metric window line. */
 var NATIVE_CROP_METRIC_INTERVAL_MS = 3e4;
+/**
+* Above this `maxWidth`, a full-frame fetch is a NATIVE full frame (the
+* `keyFrame`/group-shot rung, ~1–1.5 MB on a 4K camera) rather than a boxed
+* timeline tile or a pinned ≤640 detection frame (tens of kB). The two belong
+* in different counters or the window line says "full frames" and means two
+* payload classes three orders of magnitude apart. (D470)
+*/
+var FULL_FRAME_TILE_WIDTH_CEILING = 1920;
 function createNativeFrameTransport(deps) {
 	const { api, logger } = deps;
 	const pipelineRunnerApi = api.pipelineRunner;
@@ -64434,16 +65094,35 @@ function createNativeFrameTransport(deps) {
 			tier: reply.tier === "ram-fullframe" ? "ram-fullframe" : "native"
 		};
 	};
-	const getRemoteFrame = async (handle) => requestNativeCrop(handle, FULL_FRAME_BBOX, handle.width, replyToFullFrame);
-	const fetchNativeFullFrameTiered = async (handle, maxWidth) => requestNativeCrop(handle, FULL_FRAME_BBOX, maxWidth, replyToTieredFullFrame);
+	const getRemoteFrame = async (handle) => closeWindowAfter(requestNativeCrop(handle, FULL_FRAME_BBOX, handle.width, replyToFullFrame));
+	const fetchNativeFullFrameTiered = async (handle, maxWidth) => closeWindowAfter(requestNativeCrop(handle, FULL_FRAME_BBOX, maxWidth, replyToTieredFullFrame));
 	const getNativeFullFrameRgb = async (handle, maxWidth) => (await fetchNativeFullFrameTiered(handle, maxWidth))?.frame ?? null;
 	const cropMetricLogger = logger.child("NativeCrop");
 	let nativeHits = 0;
 	let nativeFallbacks = 0;
 	let lastCropMetricAt = 0;
+	let roiFetches = 0;
+	let fullFrames = 0;
+	let nativeFullFrames = 0;
 	const bumpCropMetric = (hit) => {
 		if (hit) nativeHits += 1;
 		else nativeFallbacks += 1;
+		maybeLogCropWindow();
+	};
+	/**
+	* Publish the window once `request` has SETTLED — never before, or the line
+	* carries a window whose own outcome has not been counted yet and throttles
+	* away the one that has. `finally`, so the deliberate throw of
+	* `fetchNativeFullFrameTiered` still reaches `persistTrackKeyFrame`.
+	*/
+	const closeWindowAfter = async (request) => {
+		try {
+			return await request;
+		} finally {
+			maybeLogCropWindow();
+		}
+	};
+	const maybeLogCropWindow = () => {
 		const now = Date.now();
 		if (now - lastCropMetricAt < NATIVE_CROP_METRIC_INTERVAL_MS) return;
 		lastCropMetricAt = now;
@@ -64453,11 +65132,20 @@ function createNativeFrameTransport(deps) {
 			detectionFrameFallbacks: nativeFallbacks,
 			wireFetches: dedupe.fetched,
 			coalesced: dedupe.coalesced,
-			reusedInWindow: dedupe.reused
+			reusedInWindow: dedupe.reused,
+			roiCalls: roiFetches,
+			tileFullFrameCalls: fullFrames,
+			nativeFullFrameCalls: nativeFullFrames
 		} });
+		roiFetches = 0;
+		fullFrames = 0;
+		nativeFullFrames = 0;
 	};
 	const requestNativeCrop = async (frameHandle, bbox, maxWidth, normalize) => {
 		if (!pipelineRunnerApi?.getNativeCrop) return null;
+		if (isFullFrameBbox(bbox)) if (maxWidth !== void 0 && maxWidth > FULL_FRAME_TILE_WIDTH_CEILING) nativeFullFrames += 1;
+		else fullFrames += 1;
+		else roiFetches += 1;
 		const native = await pipelineRunnerApi.getNativeCrop.query({
 			handle: frameHandle,
 			bbox,
@@ -66506,7 +67194,7 @@ var EventMediaDispatcher = class {
 				if (!childCropData) continue;
 				await this.deps.mediaStore.put({
 					deviceId,
-					ownerKind: "event",
+					ownerKind: "object",
 					ownerId: ev.eventId,
 					kind: child.kind,
 					timestamp: ev.timestamp,
@@ -66670,7 +67358,7 @@ var MotionEventSnapshotCapturer = class {
 		try {
 			await this.deps.media.put({
 				deviceId: input.deviceId,
-				ownerKind: "event",
+				ownerKind: "motion",
 				ownerId: input.eventId,
 				kind: "snapshot",
 				timestamp: input.timestamp,
@@ -69643,48 +70331,111 @@ function compareSummaryScores(a, b) {
 	if (a.visible !== b.visible) return a.visible - b.visible;
 	return a.quality - b.quality;
 }
-/** A candidate replaces the best only when it is STRICTLY better — a tie keeps
-*  the pixels already materialised (they cost a native round trip). */
-function isBetterSummaryScore(candidate, best) {
-	if (candidate.visible === 0) return false;
-	return best === null || compareSummaryScores(candidate, best) > 0;
-}
-//#endregion
-//#region src/pipeline-analytics/summary/group-shot.ts
-/**
-* The running argmax of one open summary's group shot.
-*
-* RAM only, on purpose: it decides WHEN pixels are worth a native round trip
-* (only when the maximum improves — D9/D18), it is not the record of the
-* shot. The record is the media row the caller writes under the summary's
-* id; after a restart an open summary simply starts its argmax again and
-* replaces the row the next time it beats what it can remember, which is
-* nothing. That is a weaker shot for one session, never a wrong one.
-*/
 var GroupShotTracker = class {
-	best = /* @__PURE__ */ new Map();
+	states = /* @__PURE__ */ new Map();
+	offered = 0;
+	materialised = 0;
+	byGap = 0;
+	byMargin = 0;
+	byWorse = 0;
 	/**
-	* Offer a frame. Returns `true` when it beats the summary's best so far —
-	* the caller's cue to materialise the pixels for THIS frame, now, while its
-	* handle is still leased.
+	* Offer a frame. Returns `true` when it is worth materialising NOW — the
+	* caller's cue to fetch the pixels for THIS frame, while its handle is
+	* still leased.
+	*
+	* The clock is `frame.timestamp`; the caller injects no second one.
 	*/
 	offer(summaryId, score, frame) {
-		if (!isBetterSummaryScore(score, (this.best.get(summaryId) ?? null)?.score ?? null)) return false;
-		this.best.set(summaryId, {
+		if (score.visible === 0) return false;
+		this.offered += 1;
+		const state = this.states.get(summaryId);
+		if (state === void 0) {
+			this.states.set(summaryId, {
+				delivered: null,
+				lastAttemptAt: frame.timestamp,
+				unlanded: 1
+			});
+			this.materialised += 1;
+			return true;
+		}
+		if (state.lastAttemptAt !== void 0 && frame.timestamp - state.lastAttemptAt < 2e3) {
+			this.byGap += 1;
+			return false;
+		}
+		if (!this.isWorthPixels(state, score)) return false;
+		state.lastAttemptAt = frame.timestamp;
+		state.unlanded += 1;
+		this.materialised += 1;
+		return true;
+	}
+	/**
+	* Nothing has landed yet → keep trying (D58) until the budget is spent.
+	* Something has landed → beat it, by the margin on the quality tiebreak.
+	*/
+	isWorthPixels(state, score) {
+		const delivered = state.delivered;
+		if (delivered === null) {
+			if (state.unlanded >= 4) {
+				this.byMargin += 1;
+				return false;
+			}
+			return true;
+		}
+		if (compareSummaryScores(score, delivered.score) <= 0) {
+			this.byWorse += 1;
+			return false;
+		}
+		if (score.visible === delivered.score.visible && score.quality - delivered.score.quality < .05) {
+			this.byMargin += 1;
+			return false;
+		}
+		return true;
+	}
+	/**
+	* A materialisation LANDED. Only this advances the baseline the next
+	* candidate must beat — a fetch that missed leaves the summary exactly as
+	* picture-less as it was, and the next frame may be worse and still worth
+	* taking.
+	*/
+	noteLanded(summaryId, score, frame) {
+		const state = this.states.get(summaryId);
+		if (state === void 0) return;
+		state.delivered = {
 			score,
 			frame
-		});
-		return true;
+		};
+		state.unlanded = 0;
 	}
-	bestOf(summaryId) {
-		return this.best.get(summaryId) ?? null;
+	/** The shot on disk for this summary, as this process last saw it land. */
+	deliveredOf(summaryId) {
+		return this.states.get(summaryId)?.delivered ?? null;
 	}
 	/** A sealed or evicted summary takes no more frames; drop its state. */
 	forget(summaryId) {
-		this.best.delete(summaryId);
+		this.states.delete(summaryId);
+	}
+	/**
+	* What the gate did since the last read. Shipped WITH the gate: without it
+	* the only evidence for a fetch that did NOT happen is hub-main's byte
+	* counter, which answers a different question a minute later.
+	*/
+	drainCounts() {
+		const counts = {
+			offered: this.offered,
+			materialised: this.materialised,
+			byGap: this.byGap,
+			byMargin: this.byMargin,
+			byWorse: this.byWorse
+		};
+		this.offered = 0;
+		this.materialised = 0;
+		this.byGap = 0;
+		this.byMargin = 0;
+		this.byWorse = 0;
+		return counts;
 	}
 	get size() {
-		return this.best.size;
+		return this.states.size;
 	}
 };
 //#endregion
@@ -69981,7 +70732,7 @@ async function buildTrainingExportPlan(readers, input) {
 					scope: "plate"
 				},
 				...(eventsByTrack.get(track.trackId) ?? []).map((eventId) => ({
-					ownerKind: "event",
+					ownerKind: "object",
 					ownerId: eventId,
 					scope: `events/${eventId}`
 				}))
@@ -70823,6 +71574,8 @@ var RETRAIN_EXPORT_MAX = 2e4;
 * surface to turn the refinement pipeline on/off for a camera.
 */
 var TTL_SWEEP_INTERVAL_MS = 5e3;
+/** Throttle for the group-shot gate's window line (D470). */
+var GROUP_SHOT_METRIC_INTERVAL_MS = 3e4;
 /**
 * How often the addon asks "is a gallery sample outside the cluster face
 * space?". A flip is rare and the check is two cheap reads — a minute keeps
@@ -70950,7 +71703,6 @@ var AUDIO_EPISODE_PERSIST_MS = 2e3;
 * the persistence (D62).
 */
 var AUDIO_EVENT_HEARTBEAT_MS = 5e3;
-var MOTION_EVENT_HEARTBEAT_MS = 5e3;
 /**
 * Stored media kinds that carry NO drawn bounding box, in fallback preference
 * order. The reel forces `?kind=crop`; when a track has no crop the endpoint may
@@ -71079,8 +71831,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	summaryStore = null;
 	/** The ONLY writer of a summary's lifecycle (D359). */
 	summarySealer = null;
-	/** The running argmax of every open summary's group shot (D359 phase 3). RAM only. */
+	/** The materialisation gate on every open summary's group shot (D359 phase 3, D470). RAM only. */
 	groupShots = new GroupShotTracker();
+	/** Throttle for the group-shot gate's window line (D470). */
+	lastGroupShotMetricAt = 0;
 	/**
 	* Tracks a gallery match has named, for the group-shot score's recognition
 	* term. "Recognised so far" rather than "at that instant": the match arrives
@@ -71517,7 +72271,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	secondarySubjects = new SecondarySubjectQueue();
 	lastFrameDimsByDevice = /* @__PURE__ */ new Map();
 	lastAudioInsertByDevice = /* @__PURE__ */ new Map();
-	lastMotionInsertByDevice = /* @__PURE__ */ new Map();
+	lastMotionTickByDevice = /* @__PURE__ */ new Map();
+	motionEpisodes = null;
 	levelStateByDevice = /* @__PURE__ */ new Map();
 	/** Per-device corroboration window for classified audio (see
 	*  `audio-confirm-window.ts`). Torn down wherever `levelStateByDevice` is —
@@ -72686,6 +73441,14 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			media: this.mediaStore
 		});
 		this.eventStore = eventStore;
+		this.motionEpisodes = new MotionEpisodeTracker({
+			closeAfterMs: require_dist.MOTION_CLOSE_AFTER_MS,
+			logger: logger.child("MotionEpisodeTracker"),
+			insertRow: (input) => this.insertMotionEpisodeRow(input.deviceId, input.timestamp, input.regionData),
+			closeRow: (input) => this.closeMotionEpisodeRow(input),
+			onNewEdge: (input) => this.onMotionEpisodeEdge(input),
+			onTick: (input) => this.onMotionEpisodeTick(input)
+		});
 		this.sensorEventStore = new SensorEventStore({
 			store: api.settingsStore,
 			logger: logger.child("SensorEventStore")
@@ -73344,11 +74107,20 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	* The mosaic is filed through the SAME `mediaStore` every event thumbnail
 	* goes through — the operator's directive, verbatim: same data structure,
 	* same storage location, no second retained store. It is written under
-	* `ownerKind: 'event'` with the window's own owner id, so it lands beside the
-	* cameras' event media (`<deviceId>/events/event/<ownerId>/…`) and is swept
-	* by the same machinery. It is deliberately NOT owned by a track: a track's
-	* media list is a LIVE viewer surface, and a cross-camera mosaic appearing in
-	* one track's tiles would be a picture that lies about what it is of.
+	* `ownerKind: 'object'` with the window's own SYNTHETIC owner id (never a
+	* real object-event id), so it lands beside the cameras' event media
+	* (`<deviceId>/events/object/<ownerId>/…`) and is swept by the same
+	* ownership-based orphan audit: `resolveMediaOwner` maps any of
+	* `motion`/`object`/`audio` to the same generic `{kind:'event'}` OwnerRef,
+	* `EventStore.existingEventIds` never finds the synthetic id in any of the
+	* three tables, and the row is reclaimed as an orphan once past the grace
+	* window — same effective lifecycle as before D476, when `event` covered
+	* all three. `object` is a pragmatic choice among equals here, not a
+	* structural fact about the mosaic (it is not itself an object-event row);
+	* flagged in the D476 ADR as a spot a future dedicated owner kind may suit
+	* better. It is deliberately NOT owned by a track: a track's media list is a
+	* LIVE viewer surface, and a cross-camera mosaic appearing in one track's
+	* tiles would be a picture that lies about what it is of.
 	*/
 	buildSummaryPorts(stores) {
 		return {
@@ -73389,7 +74161,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			},
 			storeMosaic: async ({ deviceId, ownerId, timestamp, jpeg }) => stores.mediaStore.put({
 				deviceId,
-				ownerKind: "event",
+				ownerKind: "object",
 				ownerId,
 				kind: "fullFrame",
 				timestamp,
@@ -73629,7 +74401,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			listEventIdsForTracks: async (trackIds) => {
 				if (!eventStore || trackIds.length === 0) return [];
 				return (await eventStore.queryObjectByTrackIds(trackIds)).flatMap((e) => e.trackId === void 0 ? [] : [{
-					eventId: e.id,
+					eventId: String(e.id),
 					trackId: e.trackId
 				}]);
 			},
@@ -74425,9 +75197,9 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 					})
 				]);
 				return {
-					motion,
-					object,
-					audio
+					motion: toEventLike(motion),
+					object: toEventLike(object),
+					audio: toEventLike(audio)
 				};
 			},
 			fetchMediaOwners: async ({ deviceId, ownerKind, ownerIds }) => {
@@ -74582,6 +75354,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		this.alarmPanelConvergence = null;
 		for (const unsub of this.subscriptionUnsubs) unsub();
 		this.subscriptionUnsubs = [];
+		await this.motionEpisodes?.closeAll("addon-shutdown");
 		await this.embeddingDispatcher?.stop();
 		this.embeddingDispatcher = null;
 		await this.notificationCenter?.stop();
@@ -75186,11 +75959,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				byState
 			} });
 		}
-		await Promise.all([...result.objectEvents, ...result.appearanceEvents].map((e) => this.eventStore.insertObject(e)));
+		const objectEvents = await this.persistObjectEvents(deviceId, result.objectEvents);
+		const appearanceEvents = await this.persistObjectEvents(deviceId, result.appearanceEvents);
 		if (this.notificationCenter !== null) {
 			const overlaps = processor.getLastZoneOverlaps();
 			const rejections = processor.getLastZoneRejections();
-			for (const e of result.objectEvents) {
+			for (const e of objectEvents) {
 				if (e.zones && e.zones.length > 0) {
 					const m = e.trackId ? overlaps.get(e.trackId) : void 0;
 					this.ctx.logger.info("zone membership stamped on event", {
@@ -75244,7 +76018,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		const faceGloballyEnabled = this.faceRecognizer ? await this.resolveGlobalFaceEnabled() : false;
 		const mediaSettings = await this.resolveDeviceMediaSettings(deviceId);
 		if (this.eventMediaDispatcher && frameHandle) {
-			const mediaEvents = [...result.objectEvents, ...result.appearanceEvents];
+			const mediaEvents = [...objectEvents, ...appearanceEvents];
 			const childCropsByEvent = buildEventChildCrops(mediaEvents, frame.detections);
 			const uncroppable = mediaEvents.filter((e) => e.bbox === void 0 || e.bbox.w <= 0 || e.bbox.h <= 0);
 			if (uncroppable.length > 0) this.ctx.logger.debug("event media: no crop for events with no box in this frame (a departed track has nothing to cut)", {
@@ -75258,7 +76032,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			const eventTargets = mediaEvents.filter((e) => e.bbox !== void 0 && e.bbox.w > 0 && e.bbox.h > 0).map((e) => {
 				const childCrops = childCropsByEvent.get(e.id);
 				return {
-					eventId: e.id,
+					eventId: String(e.id),
 					timestamp: e.timestamp,
 					bbox: e.bbox,
 					className: e.className,
@@ -75412,7 +76186,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			...frameHandle !== void 0 ? { frameHandle } : {}
 		});
 		if (objectEmbeddingBests.length > 0) this.persistObjectEmbeddingBests(deviceId, result.timestamp, objectEmbeddingBests, frameHandle, result.frameWidth, result.frameHeight, mediaSettings.cropPadding);
-		for (const e of result.objectEvents) this.ctx.eventBus.emit({
+		for (const e of objectEvents) this.ctx.eventBus.emit({
 			id: `pa-${e.id}`,
 			timestamp: new Date(e.timestamp),
 			source: {
@@ -75510,6 +76284,45 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	*  eight settings kinds funnel through on a cache miss, so calling the raw
 	*  reads directly here means eight kinds expiring in the same window each
 	*  pay for the same two reads — see `store/settings-raw-mirror.ts`. */
+	/**
+	* Insert the frame's object-event DRAFTS and return them with the id the
+	* database actually assigned (D474).
+	*
+	* The frame path cannot name an event: the id is a SQLite rowid, minted by
+	* the write. So this is the ONE place a draft becomes an `ObjectEvent`, and
+	* everything downstream — the media targets, the notification-centre hook,
+	* the bus emit — consumes what comes back rather than what went in.
+	*
+	* Order is preserved. A draft whose row did not land is DROPPED and SAID:
+	* it owns no media, can be named on no bus and can match no rule, and an
+	* invented id would put `event:NaN` in a media key. A branch that accepts
+	* work and produces nothing must log it.
+	*/
+	async persistObjectEvents(deviceId, drafts) {
+		if (drafts.length === 0) return [];
+		const store = this.eventStore;
+		if (store === null) return [];
+		const ids = await Promise.all(drafts.map((d) => store.insertObject(d)));
+		const persisted = [];
+		for (const [i, draft] of drafts.entries()) {
+			const id = ids[i];
+			if (id === void 0 || id === null) continue;
+			persisted.push({
+				...draft,
+				id
+			});
+		}
+		const lost = drafts.length - persisted.length;
+		if (lost > 0) this.ctx.logger.warn("object events did not persist — no id, so no media, no bus, no rule", {
+			tags: { deviceId },
+			meta: {
+				lost,
+				of: drafts.length,
+				trackIds: [...new Set(drafts.map((d) => d.trackId ?? "none"))]
+			}
+		});
+		return persisted;
+	}
 	async readDeviceSettings(deviceId, resolve) {
 		const globalRaw = this.ctxIfReady !== null ? await this.rawGlobalStoreMirror.resolve() : {};
 		const deviceRaw = await this.rawDeviceBlobMirror.resolve(deviceId);
@@ -76288,7 +77101,10 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				recognized: this.recognizedTrackIds.has(t.trackId)
 			}))
 		});
-		if (!this.groupShots.offer(open.id, score, { timestamp: result.timestamp })) return;
+		const frameRef = { timestamp: result.timestamp };
+		const worthPixels = this.groupShots.offer(open.id, score, frameRef);
+		this.logGroupShotWindow(deviceId);
+		if (!worthPixels) return;
 		const getNative = this.getNativeKeyFrameRgb;
 		const mediaStore = this.mediaStore;
 		if (!getNative || !mediaStore) return;
@@ -76310,17 +77126,48 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				maxWidth: KEYFRAME_NATIVE_MAX_WIDTH
 			})
 		}).then((outcome) => {
-			if (outcome?.kind === "landed") this.ctx.logger.debug("summary group shot landed", {
-				tags: { deviceId },
-				meta: {
-					summaryId,
-					visible: score.visible,
-					quality: Number(score.quality.toFixed(3))
-				}
-			});
+			if (outcome?.kind === "landed") {
+				this.groupShots.noteLanded(summaryId, score, frameRef);
+				this.ctx.logger.debug("summary group shot landed", {
+					tags: { deviceId },
+					meta: {
+						summaryId,
+						visible: score.visible,
+						quality: Number(score.quality.toFixed(3))
+					}
+				});
+			}
 		}).catch(() => {});
 	}
 	/**
+	* The group-shot gate's window, throttled to one line per
+	* {@link GROUP_SHOT_METRIC_INTERVAL_MS}. Process-global counts, tagged with
+	* the device that happened to close the window — the counters are the
+	* gate's, not the camera's, and the tag is there because every line about a
+	* device carries one.
+	*
+	* `materialised` is the number of 4096-px native full-frame fetches this
+	* path actually spent; `byGap` + `byMargin` + `byWorse` is what it did not.
+	*/
+	logGroupShotWindow(deviceId) {
+		const now = Date.now();
+		if (now - this.lastGroupShotMetricAt < GROUP_SHOT_METRIC_INTERVAL_MS) return;
+		this.lastGroupShotMetricAt = now;
+		const counts = this.groupShots.drainCounts();
+		if (counts.offered === 0) return;
+		this.ctx.logger.info("group shot window", {
+			tags: { deviceId },
+			meta: {
+				offered: counts.offered,
+				materialised: counts.materialised,
+				suppressedByGap: counts.byGap,
+				suppressedByMargin: counts.byMargin,
+				suppressedByWorse: counts.byWorse,
+				openSummaries: this.groupShots.size
+			}
+		});
+	}
+	/**
 	* Order the parcels a best-frame decision wants (D422). Skipped entirely at
 	* a node the registry already called offline (D58) — logged on the
 	* transition by `noteCapturesGated`, counted in the key-frame window.
@@ -76866,9 +77713,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	* The two mirrors answer different halves and neither subsumes the other:
 	*  - {@link lastTrackActivityMs} — a tracked object was alive. Present only
 	*    while the camera is ATTACHED and producing inference frames.
-	*  - {@link lastMotionInsertByDevice} — motion was reported (analyzer or
-	*    onboard). Covers a camera whose detector found nothing, and a camera
-	*    on `detectionMode: 'on-motion'` in the window before it attaches.
+	*  - {@link lastMotionTickByDevice} — motion was reported (analyzer or
+	*    onboard, ANY source). Covers a camera whose detector found nothing,
+	*    and a camera on `detectionMode: 'on-motion'` in the window before it
+	*    attaches. This is a plain per-device mirror, deliberately NOT the
+	*    per-source episode state in {@link motionEpisodes} — this question is
+	*    "is something visual happening on the camera", not "which episode".
 	*
 	* Staleness is safe in the direction that matters: a mirror that is late
 	* suppresses a marker, it never invents one.
@@ -76876,7 +77726,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	isMotionActive(deviceId, atMs, quietMs) {
 		const trackAt = this.lastTrackActivityMs.get(deviceId);
 		if (trackAt !== void 0 && atMs - trackAt < quietMs) return true;
-		const motion = this.lastMotionInsertByDevice.get(deviceId);
+		const motion = this.lastMotionTickByDevice.get(deviceId);
 		return motion !== void 0 && motion.detected && atMs - motion.atMs < quietMs;
 	}
 	/** Per-device audio-marker config, folded from the cached audio settings. */
@@ -76941,8 +77791,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	* therefore persisted nothing at all.
 	*/
 	async persistClassifiedAudio(input) {
-		const ev = {
-			id: (0, node_crypto.randomUUID)(),
+		const draft = {
 			deviceId: input.deviceId,
 			timestamp: input.timestamp,
 			kind: "audio",
@@ -76958,7 +77807,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			className: input.className,
 			atMs: input.timestamp
 		});
-		await this.eventStore.insertAudio(ev);
+		const insertedId = await this.eventStore.insertAudio(draft);
+		if (insertedId === null) return;
+		const ev = {
+			...draft,
+			id: insertedId
+		};
 		this.notificationCenter?.onAudioEventPersisted(ev);
 		this.trackStore?.addAudioLabelEpisode(input.deviceId, input.className, input.score, input.timestamp);
 		this.ctx.eventBus.emit({
@@ -77169,8 +78023,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		});
 		this.levelStateByDevice.set(deviceId, res.nextState);
 		if (!res.emit) return;
-		const ev = {
-			id: (0, node_crypto.randomUUID)(),
+		const draft = {
 			deviceId,
 			timestamp,
 			kind: "audio",
@@ -77181,7 +78034,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			className: void 0,
 			atMs: timestamp
 		});
-		await this.eventStore.insertAudio(ev);
+		const insertedId = await this.eventStore.insertAudio(draft);
+		if (insertedId === null) return;
+		const ev = {
+			...draft,
+			id: insertedId
+		};
 		this.ctx.eventBus.emit({
 			id: `pa-${ev.id}`,
 			timestamp: new Date(ev.timestamp),
@@ -77200,10 +78058,11 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		});
 	}
 	/**
-	* Persist motion-analysis bus events. Mirrors `handleAudioResult`'s
-	* coalescing strategy: emit one row on off→on transition, then one
-	* per `MOTION_EVENT_HEARTBEAT_MS` while motion stays detected. No
-	* row on off→off (silence) or while heartbeat hasn't elapsed.
+	* Persist motion-analysis bus events into the EPISODE tracker (D475): a
+	* rising edge with no open episode INSERTs a row; a further edge inside an
+	* open episode extends it in place; the episode closes on its own timer,
+	* `MOTION_CLOSE_AFTER_MS` after the last rising edge. See
+	* `motion-episode.ts` / `motion-episode-tracker.ts` for the state machine.
 	*
 	* Gated on the same `pipeline-analytics` wrapper binding as the
 	* inference + audio handlers so toggling the wrapper off for a
@@ -77213,22 +78072,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		if (this.shuttingDown) return;
 		if (!await this.bindingCache.isActive(deviceId)) return;
 		const detected = payload.detected === true;
-		const last = this.lastMotionInsertByDevice.get(deviceId);
-		const heartbeatDue = !last || timestamp - last.atMs >= MOTION_EVENT_HEARTBEAT_MS;
-		const transitionedOn = detected && (last === void 0 || last.detected === false);
-		if (!detected) {
-			if (last?.detected === true) this.lastMotionInsertByDevice.set(deviceId, {
-				detected: false,
-				atMs: timestamp
-			});
-			return;
-		}
-		if (!transitionedOn && !heartbeatDue) return;
-		const ev = {
-			id: (0, node_crypto.randomUUID)(),
-			deviceId,
-			timestamp,
-			kind: "motion",
+		this.lastMotionTickByDevice.set(deviceId, {
+			detected,
+			atMs: timestamp
+		});
+		if (detected) this.eventStore?.noteMotionSample(deviceId, payload.regionCount, timestamp);
+		await this.motionEpisodes?.observe(deviceId, "analyzer", detected, timestamp, {
 			regionCount: payload.regionCount,
 			regions: payload.regions.map((r) => ({
 				bbox: {
@@ -77242,69 +78091,29 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			})),
 			frameWidth: payload.frameWidth,
 			frameHeight: payload.frameHeight
-		};
-		this.lastMotionInsertByDevice.set(deviceId, {
-			detected,
-			atMs: timestamp
-		});
-		if (transitionedOn) this.motionOnsets.noteRisingEdge(deviceId, timestamp);
-		this.sceneEngine?.noteMotion(deviceId, timestamp);
-		await this.eventStore.insertMotion(ev);
-		this.ctx.eventBus.emit({
-			id: `pa-${ev.id}`,
-			timestamp: new Date(ev.timestamp),
-			source: {
-				type: "addon",
-				id: "pipeline-analytics",
-				addonId: "pipeline-analytics"
-			},
-			category: require_dist.EventCategory.PipelineAnalyticsDetectionEvent,
-			data: {
-				deviceId,
-				kind: "motion",
-				eventId: ev.id,
-				timestamp: ev.timestamp
-			}
 		});
-		if (transitionedOn) await this.captureMotionMarkerStill(deviceId, ev.id, ev.timestamp);
 	}
 	/**
-	* Persist firmware-driven (onboard) motion events. Mirrors
-	* {@link handleMotionAnalysis}'s coalescing — one row on off→on
-	* transition, then one per `MOTION_EVENT_HEARTBEAT_MS` while motion
-	* stays detected — but reads from the {@link MotionOnMotionChangedPayload}
-	* shape which lacks frame dimensions and pixel-level region details
-	* (firmware reports a binary detected flag plus, on rare devices, a
-	* coarse bbox via the optional `regions` field).
-	*
-	* The same `lastMotionInsertByDevice` map is shared with the analyzer
-	* path so a camera that briefly switches `motionSources` between
-	* `onboard` and `analyzer` gets consistent throttling — both paths
-	* are mutually exclusive at the event-emit layer (the runner only
-	* fires `MotionAnalysis` when its analyzer runs; onboard providers
-	* never fire `MotionAnalysis`), so there's no double-count risk.
+	* Persist firmware-driven (onboard / device-activity) motion events into
+	* the SAME episode tracker as {@link handleMotionAnalysis}, keyed per
+	* `(deviceId, source)` so the two paths can never share — or fight over —
+	* one episode on a camera whose `motionSources` lists both (D475). Reads
+	* from the {@link MotionOnMotionChangedPayload} shape which lacks frame
+	* dimensions and pixel-level region details (firmware reports a binary
+	* detected flag plus, on rare devices, a coarse bbox via the optional
+	* `regions` field).
 	*/
 	async handleOnboardMotion(deviceId, payload, timestamp) {
 		if (this.shuttingDown) return;
 		if (!await this.bindingCache.isActive(deviceId)) return;
 		const detected = payload.detected === true;
-		const last = this.lastMotionInsertByDevice.get(deviceId);
-		const heartbeatDue = !last || timestamp - last.atMs >= MOTION_EVENT_HEARTBEAT_MS;
-		const transitionedOn = detected && (last === void 0 || last.detected === false);
-		if (!detected) {
-			if (last?.detected === true) this.lastMotionInsertByDevice.set(deviceId, {
-				detected: false,
-				atMs: timestamp
-			});
-			return;
-		}
-		if (!transitionedOn && !heartbeatDue) return;
+		this.lastMotionTickByDevice.set(deviceId, {
+			detected,
+			atMs: timestamp
+		});
 		const regions = payload.regions ?? [];
-		const ev = {
-			id: (0, node_crypto.randomUUID)(),
-			deviceId,
-			timestamp,
-			kind: "motion",
+		if (detected) this.eventStore?.noteMotionSample(deviceId, regions.length, timestamp);
+		await this.motionEpisodes?.observe(deviceId, payload.source, detected, timestamp, {
 			regionCount: regions.length,
 			regions: regions.map((r) => ({
 				bbox: {
@@ -77318,17 +78127,56 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			})),
 			frameWidth: 0,
 			frameHeight: 0
+		});
+	}
+	/**
+	* `MotionEpisodeTracker.insertRow` — builds and inserts the row that opens
+	* a motion episode. `regionData` carries the per-kind fields the two motion
+	* handlers differ on (regions/frameWidth/frameHeight); everything else
+	* (id, durationMs, edges) is the episode's own concern, not the caller's.
+	*/
+	async insertMotionEpisodeRow(deviceId, timestamp, regionData) {
+		const draft = {
+			deviceId,
+			timestamp,
+			kind: "motion",
+			durationMs: null,
+			...regionData
 		};
-		this.lastMotionInsertByDevice.set(deviceId, {
-			detected,
-			atMs: timestamp
+		return this.eventStore.insertMotion(draft);
+	}
+	/**
+	* `MotionEpisodeTracker.closeRow` — the UPDATE that closes an episode.
+	*/
+	async closeMotionEpisodeRow(input) {
+		return this.eventStore.updateMotion(input.eventId, input.deviceId, {
+			durationMs: input.durationMs,
+			edges: input.edges
+		});
+	}
+	/**
+	* `MotionEpisodeTracker.onNewEdge` — the side effects the pre-D475 code
+	* fired on every `transitionedOn`: the birth-latency onset mark (D409, only
+	* the FIRST edge of a burst moves it — a further edge inside the same
+	* episode is a fresh onset in its own right, so it moves too) and the
+	* motion-marker still (self-throttled by `motion-marker-policy.ts`;
+	* `String` because a media key is a URL component while the id itself
+	* stays a number, D474).
+	*/
+	onMotionEpisodeEdge(input) {
+		this.motionOnsets.noteRisingEdge(input.deviceId, input.timestamp);
+		this.captureMotionMarkerStill(input.deviceId, String(input.eventId), input.timestamp).catch((err) => {
+			this.ctx.logger.debug("motion marker still capture failed", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					eventId: input.eventId,
+					error: require_dist.errMsg(err)
+				}
+			});
 		});
-		if (transitionedOn) this.motionOnsets.noteRisingEdge(deviceId, timestamp);
-		this.sceneEngine?.noteMotion(deviceId, timestamp);
-		await this.eventStore.insertMotion(ev);
 		this.ctx.eventBus.emit({
-			id: `pa-${ev.id}`,
-			timestamp: new Date(ev.timestamp),
+			id: `pa-${input.eventId}`,
+			timestamp: new Date(input.timestamp),
 			source: {
 				type: "addon",
 				id: "pipeline-analytics",
@@ -77336,13 +78184,23 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			},
 			category: require_dist.EventCategory.PipelineAnalyticsDetectionEvent,
 			data: {
-				deviceId,
+				deviceId: input.deviceId,
 				kind: "motion",
-				eventId: ev.id,
-				timestamp: ev.timestamp
+				eventId: input.eventId,
+				timestamp: input.timestamp
 			}
 		});
-		if (transitionedOn) await this.captureMotionMarkerStill(deviceId, ev.id, ev.timestamp);
+	}
+	/**
+	* `MotionEpisodeTracker.onTick` — fires on every `detected:true`
+	* observation that reaches an open or newly-opened episode, transition or
+	* continuation. Arms the scene quiet-edge trigger: a scene is checked
+	* `quietSeconds` AFTER the last motion, never during it, so this wants
+	* "motion is still happening" — the SAME question `onNewEdge` does not
+	* answer, since a long continuous burst is mostly continuation ticks.
+	*/
+	onMotionEpisodeTick(input) {
+		this.sceneEngine?.noteMotion(input.deviceId, input.timestamp);
 	}
 	/**
 	* The gate in front of the motion still. Both motion handlers reach it, so
@@ -79910,7 +80768,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				deps: {
 					page: ({ deviceId, scope, afterMs, limit }) => mediaStore.pageByKindForDevice({
 						deviceId,
-						ownerKind: scope === "motion-still" ? "event" : "track",
+						ownerKind: scope === "motion-still" ? "motion" : "track",
 						kind: "snapshot",
 						afterMs,
 						limit
@@ -80060,7 +80918,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		for (const { event, score } of bestEventByTrackId.values()) {
 			const mediaUrl = resolveSearchThumbnailUrl({
 				baseUrl: this.eventMediaBaseUrl,
-				eventId: event.id,
+				eventId: String(event.id),
 				...event.trackId !== void 0 && embeddingMediaKeyByTrackId.has(event.trackId) ? { embeddingMediaKey: embeddingMediaKeyByTrackId.get(event.trackId) } : {}
 			});
 			const keyFrameMediaKey = event.trackId !== void 0 ? keyFrameKeyByTrackId.get(event.trackId) : void 0;
@@ -80659,12 +81517,16 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 				deviceId: file.deviceId
 			};
 		};
-		const eventFiles = await listInfo("event", id);
+		let eventFiles = [];
+		for (const ownerType of require_dist.EVENT_OWNER_TYPES) {
+			eventFiles = await listInfo(ownerType, id);
+			if (eventFiles.length > 0) break;
+		}
 		if (preferKind !== void 0 && preferKind.length > 0) {
 			const layers = await collectCropForcedMedia({
 				listByOwner: listInfo,
 				getTrackIdForEvent
-			}, id);
+			}, id, eventFiles);
 			const bodyKeys = new Set(layers.bodyFiles.map((f) => f.key));
 			return await readWinningBlob([...layers.bodyFiles, ...layers.detailFiles], (rows) => resolveCropForcedMedia(rows.filter((r) => bodyKeys.has(r.key)), (files) => pickCleanMedia(files, preferKind), rows.filter((r) => !bodyKeys.has(r.key))), readBlob);
 		}