@camstack/addon-post-analysis 1.2.601 → 1.2.602

package/dist/pipeline-analytics/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_clip_model_registry = require("../clip-model-registry-DAZ9ie-f.js");
+const require_clip_model_registry = require("../clip-model-registry-D0-VNIW5.js");
 let node_fs = require("node:fs");
 node_fs = require_clip_model_registry.__toESM(node_fs, 1);
 let node_path = require("node:path");
@@ -6938,17 +6938,6 @@ function ncAudioSampleFromFrame(frame, timestampMs, floor) {
 		...frame.classifyOutcome !== void 0 ? { classifyOutcome: frame.classifyOutcome } : {}
 	};
 }
-/** The level-path audio row for one frame — the one row kind with no label to explain it. */
-function levelAudioEventDraft(deviceId, timestamp, frame) {
-	return {
-		deviceId,
-		timestamp,
-		kind: "audio",
-		rms: frame.level?.rms ?? 0,
-		dbfs: frame.level?.dbfs ?? 0,
-		...frame.classifyOutcome !== void 0 ? { classifyOutcome: frame.classifyOutcome } : {}
-	};
-}
 //#endregion
 //#region src/pipeline-analytics/scene/condition-resolver.ts
 var DAY = "day";
@@ -10930,7 +10919,7 @@ var NC_LIVENESS_SPEC = {
 	writeMode: "write-behind",
 	keyOf: (row) => row.subject,
 	toValue: rowToValue$1,
-	fromRecord: recordToRow$2,
+	fromRecord: recordToRow$1,
 	equalFact: (held, incoming) => held.state === incoming.state,
 	deviceIdOf: (row) => row.deviceId
 };
