@camstack/addon-post-analysis 1.2.219 → 1.2.221

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-Cnlk6Tyz.js");
+const require_dist = require("../dist-B6jHfZ6s.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -20002,6 +20002,14 @@ function checkTimelapsePacing(input) {
 		unservedWindows: []
 	};
 }
+//#endregion
+//#region src/notification-center/timelapse/timelapse-renderer.ts
+/** `part / whole` to two decimals — the shape a log line is read in. An empty
+*  whole is 0, never NaN: a ratio nobody can compare is not a measurement. */
+function ratio(part, whole) {
+	if (whole <= 0) return 0;
+	return Math.round(part / whole * 100) / 100;
+}
 /** Bound on the post-render pacing check. The check is best-effort by charter:
 *  a byte read that hangs must delay delivery by at most this, never sink it. */
 var PACING_CHECK_TIMEOUT_MS = 2e4;
@@ -20025,25 +20033,6 @@ function profileCost(profile) {
 	const i = PROFILE_BY_COST.indexOf(profile);
 	return i === -1 ? PROFILE_BY_COST.length : i;
 }
-/**
-* The CHEAPEST profile that has footage over the window.
-*
-* It used to be the profile with the MOST coverage, ties broken by name — and
-* that is a rule which picks `high` almost every time, because the high band is
-* the one that records continuously. On 2026-09-03 it did: a test render of a
-* ten-hour window chose `profile=high` at 97% coverage, which on this hub means
-* 4K read from a USB spinning disk. Decoding it made the machine stop answering
-* SSH and its own web UI for half an hour, and it had to be power-cycled.
-*
-* A timelapse is watched accelerated. Resolution buys nothing at 12 fps over a
-* night, and the cost difference between the bands is one to two orders of
-* magnitude in both bytes read and frames decoded. So there is no trade to
-* weigh: take the cheapest band that has anything, every time.
-*
-* Coverage no longer decides WHICH — only whether a band qualifies at all. A
-* band with less footage is still the right source; the gaps show as a shorter
-* video, not as a reason to read twenty times the bytes.
-*/
 function pickProfile(ranges, window) {
 	const byProfile = /* @__PURE__ */ new Map();
 	for (const r of ranges) {
@@ -20290,18 +20279,20 @@ var TimelapseRenderer = class {
 		const finished = await this.awaitReady(queued, tags);
 		const published = await this.publish(finished.id, request, tags);
 		const downloadUrl = await this.ports.resolveDownloadUrl?.({ exportId: finished.id }).catch(() => null);
+		const archive = await this.measureArchive(finished.id, request, chosen, tags);
+		const deliveredRows = archive?.rows ?? availability.filter((r) => r.profile === chosen.profile);
 		await this.verifyPacing({
 			exportId: finished.id,
 			request,
 			dense,
 			subjects,
-			availability: availability.filter((r) => r.profile === chosen.profile),
+			availability: deliveredRows,
 			tags
 		});
 		return {
 			exportId: finished.id,
 			profile: chosen.profile,
-			coverage: chosen.coverage,
+			coverage: archive?.coverage ?? chosen.coverage,
 			plan,
 			detections,
 			artifact: published.video,
@@ -20409,6 +20400,96 @@ var TimelapseRenderer = class {
 		throw new TimelapseRenderError("export-timeout", `export ${queued.id} timed out after ${this.timeoutMs}ms` + (pollFailures > 0 ? ` (${pollFailures} poll failures, last: ${lastPollError})` : ""));
 	}
 	/**
+	* The window against the archive, measured AFTER the export and always said.
+	*
+	* Three figures, one line: the window's length, what the PLAN was cut from
+	* (the availability read before the export) and what the ARCHIVE holds (the
+	* same read after it — the export's verified walk has repaired the index the
+	* calendar serves from by then). `plannedOfArchive` is the ratio D445 found
+	* at 0.20 on camera 4374 and nothing reported; a healthy night reads 1.00
+	* because both reads return the same rows.
+	*
+	* WHY THE THRESHOLD IS A SLACK AND NOT A RATIO. The two reads are the SAME
+	* query against the SAME index, so on a healthy night they return the same
+	* rows and the shortfall is exactly 0 — there is no distribution to pick a
+	* percentile out of. It is non-zero only when something CHANGED the index
+	* between them, and the export's verified walk is the only thing that does.
+	* So the bar is not "how short is too short" (the robot's night was 0.20 and
+	* a milder one would be just as wrong); it is only "is this a real change or
+	* a boundary artefact". One artefact exists: the window is closed, but a
+	* segment straddling its end can finalize while the export runs and extend
+	* the last range by its own length. {@link COVERAGE_COMPLETE_SLACK_MS} (30 s)
+	* is the slack the coverage figure already allows at exactly those edges,
+	* and it is several segments wide. No second constant, and nothing between
+	* "unchanged" and "the planner rendered from a short answer".
+	*
+	* Never throws. A re-read that fails is SAID, the plan's figure stands, and
+	* every figure that needed the archive is `null` rather than a stand-in.
+	*/
+	async measureArchive(exportId, request, chosen, tags) {
+		const { window } = request;
+		const windowSec = Math.round((window.endMs - window.startMs) / 1e3);
+		const plannedSec = Math.round(chosen.coverage.coveredMs / 1e3);
+		let rows;
+		try {
+			rows = (await this.ports.getAvailability({
+				deviceId: request.deviceId,
+				fromMs: window.startMs,
+				toMs: window.endMs,
+				profile: chosen.profile
+			})).ranges.filter((r) => r.profile === chosen.profile);
+		} catch (err) {
+			this.ports.logger.warn("timelapse coverage: archive re-read failed — the window is reported against the plan only", {
+				tags,
+				meta: {
+					exportId,
+					ruleId: request.ruleId,
+					profile: chosen.profile,
+					windowSec,
+					plannedSec,
+					plannedOfWindow: ratio(chosen.coverage.coveredMs, window.endMs - window.startMs),
+					archiveSec: null,
+					plannedOfArchive: null,
+					archiveOfWindow: null,
+					error: String(err)
+				}
+			});
+			return null;
+		}
+		const coverage = footageCoverage(rows, window.startMs, window.endMs);
+		const shortfallMs = coverage.coveredMs - chosen.coverage.coveredMs;
+		const meta = {
+			exportId,
+			ruleId: request.ruleId,
+			profile: chosen.profile,
+			windowSec,
+			plannedSec,
+			archiveSec: Math.round(coverage.coveredMs / 1e3),
+			/** What the operator ASKED for against what the file HOLDS — the ratio
+			*  the robot's night made someone file a report over: ten hours in,
+			*  6.4 s of video out. Low is not by itself a defect (a lazy source is
+			*  legitimately idle most of a night), which is why it never gates. */
+			plannedOfWindow: ratio(chosen.coverage.coveredMs, window.endMs - window.startMs),
+			archiveOfWindow: ratio(coverage.coveredMs, window.endMs - window.startMs),
+			/** The one that IS a defect: what the planner saw against what the
+			*  export's verified walk found. 0.20 on camera 4374, 1.00 when healthy. */
+			plannedOfArchive: ratio(chosen.coverage.coveredMs, coverage.coveredMs),
+			shortfallSec: Math.round(shortfallMs / 1e3)
+		};
+		if (shortfallMs > 3e4) this.ports.logger.warn("timelapse coverage: the plan was cut from less footage than the archive holds", {
+			tags,
+			meta
+		});
+		else this.ports.logger.info("timelapse coverage: the window against the archive", {
+			tags,
+			meta
+		});
+		return {
+			rows,
+			coverage
+		};
+	}
+	/**
 	* Run the pacing check against the finished file, and SAY what it found.
 	*
 	* Never throws and never blocks past its bound: the check is telemetry about
@@ -28431,6 +28512,34 @@ var MEDIA_INDEXES = [
 			"deviceId",
 			"sizeBytes"
 		]
+	}),
+	(
+	/**
+	* The per-LOCATION footprint — `COUNT(*)`/`SUM(sizeBytes) WHERE locationId
+	* = ?`, and the legacy `locationId IS NULL` half of the same question. See
+	* {@link MediaStore.footprintByLocation} (D388) and D447.
+	*
+	* **Why not `idx_media_location`.** It leads with `locationId`, so it finds
+	* the range — and then, exactly as the `idx_media_device_size` note above
+	* describes for `deviceId`, fetches the table row behind every entry to read
+	* `sizeBytes`. Every row of the store is on SOME location, so the range is
+	* the table: measured 2026-09-10/11 on `hub/sqlite-settings`, 4 128–6 962 ms
+	* per statement, every five minutes (the occupancy refresh), all night —
+	* `plan=["SEARCH … USING INDEX idx_media_location (locationId=?)"]` on every
+	* WARN. That thread is synchronous, so every configuration read in the
+	* cluster queued behind it: the orchestrator's `configMs=6640` at 23:26:11
+	* is this statement's 6 002 ms at 23:26:10.
+	*
+	* With `sizeBytes` in the index the planner never touches the table
+	* (`USING COVERING INDEX idx_media_location_size`), and the seal gate keeps
+	* its own narrower index. Same shape, same one-off caveat as its two
+	* siblings: ~30 bytes a row, one more b-tree per insert, and the first
+	* `declareCollection` after this ships builds it over every existing row —
+	* do not deploy it beside a running drain or seal.
+	*/
+	{
+		name: "idx_media_location_size",
+		columns: ["locationId", "sizeBytes"]
 	})
 ];
 /** The storage location of a media row/record: its stamped `locationId`, or
@@ -46470,6 +46579,17 @@ var AudioDetectionSettingsSchema = require_dist.object({
 	audioConfirmHits: require_dist.number().int().min(1).default(2),
 	/** Width of the corroboration window. Ignored when `audioConfirmHits` is 1. */
 	audioConfirmWindowSec: require_dist.number().positive().default(10),
+	/**
+	* How far above the camera's own 10 s mean a sample must sit to be a peak.
+	*
+	* A DIFFERENCE between two readings on the same camera, so a uniform scale
+	* offset cancels exactly and the D459 correction did not touch it. Proved,
+	* not assumed — D459 enumerates this alongside `audioMarkerMinDeviationDb`,
+	* `audioMarkerMinDeviations` and the EWMA/MAD pair. "Correcting" it by
+	* 12 dB would be introducing the very error the epoch removed.
+	*
+	* @dbfs-era relative
+	*/
 	levelDeviationDb: require_dist.number().positive().default(10),
 	levelWindowSec: require_dist.number().positive().default(10),
 	levelMaxWaitSec: require_dist.number().positive().default(20),
@@ -46479,14 +46599,44 @@ var AudioDetectionSettingsSchema = require_dist.object({
 	/** EWMA time constant for the camera's "normal" loudness, in seconds. Also
 	*  the warm-up: no marker until one time constant of audio has been heard. */
 	audioMarkerBaselineSec: require_dist.number().positive().default(300),
-	/** "High volume", absolute. A sample quieter than this is never a marker
-	*  however surprising it is for the camera. */
+	/**
+	* "High volume", absolute. A sample quieter than this is never a marker
+	* however surprising it is for the camera.
+	*
+	* NOT shifted at the D459 epoch, for the same reason as `SILENCE_FLOOR_DBFS`
+	* and with one extra argument of its own. `-25 dBFS is loud` is a statement
+	* about the scale, not a measurement taken through the old decoder: nobody
+	* read it off a meter, it is what "loud" means on a 16-bit full-scale range.
+	*
+	* The extra argument is that on the old scale this default was effectively
+	* DEAD on the 19 mis-decoded cameras — a reading of -25 there required a
+	* true level of -13 dBFS, which is a sound close to clipping. Bar 1 almost
+	* never bound on them, so the feature has been running on two of its three
+	* bars. At the epoch it starts working as designed rather than becoming too
+	* permissive.
+	*
+	* That it also ships OFF by default (`audioMarkerEnabled`) is what makes
+	* this safe to leave alone: the operator sizes the rate from the `wouldFire`
+	* counter before paying for it, and that counter is now measuring the real
+	* thing for the first time.
+	*
+	* @dbfs-era itu
+	*/
 	audioMarkerMinDbfs: require_dist.number().max(0).default(-25),
 	/** "Out of the ordinary": how many mean-absolute-deviations of the camera's
 	*  OWN jitter the sample must sit above its own mean. */
 	audioMarkerMinDeviations: require_dist.number().positive().default(4),
-	/** Floor in dB on the distance above the camera's own mean — what holds
-	*  when a dead-steady camera's deviation unit collapses toward zero. */
+	/**
+	* Floor in dB on the distance above the camera's own mean — what holds when
+	* a dead-steady camera's deviation unit collapses toward zero.
+	*
+	* A distance between two readings on the same camera: scale-invariant, and
+	* untouched by D459. The numerical coincidence with the PCMU correction
+	* (12 dB) is exactly that — a coincidence, and the reason this note exists
+	* is so nobody reads it as one of the shifted numbers.
+	*
+	* @dbfs-era relative
+	*/
 	audioMarkerMinDeviationDb: require_dist.number().positive().default(12),
 	/** Audio matters most when nothing visual is happening. A marker is
 	*  suppressed while a track is alive on the camera, or motion was reported,
@@ -65000,6 +65150,10 @@ var STALE_BASELINE_FACTOR = 5;
 * has MAD 0 and would make every deviation infinite. 1 dB is below the
 * quantisation of any real level meter, so it only ever binds on a synthetic
 * or a genuinely dead-steady signal — where bar 2 is what should decide.
+*
+* A floor on a DEVIATION, not on a level: scale-invariant, untouched by D459.
+*
+* @dbfs-era relative
 */
 var MIN_MAD_DB = 1;
 function emptyAudioBaseline() {
@@ -65283,6 +65437,44 @@ function buildAudioLabels(input) {
 	}];
 }
 //#endregion
+//#region src/pipeline-analytics/services/event-kinds-config.ts
+/** The honest answer for a pipeline that could not be read: nothing advertised. */
+var NO_EMITTABLE = {
+	macroClasses: [],
+	audioEnabled: false
+};
+/** Depth-first walk of the step tree; the detector is a root today, but the
+*  question is "is it enabled anywhere", not "is it a root". */
+function* walkSteps(steps) {
+	for (const step of steps) {
+		yield step;
+		if (step.children !== void 0) yield* walkSteps(step.children);
+	}
+}
+/**
+* The macro classes an enabled `object-detection` step emits. Order follows
+* the authority, not the stored array, so two cameras narrowed to the same
+* set render the same lanes in the same order.
+*/
+function macroClassesOf(step) {
+	const stored = step.settings?.["enabledMacroClasses"];
+	if (!Array.isArray(stored) || stored.length === 0) return [...require_dist.FIRST_LEVEL_MACRO_CLASSES];
+	const chosen = new Set(stored.filter((v) => typeof v === "string"));
+	return require_dist.FIRST_LEVEL_MACRO_CLASSES.filter((macro) => chosen.has(macro));
+}
+function emittableFromPipelineConfig(config) {
+	let macroClasses = [];
+	for (const step of walkSteps(config.steps)) {
+		if (step.addonId !== "object-detection" || step.enabled === false) continue;
+		macroClasses = macroClassesOf(step);
+		break;
+	}
+	return {
+		macroClasses,
+		audioEnabled: config.audio?.enabled === true
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/services/event-kinds.ts
 /**
 * Extensible per-device event kinds (Part B).
@@ -78190,28 +78382,26 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		};
 	}
 	/**
-	* Every event kind the device can produce: built-ins (motion + audio),
-	* detection classes actually observed on the device, and sensor kinds
-	* from LINKED devices (device-manager `getLinkedDevices`, binding-driven
-	* per linked device). Degrades to the built-ins on error.
+	* Every event kind the device can produce: built-ins (motion + audio), the
+	* detection classes its CONFIGURED pipeline can emit, and sensor kinds from
+	* LINKED devices (device-manager `getLinkedDevices`, binding-driven per
+	* linked device). Degrades to the built-ins on error.
+	*
+	* The detection and audio facts are read from `resolvePipeline` — the
+	* configuration — and never from `getCameraStatus`, which is RUNTIME: an
+	* on-motion camera holds no session between motion events
+	* (`reasons.detection: 'armed:on-motion'`, `detection: null`) and was being
+	* advertised as detecting nothing while its tracks said person / vehicle /
+	* animal ([D449](../../../../docs/decisions/adr-0449-the-timeline-taxonomy-is-the-configured-one-raw-forward-has-no-switch-and-a-one-row-write-waits-on-the-disk.md)).
 	*/
 	async listEventKinds(input) {
 		const api = this.ctx.api;
-		const status = await api.pipelineOrchestrator.getCameraStatus.query({ deviceId: input.deviceId }).catch((err) => {
-			this.ctx.logger.warn("listEventKinds: getCameraStatus failed", {
-				tags: { deviceId: input.deviceId },
-				meta: { error: require_dist.errMsg(err) }
-			});
-			return null;
-		});
-		const detectionOn = status?.detection != null;
-		const audioOn = status?.audio?.enabled === true;
-		const detectionMacros = require_dist.MACRO_LABELS.map((l) => l.id).filter((id) => id !== "package");
+		const emittable = await this.emittableFromConfig(input.deviceId, "listEventKinds");
 		return composeEventKinds({
 			linkedDevices: { getLinkedDevices: (i) => api.deviceManager.getLinkedDevices.query(i) },
 			bindings: { getBindings: (i) => api.deviceManager.getBindings.query(i) },
-			enabledMacroClasses: async () => detectionOn ? detectionMacros : [],
-			audioEnabled: async () => audioOn,
+			enabledMacroClasses: async () => emittable.macroClasses,
+			audioEnabled: async () => emittable.audioEnabled,
 			packageZonesEnabled: async (deviceId) => {
 				return (await this.resolveDevicePackageRules(deviceId)).some((r) => r.enabled !== false);
 			},
@@ -78225,6 +78415,24 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 		}, input.deviceId);
 	}
 	/**
+	* What one camera's configured pipeline can emit (`resolvePipeline`), or
+	* the honest fallback when the orchestrator could not answer: nothing
+	* advertised, and a WARN saying so. The cap's answer is a plain list, so it
+	* has no room for "unknown" — that residual of D315 is named in D449; the
+	* steady state (an armed camera with no session) is no longer in it.
+	*/
+	async emittableFromConfig(deviceId, scope) {
+		try {
+			return emittableFromPipelineConfig(await this.ctx.api.pipelineOrchestrator.resolvePipeline.query({ deviceId }));
+		} catch (err) {
+			this.ctx.logger.warn(`${scope}: resolvePipeline failed — no ML kinds advertised`, {
+				tags: { deviceId },
+				meta: { error: require_dist.errMsg(err) }
+			});
+			return NO_EMITTABLE;
+		}
+	}
+	/**
 	* `listEventKinds` for many cameras, in one call.
 	*
 	* The saving is not the round-trips the CALLER avoids — it is the fan-out
@@ -78236,11 +78444,11 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	* `getLinkedDevices` alone took 4110 ms — each one runs a full-fleet
 	* `listAll` inside device-manager and thirty of them QUEUE.
 	*
-	* Now three calls for the whole set, whatever N is: one
-	* `getCameraStatuses`, then `prefetchDeviceTopology`'s
-	* `getLinkedDevicesBatch` + `getBindingsBatch`. `composeEventKinds` is
-	* unchanged — it is handed the same per-device client interfaces, backed by
-	* maps instead of RPC.
+	* Now two calls for the whole topology, whatever N is —
+	* `prefetchDeviceTopology`'s `getLinkedDevicesBatch` + `getBindingsBatch` —
+	* plus one `resolvePipeline` per camera, all in flight at once (D449; there
+	* is no batch form of it). `composeEventKinds` is unchanged — it is handed
+	* the same per-device client interfaces, backed by maps instead of RPC.
 	*
 	* A camera whose composition fails yields an EMPTY list rather than dropping
 	* out of the response: a caller that asked for twelve and got eleven cannot
@@ -78249,15 +78457,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 	async listEventKindsBatch(input) {
 		const api = this.ctx.api;
 		const deviceIds = [...new Set(input.deviceIds)];
-		const statuses = await api.pipelineOrchestrator.getCameraStatuses.query({ deviceIds }).catch((err) => {
-			this.ctx.logger.warn("listEventKindsBatch: getCameraStatuses failed", { meta: {
-				deviceCount: deviceIds.length,
-				error: require_dist.errMsg(err)
-			} });
-			return [];
-		});
-		const statusByDevice = new Map(statuses.map((st) => [st.deviceId, st]));
-		const detectionMacros = require_dist.MACRO_LABELS.map((l) => l.id).filter((id) => id !== "package");
+		const emittableByDevice = new Map(await Promise.all(deviceIds.map(async (deviceId) => [deviceId, await this.emittableFromConfig(deviceId, "listEventKindsBatch")])));
 		const topology = await prefetchDeviceTopology({
 			getLinkedDevicesBatch: (i) => api.deviceManager.getLinkedDevicesBatch.query(i),
 			getBindingsBatch: (i) => api.deviceManager.getBindingsBatch.query(i)
@@ -78269,14 +78469,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_dist.B
 			return null;
 		});
 		return composeEventKindsForDevices(deviceIds, async (deviceId) => {
-			const status = statusByDevice.get(deviceId) ?? null;
-			const detectionOn = status?.detection != null;
-			const audioOn = status?.audio?.enabled === true;
+			const emittable = emittableByDevice.get(deviceId) ?? NO_EMITTABLE;
 			return composeEventKinds({
 				linkedDevices: topology?.linkedDevices ?? { getLinkedDevices: (i) => api.deviceManager.getLinkedDevices.query(i) },
 				bindings: topology?.bindings ?? { getBindings: (i) => api.deviceManager.getBindings.query(i) },
-				enabledMacroClasses: async () => detectionOn ? detectionMacros : [],
-				audioEnabled: async () => audioOn,
+				enabledMacroClasses: async () => emittable.macroClasses,
+				audioEnabled: async () => emittable.audioEnabled,
 				packageZonesEnabled: async (id) => {
 					return (await this.resolveDevicePackageRules(id)).some((r) => r.enabled !== false);
 				},