@camstack/addon-post-analysis 1.2.90 → 1.2.92

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-BBIhkNDY.js");
+const require_dist = require("../dist-BfrtqGyh.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -7786,17 +7786,40 @@ function referencesAudioClass(classes) {
 	if (classes === void 0) return false;
 	return classes.some((c) => c.trim().toLowerCase().startsWith("audio-"));
 }
-function matchesSystemEvent(condition, subject) {
-	if (!condition.kinds.includes(subject.kind)) return false;
-	if (condition.deviceIds !== void 0 && (subject.deviceId === void 0 || !condition.deviceIds.includes(subject.deviceId))) return false;
-	if (condition.deviceTypes !== void 0 && (subject.deviceType === void 0 || !condition.deviceTypes.includes(subject.deviceType))) return false;
-	if (condition.nodeIds !== void 0) {
-		if (!subjectNodes(subject).some((id) => condition.nodeIds.includes(id))) return false;
+/**
+* Match one system subject against one rule's system-event condition.
+*
+* EVERY NARROWING FILTER IS SCOPED TO ITS KIND FAMILY, and the scoping is not
+* decided here: `systemEventFilterApplies` (in `@camstack/types`) is the one
+* statement of it, and both rule editors compute their filter visibility from
+* the same predicate. A filter outside a kind's family is IGNORED — never an
+* exclusion. It used to be an exclusion, and that made the operator's
+* eleven-kind rule with `deviceTypes: ['camera']` deliverable for exactly the
+* two kinds that carry a device type; the other nine failed closed and logged
+* nothing for four days.
+*
+* Inside its family a filter still narrows, and still fails CLOSED when the
+* subject cannot produce the identity it tests.
+*
+* Returns `undefined` on a match.
+*/
+function systemEventExclusion(condition, subject) {
+	if (!condition.kinds.includes(subject.kind)) return "kinds";
+	const applies = (filter) => require_dist.systemEventFilterApplies(subject.kind, filter);
+	if (condition.deviceIds !== void 0 && applies("deviceIds")) {
+		if (subject.deviceId === void 0 || !condition.deviceIds.includes(subject.deviceId)) return "deviceIds";
 	}
-	if (condition.packageNames !== void 0) {
-		if (!subjectPackages(subject).some((name) => condition.packageNames.includes(name))) return false;
+	if (condition.deviceTypes !== void 0 && applies("deviceTypes")) {
+		if (subject.deviceType === void 0 || !condition.deviceTypes.includes(subject.deviceType)) return "deviceTypes";
+	}
+	const wantedNodes = condition.nodeIds;
+	if (wantedNodes !== void 0 && applies("nodeIds")) {
+		if (!subjectNodes(subject).some((id) => wantedNodes.includes(id))) return "nodeIds";
+	}
+	const wantedPackages = condition.packageNames;
+	if (wantedPackages !== void 0 && applies("packageNames")) {
+		if (!subjectPackages(subject).some((name) => wantedPackages.includes(name))) return "packageNames";
 	}
-	return true;
 }
 function subjectNodes(subject) {
 	const ids = [...subject.nodeIds ?? []];
@@ -7812,7 +7835,14 @@ function evaluateRule(rule, subject, deviceState, zoneOwners, sceneStates) {
 	if (subject.kind === "system-event") {
 		if (rule.delivery !== "system-event") return fail("delivery");
 		const condition = rule.conditions.systemEvent;
-		if (condition === void 0 || subject.systemEvent === void 0 || !matchesSystemEvent(condition, subject.systemEvent)) return fail("systemEvent");
+		const systemEvent = subject.systemEvent;
+		if (condition === void 0 || systemEvent === void 0) return fail("systemEvent");
+		const excluded = systemEventExclusion(condition, systemEvent);
+		if (excluded !== void 0) return excluded === "kinds" ? fail("systemEvent") : {
+			matched: false,
+			failedCondition: "systemEvent",
+			excludedBySystemEventFilter: excluded
+		};
 		if (rule.conditions.occupancy !== void 0) return fail("occupancy");
 		if (rule.conditions.audio !== void 0) return fail("audio");
 	} else if (subject.kind === "occupancy-event") {
@@ -20060,6 +20090,39 @@ var NotificationCenter = class NotificationCenter {
 		if (identity.isCamera && identity.detectionActive === false) return "detection-off";
 	}
 	/**
+	* "Your rule covers this kind, and your own filter dropped it."
+	*
+	* INFO, not debug, and unconditional. The alternative is what shipped: a
+	* rule that selected eleven system-event kinds delivered two of them for
+	* four days, and the nine it silently refused produced no line anywhere —
+	* indistinguishable from an intake that had stopped emitting. The filter is
+	* NAMED, and so is the value that failed it, because the fix is always an
+	* edit to that one list.
+	*
+	* `tags.deviceId` carries the SUBJECT's numeric device id (the system
+	* subject's own `deviceId` is the sentinel {@link NC_SYSTEM_DEVICE_ID}), so
+	* "why is 617 louder than 2018?" is answerable by grouping. A node- or
+	* package-scoped exclusion is about no device and carries no tag.
+	*/
+	reportSystemFilterExclusion(rule, subject, filter) {
+		const system = subject.systemEvent;
+		if (system === void 0) return;
+		this.logger.info("system event excluded by a rule filter", {
+			...system.deviceId !== void 0 ? { tags: { deviceId: system.deviceId } } : {},
+			meta: {
+				ruleId: rule.id,
+				rule: rule.name,
+				kind: system.kind,
+				filter,
+				eventId: subject.recordId,
+				subject: system.subject,
+				...system.deviceType !== void 0 ? { deviceType: system.deviceType } : {},
+				...system.nodeId !== void 0 ? { nodeId: system.nodeId } : {},
+				...system.packageName !== void 0 ? { packageName: system.packageName } : {}
+			}
+		});
+	}
+	/**
 	* SAY that the scene gate suppressed this rule.
 	*
 	* A branch that drops work silently logs it — the three-hour media blackout
@@ -20479,6 +20542,7 @@ var NotificationCenter = class NotificationCenter {
 			const evaluation = evaluateRule(rule, subject, (id) => this.deviceStates.get(id), (id) => this.zoneOwners.get(id), (sceneId) => this.sceneStates.get(sceneId));
 			if (!evaluation.matched) {
 				if (evaluation.failedCondition === "scene") this.reportSceneSuppression(rule, subject);
+				if (evaluation.excludedBySystemEventFilter !== void 0) this.reportSystemFilterExclusion(rule, subject, evaluation.excludedBySystemEventFilter);
 				rejections.push(`${rule.name}:${evaluation.failedCondition ?? "unknown"}`);
 				outcomes.push({
 					ruleId: rule.id,
@@ -22379,7 +22443,7 @@ var ncActions = require_dist.defineCustomActions({
 	"nc.getArtifact": require_dist.customAction(require_dist.object({ artifactId: require_dist.string().min(1) }), require_dist.object({ artifact: NcArtifactRecordSchema.nullable() }), { caller: "required" })
 });
 /** Fail-closed caller resolution — an absent forwarded caller is NEVER admin. */
-function requireCaller(caller) {
+function requireCaller$1(caller) {
 	if (!caller || typeof caller.userId !== "string" || caller.userId.length === 0) throw new Error("forbidden: authenticated caller required");
 	return caller;
 }
@@ -22477,14 +22541,14 @@ function makeNcActionHandlers(deps) {
 	};
 	return {
 		"nc.listRules": async (_input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			return { rules: (c.isAdmin ? deps.ruleStore.list() : deps.ruleStore.listForOwner(c.userId)).map((r) => ({
 				...r,
 				readOnly: !c.isAdmin && r.ownerUserId !== c.userId
 			})) };
 		},
 		"nc.listTrackGroups": async (input, caller) => {
-			requireCaller(caller);
+			requireCaller$1(caller);
 			const list = deps.listTrackGroups;
 			if (list === void 0) return { groups: [] };
 			return { groups: [...await list(input)] };
@@ -22494,7 +22558,7 @@ function makeNcActionHandlers(deps) {
 			taxonomy: require_dist.NC_TAXONOMY
 		}),
 		"nc.createRule": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			const parsed = require_dist.NcRuleInputSchema.parse(input.rule);
 			await assertTargetsOwned(parsed.targets.map((t) => t.targetId), c);
 			const rule = await deps.ruleStore.create({
@@ -22508,7 +22572,7 @@ function makeNcActionHandlers(deps) {
 			return { rule };
 		},
 		"nc.updateRule": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			assertRuleEditable(input.ruleId, c);
 			const patch = require_dist.NcRulePatchSchema.parse(input.patch);
 			if (patch.targets !== void 0) await assertTargetsOwned(patch.targets.map((t) => t.targetId), c);
@@ -22521,7 +22585,7 @@ function makeNcActionHandlers(deps) {
 			return { rule };
 		},
 		"nc.deleteRule": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			assertRuleEditable(input.ruleId, c);
 			await deps.ruleStore.delete(input.ruleId);
 			deps.logger.info("nc rule deleted", { meta: {
@@ -22531,11 +22595,11 @@ function makeNcActionHandlers(deps) {
 			return { success: true };
 		},
 		"nc.listSnoozes": async (_input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			return { snoozes: [...deps.snooze.list(c.userId, c.isAdmin)] };
 		},
 		"nc.createSnooze": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			const parsed = require_dist.NcSnoozeInputSchema.parse(input.snooze);
 			if (parsed.ruleId !== void 0) assertRuleVisible(parsed.ruleId, c);
 			const snooze = await deps.snooze.create(parsed, c);
@@ -22548,12 +22612,12 @@ function makeNcActionHandlers(deps) {
 			return { snooze };
 		},
 		"nc.cancelSnooze": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			await deps.snooze.cancel(input.snoozeId, c);
 			return { success: true };
 		},
 		"nc.injectTestEvent": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			if (!c.isAdmin) throw new Error("forbidden: admin required to inject a test event");
 			const inject = deps.injectTestEvent;
 			if (inject === void 0) throw new Error("this node does not host the notification centre — inject on the hub");
@@ -22569,7 +22633,7 @@ function makeNcActionHandlers(deps) {
 			return inject(parsed);
 		},
 		"nc.testRule": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			if (!c.isAdmin) throw new Error("forbidden: admin required to test a rule");
 			const inject = deps.injectTestEvent;
 			if (inject === void 0) throw new Error("this node does not host the notification centre — test on the hub");
@@ -22601,7 +22665,7 @@ function makeNcActionHandlers(deps) {
 			};
 		},
 		"nc.getRuleStatus": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			const status = deps.ruleStatus;
 			if (status === void 0) throw new Error("this node does not host the notification centre — ask the hub");
 			const detection = deps.ruleStore.get(input.ruleId);
@@ -22617,7 +22681,7 @@ function makeNcActionHandlers(deps) {
 			throw new Error(`rule not found: ${input.ruleId}`);
 		},
 		"nc.listTimelapseRules": async (_input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			const tl = requireTimelapse();
 			return { rules: (c.isAdmin ? tl.store.list() : tl.store.listForOwner(c.userId)).map((r) => ({
 				...r,
@@ -22625,7 +22689,7 @@ function makeNcActionHandlers(deps) {
 			})) };
 		},
 		"nc.upsertTimelapseRule": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			const tl = requireTimelapse();
 			if (input.ruleId === void 0) {
 				if (input.rule === void 0) throw new Error("upsertTimelapseRule: rule or ruleId required");
@@ -22661,7 +22725,7 @@ function makeNcActionHandlers(deps) {
 			return { rule };
 		},
 		"nc.deleteTimelapseRule": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			const tl = requireTimelapse();
 			assertTimelapseEditable(input.ruleId, c, tl);
 			await tl.store.delete(input.ruleId);
@@ -22672,7 +22736,7 @@ function makeNcActionHandlers(deps) {
 			return { success: true };
 		},
 		"nc.testTimelapseRule": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			if (!c.isAdmin) throw new Error("forbidden: admin required to produce a test timelapse");
 			const tl = requireTimelapse();
 			deps.logger.info("timelapse test requested", {
@@ -22699,14 +22763,14 @@ function makeNcActionHandlers(deps) {
 			};
 		},
 		"nc.setRuleTargetEnabled": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			assertRuleVisible(input.ruleId, c);
 			await assertTargetsOwned([input.targetId], c);
 			await deps.ruleStore.setRuleTargetEnabled(input.ruleId, input.targetId, input.enabled);
 			return { success: true };
 		},
 		"nc.listSummaryRules": async (_input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			const sum = requireSummary();
 			return { rules: (c.isAdmin ? sum.store.list() : sum.store.listForOwner(c.userId)).map((r) => ({
 				...r,
@@ -22714,7 +22778,7 @@ function makeNcActionHandlers(deps) {
 			})) };
 		},
 		"nc.upsertSummaryRule": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			if (!c.isAdmin) throw new Error("forbidden: admin required to author a summary rule");
 			const sum = requireSummary();
 			if (input.ruleId === void 0) {
@@ -22747,7 +22811,7 @@ function makeNcActionHandlers(deps) {
 			return { rule };
 		},
 		"nc.deleteSummaryRule": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			if (!c.isAdmin) throw new Error("forbidden: admin required to delete a summary rule");
 			await requireSummary().store.delete(input.ruleId);
 			deps.logger.info("summary rule deleted", { meta: {
@@ -22757,7 +22821,7 @@ function makeNcActionHandlers(deps) {
 			return { success: true };
 		},
 		"nc.testSummaryRule": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			if (!c.isAdmin) throw new Error("forbidden: admin required to produce a test summary");
 			const sum = requireSummary();
 			const startMs = input.windowStartMs;
@@ -22804,7 +22868,7 @@ function makeNcActionHandlers(deps) {
 		"nc.setLanguage": async (input) => requireTexts().setLanguage(input.language),
 		"nc.setTextOverrides": async (input) => requireTexts().setOverrides(input.language, input.overrides),
 		"nc.listArtifacts": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			const page = await requireArtifacts().list(input, {
 				userId: c.userId,
 				isAdmin: c.isAdmin
@@ -22816,7 +22880,7 @@ function makeNcActionHandlers(deps) {
 			};
 		},
 		"nc.getArtifact": async (input, caller) => {
-			const c = requireCaller(caller);
+			const c = requireCaller$1(caller);
 			return { artifact: await requireArtifacts().get(input.artifactId, {
 				userId: c.userId,
 				isAdmin: c.isAdmin
@@ -24465,11 +24529,11 @@ var WipeResultSchema = require_dist.object({ deleted: require_dist.number() });
 * and can never be called: the bridge insists on `{}` and the schema rejects
 * it. Verified on the live hub, both directions.
 */
-var NoInputSchema = require_dist.object({});
+var NoInputSchema$1 = require_dist.object({});
 var embeddingActions = require_dist.defineCustomActions({
 	"embedding.rebuild": require_dist.customAction(RebuildInputSchema, RebuildStartedSchema, { auth: "admin" }),
-	"embedding.rebuildStatus": require_dist.customAction(NoInputSchema, RebuildStatusSchema),
-	"embedding.wipe": require_dist.customAction(NoInputSchema, WipeResultSchema, { auth: "admin" })
+	"embedding.rebuildStatus": require_dist.customAction(NoInputSchema$1, RebuildStatusSchema),
+	"embedding.wipe": require_dist.customAction(NoInputSchema$1, WipeResultSchema, { auth: "admin" })
 });
 //#endregion
 //#region src/pipeline-analytics/map-with-concurrency.ts
@@ -28792,88 +28856,6 @@ var PlateGalleryProvider = class {
 	}
 };
 //#endregion
-//#region src/pipeline-analytics/retention/orphan-audit-actions.ts
-/**
-* The operator button for the orphan audit.
-*
-* The audit engine, its five bounds and its resumable cursor already existed
-* and had run in `report` mode for weeks; what it had no way to be was
-* *asked*. Its only trigger was a 6-hourly timer reading a durable setting, so
-* draining a standing backlog meant flipping a persistent mode, waiting up to
-* six hours, and remembering to flip it back — with nothing returned to look
-* at. On 2026-08-14 the backlog was 74,700 media rows / 18.9 GB plus 23,296
-* object events and 4,543 CLIP vectors (D161), and that is not a thing to
-* drain by leaving a switch on.
-*
-* Three properties this action does NOT leave to the caller's care:
-*
-*  1. **Dry run is the default.** `mode` omitted means `report`: it counts,
-*     logs and returns, and deletes nothing — regardless of what the durable
-*     `orphanAuditMode` setting says. `reclaim` is a word that has to be
-*     typed. The engine's own default is the same for the same reason.
-*  2. **It is paced.** `pageSize` bounds one read, `maxRowsPerScope` bounds
-*     one pass, `maxReclaimPerScope` bounds the damage, and the engine yields
-*     the thread between pages — `better-sqlite3` is synchronous and shares
-*     hub-main with every live frame.
-*  3. **It answers.** The report comes back per collection with rows AND
-*     bytes, so "did it do anything" is not a question anyone has to infer
-*     from a log line.
-*/
-/**
-* `report` counts; `reclaim` deletes.
-*
-* `.default('report')` is load-bearing, not decoration: the settings form
-* sends `{}` for a button with no fields, and the safe interpretation of an
-* unstated intent here is the one that destroys nothing.
-*/
-var OrphanAuditActionModeSchema = require_dist._enum(["report", "reclaim"]).default("report");
-var OrphanAuditActionInputSchema = require_dist.object({
-	mode: OrphanAuditActionModeSchema,
-	/**
-	* Start every scope from the top instead of resuming its persisted cursor.
-	*
-	* What draining a backlog wants, and never the default — the cursor exists
-	* so a 6-hourly pass makes progress instead of re-walking the same head.
-	*/
-	restart: require_dist.boolean().optional(),
-	/** Rows read per statement. Smaller = more yields = a gentler pass. */
-	pageSize: require_dist.number().int().min(50).max(5e3).optional(),
-	/** Rows EXAMINED per collection in this pass — the pacing bound. */
-	maxRowsPerScope: require_dist.number().int().min(1).max(2e5).optional(),
-	/** Rows DELETED per collection in this pass — the blast-radius bound. */
-	maxReclaimPerScope: require_dist.number().int().min(1).max(1e5).optional(),
-	/**
-	* Minutes of immunity for a recent row. Protective ONLY — raising it can
-	* exclusively save rows, never select them, which is what keeps this off
-	* the one-age-keyed-sweep guard's books.
-	*/
-	graceMinutes: require_dist.number().int().min(1).max(10080).optional()
-});
-var OrphanAuditScopeReportSchema = require_dist.object({
-	collection: require_dist.string(),
-	examined: require_dist.number(),
-	orphans: require_dist.number(),
-	reclaimed: require_dist.number(),
-	bytesReclaimed: require_dist.number(),
-	exempt: require_dist.number(),
-	withinGrace: require_dist.number(),
-	unresolvable: require_dist.number(),
-	stoppedBy: require_dist.string(),
-	/** Where the NEXT pass resumes. `0` = the scope was walked to the end. */
-	nextCursor: require_dist.number()
-});
-var OrphanAuditActionResultSchema = require_dist.object({
-	/** `false` when a pass was already in flight — nothing was done. */
-	ran: require_dist.boolean(),
-	mode: require_dist._enum(["report", "reclaim"]),
-	scopes: require_dist.array(OrphanAuditScopeReportSchema),
-	totalOrphans: require_dist.number(),
-	totalReclaimed: require_dist.number(),
-	totalBytesReclaimed: require_dist.number(),
-	durationMs: require_dist.number()
-});
-var orphanAuditActions = require_dist.defineCustomActions({ "retention.orphanAudit": require_dist.customAction(OrphanAuditActionInputSchema, OrphanAuditActionResultSchema, { auth: "admin" }) });
-//#endregion
 //#region src/pipeline-analytics/store/storage-pressure.ts
 /**
 * storage-pressure — make a full disk something the system REACTS to, not just
@@ -29040,6 +29022,11 @@ var FACE_MEDIA_OWNER_PREFIX = "face-";
 *  `plate-<trackId>`. Used by `deleteByTracks` to derive the plate crop owners
 *  of a set of tracks without a `trackId` column on media rows. */
 var PLATE_MEDIA_OWNER_PREFIX = "plate-";
+/** Index rows per page inside one presence chunk. Must stay under
+*  `SETTINGS_QUERY_DEFAULT_ROW_CAP` (2 000) so the engine's backstop can never
+*  silently truncate a page — an owner reported absent because a cap bit would
+*  DELETE a live thumbnail from the surface. */
+var MEDIA_PRESENCE_PAGE_SIZE = 1e3;
 /**
 * Kinds that hold exactly ONE row per `(ownerKind, ownerId)` — the current
 * "best"/rolling/first artefact, never a filmstrip. Their row id + blob path are
@@ -29467,6 +29454,59 @@ var MediaStore = class {
 		});
 	}
 	/**
+	* Which of `ownerIds` hold at least ONE media row — index only, no blob is
+	* opened, no base64 is allocated.
+	*
+	* This is the licence `videoclips` needs to publish a `thumbnail`. The
+	* event-media URL is stamped from a template for every event in the system,
+	* so "the plane is up" was being served as "there are bytes": 64 of one
+	* camera's 179 clips pointed at a 404 on 2026-08-17.
+	*
+	* Batched by `whereIn` and paged by offset. NOT `listInfoByOwner` in a loop:
+	* that is one query per owner, which is the N+1 this exists to prevent (and
+	* `queryObjectByTrackIds` already records what believing `whereIn` was
+	* unavailable cost the search path).
+	*
+	* `deviceId` is the AUTHORIZATION filter, exactly as in `listByOwner`.
+	*
+	* THROWS on a query failure rather than answering partially — a probe that
+	* quietly under-reports reads as "these owners have nothing", and the caller
+	* drops thumbnails that exist.
+	*/
+	async ownersWithMedia(ownerKind, ownerIds, deviceId) {
+		const found = /* @__PURE__ */ new Set();
+		const unique = [...new Set(ownerIds)];
+		for (let i = 0; i < unique.length; i += 200) {
+			const chunk = unique.slice(i, i + 200);
+			const answered = /* @__PURE__ */ new Set();
+			for (let offset = 0;; offset += MEDIA_PRESENCE_PAGE_SIZE) {
+				const rows = await this.store.query.query({
+					collection: MEDIA_COLLECTION,
+					filter: {
+						where: {
+							ownerKind,
+							deviceId
+						},
+						whereIn: { ownerId: chunk },
+						orderBy: {
+							field: "ownerId",
+							direction: "asc"
+						},
+						limit: MEDIA_PRESENCE_PAGE_SIZE,
+						offset
+					}
+				});
+				for (const row of rows) {
+					const ownerId = row.data["ownerId"];
+					if (typeof ownerId === "string") answered.add(ownerId);
+				}
+				if (rows.length < 1e3 || answered.size >= chunk.length) break;
+			}
+			for (const ownerId of answered) found.add(ownerId);
+		}
+		return found;
+	}
+	/**
 	* Delete all media (blobs + index rows) for the given owners of one kind.
 	* Best-effort per row; returns the number of index rows removed.
 	*/
@@ -29814,6 +29854,88 @@ async function reconcileDeviceFromDisk(deps, deviceId) {
 	};
 }
 //#endregion
+//#region src/pipeline-analytics/retention/orphan-audit-actions.ts
+/**
+* The operator button for the orphan audit.
+*
+* The audit engine, its five bounds and its resumable cursor already existed
+* and had run in `report` mode for weeks; what it had no way to be was
+* *asked*. Its only trigger was a 6-hourly timer reading a durable setting, so
+* draining a standing backlog meant flipping a persistent mode, waiting up to
+* six hours, and remembering to flip it back — with nothing returned to look
+* at. On 2026-08-14 the backlog was 74,700 media rows / 18.9 GB plus 23,296
+* object events and 4,543 CLIP vectors (D161), and that is not a thing to
+* drain by leaving a switch on.
+*
+* Three properties this action does NOT leave to the caller's care:
+*
+*  1. **Dry run is the default.** `mode` omitted means `report`: it counts,
+*     logs and returns, and deletes nothing — regardless of what the durable
+*     `orphanAuditMode` setting says. `reclaim` is a word that has to be
+*     typed. The engine's own default is the same for the same reason.
+*  2. **It is paced.** `pageSize` bounds one read, `maxRowsPerScope` bounds
+*     one pass, `maxReclaimPerScope` bounds the damage, and the engine yields
+*     the thread between pages — `better-sqlite3` is synchronous and shares
+*     hub-main with every live frame.
+*  3. **It answers.** The report comes back per collection with rows AND
+*     bytes, so "did it do anything" is not a question anyone has to infer
+*     from a log line.
+*/
+/**
+* `report` counts; `reclaim` deletes.
+*
+* `.default('report')` is load-bearing, not decoration: the settings form
+* sends `{}` for a button with no fields, and the safe interpretation of an
+* unstated intent here is the one that destroys nothing.
+*/
+var OrphanAuditActionModeSchema = require_dist._enum(["report", "reclaim"]).default("report");
+var OrphanAuditActionInputSchema = require_dist.object({
+	mode: OrphanAuditActionModeSchema,
+	/**
+	* Start every scope from the top instead of resuming its persisted cursor.
+	*
+	* What draining a backlog wants, and never the default — the cursor exists
+	* so a 6-hourly pass makes progress instead of re-walking the same head.
+	*/
+	restart: require_dist.boolean().optional(),
+	/** Rows read per statement. Smaller = more yields = a gentler pass. */
+	pageSize: require_dist.number().int().min(50).max(5e3).optional(),
+	/** Rows EXAMINED per collection in this pass — the pacing bound. */
+	maxRowsPerScope: require_dist.number().int().min(1).max(2e5).optional(),
+	/** Rows DELETED per collection in this pass — the blast-radius bound. */
+	maxReclaimPerScope: require_dist.number().int().min(1).max(1e5).optional(),
+	/**
+	* Minutes of immunity for a recent row. Protective ONLY — raising it can
+	* exclusively save rows, never select them, which is what keeps this off
+	* the one-age-keyed-sweep guard's books.
+	*/
+	graceMinutes: require_dist.number().int().min(1).max(10080).optional()
+});
+var OrphanAuditScopeReportSchema = require_dist.object({
+	collection: require_dist.string(),
+	examined: require_dist.number(),
+	orphans: require_dist.number(),
+	reclaimed: require_dist.number(),
+	bytesReclaimed: require_dist.number(),
+	exempt: require_dist.number(),
+	withinGrace: require_dist.number(),
+	unresolvable: require_dist.number(),
+	stoppedBy: require_dist.string(),
+	/** Where the NEXT pass resumes. `0` = the scope was walked to the end. */
+	nextCursor: require_dist.number()
+});
+var OrphanAuditActionResultSchema = require_dist.object({
+	/** `false` when a pass was already in flight — nothing was done. */
+	ran: require_dist.boolean(),
+	mode: require_dist._enum(["report", "reclaim"]),
+	scopes: require_dist.array(OrphanAuditScopeReportSchema),
+	totalOrphans: require_dist.number(),
+	totalReclaimed: require_dist.number(),
+	totalBytesReclaimed: require_dist.number(),
+	durationMs: require_dist.number()
+});
+var orphanAuditActions = require_dist.defineCustomActions({ "retention.orphanAudit": require_dist.customAction(OrphanAuditActionInputSchema, OrphanAuditActionResultSchema, { auth: "admin" }) });
+//#endregion
 //#region src/pipeline-analytics/videoclip-visits.ts
 /**
 * Videoclip visits — the grain a clip should have on an events-mode camera.
@@ -29880,7 +30002,22 @@ function dominantKind(attached) {
 	for (const kind of KIND_ORDER) if (attached.some((a) => a.kind === kind)) return kind;
 	return "motion";
 }
-function visitsToClips(visits, events, pad) {
+/**
+* The instant a recorded still can actually be decoded inside a visit: the
+* midpoint of its LONGEST contiguous range.
+*
+* NOT the midpoint of the visit. A visit spans its holes by construction (it is
+* ranges glued across gaps up to `VISIT_MERGE_GAP_MS`), so the naive midpoint
+* lands in dead air roughly as often as not and the recorder's still route
+* answers 204 for a visit with plenty of footage.
+*/
+function stillInstantMs(ranges) {
+	let best;
+	for (const range of ranges) if (best === void 0 || range.endMs - range.startMs > best.endMs - best.startMs) best = range;
+	if (best === void 0) return void 0;
+	return Math.floor((best.startMs + best.endMs) / 2);
+}
+function visitsToClips(visits, events, pad, vouched) {
 	const tagged = [
 		...events.object.map((event) => ({
 			kind: "object",
@@ -29898,7 +30035,8 @@ function visitsToClips(visits, events, pad) {
 	return visits.map((visit) => {
 		const attached = tagged.filter((t) => eventOverlapsVisit(t.event, visit, pad));
 		const kind = dominantKind(attached);
-		const withThumb = attached.find((a) => a.kind === kind && a.event.mediaUrl) ?? attached.find((a) => a.event.mediaUrl);
+		const withThumb = attached.find((a) => a.kind === kind && a.event.mediaUrl && vouched.has(a.event.id)) ?? attached.find((a) => a.event.mediaUrl && vouched.has(a.event.id));
+		const stillAtMs = stillInstantMs(visit.ranges);
 		return {
 			id: `analytics:${visit.startMs}:${visit.endMs}:${VISIT_EVENT_ID}`,
 			source: "analytics",
@@ -29907,8 +30045,10 @@ function visitsToClips(visits, events, pad) {
 				startMs: visit.startMs,
 				endMs: visit.endMs
 			},
-			thumbnail: withThumb?.event.mediaUrl,
-			eventIds: attached.map((a) => a.event.id),
+			...withThumb?.event.mediaUrl !== void 0 ? { thumbnail: withThumb.event.mediaUrl } : {},
+			...stillAtMs !== void 0 ? { stillAtMs } : {},
+			eventIds: attached.slice(0, 24).map((a) => a.event.id),
+			eventCount: attached.length,
 			holes: [...visit.holes]
 		};
 	}).toSorted((a, b) => b.timeRange.startMs - a.timeRange.startMs);
@@ -29932,6 +30072,17 @@ function visitsToClips(visits, events, pad) {
 * injected fetch/resolve deps so the compose logic is testable without I/O.
 */
 var SOURCE = "analytics";
+/**
+* Backstop on the ANNOTATION read — never on the clip list.
+*
+* A visit is annotated by every event inside it, so the clip `limit` must not
+* reach this fetch (one 615 visit legitimately spans 2 345 motion rows). This
+* bound exists only so a pathological camera-day cannot pull an unbounded page:
+* the store orders `timestamp DESC`, so a truncation drops the OLDEST rows and
+* the EARLIEST visits silently lose their annotations — which is why hitting it
+* is logged, per camera, rather than absorbed.
+*/
+var VISIT_EVENT_FETCH_LIMIT = 5e3;
 function clipIdFor(eventId, startMs, endMs) {
 	return `${SOURCE}:${startMs}:${endMs}:${eventId}`;
 }
@@ -29952,7 +30103,7 @@ function parseClipId(clipId) {
 	};
 }
 /** Map per-kind events into time-ranged clips, newest-first. Pure. */
-function eventsToClips(events, pad) {
+function eventsToClips(events, pad, vouched) {
 	const make = (e, kind) => {
 		const startMs = e.timestamp - pad.preMs;
 		const endMs = e.timestamp + pad.postMs;
@@ -29964,7 +30115,7 @@ function eventsToClips(events, pad) {
 				startMs,
 				endMs
 			},
-			thumbnail: e.mediaUrl
+			...e.mediaUrl !== void 0 && vouched.has(e.id) ? { thumbnail: e.mediaUrl } : {}
 		};
 	};
 	return [
@@ -29973,29 +30124,106 @@ function eventsToClips(events, pad) {
 		...events.audio.map((e) => make(e, "audio"))
 	].toSorted((a, b) => b.timeRange.startMs - a.timeRange.startMs);
 }
+/** Every id in the three buckets, in the order the composers tag them. */
+function allEventIds(events) {
+	return [
+		...events.motion,
+		...events.object,
+		...events.audio
+	].map((e) => e.id);
+}
+/**
+* Resolve the event ids whose `mediaUrl` is backed by real bytes, mirroring
+* `resolveDefaultEventMedia`: the event's OWN media when it has any, else its
+* owning TRACK's. 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.
+*
+* 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 residualTracks = [];
+	const seenTracks = /* @__PURE__ */ new Set();
+	for (const event of events.object) {
+		const trackId = event.trackId;
+		if (trackId === void 0 || ownMedia.has(event.id) || seenTracks.has(trackId)) continue;
+		seenTracks.add(trackId);
+		residualTracks.push(trackId);
+	}
+	const trackMedia = residualTracks.length === 0 ? /* @__PURE__ */ new Set() : await fetchMediaOwners({
+		deviceId,
+		ownerKind: "track",
+		ownerIds: residualTracks
+	});
+	const vouched = new Set(ownMedia);
+	for (const event of events.object) {
+		const trackId = event.trackId;
+		if (trackId !== void 0 && trackMedia.has(trackId)) vouched.add(event.id);
+	}
+	return vouched;
+}
+/** Keep only clips that actually touch the caller's window. The reads are
+*  widened by {@link leftOverhangMs}; the ANSWER is not. */
+function intersectsWindow(clip, since, until) {
+	return clip.timeRange.startMs < until && clip.timeRange.endMs > since;
+}
+/**
+* How far BEFORE `since` the event + availability reads must reach.
+*
+* A visit straddling `since` keeps its heartbeat rows and loses the transition
+* row — the only one that ever carries a snapshot — so the same visit shows a
+* picture or doesn't depending on where the operator scrolled. One wider range
+* scan on an indexed column buys a list that stops changing under the cursor.
+*/
+function leftOverhangMs(pad) {
+	return require_dist.VISIT_MERGE_GAP_MS + pad.preMs;
+}
 function createVideoclipsProvider(deps) {
 	return {
 		listClips: async ({ deviceId, since, until, limit }) => {
+			const readSince = since - leftOverhangMs(deps.defaultPad);
 			const events = await deps.fetchEvents({
 				deviceId,
-				since,
+				since: readSince,
 				until,
-				...deps.fetchAvailability ? {} : { limit }
+				limit: deps.fetchAvailability ? VISIT_EVENT_FETCH_LIMIT : limit
 			});
-			let clips = eventsToClips(events, deps.defaultPad);
+			warnOnTruncatedFetch(deps, deviceId, events);
+			let vouched = /* @__PURE__ */ new Set();
+			try {
+				vouched = await resolveVouchedEvents(deviceId, events, deps.fetchMediaOwners);
+			} catch (err) {
+				deps.logWarn?.("videoclips: media presence read failed — listing without thumbnails", {
+					deviceId,
+					events: allEventIds(events).length,
+					error: err instanceof Error ? err.message : String(err)
+				});
+			}
+			let clips = eventsToClips(events, deps.defaultPad, vouched);
 			if (deps.fetchAvailability) try {
 				clips = visitsToClips(clusterFootageVisits(await deps.fetchAvailability({
 					deviceId,
-					since,
+					since: readSince,
 					until
-				}), require_dist.VISIT_MERGE_GAP_MS), events, deps.defaultPad);
+				}), require_dist.VISIT_MERGE_GAP_MS), events, deps.defaultPad, vouched);
 			} catch (err) {
 				deps.logWarn?.("videoclips: availability read failed — listing unfiltered", {
 					deviceId,
 					error: err instanceof Error ? err.message : String(err)
 				});
 			}
-			return limit != null ? clips.slice(0, limit) : clips;
+			const inWindow = clips.filter((c) => intersectsWindow(c, since, until));
+			const answer = limit != null ? inWindow.slice(0, limit) : inWindow;
+			reportUnvouchedClips(deps, deviceId, answer);
+			return answer;
 		},
 		getClipPlayback: async ({ deviceId, clipId }) => {
 			const parsed = parseClipId(clipId);
@@ -30008,6 +30236,247 @@ function createVideoclipsProvider(deps) {
 		}
 	};
 }
+/** The annotation backstop biting is a SILENT loss of the earliest visits'
+*  events — say so, per camera, instead of shipping a thinner list. */
+function warnOnTruncatedFetch(deps, deviceId, events) {
+	if (!deps.fetchAvailability) return;
+	const truncated = [
+		"motion",
+		"object",
+		"audio"
+	].filter((kind) => events[kind].length >= VISIT_EVENT_FETCH_LIMIT);
+	if (truncated.length === 0) return;
+	deps.logWarn?.("videoclips: annotation fetch truncated — earliest visits lose their events", {
+		deviceId,
+		kinds: truncated,
+		limit: VISIT_EVENT_FETCH_LIMIT
+	});
+}
+/** The operator's acceptance criterion as a number: a rising count on one
+*  camera is its motion-snapshot capturer failing, not a quiet day. */
+function reportUnvouchedClips(deps, deviceId, clips) {
+	const clipsWithoutStill = clips.filter((c) => c.thumbnail === void 0).length;
+	if (clipsWithoutStill === 0) return;
+	deps.logInfo?.("videoclips: visit has no vouched still", {
+		deviceId,
+		clipsWithoutStill,
+		clips: clips.length
+	});
+}
+//#endregion
+//#region src/pipeline-analytics/viewer-settings-actions.ts
+/**
+* Viewer settings snapshots — hub-shared named blobs of the viewer's stores.
+*
+* Rides `addons.custom` (`viewerSettings.*`) so it ships with an addon deploy
+* and does not wait on a cap/codegen/server image. Ownership is the
+* authenticated caller (`caller: 'required'`); snapshots are visible to every
+* hub user, overwrite/delete only of one's own.
+*/
+/**
+* @durable class=config owner=pipeline-analytics
+*   write="a signed-in viewer user saves a named snapshot of their local stores"
+*   retention="none — a row goes only when its owner deletes it"
+*/
+var VIEWER_SETTINGS_SNAPSHOTS_COLLECTION = "viewer-settings-snapshots";
+var COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true,
+		notNull: true
+	},
+	{
+		name: "name",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "ownerUserId",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "ownerUsername",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "createdAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "updatedAt",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "blob",
+		type: "JSON",
+		notNull: true
+	}
+];
+var NameSchema = require_dist.string().trim().min(1).max(80);
+var BlobSchema = require_dist.record(require_dist.string(), require_dist.unknown());
+var ViewerSettingsSnapshotSummarySchema = require_dist.object({
+	id: require_dist.string(),
+	name: require_dist.string(),
+	ownerUserId: require_dist.string(),
+	ownerUsername: require_dist.string(),
+	createdAt: require_dist.number().int(),
+	updatedAt: require_dist.number().int(),
+	mine: require_dist.boolean()
+});
+var ViewerSettingsSnapshotSchema = ViewerSettingsSnapshotSummarySchema.extend({ blob: BlobSchema });
+var NoInputSchema = require_dist.object({});
+var viewerSettingsActions = require_dist.defineCustomActions({
+	"viewerSettings.list": require_dist.customAction(NoInputSchema, require_dist.object({ snapshots: require_dist.array(ViewerSettingsSnapshotSummarySchema) }), { caller: "required" }),
+	"viewerSettings.save": require_dist.customAction(require_dist.object({
+		name: NameSchema,
+		blob: BlobSchema,
+		ownerUsername: require_dist.string().min(1).max(80)
+	}), require_dist.object({ snapshot: ViewerSettingsSnapshotSummarySchema }), {
+		kind: "mutation",
+		caller: "required"
+	}),
+	"viewerSettings.get": require_dist.customAction(require_dist.object({ id: require_dist.string().min(1) }), require_dist.object({ snapshot: ViewerSettingsSnapshotSchema.nullable() }), { caller: "required" }),
+	"viewerSettings.delete": require_dist.customAction(require_dist.object({ id: require_dist.string().min(1) }), require_dist.object({ success: require_dist.literal(true) }), {
+		kind: "mutation",
+		caller: "required"
+	})
+});
+function requireCaller(caller) {
+	if (!caller) throw new Error("viewerSettings: authenticated caller required");
+	return caller;
+}
+function asRecord(data) {
+	return typeof data === "object" && data !== null ? data : {};
+}
+function toSummary(id, data, callerUserId) {
+	const parsed = ViewerSettingsSnapshotSummarySchema.omit({ mine: true }).safeParse({
+		id,
+		name: data.name,
+		ownerUserId: data.ownerUserId,
+		ownerUsername: data.ownerUsername,
+		createdAt: data.createdAt,
+		updatedAt: data.updatedAt
+	});
+	if (!parsed.success) return null;
+	return {
+		...parsed.data,
+		mine: parsed.data.ownerUserId === callerUserId
+	};
+}
+var ViewerSettingsSnapshotStore = class {
+	store;
+	constructor(store) {
+		this.store = store;
+	}
+	static async declare(store) {
+		await store.declareCollection.mutate({
+			collection: VIEWER_SETTINGS_SNAPSHOTS_COLLECTION,
+			columns: [...COLUMNS],
+			indexes: [{
+				name: "idx_viewer_settings_owner",
+				columns: ["ownerUserId"]
+			}]
+		});
+	}
+	async list(caller) {
+		const rows = await this.store.query.query({
+			collection: VIEWER_SETTINGS_SNAPSHOTS_COLLECTION,
+			filter: {
+				orderBy: {
+					field: "updatedAt",
+					direction: "desc"
+				},
+				limit: 200
+			}
+		});
+		const out = [];
+		for (const row of rows) {
+			const summary = toSummary(row.id, asRecord(row.data), caller.userId);
+			if (summary) out.push(summary);
+		}
+		return out;
+	}
+	async get(id, caller) {
+		const row = (await this.store.query.query({
+			collection: VIEWER_SETTINGS_SNAPSHOTS_COLLECTION,
+			filter: {
+				where: { id },
+				limit: 1
+			}
+		}))[0];
+		if (!row) return null;
+		const data = asRecord(row.data);
+		const summary = toSummary(row.id, data, caller.userId);
+		if (!summary) return null;
+		const blob = BlobSchema.safeParse(data.blob);
+		if (!blob.success) return null;
+		return {
+			...summary,
+			blob: blob.data
+		};
+	}
+	async save(input, caller) {
+		const now = Date.now();
+		const prior = (await this.store.query.query({
+			collection: VIEWER_SETTINGS_SNAPSHOTS_COLLECTION,
+			filter: {
+				where: {
+					ownerUserId: caller.userId,
+					name: input.name
+				},
+				limit: 1
+			}
+		}))[0];
+		const id = prior?.id ?? (0, node_crypto.randomUUID)();
+		const createdAt = typeof asRecord(prior?.data).createdAt === "number" ? asRecord(prior?.data).createdAt : now;
+		await this.store.set.mutate({
+			collection: VIEWER_SETTINGS_SNAPSHOTS_COLLECTION,
+			key: id,
+			value: {
+				name: input.name,
+				ownerUserId: caller.userId,
+				ownerUsername: input.ownerUsername,
+				createdAt,
+				updatedAt: now,
+				blob: input.blob
+			}
+		});
+		return {
+			id,
+			name: input.name,
+			ownerUserId: caller.userId,
+			ownerUsername: input.ownerUsername,
+			createdAt,
+			updatedAt: now,
+			mine: true
+		};
+	}
+	async delete(id, caller) {
+		const row = await this.get(id, caller);
+		if (!row) throw new Error("viewerSettings: snapshot not found");
+		if (row.ownerUserId !== caller.userId && !caller.isAdmin) throw new Error("viewerSettings: only the owner can delete this snapshot");
+		await this.store.delete.mutate({
+			collection: VIEWER_SETTINGS_SNAPSHOTS_COLLECTION,
+			key: id
+		});
+	}
+};
+function makeViewerSettingsActionHandlers(store) {
+	return {
+		"viewerSettings.list": async (_input, caller) => ({ snapshots: await store.list(requireCaller(caller)) }),
+		"viewerSettings.save": async (input, caller) => ({ snapshot: await store.save(input, requireCaller(caller)) }),
+		"viewerSettings.get": async (input, caller) => ({ snapshot: await store.get(input.id, requireCaller(caller)) }),
+		"viewerSettings.delete": async (input, caller) => {
+			await store.delete(input.id, requireCaller(caller));
+			return { success: true };
+		}
+	};
+}
 /**
 * The VIDEO's playback rate — 4×, the same as {@link NC_GIF_SPEED}.
 *
@@ -30814,7 +31283,15 @@ var AudioDetectionSettingsSchema = require_dist.object({
 	/** Flood ceiling: markers per camera per rolling 24 h. This, not the
 	*  thresholds, is what bounds the worst case — a mis-tuned threshold can
 	*  only ever cost the operator this many markers a day. */
-	audioMarkerMaxPerDay: require_dist.number().int().positive().default(12)
+	audioMarkerMaxPerDay: require_dist.number().int().positive().default(12),
+	/** Materialize one event + one synthetic track per classified episode. */
+	audioEpisodeEnabled: require_dist.boolean().default(true),
+	/** Class must be heard continuously this long before the episode opens. */
+	audioEpisodeOpenHoldSec: require_dist.number().nonnegative().default(1.5),
+	/** Class must be absent this long before the episode closes. */
+	audioEpisodeCloseGapSec: require_dist.number().positive().default(12),
+	/** After close, the same class cannot reopen until this elapses. */
+	audioEpisodeCooldownSec: require_dist.number().nonnegative().default(30)
 });
 var AUDIO_DETECTION_DEFAULTS = AudioDetectionSettingsSchema.parse({});
 /**
@@ -30838,6 +31315,159 @@ function resolveAudioDetectionSettings(raw) {
 	return resolved.success ? resolved.data : AUDIO_DETECTION_DEFAULTS;
 }
 //#endregion
+//#region src/pipeline-analytics/audio-episode-hysteresis.ts
+var EMPTY = {
+	pendingClass: null,
+	pendingSinceMs: 0,
+	openClass: null,
+	episodeId: null,
+	lastHeardMs: 0,
+	lastClosedClass: null,
+	lastClosedMs: 0
+};
+function emptyAudioEpisodeState() {
+	return EMPTY;
+}
+function episodeIdFor(className, timestampMs) {
+	return `${className}:${timestampMs}`;
+}
+function inCooldown(state, className, timestampMs, knobs) {
+	return state.lastClosedClass === className && timestampMs - state.lastClosedMs < knobs.cooldownMs;
+}
+function closedState(className, atMs) {
+	return {
+		...EMPTY,
+		lastClosedClass: className,
+		lastClosedMs: atMs
+	};
+}
+function observeAudioEpisode(state, sample, knobs) {
+	if (!knobs.enabled) return {
+		nextState: EMPTY,
+		action: { kind: "none" }
+	};
+	const { timestampMs, className } = sample;
+	const openClass = state.openClass;
+	const openId = state.episodeId;
+	if (openClass !== null && openId !== null) {
+		if (className === openClass) return {
+			nextState: {
+				...state,
+				pendingClass: null,
+				pendingSinceMs: 0,
+				lastHeardMs: timestampMs
+			},
+			action: {
+				kind: "hold",
+				className: openClass,
+				episodeId: openId
+			}
+		};
+		if (className === null) {
+			if (timestampMs - state.lastHeardMs < knobs.closeGapMs) return {
+				nextState: state,
+				action: { kind: "none" }
+			};
+			return {
+				nextState: closedState(openClass, timestampMs),
+				action: {
+					kind: "close",
+					className: openClass,
+					episodeId: openId
+				}
+			};
+		}
+		if (inCooldown(state, className, timestampMs, knobs)) return {
+			nextState: state,
+			action: { kind: "none" }
+		};
+		const pendingSince = state.pendingClass === className ? state.pendingSinceMs : timestampMs;
+		if (knobs.openHoldMs === 0 || state.pendingClass === className && timestampMs - pendingSince >= knobs.openHoldMs) {
+			const openedId = episodeIdFor(className, timestampMs);
+			return {
+				nextState: {
+					pendingClass: null,
+					pendingSinceMs: 0,
+					openClass: className,
+					episodeId: openedId,
+					lastHeardMs: timestampMs,
+					lastClosedClass: openClass,
+					lastClosedMs: timestampMs
+				},
+				action: {
+					kind: "replace",
+					closed: {
+						className: openClass,
+						episodeId: openId
+					},
+					opened: {
+						className,
+						episodeId: openedId
+					}
+				}
+			};
+		}
+		return {
+			nextState: {
+				...state,
+				pendingClass: className,
+				pendingSinceMs: pendingSince
+			},
+			action: { kind: "none" }
+		};
+	}
+	if (className === null) {
+		if (state.pendingClass === null) return {
+			nextState: state,
+			action: { kind: "none" }
+		};
+		return {
+			nextState: {
+				...state,
+				pendingClass: null,
+				pendingSinceMs: 0
+			},
+			action: { kind: "none" }
+		};
+	}
+	if (inCooldown(state, className, timestampMs, knobs)) return {
+		nextState: state,
+		action: { kind: "none" }
+	};
+	const pendingSince = state.pendingClass === className ? state.pendingSinceMs : timestampMs;
+	if (knobs.openHoldMs === 0 || state.pendingClass === className && timestampMs - pendingSince >= knobs.openHoldMs) {
+		const episodeId = episodeIdFor(className, timestampMs);
+		return {
+			nextState: {
+				pendingClass: null,
+				pendingSinceMs: 0,
+				openClass: className,
+				episodeId,
+				lastHeardMs: timestampMs,
+				lastClosedClass: state.lastClosedClass,
+				lastClosedMs: state.lastClosedMs
+			},
+			action: {
+				kind: "open",
+				className,
+				episodeId
+			}
+		};
+	}
+	if (state.pendingClass === className) return {
+		nextState: state,
+		action: { kind: "none" }
+	};
+	return {
+		nextState: {
+			...state,
+			pendingClass: className,
+			pendingSinceMs: timestampMs
+		},
+		action: { kind: "none" }
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/audio-event-router.ts
 /**
 * Decide whether an audio frame is a (meaningful) classification event or a
@@ -46823,6 +47453,66 @@ var EventMediaDispatcher = class {
 		}
 	}
 };
+var SnapshotTimeoutError$1 = class extends Error {
+	constructor(ms) {
+		super(`snapshot cap timed out after ${ms}ms`);
+		this.name = "SnapshotTimeoutError";
+	}
+};
+function withTimeout$1(promise, ms) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => reject(new SnapshotTimeoutError$1(ms)), ms);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}, (err) => {
+			clearTimeout(timer);
+			reject(err instanceof Error ? err : new Error(String(err)));
+		});
+	});
+}
+var MotionEventSnapshotCapturer = class {
+	deps;
+	snapshotTimeoutMs;
+	constructor(deps) {
+		this.deps = deps;
+		this.snapshotTimeoutMs = deps.snapshotTimeoutMs ?? 2500;
+	}
+	/**
+	* Fetch a still and persist it as the motion event's snapshot. Never
+	* throws — the durable record is the motion row, already inserted by
+	* the caller.
+	*/
+	async capture(input) {
+		let snap;
+		try {
+			snap = await withTimeout$1(this.deps.snapshot.getSnapshot({ deviceId: input.deviceId }), this.snapshotTimeoutMs);
+		} catch (err) {
+			this.deps.onError?.(err instanceof SnapshotTimeoutError$1 ? "snapshotTimeout" : "snapshotFetch", err, input.deviceId);
+			return;
+		}
+		if (snap === null) return;
+		const raw = Buffer.from(snap.base64, "base64");
+		let data = raw;
+		try {
+			data = await downscaleFullFrameJpeg(raw, 960, 540);
+		} catch (err) {
+			this.deps.onError?.("downscaleSnapshot", err, input.deviceId);
+		}
+		try {
+			await this.deps.media.put({
+				deviceId: input.deviceId,
+				ownerKind: "event",
+				ownerId: input.eventId,
+				kind: "snapshot",
+				timestamp: input.timestamp,
+				data
+			});
+		} catch (err) {
+			this.deps.onError?.("snapshotMedia", err, input.deviceId);
+		}
+	}
+};
 /**
 * Project one `DeviceStateChanged` of a mapped sensor/control cap into a
 * synthetic track per camera the event belongs to. Returns the number of
@@ -46919,16 +47609,16 @@ var DEFAULT_DEBOUNCE_MS = 1e4;
 /** A hanging snapshot cap must not stall the sensor state-change path. */
 var DEFAULT_SNAPSHOT_TIMEOUT_MS = 1e4;
 /** Distinguishes a snapshot-cap timeout from a fetch failure for reporting. */
-var SnapshotTimeoutError$1 = class extends Error {
+var SnapshotTimeoutError = class extends Error {
 	constructor(ms) {
 		super(`snapshot cap timed out after ${ms}ms`);
 		this.name = "SnapshotTimeoutError";
 	}
 };
 /** Reject with `SnapshotTimeoutError` if `promise` doesn't settle within `ms`. */
-function withTimeout$1(promise, ms) {
+function withTimeout(promise, ms) {
 	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => reject(new SnapshotTimeoutError$1(ms)), ms);
+		const timer = setTimeout(() => reject(new SnapshotTimeoutError(ms)), ms);
 		promise.then((value) => {
 			clearTimeout(timer);
 			resolve(value);
@@ -46983,11 +47673,11 @@ var SyntheticTrackMaterializer = class {
 	*/
 	async fetchSnapshot(cameraId, timeoutMs) {
 		try {
-			const snap = await withTimeout$1(this.deps.snapshot.getSnapshot({ deviceId: cameraId }), timeoutMs);
+			const snap = await withTimeout(this.deps.snapshot.getSnapshot({ deviceId: cameraId }), timeoutMs);
 			if (snap === null) this.deps.onError?.("getSnapshot", /* @__PURE__ */ new Error("snapshot returned null"), cameraId);
 			return snap;
 		} catch (err) {
-			this.deps.onError?.(err instanceof SnapshotTimeoutError$1 ? "snapshotTimeout" : "snapshotMedia", err, cameraId);
+			this.deps.onError?.(err instanceof SnapshotTimeoutError ? "snapshotTimeout" : "snapshotMedia", err, cameraId);
 			return null;
 		}
 	}
@@ -47053,66 +47743,6 @@ var SyntheticTrackMaterializer = class {
 		return track;
 	}
 };
-var SnapshotTimeoutError = class extends Error {
-	constructor(ms) {
-		super(`snapshot cap timed out after ${ms}ms`);
-		this.name = "SnapshotTimeoutError";
-	}
-};
-function withTimeout(promise, ms) {
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => reject(new SnapshotTimeoutError(ms)), ms);
-		promise.then((value) => {
-			clearTimeout(timer);
-			resolve(value);
-		}, (err) => {
-			clearTimeout(timer);
-			reject(err instanceof Error ? err : new Error(String(err)));
-		});
-	});
-}
-var MotionEventSnapshotCapturer = class {
-	deps;
-	snapshotTimeoutMs;
-	constructor(deps) {
-		this.deps = deps;
-		this.snapshotTimeoutMs = deps.snapshotTimeoutMs ?? 2500;
-	}
-	/**
-	* Fetch a still and persist it as the motion event's snapshot. Never
-	* throws — the durable record is the motion row, already inserted by
-	* the caller.
-	*/
-	async capture(input) {
-		let snap;
-		try {
-			snap = await withTimeout(this.deps.snapshot.getSnapshot({ deviceId: input.deviceId }), this.snapshotTimeoutMs);
-		} catch (err) {
-			this.deps.onError?.(err instanceof SnapshotTimeoutError ? "snapshotTimeout" : "snapshotFetch", err, input.deviceId);
-			return;
-		}
-		if (snap === null) return;
-		const raw = Buffer.from(snap.base64, "base64");
-		let data = raw;
-		try {
-			data = await downscaleFullFrameJpeg(raw, 960, 540);
-		} catch (err) {
-			this.deps.onError?.("downscaleSnapshot", err, input.deviceId);
-		}
-		try {
-			await this.deps.media.put({
-				deviceId: input.deviceId,
-				ownerKind: "event",
-				ownerId: input.eventId,
-				kind: "snapshot",
-				timestamp: input.timestamp,
-				data
-			});
-		} catch (err) {
-			this.deps.onError?.("snapshotMedia", err, input.deviceId);
-		}
-	}
-};
 var TrackingSettingsSchema = require_dist.object({
 	/**
 	* How much of a detection's box must lie inside a zone (0-1 fraction of the
@@ -48402,6 +49032,51 @@ function buildGlobalSettingsSchema() {
 				}
 			]
 		},
+		{
+			id: "audio-episodes",
+			title: "Audio episodes",
+			description: "One timeline track and one event per classified sound, held open with hysteresis so a long cry is not four tracks. No class filter: speech, crying, a bark — the knobs below are what stop repeats. Leave on for a day or two and judge the spam, then tighten per camera.",
+			columns: 2,
+			fields: [
+				{
+					type: "boolean",
+					key: "audioEpisodeEnabled",
+					label: "Create audio episodes",
+					description: "When off, classified audio still notifies from other paths but does not open a synthetic track or coalesce classification events.",
+					default: AUDIO_DETECTION_DEFAULTS.audioEpisodeEnabled
+				},
+				{
+					type: "number",
+					key: "audioEpisodeOpenHoldSec",
+					label: "Open hold",
+					description: "The class must be heard continuously this long before an episode opens. Filters 200 ms blips.",
+					min: 0,
+					step: .5,
+					default: AUDIO_DETECTION_DEFAULTS.audioEpisodeOpenHoldSec,
+					unit: "s"
+				},
+				{
+					type: "number",
+					key: "audioEpisodeCloseGapSec",
+					label: "Close gap",
+					description: "The class must be absent this long before the episode closes. A pause inside a cry does not start a second track.",
+					min: 1,
+					step: 1,
+					default: AUDIO_DETECTION_DEFAULTS.audioEpisodeCloseGapSec,
+					unit: "s"
+				},
+				{
+					type: "number",
+					key: "audioEpisodeCooldownSec",
+					label: "Cooldown",
+					description: "After an episode closes, the same class cannot reopen until this elapses.",
+					min: 0,
+					step: 5,
+					default: AUDIO_DETECTION_DEFAULTS.audioEpisodeCooldownSec,
+					unit: "s"
+				}
+			]
+		},
 		{
 			id: "face-recognition",
 			title: "Face recognition",
@@ -49887,7 +50562,8 @@ var customActions = {
 	...ncActions,
 	...embeddingActions,
 	...debugActions,
-	...orphanAuditActions
+	...orphanAuditActions,
+	...viewerSettingsActions
 };
 /**
 * Assist threshold when the caller does not pin one. Packages have their own
@@ -49989,7 +50665,12 @@ var LTS_FLUSH_INTERVAL_MS = 6e4;
 var OPS_LOG_RETENTION_MS = 720 * 60 * 6e4;
 /** Throttle for the "overlay synthesis failed" warn — one line / minute / device. */
 var OVERLAY_SYNTHESIS_WARN_THROTTLE_MS = 6e4;
-var AUDIO_EVENT_HEARTBEAT_MS = 5e3;
+/** How recently a spatial track must have been alive to count as "visual
+*  happening" — stamp audio labels on that track instead of opening a
+*  synthetic audio episode. */
+var AUDIO_EPISODE_VISUAL_QUIET_MS = 2e3;
+/** Persist lastSeen on an open synthetic audio track at most this often. */
+var AUDIO_EPISODE_PERSIST_MS = 2e3;
 var MOTION_EVENT_HEARTBEAT_MS = 5e3;
 /**
 * Stored media kinds that carry NO drawn bounding box, in fallback preference
@@ -50461,6 +51142,11 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	* fallible read on the decision path.
 	*/
 	lastTrackActivityMs = /* @__PURE__ */ new Map();
+	/** Per-device classified-audio episode hysteresis. */
+	audioEpisodeByDevice = /* @__PURE__ */ new Map();
+	/** Open synthetic tracks keyed by hysteresis episodeId. */
+	audioEpisodeTracks = /* @__PURE__ */ new Map();
+	audioEpisodeLastPersistMs = /* @__PURE__ */ new Map();
 	settingsCaches = new DeviceSettingsCacheHub();
 	/** Avoids a store read every ~30 Hz audio frame. */
 	audioSettingsCache = this.settingsCaches.registerDeviceCache("audio-detection", SETTINGS_CACHE_TTL_MS);
@@ -50744,6 +51430,7 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 	*  NAME — its scope list is derived from the classification registry, not
 	*  from a set of store instances. */
 	settingsStore = null;
+	viewerSettingsSnapshots = null;
 	/** Per-scope resume cursors, so a run interrupted by a restart costs one
 	*  page rather than a full rescan. In RAM: losing them costs a rescan, and
 	*  persisting them would be a durable record of a purely advisory position. */
@@ -50881,12 +51568,14 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					...ncActions,
 					...embeddingActions,
 					...debugActions,
-					...orphanAuditActions
+					...orphanAuditActions,
+					...viewerSettingsActions
 				},
 				actionHandlers: {
 					...ncHandlers,
 					...this.buildEmbeddingActionHandlers(),
-					...this.buildDebugActionHandlers()
+					...this.buildDebugActionHandlers(),
+					...this.viewerSettingsSnapshots ? makeViewerSettingsActionHandlers(this.viewerSettingsSnapshots) : {}
 				}
 			} : {}
 		};
@@ -51061,8 +51750,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			OpsLogStore.declare(api.settingsStore),
 			AnalyticsLts.declare(api.settingsStore),
 			SceneStore.declare(api.settingsStore),
-			NotificationCenter.declare(api.settingsStore)
+			NotificationCenter.declare(api.settingsStore),
+			ViewerSettingsSnapshotStore.declare(api.settingsStore)
 		]);
+		this.viewerSettingsSnapshots = new ViewerSettingsSnapshotStore(api.settingsStore);
 		runLabelTierMigration({
 			store: api.settingsStore,
 			logger: this.ctx.logger,
@@ -52322,6 +53013,11 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 		this.forgetDeviceProcessors(deviceId);
 		this.levelStateByDevice.delete(deviceId);
 		this.lastTrackActivityMs.delete(deviceId);
+		this.audioEpisodeByDevice.delete(deviceId);
+		for (const [episodeId, track] of this.audioEpisodeTracks) if (track.deviceId === deviceId) {
+			this.audioEpisodeTracks.delete(episodeId);
+			this.audioEpisodeLastPersistMs.delete(episodeId);
+		}
 		this.audioMarkers?.forgetDevice(deviceId);
 		this.settingsCaches.clearDevice(deviceId);
 		this.bindingCache?.invalidate(deviceId);
@@ -52586,6 +53282,9 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 					audio
 				};
 			},
+			fetchMediaOwners: async ({ deviceId, ownerKind, ownerIds }) => {
+				return stores.mediaStore.ownersWithMedia(ownerKind, ownerIds, deviceId);
+			},
 			fetchAvailability: async ({ deviceId, since, until }) => {
 				return (await api.recording.getAvailability.query({
 					deviceId,
@@ -52597,6 +53296,10 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				tags: { deviceId: Number(meta["deviceId"]) },
 				meta
 			}),
+			logInfo: (message, meta) => this.ctx.logger.info(message, {
+				tags: { deviceId: Number(meta["deviceId"]) },
+				meta
+			}),
 			resolvePlayback: async ({ deviceId, startMs, endMs }) => {
 				const manifest = await api.recording.getPlaybackManifest.query({
 					deviceId,
@@ -54218,6 +54921,146 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 			maxPerDay: settings.audioMarkerMaxPerDay
 		};
 	}
+	audioEpisodeKnobs(settings) {
+		return {
+			enabled: settings.audioEpisodeEnabled,
+			openHoldMs: settings.audioEpisodeOpenHoldSec * 1e3,
+			closeGapMs: settings.audioEpisodeCloseGapSec * 1e3,
+			cooldownMs: settings.audioEpisodeCooldownSec * 1e3
+		};
+	}
+	hasLiveVisualTrack(deviceId, atMs) {
+		const at = this.lastTrackActivityMs.get(deviceId);
+		return at !== void 0 && atMs - at < AUDIO_EPISODE_VISUAL_QUIET_MS;
+	}
+	async driveAudioEpisode(input) {
+		const { nextState, action } = observeAudioEpisode(this.audioEpisodeByDevice.get(input.deviceId) ?? emptyAudioEpisodeState(), {
+			timestampMs: input.timestamp,
+			className: input.className
+		}, input.knobs);
+		this.audioEpisodeByDevice.set(input.deviceId, nextState);
+		switch (action.kind) {
+			case "none": return;
+			case "open":
+				await this.openAudioEpisode(input, action);
+				return;
+			case "hold":
+				await this.holdAudioEpisode(input, action);
+				return;
+			case "close":
+				await this.persistAudioEpisodeLastSeen(action, input.timestamp, true);
+				return;
+			case "replace":
+				await this.persistAudioEpisodeLastSeen(action.closed, input.timestamp, true);
+				await this.openAudioEpisode(input, action.opened);
+				return;
+		}
+	}
+	async openAudioEpisode(input, ref) {
+		const ev = {
+			id: (0, node_crypto.randomUUID)(),
+			deviceId: input.deviceId,
+			timestamp: input.timestamp,
+			kind: "audio",
+			rms: input.rms,
+			dbfs: input.dbfs,
+			classification: {
+				className: ref.className,
+				...input.originalClass !== void 0 ? { originalClass: input.originalClass } : {},
+				score: input.score
+			}
+		};
+		this.lastAudioInsertByDevice.set(input.deviceId, {
+			className: ref.className,
+			atMs: input.timestamp
+		});
+		await this.eventStore.insertAudio(ev);
+		this.notificationCenter?.onAudioEventPersisted(ev);
+		this.trackStore?.addAudioLabelEpisode(input.deviceId, ref.className, input.score, input.timestamp);
+		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: input.deviceId,
+				kind: "audio",
+				eventId: ev.id,
+				timestamp: ev.timestamp
+			}
+		});
+		if (this.hasLiveVisualTrack(input.deviceId, input.timestamp)) return;
+		const materializer = this.syntheticTracks;
+		if (materializer === null) return;
+		try {
+			const track = await materializer.materialize({
+				cameraId: input.deviceId,
+				sourceDeviceId: input.deviceId,
+				source: "audio",
+				kind: ref.className,
+				timestamp: input.timestamp,
+				audioLabels: [{
+					label: ref.className,
+					peakScore: input.score,
+					count: 1,
+					firstAt: input.timestamp,
+					lastAt: input.timestamp
+				}]
+			});
+			if (track) {
+				this.audioEpisodeTracks.set(ref.episodeId, track);
+				this.audioEpisodeLastPersistMs.set(ref.episodeId, input.timestamp);
+			}
+		} catch (err) {
+			this.ctx.logger.warn("audio-episode synthetic track failed", {
+				tags: { deviceId: input.deviceId },
+				meta: {
+					className: ref.className,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+	}
+	async holdAudioEpisode(input, ref) {
+		await this.persistAudioEpisodeLastSeen(ref, input.timestamp, false);
+	}
+	async persistAudioEpisodeLastSeen(ref, timestamp, force) {
+		const track = this.audioEpisodeTracks.get(ref.episodeId);
+		if (!track) {
+			if (force) {
+				this.audioEpisodeTracks.delete(ref.episodeId);
+				this.audioEpisodeLastPersistMs.delete(ref.episodeId);
+			}
+			return;
+		}
+		const last = this.audioEpisodeLastPersistMs.get(ref.episodeId) ?? 0;
+		if (!force && timestamp - last < AUDIO_EPISODE_PERSIST_MS) return;
+		const updated = {
+			...track,
+			lastSeen: timestamp
+		};
+		this.audioEpisodeTracks.set(ref.episodeId, updated);
+		this.audioEpisodeLastPersistMs.set(ref.episodeId, timestamp);
+		try {
+			await this.trackStore?.persistSyntheticTrack(updated);
+		} catch (err) {
+			this.ctx.logger.warn("audio-episode lastSeen persist failed", {
+				tags: { deviceId: track.deviceId },
+				meta: {
+					episodeId: ref.episodeId,
+					error: require_dist.errMsg(err)
+				}
+			});
+		}
+		if (force) {
+			this.audioEpisodeTracks.delete(ref.episodeId);
+			this.audioEpisodeLastPersistMs.delete(ref.episodeId);
+		}
+	}
 	async handleAudioResult(data) {
 		if (this.shuttingDown) return;
 		const { deviceId, frame } = data;
@@ -54261,48 +55104,27 @@ var PipelineAnalyticsAddon = class extends require_dist.BaseAddon {
 				});
 				return;
 			}
-			const last = this.lastAudioInsertByDevice.get(deviceId);
-			const sameClass = last?.className === route.className;
-			const heartbeatDue = !last || timestamp - last.atMs >= AUDIO_EVENT_HEARTBEAT_MS;
-			if (sameClass && !heartbeatDue) return;
-			const ev = {
-				id: (0, node_crypto.randomUUID)(),
+			await this.driveAudioEpisode({
 				deviceId,
 				timestamp,
-				kind: "audio",
+				className: route.className,
+				score: topClassification.score,
+				originalClass: topClassification.debug?.originalClass,
 				rms: level?.rms ?? 0,
 				dbfs: level?.dbfs ?? 0,
-				classification: {
-					className: topClassification.macroClass,
-					...topClassification.debug?.originalClass !== void 0 ? { originalClass: topClassification.debug.originalClass } : {},
-					score: topClassification.score
-				}
-			};
-			this.lastAudioInsertByDevice.set(deviceId, {
-				className: route.className,
-				atMs: timestamp
-			});
-			await this.eventStore.insertAudio(ev);
-			this.notificationCenter?.onAudioEventPersisted(ev);
-			this.trackStore?.addAudioLabelEpisode(deviceId, route.className, topClassification.score, timestamp);
-			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: "audio",
-					eventId: ev.id,
-					timestamp: ev.timestamp
-				}
+				knobs: this.audioEpisodeKnobs(settings)
 			});
 			return;
 		}
+		await this.driveAudioEpisode({
+			deviceId,
+			timestamp,
+			className: null,
+			score: 0,
+			rms: level?.rms ?? 0,
+			dbfs: level?.dbfs ?? 0,
+			knobs: this.audioEpisodeKnobs(settings)
+		});
 		const res = observeLevel(this.levelStateByDevice.get(deviceId) ?? emptyLevelState(), {
 			timestampMs: timestamp,
 			dbfs: level?.dbfs ?? -Infinity