@@ -11117,7 +11106,7 @@ function rowToValue$1(row) {
 * (silent) rather than hydrating a state nothing can ever equal, which would
 * make every future event a phantom flip.
 */
-function recordToRow$2(subject, data) {
+function recordToRow$1(subject, data) {
 	if (subject.length === 0) return null;
 	const state = data["state"];
 	if (state !== "online" && state !== "offline") return null;
@@ -12598,7 +12587,7 @@ var NC_OCCUPANCY_SPEC = {
 	writeMode: "write-through",
 	keyOf: (row) => row.key,
 	toValue: rowToValue,
-	fromRecord: recordToRow$1,
+	fromRecord: recordToRow,
 	deviceIdOf: (row) => row.deviceId
 };
 var OccupancyStore = class {
@@ -12675,7 +12664,7 @@ function rowToValue(row) {
 * {@link parseOccupancyKey} rejects — so the caller skips it (cold re-observe)
 * rather than hydrating a mis-parsed scope.
 */
-function recordToRow$1(key, data) {
+function recordToRow(key, data) {
 	const scope = parseOccupancyKey(key);
 	if (scope === null) return null;
 	const deviceId = Number(data["deviceId"]);
@@ -50543,7 +50532,7 @@ function previewBlurSigma(frameWidth) {
 }
 /** Break a word too long for one line into line-width pieces. Without this a
 *  single 200-character token wraps to nothing and overflows both edges. */
-function chunk$2(word, size) {
+function chunk$1(word, size) {
 	const pieces = [];
 	for (let i = 0; i < word.length; i += size) pieces.push(word.slice(i, i + size));
 	return pieces;
@@ -50551,7 +50540,7 @@ function chunk$2(word, size) {
 /** Greedy word wrap at a character budget — the only measurement available,
 *  since librsvg lays the text out long after this string is written. */
 function wrapLines(text, maxChars) {
-	return text.split(" ").filter((w) => w.length > 0).reduce((lines, word) => (word.length > maxChars ? chunk$2(word, maxChars) : [word]).reduce((acc, piece) => {
+	return text.split(" ").filter((w) => w.length > 0).reduce((lines, word) => (word.length > maxChars ? chunk$1(word, maxChars) : [word]).reduce((acc, piece) => {
 		const last = acc.at(-1);
 		if (last === void 0) return [piece];
 		const merged = `${last} ${piece}`;
@@ -60482,7 +60471,7 @@ async function readRescoreFingerprint(ports) {
 		clusterModelId
 	};
 }
-function chunk$1(items, size) {
+function chunk(items, size) {
 	const out = [];
 	for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
 	return out;
@@ -60604,7 +60593,7 @@ var FaceRescoreJob = class {
 			fingerprint: fingerprint.combined
 		});
 		const paramsByDevice = /* @__PURE__ */ new Map();
-		for (const batchIds of chunk$1(ids, RESCORE_BATCH_SIZE)) {
+		for (const batchIds of chunk(ids, RESCORE_BATCH_SIZE)) {
 			if (this.stopped) throw new Error("stopped before completion");
 			const storeStart = this.ports.now();
 			const batch = await this.ports.loadRescoreBatch(batchIds);
@@ -98360,431 +98349,6 @@ var SweepCursorStore = class SweepCursorStore {
 	}
 };
 //#endregion
-//#region src/durable/lts-aggregator.ts
-/** Wall-clock bucket width. Five minutes, matching HA's statistics tier. */
-var LTS_BUCKET_MS = 5 * 6e4;
-/**
-* Row cap per (subject, series, scope) — one year of five-minute buckets, the
-* same number HA's own docs use. At ~60 bytes a row that is ~6 MB per series
-* per camera-year, against a `media` table already measured in hundreds of MB.
-*/
-var LTS_MAX_ROWS_PER_SERIES = 105120;
-/** Buckets written per transaction — bounds one statement, not the flush. */
-var FLUSH_BATCH = 200;
-/** How often the row cap is enforced. Rarely: it is a bound, not a deadline. */
-var CAP_SWEEP_INTERVAL_MS = 6 * 36e5;
-/**
-* The row's identity IS its four key columns (D871): a composite
-* `primaryKey` + `WITHOUT ROWID`, so the table is its own index and there is no
-* TEXT `id` repeating what the row already says. The old layout kept
-* `<subject>|<series>|<scope>|<bucketStart>` as a TEXT primary key beside the
-* four columns — 85 MB of rows plus a 44 MB autoindex for 1.07 M rows. A
-* composite-key collection is written with `upsertMany` (a bucket flushed twice
-* replaces itself) and read with `query` / `count` / `deleteWhere`; the calls
-* that address one row by id are refused by the engine.
-*/
-var LTS_KEY_COLUMNS = [
-	"subject",
-	"series",
-	"scope",
-	"bucketStart"
-];
-var LTS_COLUMNS = [
-	(
-	/** The camera id, or the node id. One column, because every query is
-	*  "this thing over time" and the thing is one or the other. */
-	{
-		name: "subject",
-		type: "TEXT"
-	}),
-	(
-	/** Numeric mirror of `subject` for camera rows, so a per-camera question is
-	*  answered by an integer index — every log line and every query about a
-	*  device in this repo is keyed by the numeric id. `NULL` for node rows. */
-	{
-		name: "deviceId",
-		type: "INTEGER"
-	}),
-	{
-		name: "series",
-		type: "TEXT"
-	},
-	(
-	/** Sub-scope within a series: a zoneId for occupancy, `''` otherwise. */
-	{
-		name: "scope",
-		type: "TEXT"
-	}),
-	(
-	/** Bucket start, wall-clock aligned to {@link LTS_BUCKET_MS}. */
-	{
-		name: "bucketStart",
-		type: "INTEGER"
-	}),
-	{
-		name: "samples",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "sum",
-		type: "REAL",
-		notNull: true
-	},
-	{
-		name: "min",
-		type: "REAL",
-		notNull: true
-	},
-	{
-		name: "max",
-		type: "REAL",
-		notNull: true
-	}
-];
-/**
-* The primary key serves every per-subject read (`subject, series, scope` then a
-* `bucketStart` range, already in bucket order); this index serves the read that
-* names a series without a subject. The old `deviceId` index went with the TEXT
-* id: nothing queries a series by the numeric mirror.
-*/
-var LTS_INDEXES = [{
-	name: "idx_lts_series_bucket",
-	columns: ["series", "bucketStart"]
-}];
-function ltsBucketStart(at, bucketMs = LTS_BUCKET_MS) {
-	return Math.floor(at / bucketMs) * bucketMs;
-}
-var LtsAggregator = class {
-	open = /* @__PURE__ */ new Map();
-	/** Every (subject, series, scope) that has produced a row in this process —
-	*  the groups the cap sweep has any reason to look at. */
-	groups = /* @__PURE__ */ new Set();
-	lastCapSweepAt = 0;
-	collection;
-	store;
-	logger;
-	nowFn;
-	bucketMs;
-	maxRows;
-	constructor(deps) {
-		this.collection = deps.collection;
-		this.store = deps.store;
-		this.logger = deps.logger;
-		this.nowFn = deps.now ?? (() => Date.now());
-		this.bucketMs = deps.bucketMs ?? LTS_BUCKET_MS;
-		this.maxRows = deps.maxRowsPerSeries ?? LTS_MAX_ROWS_PER_SERIES;
-	}
-	static declare(store, collection) {
-		return store.declareCollection.mutate({
-			collection,
-			columns: [...LTS_COLUMNS],
-			primaryKey: [...LTS_KEY_COLUMNS],
-			withoutRowid: true,
-			indexes: [...LTS_INDEXES]
-		});
-	}
-	/**
-	* Record one observation. Synchronous, allocation-free after the first
-	* sample of a bucket, and it cannot throw — it sits on paths that are
-	* already producing the value for another reason and must not learn a new
-	* failure mode.
-	*
-	* A non-finite value is DROPPED rather than folded in: one `NaN` would make
-	* `sum`, `min` and `max` all `NaN` for the whole bucket, turning a skewed
-	* row into a meaningless one.
-	*/
-	note(input) {
-		if (!Number.isFinite(input.value)) return;
-		const at = input.at ?? this.nowFn();
-		const scope = input.scope ?? "";
-		const bucketStart = ltsBucketStart(at, this.bucketMs);
-		const key = rowId(input.subject, input.series, scope, bucketStart);
-		const held = this.open.get(key);
-		if (held === void 0) {
-			this.open.set(key, {
-				subject: input.subject,
-				...input.deviceId !== void 0 ? { deviceId: input.deviceId } : {},
-				series: input.series,
-				scope,
-				bucketStart,
-				samples: 1,
-				sum: input.value,
-				min: input.value,
-				max: input.value
-			});
-			return;
-		}
-		held.samples += 1;
-		held.sum += input.value;
-		if (input.value < held.min) held.min = input.value;
-		if (input.value > held.max) held.max = input.value;
-	}
-	/** Buckets currently accumulating — diagnostics, and what a flush would write. */
-	openBuckets() {
-		return [...this.open.values()].map(toRow);
-	}
-	/**
-	* Write every bucket that has CLOSED (its window ended at or before `now`)
-	* and drop it from RAM. Returns the number of rows written.
-	*
-	* The current bucket is deliberately left alone: writing it early would mean
-	* rewriting it on the next tick, which turns one row into up to sixty and
-	* offers every one of them to the checkpoint lottery (D96).
-	*/
-	async flushDue(now = this.nowFn()) {
-		const currentBucket = ltsBucketStart(now, this.bucketMs);
-		const due = [...this.open.values()].filter((b) => b.bucketStart < currentBucket);
-		if (due.length === 0) {
-			await this.maybeSweepCap(now);
-			return 0;
-		}
-		let written = 0;
-		for (const batch of chunk(due, FLUSH_BATCH)) {
-			written += await this.writeBatch(batch);
-			for (const bucket of batch) this.open.delete(rowId(bucket.subject, bucket.series, bucket.scope, bucket.bucketStart));
-		}
-		await this.maybeSweepCap(now);
-		return written;
-	}
-	/**
-	* Upsert one batch in a single transaction. If the batch is refused as a
-	* whole (all-or-nothing), each bucket is retried alone so one bad row costs
-	* one interval, not forty. Returns the number of rows written.
-	*/
-	async writeBatch(batch) {
-		try {
-			await this.upsert(batch);
-			for (const bucket of batch) this.groups.add(groupKey(bucket.subject, bucket.series, bucket.scope));
-			return batch.length;
-		} catch (err) {
-			if (batch.length > 1) {
-				let written = 0;
-				for (const bucket of batch) written += await this.writeBatch([bucket]);
-				return written;
-			}
-			const bucket = batch[0];
-			this.logger.warn("lts bucket write failed — this interval will be missing", {
-				...bucket?.deviceId !== void 0 ? { tags: { deviceId: bucket.deviceId } } : {},
-				meta: {
-					collection: this.collection,
-					series: bucket?.series,
-					subject: bucket?.subject,
-					bucketStart: bucket?.bucketStart,
-					error: String(err)
-				}
-			});
-			return 0;
-		}
-	}
-	async upsert(batch) {
-		await this.store.upsertMany.mutate({
-			collection: this.collection,
-			conflict: [...LTS_KEY_COLUMNS],
-			records: batch.map((bucket) => ({ data: {
-				subject: bucket.subject,
-				deviceId: bucket.deviceId ?? null,
-				series: bucket.series,
-				scope: bucket.scope,
-				bucketStart: bucket.bucketStart,
-				samples: bucket.samples,
-				sum: bucket.sum,
-				min: bucket.min,
-				max: bucket.max
-			} }))
-		});
-	}
-	/** Read closed buckets back. The read surface every chart will use. */
-	async read(query = {}) {
-		const where = {};
-		if (query.series !== void 0) where["series"] = query.series;
-		if (query.subject !== void 0) where["subject"] = query.subject;
-		if (query.scope !== void 0) where["scope"] = query.scope;
-		const records = await this.store.query.query({
-			collection: this.collection,
-			filter: {
-				...Object.keys(where).length > 0 ? { where } : {},
-				...query.from !== void 0 || query.to !== void 0 ? { whereBetween: { bucketStart: [query.from ?? 0, query.to ?? Number.MAX_SAFE_INTEGER] } } : {},
-				orderBy: {
-					field: "bucketStart",
-					direction: "asc"
-				},
-				limit: query.limit ?? 5e3
-			}
-		});
-		const rows = [];
-		for (const record of records) {
-			const row = recordToRow(record.data);
-			if (row !== null) rows.push(row);
-		}
-		return rows;
-	}
-	/**
-	* Enforce the per-(subject, series, scope) row cap, at most once every six
-	* hours. Only groups this process has written to are examined: a group with
-	* no new rows cannot have crossed a cap it was under.
-	*/
-	async maybeSweepCap(now) {
-		if (now - this.lastCapSweepAt < CAP_SWEEP_INTERVAL_MS) return;
-		this.lastCapSweepAt = now;
-		for (const group of this.groups) {
-			const [subject, series, scope] = group.split("\0");
-			if (subject === void 0 || series === void 0 || scope === void 0) continue;
-			const where = {
-				subject,
-				series,
-				scope
-			};
-			try {
-				const excess = await this.store.count.query({
-					collection: this.collection,
-					filter: { where }
-				}) - this.maxRows;
-				if (excess <= 0) continue;
-				const cutoff = (await this.store.query.query({
-					collection: this.collection,
-					filter: {
-						where,
-						orderBy: {
-							field: "bucketStart",
-							direction: "asc"
-						},
-						limit: excess
-					}
-				})).at(-1)?.data["bucketStart"];
-				if (typeof cutoff !== "number") continue;
-				const { deleted } = await this.store.deleteWhere.mutate({
-					collection: this.collection,
-					filter: {
-						where,
-						whereBetween: { bucketStart: [0, cutoff] }
-					}
-				});
-				this.logger.info("lts row cap enforced", { meta: {
-					collection: this.collection,
-					series,
-					subject,
-					deleted,
-					cap: this.maxRows
-				} });
-			} catch (err) {
-				this.logger.warn("lts row cap sweep failed — the series keeps growing this cycle", { meta: {
-					collection: this.collection,
-					series,
-					subject,
-					error: String(err)
-				} });
-			}
-		}
-	}
-};
-function chunk(items, size) {
-	const out = [];
-	for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
-	return out;
-}
-function groupKey(subject, series, scope) {
-	return `${subject}${series}${scope}`;
-}
-function rowId(subject, series, scope, bucketStart) {
-	return `${subject}|${series}|${scope}|${bucketStart}`;
-}
-function toRow(bucket) {
-	return {
-		subject: bucket.subject,
-		...bucket.deviceId !== void 0 ? { deviceId: bucket.deviceId } : {},
-		series: bucket.series,
-		scope: bucket.scope,
-		bucketStart: bucket.bucketStart,
-		samples: bucket.samples,
-		sum: bucket.sum,
-		min: bucket.min,
-		max: bucket.max
-	};
-}
-/** Structural validation on read. A malformed row is skipped, never charted. */
-function recordToRow(data) {
-	const subject = data["subject"];
-	const series = data["series"];
-	const scope = data["scope"];
-	if (typeof subject !== "string" || typeof series !== "string") return null;
-	const bucketStart = Number(data["bucketStart"]);
-	const samples = Number(data["samples"]);
-	const sum = Number(data["sum"]);
-	const min = Number(data["min"]);
-	const max = Number(data["max"]);
-	if (![
-		bucketStart,
-		samples,
-		sum,
-		min,
-		max
-	].every((n) => Number.isFinite(n))) return null;
-	const rawDeviceId = data["deviceId"];
-	const deviceId = typeof rawDeviceId === "number" && Number.isFinite(rawDeviceId) ? rawDeviceId : void 0;
-	return {
-		subject,
-		...deviceId !== void 0 ? { deviceId } : {},
-		series,
-		scope: typeof scope === "string" ? scope : "",
-		bucketStart,
-		samples,
-		sum,
-		min,
-		max
-	};
-}
-//#endregion
-//#region src/pipeline-analytics/store/lts-store.ts
-/**
-* @durable class=ledger owner=pipeline-analytics
-*   write="one row per (camera, series, zone, 5-min bucket), written ONCE when the bucket closes; a camera with no sample writes nothing"
-*   retention="row CAP per (subject, series, scope) — 105,120 rows ≈ one year of 5-minute buckets. Deliberately not an age sweep: an LTS row has no owner to be orphaned from and no clock but its own (D61)."
-*/
-var LTS_COLLECTION = "pipeline-analytics:stats-5m-v2";
-var AnalyticsLts = class {
-	lts;
-	constructor(deps) {
-		this.lts = new LtsAggregator({
-			collection: LTS_COLLECTION,
-			store: deps.store,
-			logger: deps.logger,
-			...deps.now !== void 0 ? { now: deps.now } : {}
-		});
-	}
-	static declare(store) {
-		return LtsAggregator.declare(store, LTS_COLLECTION);
-	}
-	/**
-	* One camera sample. Synchronous and infallible by contract — every call
-	* site is a path that already produced the value for another reason, and
-	* none of them may learn a new failure mode because a chart exists.
-	*/
-	note(series, deviceId, value, at, scope) {
-		this.lts.note({
-			subject: String(deviceId),
-			deviceId,
-			series,
-			...scope !== void 0 ? { scope } : {},
-			value,
-			...at !== void 0 ? { at } : {}
-		});
-	}
-	/** Write every bucket that has closed. Driven by the addon's flush timer. */
-	flushDue(now) {
-		return this.lts.flushDue(now);
-	}
-	/** The read surface charts will use. */
-	read(query) {
-		return this.lts.read(query);
-	}
-	/** Buckets still accumulating — makes "is it running" answerable at once,
-	*  instead of after five minutes of silence. */
-	openBuckets() {
-		return this.lts.openBuckets();
-	}
-};
-//#endregion
 //#region src/pipeline-analytics/store/identity-store.ts
 /**
 * IdentityStore — per-person identity registry for face recognition.
@@ -101828,13 +101392,6 @@ var ANALYTICS_COLLECTIONS = [
 			why: "a phantom cell is a property of the SCENE — \"this patch of pixels keeps producing 4-second motionless tracks\" — not of any track. The tracks that produced it are dead by construction (that is the entire premise: the stationary registry cannot see them because they never live long enough to be promoted), so there is no owner it could be orphaned from. Its bound is its own 24h close window plus a 512-cell-per-device cap, both enforced by the registry on write — deliberately not an age sweep, which would be a second clock (D61)."
 		}
 	},
-	{
-		collection: LTS_COLLECTION,
-		classification: {
-			kind: "never-orphaned",
-			why: "a five-minute statistics row summarises an INTERVAL, not an entity — there is no owner it can be orphaned from. Its bound is a ROW CAP per (subject, series, scope) enforced by the aggregator itself (105,120 rows ≈ one year), deliberately not an age sweep: D61 collapsed ten disagreeing age clocks into one, and an LTS series has no clock but its own."
-		}
-	},
 	{
 		collection: RETRAIN_ANNOTATIONS_COLLECTION,
 		classification: {
@@ -107138,6 +106695,78 @@ Object.freeze({
 		"path": "online",
 		"valueType": "boolean"
 	}],
+	"dishwasher": [
+		{
+			"path": "state",
+			"valueType": "enum",
+			"enumValues": [
+				"idle",
+				"running",
+				"paused",
+				"finished",
+				"error",
+				"unavailable"
+			]
+		},
+		{
+			"path": "program",
+			"valueType": "string"
+		},
+		{
+			"path": "remainingMinutes",
+			"valueType": "number"
+		},
+		{
+			"path": "progressPercent",
+			"valueType": "number"
+		},
+		{
+			"path": "doorOpen",
+			"valueType": "boolean"
+		},
+		{
+			"path": "remoteStartAllowed",
+			"valueType": "boolean"
+		},
+		{
+			"path": "powerOn",
+			"valueType": "boolean"
+		},
+		{
+			"path": "saltLevel",
+			"valueType": "enum",
+			"enumValues": [
+				"ok",
+				"low",
+				"empty"
+			]
+		},
+		{
+			"path": "rinseAidLevel",
+			"valueType": "enum",
+			"enumValues": [
+				"ok",
+				"low",
+				"empty"
+			]
+		},
+		{
+			"path": "halfLoad",
+			"valueType": "boolean"
+		},
+		{
+			"path": "hygienePlus",
+			"valueType": "boolean"
+		},
+		{
+			"path": "errorCode",
+			"valueType": "number"
+		},
+		{
+			"path": "errorLabel",
+			"valueType": "string"
+		}
+	],
 	"doorbell": [{
 		"path": "lastPressedAt",
 		"valueType": "number"
@@ -107228,6 +106857,10 @@ Object.freeze({
 		"path": "detected",
 		"valueType": "boolean"
 	}],
+	"heating-valve": [{
+		"path": "position",
+		"valueType": "number"
+	}],
 	"humidifier": [
 		{
 			"path": "on",
@@ -110656,6 +110289,189 @@ var MigrationMarkerStore = class MigrationMarkerStore {
 	};
 };
 //#endregion
+//#region src/pipeline-analytics/store/analytics-history-keys.ts
+/** Declared addon series keys (D850). */
+var ANALYTICS_HISTORY_BUCKET_SERIES = {
+	motion: "addon:pipeline-analytics/motion",
+	"audio-dbfs": "addon:pipeline-analytics/audio-dbfs",
+	occupancy: "addon:pipeline-analytics/occupancy"
+};
+var ANALYTICS_AUDIO_LEVEL_KEY = "addon:pipeline-analytics/audio-level";
+/** Map the public cap enum to the device-history key (read path). */
+function historyKeyForLtsSeries(series) {
+	if (series === "battery") return "cap:battery.percentage";
+	return ANALYTICS_HISTORY_BUCKET_SERIES[series];
+}
+//#endregion
+//#region src/pipeline-analytics/store/analytics-history-producer.ts
+var BUCKET_SERIES_META = [
+	{
+		name: "motion",
+		displayName: "Motion events (region count)"
+	},
+	{
+		name: "audio-dbfs",
+		displayName: "Audio noise baseline (dBFS)",
+		unit: "dBFS"
+	},
+	{
+		name: "occupancy",
+		displayName: "Occupancy count"
+	}
+];
+var AUDIO_LEVEL_SERIES = {
+	name: "audio-level",
+	displayName: "Audio level (dBFS)",
+	unit: "dBFS"
+};
+var AnalyticsHistoryProducer = class {
+	accum = new require_clip_model_registry.BucketAccumulator();
+	deviceHistory;
+	logger;
+	nowFn;
+	declared = false;
+	constructor(deps) {
+		this.deviceHistory = deps.deviceHistory;
+		this.logger = deps.logger;
+		this.nowFn = deps.now ?? (() => Date.now());
+	}
+	async declare() {
+		if (this.declared) return;
+		for (const meta of BUCKET_SERIES_META) await this.deviceHistory.declareSeries({
+			name: meta.name,
+			subjectKind: "device",
+			kind: "gauge",
+			displayName: meta.displayName,
+			ingest: "buckets",
+			...meta.unit !== void 0 ? { unit: meta.unit } : {}
+		});
+		await this.deviceHistory.declareSeries({
+			name: AUDIO_LEVEL_SERIES.name,
+			subjectKind: "device",
+			kind: "gauge",
+			displayName: AUDIO_LEVEL_SERIES.displayName,
+			unit: AUDIO_LEVEL_SERIES.unit,
+			ingest: "points"
+		});
+		this.declared = true;
+	}
+	note(series, deviceId, value, at, scope) {
+		const key = ANALYTICS_HISTORY_BUCKET_SERIES[series];
+		this.accum.note(key, {
+			kind: "device",
+			deviceId
+		}, scope ?? "", value, at ?? this.nowFn());
+	}
+	recordAudioLevel(deviceId, dbfs, at) {
+		const record = this.deviceHistory.record;
+		if (record === void 0) return;
+		record.call(this.deviceHistory, { points: [{
+			key: ANALYTICS_AUDIO_LEVEL_KEY,
+			subject: {
+				kind: "device",
+				deviceId
+			},
+			scope: "",
+			ts: at,
+			value: dbfs
+		}] }).catch((err) => {
+			this.logger.warn("audio level history point not stored", {
+				tags: { deviceId },
+				meta: { error: err instanceof Error ? err.message : String(err) }
+			});
+		});
+	}
+	async flushDue(now) {
+		const at = now ?? this.nowFn();
+		const closed = this.accum.takeClosed(at);
+		if (closed.length === 0) return 0;
+		try {
+			return (await this.deviceHistory.recordBuckets({ buckets: closed })).accepted;
+		} catch (err) {
+			const dropped = this.accum.requeue(closed);
+			this.logger.warn("analytics history bucket flush failed — requeued", { meta: {
+				buckets: closed.length,
+				dropped: dropped.length,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			return 0;
+		}
+	}
+	pendingBucketCount() {
+		return this.accum.pendingBucketCount();
+	}
+	async readLongTermBuckets(input) {
+		const key = historyKeyForLtsSeries(input.series);
+		const result = await this.deviceHistory.query({
+			deviceId: input.deviceId,
+			key,
+			...input.scope !== void 0 ? { scope: input.scope } : {},
+			from: input.from,
+			to: input.to,
+			resolution: "5m",
+			...input.limit !== void 0 ? { maxPoints: input.limit } : {}
+		});
+		const out = [];
+		for (const s of result.series) for (const p of s.points) {
+			if (p.mean === null) continue;
+			out.push({
+				scope: s.scope,
+				bucketStart: p.t,
+				samples: p.samples,
+				sum: p.mean * p.samples,
+				min: p.min,
+				max: p.max
+			});
+		}
+		return out.toSorted((a, b) => a.bucketStart - b.bucketStart);
+	}
+	/** Admin debug read — maps device-history 5m buckets to legacy LTS row shape. */
+	async readDebug(input) {
+		const deviceId = input.subject !== void 0 ? Number(input.subject) : NaN;
+		if (!Number.isFinite(deviceId) || input.series === void 0) return [];
+		const key = historyKeyForLtsSeries(input.series);
+		const result = await this.deviceHistory.query({
+			deviceId,
+			key,
+			...input.scope !== void 0 ? { scope: input.scope } : {},
+			from: input.from ?? 0,
+			to: input.to ?? this.nowFn(),
+			resolution: "5m",
+			...input.limit !== void 0 ? { maxPoints: input.limit } : {}
+		});
+		const rows = [];
+		for (const s of result.series) for (const p of s.points) {
+			if (p.mean === null) continue;
+			rows.push({
+				subject: String(deviceId),
+				deviceId,
+				series: input.series,
+				scope: s.scope,
+				bucketStart: p.t,
+				samples: p.samples,
+				sum: p.mean * p.samples,
+				min: p.min,
+				max: p.max
+			});
+		}
+		return rows;
+	}
+	openBucketsForDebug() {
+		return [];
+	}
+};
+//#endregion
+//#region src/pipeline-analytics/store/device-history-write-client.ts
+/** Adapt tRPC-shaped `ctx.api.deviceHistory` to the producer's plain async surface. */
+function deviceHistoryWriteClient(api) {
+	return {
+		declareSeries: (input) => api.declareSeries.mutate(input),
+		record: (input) => api.record.mutate({ points: [...input.points] }),
+		recordBuckets: (input) => api.recordBuckets.mutate({ buckets: [...input.buckets] }),
+		query: (input) => api.query.query(input)
+	};
+}
+//#endregion
 //#region src/pipeline-analytics/store/media-subject-shot.ts
 /** Preference among rows that tie on time. Lower is better. */
 var SUBJECT_SHOT_KIND_RANK = {
@@ -112990,7 +112806,7 @@ var NcArtifactSecretSchema = require_clip_model_registry.string();
 var EmbeddingEnabledSchema = require_clip_model_registry.boolean();
 var SILENCE_FLOOR_DBFS = -55;
 var RETENTION_SWEEP_INTERVAL_MS = 5 * 6e4;
-/** How often closed LTS buckets are written. See `store/lts-store.ts`. */
+/** How often closed history buckets are flushed. See `analytics-history-producer.ts`. */
 var LTS_FLUSH_INTERVAL_MS = 6e4;
 /**
 * How long the events ops-log is kept when the cluster has said nothing. 30
@@ -114646,7 +114462,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	/**
 	* Five-minute long-term statistics — the tier this system did not have.
 	* Global for every camera (no opt-in: a baseline nobody enables is the
-	* failure mode `observe` mode was already in). See `store/lts-store.ts`.
+	* failure mode `observe` mode was already in). See `analytics-history-producer.ts`.
 	*/
 	lts = null;
 	/** The runner node that last produced a frame for a camera — see
@@ -114813,7 +114629,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			onAudioResult: (data) => this.handleAudioResult(data),
 			onMotionAnalysis: (deviceId, data, timestampMs) => this.handleMotionAnalysis(deviceId, data, timestampMs),
 			onOnboardMotion: (deviceId, data, timestampMs) => this.handleOnboardMotion(deviceId, data, timestampMs),
-			onBatterySample: (deviceId, percentage, at) => this.lts?.note("battery", deviceId, percentage, at),
 			onSensorStateChanged: (data, timestampMs) => this.dispatchSensorStateChanged(data, timestampMs),
 			onBindingsChanged: (data) => this.handleBindingsChangedEvent(data),
 			onDeviceUnregistered: (deviceId) => this.handleDeviceUnregisteredEvent(deviceId),
@@ -115142,7 +114957,6 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			TrackingTapeIndexStore.declare(api.settingsStore),
 			BirthDecisionLedgerStore.declare(api.settingsStore),
 			TrackRelationsStore.declare(api.settingsStore),
-			AnalyticsLts.declare(api.settingsStore),
 			declarePaAnalyticsBootRecordBackedLegacy(api.settingsStore, isHub),
 			declareNotificationCenterBootCollections(api.settingsStore, isHub)
 		]);
@@ -115498,9 +115312,12 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 			}
 		});
 		this.refreshDeviceAlertSettings();
-		this.lts = new AnalyticsLts({
-			store: api.settingsStore,
-			logger: logger.child("lts")
+		this.lts = new AnalyticsHistoryProducer({
+			deviceHistory: deviceHistoryWriteClient(api.deviceHistory),
+			logger: logger.child("device-history")
+		});
+		this.lts.declare().catch((err) => {
+			logger.warn("pipeline-analytics history series declare failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
 		const lts = this.lts;
 		const eventStore = new EventStore({
@@ -116967,8 +116784,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 					open: []
 				};
 				return {
-					rows: (await lts.read(input)).map(withMean),
-					open: lts.openBuckets().map(withMean)
+					rows: (await lts.readDebug(input)).map(withMean),
+					open: lts.openBucketsForDebug().map(withMean)
 				};
 			},
 			/**
@@ -121044,33 +120861,8 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 		});
 		this.levelStateByDevice.set(deviceId, res.nextState);
 		if (!res.emit) return;
-		const draft = levelAudioEventDraft(deviceId, timestamp, frame);
-		this.lastAudioInsertByDevice.set(deviceId, {
-			className: void 0,
-			atMs: timestamp
-		});
-		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),
-			source: {
-				type: "addon",
-				id: "pipeline-analytics",
-				addonId: "pipeline-analytics"
-			},
-			category: require_clip_model_registry.EventCategory.PipelineAnalyticsDetectionEvent,
-			data: {
-				deviceId,
-				kind: "audio",
-				eventId: ev.id,
-				timestamp: ev.timestamp
-			}
-		});
+		const dbfs = level?.dbfs ?? Number.NEGATIVE_INFINITY;
+		this.lts?.recordAudioLevel(deviceId, dbfs, timestamp);
 	}
 	/**
 	* Persist motion-analysis bus events into the EPISODE tracker (D475): a
@@ -125185,21 +124977,7 @@ var PipelineAnalyticsAddon = class PipelineAnalyticsAddon extends require_clip_m
 	async readLongTermSeries(input) {
 		const lts = this.lts;
 		if (!lts) throw new Error("pipeline-analytics: the long-term store is not ready yet");
-		return (await lts.read({
-			subject: String(input.deviceId),
-			series: input.series,
-			...input.scope !== void 0 ? { scope: input.scope } : {},
-			from: input.from,
-			to: input.to,
-			...input.limit !== void 0 ? { limit: input.limit } : {}
-		})).map((r) => ({
-			scope: r.scope,
-			bucketStart: r.bucketStart,
-			samples: r.samples,
-			sum: r.sum,
-			min: r.min,
-			max: r.max
-		}));
+		return lts.readLongTermBuckets(input);
 	}
 	async getEventStoreFootprint() {
 		return this.queryFacade.getEventStoreFootprint();