@camstack/system 1.2.446 → 1.2.448

package/dist/builtins/device-history/device-history.addon.js

@@ -0,0 +1,2823 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+require("../../chunk-Cek0wNdY.js");
+const require_dist = require("../../dist-Ct88catN.js");
+//#region src/builtins/device-history/store/series-registry.ts
+function subjectIdOf(subject) {
+	return subject.kind === "device" ? `d:${subject.deviceId}` : `n:${subject.nodeId}`;
+}
+function deviceIdOf(subject) {
+	return subject.kind === "device" ? subject.deviceId : null;
+}
+function identityOf(key, subjectId, scope) {
+	return `${key}\u0000${subjectId}\u0000${scope}`;
+}
+var LOAD_PAGE = 5e3;
+var SeriesRegistry = class {
+	store;
+	metrics = /* @__PURE__ */ new Map();
+	byIdentity = /* @__PURE__ */ new Map();
+	byId = /* @__PURE__ */ new Map();
+	inflight = /* @__PURE__ */ new Map();
+	removeListeners = [];
+	constructor(store) {
+		this.store = store;
+	}
+	async load() {
+		this.metrics.clear();
+		this.byIdentity.clear();
+		this.byId.clear();
+		for (const m of await this.store.loadMetrics()) this.metrics.set(m.key, m);
+		let afterId = 0;
+		for (;;) {
+			const page = await this.store.loadSeriesPage(afterId, LOAD_PAGE);
+			for (const s of page) this.index(s);
+			const last = page[page.length - 1];
+			if (last === void 0 || page.length < LOAD_PAGE) break;
+			afterId = last.id;
+		}
+	}
+	index(series) {
+		this.byId.set(series.id, series);
+		this.byIdentity.set(identityOf(series.key, series.subject, series.scope), series);
+	}
+	metric(key) {
+		return this.metrics.get(key);
+	}
+	allMetrics() {
+		return [...this.metrics.values()];
+	}
+	/** Persist and remember a metric; idempotent. */
+	async declareMetric(metric) {
+		const existing = this.metrics.get(metric.key);
+		if (existing !== void 0 && sameMetric(existing, metric)) return;
+		await this.store.upsertMetric(metric);
+		this.metrics.set(metric.key, metric);
+	}
+	find(key, subjectId, scope) {
+		return this.byIdentity.get(identityOf(key, subjectId, scope));
+	}
+	byIdOf(id) {
+		return this.byId.get(id);
+	}
+	all() {
+		return [...this.byId.values()];
+	}
+	forSubject(subjectId) {
+		return this.all().filter((s) => s.subject === subjectId);
+	}
+	forKeyAndSubject(key, subjectId) {
+		return this.all().filter((s) => s.key === key && s.subject === subjectId);
+	}
+	/** The series, created on first sight. `ts` stamps `first_ts`/`last_ts` of a new one. */
+	async ensure(key, subject, scope, ts) {
+		const subjectId = subjectIdOf(subject);
+		const identity = identityOf(key, subjectId, scope);
+		const known = this.byIdentity.get(identity);
+		if (known !== void 0) return known;
+		const pending = this.inflight.get(identity);
+		if (pending !== void 0) return pending;
+		const created = this.create(key, subjectId, deviceIdOf(subject), scope, ts).finally(() => {
+			this.inflight.delete(identity);
+		});
+		this.inflight.set(identity, created);
+		return created;
+	}
+	async create(key, subjectId, deviceId, scope, ts) {
+		const stored = await this.store.findSeries(key, subjectId, scope) ?? await this.store.insertSeries({
+			key,
+			subject: subjectId,
+			deviceId,
+			scope,
+			ts
+		});
+		this.index(stored);
+		return stored;
+	}
+	/** Remember a widened span (the store write is the caller's). */
+	noteSpan(id, firstTs, lastTs) {
+		const current = this.byId.get(id);
+		if (current === void 0) return;
+		this.index({
+			...current,
+			firstTs: Math.min(current.firstTs, firstTs),
+			lastTs: Math.max(current.lastTs, lastTs)
+		});
+	}
+	remove(id) {
+		const current = this.byId.get(id);
+		if (current === void 0) return;
+		this.byId.delete(id);
+		this.byIdentity.delete(identityOf(current.key, current.subject, current.scope));
+		for (const listener of this.removeListeners) listener(current);
+	}
+	/** Per-series state elsewhere (last recorded value, dirty marks, rate limits) is dropped through this. */
+	onRemove(listener) {
+		this.removeListeners.push(listener);
+	}
+};
+function sameMetric(a, b) {
+	return a.source === b.source && a.ownerAddon === b.ownerAddon && a.subjectKind === b.subjectKind && a.kind === b.kind && a.unit === b.unit && a.displayName === b.displayName && a.ingest === b.ingest;
+}
+//#endregion
+//#region src/builtins/device-history/capture/capture-filter.ts
+/**
+* The per-point capture decision for a cap field (D850, plan §5.3). PURE.
+*
+* A point is written only when the value CHANGED from the last one recorded,
+* by more than the field's deadband, and no sooner than its capture floor:
+*
+*  - `unchanged`  — the same value again; a change-only series stores nothing;
+*  - `deadband`   — a change smaller than `deadband` (absolute) or
+*                   `deadbandPct` (relative to the last recorded value); a slow
+*                   drift is still caught, because the comparison is against
+*                   the last RECORDED value, not the last seen one;
+*  - `defer`      — changed, but inside `minIntervalMs` of the last recorded
+*                   point. NOT dropped: the caller keeps it pending and emits it
+*                   once the floor has passed, so a burst never loses its end.
+*/
+/** Tolerance for floating-point steps such as 21.3 - 21.2 against a 0.1 deadband. */
+var DEADBAND_EPSILON = 1e-9;
+/** The capture floor of a field: its own `minIntervalMs`, else the kind's default. */
+function minIntervalOf(spec) {
+	if (spec.minIntervalMs !== void 0) return spec.minIntervalMs;
+	return spec.kind === "boolean" ? 0 : require_dist.HISTORY_DEFAULT_MIN_INTERVAL_MS;
+}
+function clearsDeadband(spec, last, value) {
+	if (spec.kind === "boolean") return true;
+	const delta = Math.abs(value - last);
+	if (spec.deadband !== void 0 && delta < spec.deadband - DEADBAND_EPSILON) return false;
+	if (spec.deadbandPct !== void 0) {
+		if (delta < Math.abs(last) * spec.deadbandPct / 100 - DEADBAND_EPSILON) return false;
+	}
+	return true;
+}
+function decideCapture(spec, recorded, value, now, options = {}) {
+	if (!Number.isFinite(value)) return {
+		action: "skip",
+		reason: "non-finite"
+	};
+	if (recorded === null) return { action: "emit" };
+	if (value === recorded.value) return {
+		action: "skip",
+		reason: "unchanged"
+	};
+	if (!clearsDeadband(spec, recorded.value, value)) return {
+		action: "skip",
+		reason: "deadband"
+	};
+	if (options.ignoreFloor !== true) {
+		const notBefore = recorded.ts + minIntervalOf(spec);
+		if (now < notBefore) return {
+			action: "defer",
+			notBefore
+		};
+	}
+	return { action: "emit" };
+}
+//#endregion
+//#region src/builtins/device-history/capture/device-directory.ts
+/**
+* Which devices exist and what type they are — the "real devices only" gate
+* (`hub` and `container` are not devices anyone charts) and the
+* `excludeDeviceTypes` gate of a history field.
+*
+* Built from `deviceManager.listAll({ projection: 'slim' })` at boot and every
+* reconcile, and per device (`getDevice`) the first time a state event names one
+* the map does not know. A FAILED read changes nothing (D49): the previous map
+* stays, and the failure is counted and logged, never read as "no devices".
+*/
+function isRealDeviceType(type) {
+	return type !== require_dist.DeviceType.Hub && type !== require_dist.DeviceType.Container;
+}
+var DeviceDirectory = class {
+	source;
+	counters;
+	logger;
+	clock;
+	types = /* @__PURE__ */ new Map();
+	inflight = /* @__PURE__ */ new Map();
+	refreshInflight = null;
+	lastFullRefreshAt = null;
+	constructor(source, counters, logger, clock) {
+		this.source = source;
+		this.counters = counters;
+		this.logger = logger;
+		this.clock = clock;
+	}
+	typeOf(deviceId) {
+		return this.types.get(deviceId);
+	}
+	size() {
+		return this.types.size;
+	}
+	/** When the full listing last ANSWERED; `null` before the first answer. */
+	lastRefreshAt() {
+		return this.lastFullRefreshAt;
+	}
+	/** Ids in the directory now (the last full listing plus per-device lookups). */
+	listedIds() {
+		return new Set(this.types.keys());
+	}
+	knows(deviceId) {
+		return this.types.has(deviceId);
+	}
+	/** Replace the map from the full listing. Returns false (map untouched) when the read failed. */
+	refresh() {
+		if (this.refreshInflight !== null) return this.refreshInflight;
+		const run = this.doRefresh().finally(() => {
+			this.refreshInflight = null;
+		});
+		this.refreshInflight = run;
+		return run;
+	}
+	async doRefresh() {
+		try {
+			const all = await this.source.listAll();
+			this.types = new Map(all.map((d) => [d.id, d.type]));
+			this.lastFullRefreshAt = this.clock();
+			this.counters.directoryRefreshAt = this.lastFullRefreshAt;
+			return true;
+		} catch (err) {
+			this.logger.warn("device directory: listing failed — keeping the previous map", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return false;
+		}
+	}
+	/** The device's type, asking the hub once when the map does not know it. */
+	ensure(deviceId) {
+		const known = this.types.get(deviceId);
+		if (known !== void 0) return Promise.resolve(known);
+		const pending = this.inflight.get(deviceId);
+		if (pending !== void 0) return pending;
+		const run = this.lookup(deviceId).finally(() => {
+			this.inflight.delete(deviceId);
+		});
+		this.inflight.set(deviceId, run);
+		return run;
+	}
+	async lookup(deviceId) {
+		try {
+			const device = await this.source.getDevice(deviceId);
+			if (device === null) return void 0;
+			this.types.set(device.id, device.type);
+			return device.type;
+		} catch (err) {
+			this.logger.warn("device directory: lookup failed", {
+				tags: { deviceId },
+				meta: { error: err instanceof Error ? err.message : String(err) }
+			});
+			return;
+		}
+	}
+};
+//#endregion
+//#region src/builtins/device-history/capture/field-path.ts
+/**
+* Reading a history field out of a cap slice. A catalog path is a top-level
+* `runtimeState` key or a path into a FIXED object (`dustBin.level`); the
+* catalog guard keeps it out of arrays and records, so a plain walk is enough.
+*/
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The value at `path`, or `undefined` when any step is missing or not an object. */
+function readPath(slice, path) {
+	let current = slice;
+	for (const step of path.split(".")) {
+		if (!isRecord$1(current)) return void 0;
+		current = current[step];
+	}
+	return current;
+}
+/**
+* The number a field contributes: a finite number for a gauge/counter, 0/1 for
+* a boolean field. Anything else (null, undefined, a string, NaN) is NOT a
+* reading — `null` means unknown and must never become 0.
+*/
+function readNumeric(slice, path, kind) {
+	const raw = readPath(slice, path);
+	if (kind === "boolean") {
+		if (typeof raw === "boolean") return raw ? 1 : 0;
+		return null;
+	}
+	if (typeof raw === "number" && Number.isFinite(raw)) return raw;
+	return null;
+}
+/** A unit string a `unitFrom` sibling field states, or `null` when it states none. */
+function readUnit(slice, unitFrom) {
+	const raw = readPath(slice, unitFrom);
+	return typeof raw === "string" && raw.length > 0 ? raw : null;
+}
+//#endregion
+//#region src/builtins/device-history/capture/capture-engine.ts
+var CAP_KEY_PREFIX = "cap:";
+function capSeriesKey(capName, fieldPath) {
+	return `${CAP_KEY_PREFIX}${capName}.${fieldPath}`;
+}
+function humanize(capName, fieldPath) {
+	const field = fieldPath.replace(/([A-Z])/g, " $1").replace(/\./g, " ").toLowerCase();
+	return `${capName.replace(/-/g, " ")} ${field}`;
+}
+/** The metric rows of every catalog field (owner `device-history`). */
+function catalogMetrics(catalog, now) {
+	return Object.entries(catalog).flatMap(([capName, fields]) => Object.entries(fields).map(([path, spec]) => ({
+		key: capSeriesKey(capName, path),
+		source: "cap",
+		ownerAddon: "device-history",
+		subjectKind: "device",
+		kind: spec.kind,
+		unit: spec.unit ?? null,
+		displayName: spec.displayName ?? humanize(capName, path),
+		ingest: "points",
+		declaredAt: now
+	})));
+}
+/** Devices waiting on a type lookup; beyond this the oldest is dropped (and counted). */
+var MAX_PARKED_DEVICES = 5e3;
+/** Seeding reads the newest raw row of each cap series, this many at once. */
+var SEED_CONCURRENCY = 8;
+var CaptureEngine = class {
+	deps;
+	recorded = /* @__PURE__ */ new Map();
+	pending = /* @__PURE__ */ new Map();
+	parked = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** Learn the last recorded value of every cap series from the store, so a restart repeats nothing. */
+	async seed() {
+		const { registry, store } = this.deps;
+		const capSeries = registry.all().filter((s) => s.key.startsWith(CAP_KEY_PREFIX));
+		for (let i = 0; i < capSeries.length; i += SEED_CONCURRENCY) await Promise.all(capSeries.slice(i, i + SEED_CONCURRENCY).map(async (series) => {
+			const newest = await store.rawBefore(series.id, Number.MAX_SAFE_INTEGER);
+			if (newest === null) return;
+			this.recorded.set(identityOf(series.key, series.subject, series.scope), newest);
+		}));
+	}
+	/** One `DeviceStateChanged`. Synchronous: the bus must never wait on us. */
+	handleState(deviceId, capName, slice, at) {
+		const fields = this.deps.catalog[capName];
+		if (fields === void 0) return;
+		const { counters, directory } = this.deps;
+		counters.eventsSeen += 1;
+		if (this.deps.optedOut().has(deviceId)) {
+			counters.skip("opted-out");
+			return;
+		}
+		const type = directory.typeOf(deviceId);
+		if (type === void 0) {
+			this.park(deviceId, capName, slice, at);
+			return;
+		}
+		if (!isRealDeviceType(type)) {
+			counters.skip("not-a-real-device");
+			return;
+		}
+		for (const [path, spec] of Object.entries(fields)) {
+			if (spec.excludeDeviceTypes?.includes(type) === true) {
+				counters.skip("excluded-device-type");
+				continue;
+			}
+			const value = readNumeric(slice, path, spec.kind);
+			if (value === null) continue;
+			this.consider(deviceId, capName, path, spec, value, at, false);
+		}
+	}
+	consider(deviceId, capName, path, spec, value, at, reconciling) {
+		const key = capSeriesKey(capName, path);
+		const subject = {
+			kind: "device",
+			deviceId
+		};
+		const identity = identityOf(key, `d:${deviceId}`, "");
+		const decision = decideCapture(spec, this.recorded.get(identity) ?? null, value, at, { ignoreFloor: reconciling });
+		if (decision.action === "emit") {
+			this.emit(identity, key, subject, value, at);
+			if (reconciling) this.deps.counters.reconciledPoints += 1;
+			return;
+		}
+		if (decision.action === "defer") {
+			this.pending.set(identity, {
+				key,
+				subject,
+				spec,
+				value
+			});
+			return;
+		}
+		this.pending.delete(identity);
+		this.deps.counters.skip(decision.reason);
+	}
+	emit(identity, key, subject, value, ts) {
+		this.recorded.set(identity, {
+			value,
+			ts
+		});
+		this.pending.delete(identity);
+		this.deps.counters.pointsEmitted += 1;
+		this.deps.writer.enqueue({
+			key,
+			subject,
+			scope: "",
+			ts,
+			value
+		});
+	}
+	/** Emit every pending change whose capture floor has passed, stamped where the floor ended. */
+	tickPending(now) {
+		for (const [identity, p] of this.pending) {
+			const recorded = this.recorded.get(identity);
+			const deviceId = p.subject.kind === "device" ? p.subject.deviceId : -1;
+			if (this.deps.optedOut().has(deviceId)) {
+				this.pending.delete(identity);
+				this.deps.counters.skip("opted-out");
+				continue;
+			}
+			const notBefore = (recorded?.ts ?? now) + minIntervalOf(p.spec);
+			if (now < notBefore) continue;
+			this.emit(identity, p.key, p.subject, p.value, notBefore);
+			this.deps.counters.trailingEmitted += 1;
+		}
+	}
+	park(deviceId, capName, slice, at) {
+		const existing = this.parked.get(deviceId);
+		if (existing !== void 0) {
+			existing.set(capName, {
+				capName,
+				slice,
+				at
+			});
+			return;
+		}
+		if (this.parked.size >= MAX_PARKED_DEVICES) {
+			const oldest = this.parked.keys().next();
+			if (oldest.done !== true) this.parked.delete(oldest.value);
+			this.deps.counters.skip("parked-overflow");
+		}
+		this.parked.set(deviceId, new Map([[capName, {
+			capName,
+			slice,
+			at
+		}]]));
+		this.deps.directory.ensure(deviceId).then((type) => {
+			const waiting = this.parked.get(deviceId);
+			this.parked.delete(deviceId);
+			if (waiting === void 0) return;
+			if (type === void 0) {
+				this.deps.counters.skip("unknown-device", waiting.size);
+				return;
+			}
+			for (const p of waiting.values()) this.handleState(deviceId, p.capName, p.slice, p.at);
+		});
+	}
+	/**
+	* Restore a missed change from the state mirror's whole snapshot: a field whose
+	* value differs from the last recorded one gets a point stamped `now`.
+	* Additive only — it never removes anything, and a snapshot that could not be
+	* read is the CALLER's failure to count (D49), not an empty snapshot.
+	*/
+	reconcile(snapshots, now) {
+		const optedOut = this.deps.optedOut();
+		for (const [deviceKey, caps] of Object.entries(snapshots)) {
+			const deviceId = Number(deviceKey);
+			if (!Number.isInteger(deviceId) || optedOut.has(deviceId)) continue;
+			const type = this.deps.directory.typeOf(deviceId);
+			if (type === void 0 || !isRealDeviceType(type)) continue;
+			for (const [capName, fields] of Object.entries(this.deps.catalog)) {
+				const slice = caps[capName];
+				if (slice === void 0) continue;
+				for (const [path, spec] of Object.entries(fields)) {
+					if (spec.excludeDeviceTypes?.includes(type) === true) continue;
+					const value = readNumeric(slice, path, spec.kind);
+					if (value === null) continue;
+					this.consider(deviceId, capName, path, spec, value, now, true);
+				}
+			}
+		}
+	}
+	/**
+	* Forget what was "recorded" for points that never reached the store (dropped),
+	* so the next change-only comparison — and the next reconcile — starts from what
+	* is really there instead of leaving a hole until the value moves.
+	*/
+	forget(points) {
+		for (const p of points) {
+			const identity = identityOf(p.key, subjectIdOf(p.subject), p.scope);
+			this.recorded.delete(identity);
+			this.pending.delete(identity);
+		}
+	}
+	/** A purged series leaves no state behind. */
+	forgetSeries(series) {
+		const identity = identityOf(series.key, series.subject, series.scope);
+		this.recorded.delete(identity);
+		this.pending.delete(identity);
+	}
+	/** For status and specs. */
+	pendingCount() {
+		return this.pending.size;
+	}
+	/** The last recorded state of a series, for specs. */
+	lastRecorded(key, subjectId) {
+		return this.recorded.get(identityOf(key, subjectId, ""));
+	}
+};
+//#endregion
+//#region src/builtins/device-history/capture/point-writer.ts
+var FLUSH_INTERVAL_MS = 1e4;
+var MAX_BUFFER_AGE_MS = 6e4;
+/** Beyond this many queued points the oldest are dropped. */
+var MAX_QUEUE_POINTS = 1e5;
+/** The share of the queue dropped at once when it is full. */
+var QUEUE_DROP_FRACTION = .1;
+/** Device ids named in a drop line, so a line stays short. */
+var MAX_DEVICES_IN_DROP_LINE = 20;
+/** Tagged per-device drop lines per event, and the quiet time between events that print them. */
+var MAX_DEVICE_LINES_PER_DROP = 10;
+var DEVICE_LINES_MIN_GAP_MS = 1e4;
+var PointWriter = class {
+	deps;
+	queue = [];
+	flushing = null;
+	lastDeviceLinesAt = Number.NEGATIVE_INFINITY;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	enqueue(point) {
+		this.queue.push({
+			...point,
+			bufferedAt: this.deps.clock()
+		});
+		if (this.queue.length > 1e5) {
+			const count = Math.ceil(MAX_QUEUE_POINTS * QUEUE_DROP_FRACTION);
+			this.drop(this.queue.splice(0, count), "queue full");
+		}
+	}
+	depth() {
+		return this.queue.length;
+	}
+	/** One flush at a time; a call while one runs waits for it and returns. */
+	flush() {
+		if (this.flushing !== null) return this.flushing;
+		const run = this.doFlush().finally(() => {
+			this.flushing = null;
+		});
+		this.flushing = run;
+		return run;
+	}
+	async doFlush() {
+		const batch = this.queue;
+		if (batch.length === 0) return;
+		this.queue = [];
+		const { registry, store, counters, logger, clock } = this.deps;
+		try {
+			const bySeries = /* @__PURE__ */ new Map();
+			for (const point of batch) {
+				const series = await registry.ensure(point.key, point.subject, point.scope, point.ts);
+				const list = bySeries.get(series.id) ?? [];
+				list.push({
+					ts: point.ts,
+					value: point.value
+				});
+				bySeries.set(series.id, list);
+			}
+			const rows = [...bySeries].flatMap(([seriesId, points]) => points.map((p) => ({
+				seriesId,
+				ts: p.ts,
+				value: p.value
+			})));
+			await store.upsertRaw(rows);
+			await this.recordSpans(bySeries);
+			counters.pointsWritten += rows.length;
+			counters.addRawRows(rows.length);
+			counters.lastFlushAt = clock();
+			this.deps.onWritten([...bySeries].map(([seriesId, points]) => ({
+				seriesId,
+				timestamps: points.map((p) => p.ts)
+			})));
+		} catch (err) {
+			counters.flushFailures += 1;
+			logger.warn("device-history: raw flush failed — keeping the batch", { meta: {
+				points: batch.length,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			this.requeue(batch);
+		}
+	}
+	async recordSpans(bySeries) {
+		const { registry, store } = this.deps;
+		const touch = [];
+		for (const [seriesId, points] of bySeries) {
+			const current = registry.byIdOf(seriesId);
+			if (current === void 0) continue;
+			let minTs = Number.POSITIVE_INFINITY;
+			let maxTs = Number.NEGATIVE_INFINITY;
+			for (const p of points) {
+				if (p.ts < minTs) minTs = p.ts;
+				if (p.ts > maxTs) maxTs = p.ts;
+			}
+			if (minTs < current.firstTs) await store.widenSeriesStart(seriesId, minTs);
+			if (maxTs > current.lastTs) touch.push({
+				id: seriesId,
+				lastTs: maxTs
+			});
+			registry.noteSpan(seriesId, minTs, maxTs);
+		}
+		await store.touchSeries(touch);
+	}
+	requeue(batch) {
+		const now = this.deps.clock();
+		const keep = [];
+		const dropped = [];
+		for (const point of batch) if (now - point.bufferedAt > 6e4) dropped.push(point);
+		else keep.push(point);
+		this.queue = [...keep, ...this.queue];
+		if (dropped.length > 0) this.drop(dropped, `older than ${MAX_BUFFER_AGE_MS} ms`);
+	}
+	/** Account for, say, and report to the owner a set of points that will never be written. */
+	drop(dropped, reason) {
+		if (dropped.length === 0) return;
+		const { counters, logger, clock } = this.deps;
+		counters.pointsDropped += dropped.length;
+		const perDevice = /* @__PURE__ */ new Map();
+		for (const p of dropped) if (p.subject.kind === "device") perDevice.set(p.subject.deviceId, (perDevice.get(p.subject.deviceId) ?? 0) + 1);
+		logger.error("device-history: dropped points the store would not take", { meta: {
+			dropped: dropped.length,
+			reason,
+			maxAgeMs: MAX_BUFFER_AGE_MS,
+			deviceIds: [...perDevice.keys()].slice(0, MAX_DEVICES_IN_DROP_LINE)
+		} });
+		const now = clock();
+		if (now - this.lastDeviceLinesAt >= DEVICE_LINES_MIN_GAP_MS) {
+			this.lastDeviceLinesAt = now;
+			for (const [deviceId, count] of [...perDevice].slice(0, MAX_DEVICE_LINES_PER_DROP)) logger.warn("device-history: points dropped for this device", {
+				tags: { deviceId },
+				meta: {
+					dropped: count,
+					reason
+				}
+			});
+		}
+		this.deps.onDropped(dropped);
+	}
+};
+//#endregion
+//#region src/builtins/device-history/time/bucket-time.ts
+/**
+* Bucket arithmetic for the three rollup tiers (D850, plan §4/§5.5).
+*
+* 5m and 1h buckets are aligned to UTC; a 1d bucket starts at HUB-LOCAL
+* midnight, so a day is 23, 24 or 25 hours long across a DST change (operator
+* answer Q4). Pure: the zone is the process zone (`TZ`), nothing is read from
+* the environment here.
+*/
+var FIVE_MINUTES_MS = 5 * 6e4;
+var HOUR_MS = 60 * 6e4;
+var DAY_MS = 24 * HOUR_MS;
+function floorTo(ts, widthMs) {
+	return Math.floor(ts / widthMs) * widthMs;
+}
+/** Hub-local midnight at or before `ts`. */
+function startOfLocalDay(ts) {
+	const d = new Date(ts);
+	d.setHours(0, 0, 0, 0);
+	return d.getTime();
+}
+/** The local midnight following the local midnight `dayStart`. */
+function nextLocalDayStart(dayStart) {
+	const d = new Date(dayStart);
+	d.setDate(d.getDate() + 1);
+	d.setHours(0, 0, 0, 0);
+	return d.getTime();
+}
+/** Start of the `tier` bucket containing `ts`. */
+function bucketStartOf(tier, ts) {
+	if (tier === "5m") return floorTo(ts, FIVE_MINUTES_MS);
+	if (tier === "1h") return floorTo(ts, HOUR_MS);
+	return startOfLocalDay(ts);
+}
+/** Exclusive end of the `tier` bucket that starts at `start`. */
+function bucketEndOf(tier, start) {
+	if (tier === "5m") return start + FIVE_MINUTES_MS;
+	if (tier === "1h") return start + HOUR_MS;
+	return nextLocalDayStart(start);
+}
+/** Quiet time after a bucket closes before it is rolled up (late writers). */
+var ROLLUP_GRACE_MS = {
+	"5m": 3e4,
+	"1h": 5 * 6e4,
+	"1d": 15 * 6e4
+};
+function addRefusal(refusals, key, reason) {
+	const byReason = refusals.get(key) ?? /* @__PURE__ */ new Map();
+	byReason.set(reason, (byReason.get(reason) ?? 0) + 1);
+	refusals.set(key, byReason);
+}
+function toResult(accepted, refusals) {
+	return {
+		accepted,
+		refused: [...refusals].flatMap(([key, byReason]) => [...byReason].map(([reason, count]) => ({
+			key,
+			reason,
+			count
+		})))
+	};
+}
+var ProducerIngest = class {
+	deps;
+	/** Last accepted point time per series, for the sustained-rate bound. */
+	lastAccepted = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** A purged series leaves no rate-limit state behind. */
+	forgetSeries(series) {
+		this.lastAccepted.delete(identityOf(series.key, series.subject, series.scope));
+	}
+	async declareSeries(callerAddonId, input) {
+		if (callerAddonId === null) throw new Error("declareSeries: the caller addon could not be identified");
+		const key = `addon:${callerAddonId}/${input.name}`;
+		const metric = {
+			key,
+			source: "addon",
+			ownerAddon: callerAddonId,
+			subjectKind: input.subjectKind,
+			kind: input.kind,
+			unit: input.unit ?? null,
+			displayName: input.displayName,
+			ingest: input.ingest,
+			declaredAt: this.deps.clock()
+		};
+		await this.deps.registry.declareMetric(metric);
+		return { key };
+	}
+	/** Why a write to `metric` by `caller` for this subject must be refused, or null. */
+	async refusalFor(callerAddonId, metric, ingest, subject) {
+		if (metric === void 0) return "undeclared";
+		if (callerAddonId === null || metric.ownerAddon !== callerAddonId) return "not-owner";
+		if (metric.ingest !== ingest) return "ingest-mismatch";
+		if (metric.subjectKind !== subject.kind) return "undeclared";
+		if (subject.kind === "device") {
+			if (this.deps.optedOut().has(subject.deviceId)) return "opted-out";
+			const type = await this.deps.directory.ensure(subject.deviceId);
+			if (type === void 0 || !isRealDeviceType(type)) return "not-a-real-device";
+		}
+		return null;
+	}
+	async record(callerAddonId, points) {
+		const { clock, counters } = this.deps;
+		const now = clock();
+		const { rawMs } = this.deps.retention();
+		const refusals = /* @__PURE__ */ new Map();
+		let accepted = 0;
+		for (const point of points) {
+			const reason = await this.refusalFor(callerAddonId, this.deps.registry.metric(point.key), "points", point.subject);
+			if (reason !== null) {
+				addRefusal(refusals, point.key, reason);
+				counters.refuse(reason);
+				continue;
+			}
+			if (!Number.isFinite(point.value) || !Number.isFinite(point.ts) || point.ts > now + 3e5 || point.ts < now - rawMs) {
+				addRefusal(refusals, point.key, "out-of-range");
+				counters.refuse("out-of-range");
+				continue;
+			}
+			const identity = identityOf(point.key, subjectIdOf(point.subject), point.scope);
+			const last = this.lastAccepted.get(identity);
+			if (last !== void 0 && point.ts >= last && point.ts - last < 1e4) {
+				addRefusal(refusals, point.key, "rate");
+				counters.refuse("rate");
+				continue;
+			}
+			this.lastAccepted.set(identity, Math.max(last ?? point.ts, point.ts));
+			this.deps.writer.enqueue({
+				key: point.key,
+				subject: point.subject,
+				scope: point.scope,
+				ts: point.ts,
+				value: point.value
+			});
+			accepted += 1;
+		}
+		counters.ingestAccepted += accepted;
+		return toResult(accepted, refusals);
+	}
+	async recordBuckets(callerAddonId, buckets) {
+		const { clock, counters, registry, store } = this.deps;
+		const now = clock();
+		const { fiveMinuteMs } = this.deps.retention();
+		const refusals = /* @__PURE__ */ new Map();
+		const rows = [];
+		for (const bucket of buckets) {
+			const reason = await this.refusalFor(callerAddonId, registry.metric(bucket.key), "buckets", bucket.subject);
+			if (reason !== null) {
+				addRefusal(refusals, bucket.key, reason);
+				counters.refuse(reason);
+				continue;
+			}
+			const aligned = bucket.bucketStart % FIVE_MINUTES_MS === 0;
+			const consistent = Number.isFinite(bucket.sum) && Number.isFinite(bucket.min) && Number.isFinite(bucket.max) && bucket.min <= bucket.max;
+			if (!aligned || !consistent || bucket.bucketStart > now + 3e5 || bucket.bucketStart < now - fiveMinuteMs) {
+				addRefusal(refusals, bucket.key, "out-of-range");
+				counters.refuse("out-of-range");
+				continue;
+			}
+			const series = await registry.ensure(bucket.key, bucket.subject, bucket.scope, bucket.bucketStart);
+			rows.push({
+				seriesId: series.id,
+				bucketStart: bucket.bucketStart,
+				samples: bucket.samples,
+				sum: bucket.sum,
+				min: bucket.min,
+				max: bucket.max,
+				last: bucket.last,
+				lastTs: bucket.lastTs,
+				twSum: null,
+				twMs: null
+			});
+		}
+		await store.upsertRollups("5m", rows);
+		const bySeries = /* @__PURE__ */ new Map();
+		for (const row of rows) bySeries.set(row.seriesId, [...bySeries.get(row.seriesId) ?? [], row.bucketStart]);
+		for (const [seriesId, starts] of bySeries) counters.noteRollupRows("5m", seriesId, starts.toSorted((a, b) => a - b));
+		await this.recordSpans(rows);
+		for (const row of rows) this.deps.onBucketWritten(row.seriesId, row.bucketStart);
+		counters.ingestAccepted += rows.length;
+		return toResult(rows.length, refusals);
+	}
+	/** Persist the widened span of every series a bucket batch touched, then remember it. */
+	async recordSpans(rows) {
+		const { registry, store } = this.deps;
+		const spans = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			const end = row.lastTs ?? row.bucketStart;
+			const span = spans.get(row.seriesId);
+			spans.set(row.seriesId, {
+				first: span === void 0 ? row.bucketStart : Math.min(span.first, row.bucketStart),
+				last: span === void 0 ? end : Math.max(span.last, end)
+			});
+		}
+		const touch = [];
+		for (const [id, span] of spans) {
+			const current = registry.byIdOf(id);
+			if (current === void 0) continue;
+			if (span.first < current.firstTs) await store.widenSeriesStart(id, span.first);
+			if (span.last > current.lastTs) touch.push({
+				id,
+				lastTs: span.last
+			});
+			registry.noteSpan(id, span.first, span.last);
+		}
+		await store.touchSeries(touch);
+	}
+};
+//#endregion
+//#region src/builtins/device-history/query/history-query.ts
+var TIER_ORDER = [
+	"raw",
+	"5m",
+	"1h",
+	"1d"
+];
+var BUCKET_MS = {
+	"5m": FIVE_MINUTES_MS,
+	"1h": HOUR_MS,
+	"1d": DAY_MS
+};
+/** A key with more scopes than this is cut (a zone x class matrix, not a chart). */
+var MAX_SCOPES = 50;
+function retentionMsOf(tier, policy) {
+	if (tier === "raw") return policy.rawDays * DAY_MS;
+	if (tier === "5m") return policy.fiveMinuteDays * DAY_MS;
+	if (tier === "1h") return policy.hourDays * DAY_MS;
+	return policy.dayDays === null || policy.dayDays <= 0 ? null : policy.dayDays * DAY_MS;
+}
+function rawPoint(ts, value) {
+	return {
+		t: ts,
+		samples: 1,
+		mean: value,
+		twMean: null,
+		min: value,
+		max: value,
+		last: value
+	};
+}
+function rollupPoint(row) {
+	return {
+		t: row.bucketStart,
+		samples: row.samples,
+		mean: row.samples > 0 ? row.sum / row.samples : null,
+		twMean: row.twSum !== null && row.twMs !== null && row.twMs > 0 ? row.twSum / row.twMs : null,
+		min: row.min,
+		max: row.max,
+		last: row.last
+	};
+}
+var HistoryQuery = class {
+	deps;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async query(input) {
+		const { registry } = this.deps;
+		const subjectId = subjectIdOf(input.subject);
+		const wanted = registry.forKeyAndSubject(input.key, subjectId).filter((s) => input.scope === void 0 || s.scope === input.scope).toSorted((a, b) => a.scope.localeCompare(b.scope)).slice(0, MAX_SCOPES);
+		const candidates = this.coveringTiers(input.from);
+		const forced = input.resolution === "auto" ? null : input.resolution;
+		const order = forced === null ? candidates : [forced];
+		let chosen = order[order.length - 1] ?? "1d";
+		let reads = [];
+		for (const [index, tier] of order.entries()) {
+			const last = index === order.length - 1;
+			if (!this.fits(tier, input, wanted) && !last) continue;
+			chosen = tier;
+			reads = await Promise.all(wanted.map(async (s) => [s, await this.readTier(tier, s, input)]));
+			if (reads.some(([, r]) => r.overflow) && !last) continue;
+			break;
+		}
+		const series = [];
+		for (const [s, read] of reads) series.push({
+			scope: s.scope,
+			before: await this.before(chosen, s, input.from),
+			points: read.points
+		});
+		return {
+			resolution: chosen,
+			series,
+			truncated: reads.some(([, r]) => r.overflow)
+		};
+	}
+	/** Tiers whose retention covers `from`, finest first; the coarsest is always present. */
+	coveringTiers(from) {
+		const policy = this.deps.retention();
+		const now = this.deps.clock();
+		const covering = TIER_ORDER.filter((tier) => {
+			const ms = retentionMsOf(tier, policy);
+			return ms === null || from >= now - ms;
+		});
+		return covering.length > 0 ? covering : ["1d"];
+	}
+	/** Cheap fit test for rollup tiers; raw is decided by the read itself. */
+	fits(tier, input, series) {
+		if (tier === "raw" || series.length === 0) return true;
+		const width = BUCKET_MS[tier];
+		return Math.ceil((input.to - input.from) / width) <= input.maxPoints;
+	}
+	async readTier(tier, series, input) {
+		const { store } = this.deps;
+		const limit = input.maxPoints + 1;
+		if (tier === "raw") {
+			const rows = await store.readRaw(series.id, input.from, input.to, limit, "desc");
+			return this.shape(rows.map((r) => rawPoint(r.ts, r.value)), input.maxPoints);
+		}
+		const lower = bucketStartOf(tier, input.from);
+		const rows = await store.readRollups(tier, series.id, lower, input.to, limit, "desc");
+		return this.shape(rows.map(rollupPoint), input.maxPoints);
+	}
+	/** Rows arrive newest first and one over the bound; keep the newest `maxPoints`, oldest first. */
+	shape(newestFirst, maxPoints) {
+		const overflow = newestFirst.length > maxPoints;
+		return {
+			points: (overflow ? newestFirst.slice(0, maxPoints) : newestFirst).toReversed(),
+			overflow
+		};
+	}
+	async before(tier, series, from) {
+		const { store } = this.deps;
+		if (tier === "raw") {
+			const p = await store.rawBefore(series.id, from);
+			return p === null ? null : {
+				t: p.ts,
+				value: p.value
+			};
+		}
+		const row = await store.rollupBefore(tier, series.id, bucketStartOf(tier, from));
+		return row === null ? null : {
+			t: row.bucketStart,
+			value: row.last
+		};
+	}
+	async listSeries(subject) {
+		const { registry } = this.deps;
+		const slices = /* @__PURE__ */ new Map();
+		const infos = [];
+		for (const s of registry.forSubject(subjectIdOf(subject))) {
+			const metric = registry.metric(s.key);
+			if (metric === void 0) continue;
+			infos.push({
+				key: s.key,
+				scope: s.scope,
+				kind: metric.kind,
+				unit: await this.unitOf(subject, s, metric.unit, slices),
+				displayName: metric.displayName,
+				source: metric.source,
+				firstTs: s.firstTs,
+				lastTs: s.lastTs
+			});
+		}
+		return infos.toSorted((a, b) => a.key.localeCompare(b.key) || a.scope.localeCompare(b.scope));
+	}
+	/** The metric's fixed unit, else the device's own (a `unitFrom` field), else unknown. */
+	async unitOf(subject, series, fixed, slices) {
+		if (fixed !== null || subject.kind !== "device" || !series.key.startsWith("cap:")) return fixed;
+		const spec = this.specOf(series.key);
+		if (spec?.unitFrom === void 0) return null;
+		const capName = series.key.slice(CAP_KEY_PREFIX.length, series.key.indexOf("."));
+		const pending = slices.get(capName) ?? this.deps.readCapSlice(subject.deviceId, capName).catch(() => null);
+		slices.set(capName, pending);
+		const slice = await pending;
+		return slice === null ? null : readUnit(slice, spec.unitFrom);
+	}
+	specOf(key) {
+		const body = key.slice(CAP_KEY_PREFIX.length);
+		const dot = body.indexOf(".");
+		if (dot < 0) return void 0;
+		return this.deps.catalog[body.slice(0, dot)]?.[body.slice(dot + 1)];
+	}
+};
+//#endregion
+//#region src/builtins/device-history/retention/departure-tracker.ts
+var DEPARTED_ABSENCE_MS = 7 * DAY_MS;
+var DepartureTracker = class {
+	store;
+	registry;
+	logger;
+	missing = /* @__PURE__ */ new Map();
+	constructor(store, registry, logger) {
+		this.store = store;
+		this.registry = registry;
+		this.logger = logger;
+	}
+	async load() {
+		this.missing = await this.store.loadDepartures();
+	}
+	missingSince(deviceId) {
+		return this.missing.get(deviceId);
+	}
+	/** Forget a device's clock — its series were removed because it was DELETED (D865). */
+	async forget(deviceId) {
+		await this.store.clearMissing([deviceId]);
+		const next = new Map(this.missing);
+		next.delete(deviceId);
+		this.missing = next;
+	}
+	/** Feed one SUCCESSFUL listing. A failed read never reaches here. */
+	async observe(listed, now) {
+		const withSeries = new Set(this.registry.all().flatMap((s) => s.deviceId === null ? [] : [s.deviceId]));
+		const back = [...this.missing.keys()].filter((id) => listed.has(id));
+		const gone = [...withSeries].filter((id) => !listed.has(id) && !this.missing.has(id));
+		try {
+			await this.store.clearMissing(back);
+			await this.store.markMissing(gone, now);
+		} catch (err) {
+			this.logger.warn("device-history: departure clock not written", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return;
+		}
+		const next = new Map(this.missing);
+		for (const id of back) next.delete(id);
+		for (const id of gone) next.set(id, now);
+		this.missing = next;
+	}
+};
+//#endregion
+//#region src/builtins/device-history/retention/retention.ts
+var DEFAULT_RETENTION = {
+	rawDays: 7,
+	fiveMinuteDays: 14,
+	hourDays: 365,
+	dayDays: null
+};
+/** Cutoff per tier: rows strictly older are deleted. `null` = keep forever. */
+function retentionCutoffs(policy, now) {
+	return {
+		raw: now - policy.rawDays * DAY_MS,
+		"5m": now - policy.fiveMinuteDays * DAY_MS,
+		"1h": now - policy.hourDays * DAY_MS,
+		"1d": policy.dayDays === null || policy.dayDays <= 0 ? null : now - policy.dayDays * DAY_MS
+	};
+}
+var TIERS = [
+	"raw",
+	"5m",
+	"1h",
+	"1d"
+];
+var RETENTION_STEP_MS = {
+	raw: HOUR_MS,
+	"5m": HOUR_MS,
+	"1h": DAY_MS,
+	"1d": DAY_MS
+};
+var MAX_PURGES_PER_RUN = 20;
+/** Width of one delete statement's time range, per tier. */
+var SLICE_MS = {
+	raw: DAY_MS,
+	"5m": DAY_MS,
+	"1h": 30 * DAY_MS,
+	"1d": 30 * DAY_MS
+};
+/** A bucket's start may precede the series' first point by up to a day. */
+var BUCKET_LEAD_MS = 2 * DAY_MS;
+/** The short tiers hold nothing older than this unless the operator configured more. */
+var SHORT_TIER_LOOKBACK_MS = 400 * DAY_MS;
+var yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+var RetentionJob = class {
+	deps;
+	appliedUpTo = /* @__PURE__ */ new Map();
+	running = null;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	run(policy, now) {
+		if (this.running !== null) return this.running;
+		const run = this.doRun(policy, now).finally(() => {
+			this.running = null;
+		});
+		this.running = run;
+		return run;
+	}
+	async doRun(policy, now) {
+		const { registry, counters, logger } = this.deps;
+		const cutoffs = retentionCutoffs(policy, now);
+		try {
+			for (const tier of TIERS) {
+				const cutoff = cutoffs[tier];
+				if (cutoff === null) continue;
+				for (const series of registry.all()) {
+					if (series.firstTs - 864e5 >= cutoff) continue;
+					if (tier === "raw" && registry.metric(series.key)?.ingest === "buckets") continue;
+					const marker = `${tier}:${series.id}`;
+					const applied = this.appliedUpTo.get(marker);
+					if (applied !== void 0 && cutoff - applied < RETENTION_STEP_MS[tier]) continue;
+					const lo = Math.max(0, applied === void 0 ? series.firstTs - BUCKET_LEAD_MS : applied - RETENTION_STEP_MS[tier]);
+					counters.addDeleted(tier, await this.deleteSliced(tier, series.id, lo, cutoff - 1));
+					this.appliedUpTo.set(marker, cutoff);
+				}
+			}
+			await this.purgeDeparted(now);
+			counters.retentionLastRunAt = now;
+		} catch (err) {
+			logger.warn("device-history: retention pass failed — retried at the next run", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+	}
+	/** Delete `[lo, hiInclusive]` of one tier in time slices, yielding between them. */
+	/** Drop the visit markers of a purged series. */
+	forgetSeries(seriesId) {
+		for (const tier of TIERS) this.appliedUpTo.delete(`${tier}:${seriesId}`);
+	}
+	async deleteSliced(tier, seriesId, lo, hiInclusive) {
+		const yieldNow = this.deps.yieldNow ?? yieldToEventLoop;
+		let deleted = 0;
+		for (let from = lo; from <= hiInclusive; from += SLICE_MS[tier]) {
+			const to = Math.min(from + SLICE_MS[tier] - 1, hiInclusive);
+			deleted += await this.deps.store.deleteRange(tier, seriesId, from, to);
+			await yieldNow();
+		}
+		return deleted;
+	}
+	/** Tier by tier in slices, then the series row (and whatever the slices missed). */
+	async purgeSeries(series, now) {
+		for (const tier of TIERS) {
+			const lo = tier === "raw" || tier === "5m" ? Math.max(series.firstTs - BUCKET_LEAD_MS, now - SHORT_TIER_LOOKBACK_MS) : series.firstTs - BUCKET_LEAD_MS;
+			await this.deleteSliced(tier, series.id, Math.max(0, lo), now + DAY_MS);
+		}
+		await this.deps.store.deleteSeries(series.id);
+	}
+	/**
+	* Delete every series of a DELETED device now (D865). Driven by a tombstone
+	* through the `device-removal-hook`, never by a listing: the week-long
+	* absence clock above remains the backstop for a device removed before
+	* tombstones existed.
+	*/
+	async purgeDevice(deviceId, now) {
+		const { registry, counters } = this.deps;
+		let purged = 0;
+		for (const series of registry.all()) {
+			if (series.deviceId !== deviceId) continue;
+			await this.purgeSeries(series, now);
+			registry.remove(series.id);
+			counters.purgedSeries += 1;
+			purged += 1;
+		}
+		return purged;
+	}
+	async purgeDeparted(now) {
+		const { registry, departures, counters, logger } = this.deps;
+		let purged = 0;
+		for (const series of registry.all()) {
+			if (purged >= MAX_PURGES_PER_RUN) break;
+			if (series.deviceId === null) continue;
+			const since = departures.missingSince(series.deviceId);
+			if (since === void 0 || now - since < DEPARTED_ABSENCE_MS) continue;
+			await this.purgeSeries(series, now);
+			registry.remove(series.id);
+			counters.purgedSeries += 1;
+			purged += 1;
+			logger.info("device-history: purged the series of an unregistered device", {
+				tags: { deviceId: series.deviceId },
+				meta: { key: series.key }
+			});
+		}
+	}
+};
+//#endregion
+//#region src/builtins/device-history/store/history-schema.ts
+var HISTORY_NAMESPACE = "device-history";
+var COLLECTIONS = {
+	metrics: "metrics",
+	series: "series",
+	raw: "raw",
+	rollup5m: "rollup-5m",
+	rollup1h: "rollup-1h",
+	rollup1d: "rollup-1d",
+	optOuts: "device-opt-outs",
+	departures: "device-departures"
+};
+function rollupCollectionOf(tier) {
+	if (tier === "5m") return COLLECTIONS.rollup5m;
+	if (tier === "1h") return COLLECTIONS.rollup1h;
+	return COLLECTIONS.rollup1d;
+}
+function rollupDeclaration(collection) {
+	return {
+		namespace: HISTORY_NAMESPACE,
+		collection,
+		database: "history",
+		primaryKey: ["series_id", "bucket_start"],
+		withoutRowid: true,
+		columns: [
+			{
+				name: "series_id",
+				type: "INTEGER"
+			},
+			{
+				name: "bucket_start",
+				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
+			},
+			{
+				name: "last",
+				type: "REAL"
+			},
+			{
+				name: "last_ts",
+				type: "INTEGER"
+			},
+			{
+				name: "tw_sum",
+				type: "REAL"
+			},
+			{
+				name: "tw_ms",
+				type: "INTEGER"
+			}
+		]
+	};
+}
+var HISTORY_DECLARATIONS = [
+	{
+		namespace: HISTORY_NAMESPACE,
+		collection: COLLECTIONS.metrics,
+		database: "history",
+		columns: [
+			{
+				name: "key",
+				type: "TEXT",
+				primaryKey: true,
+				notNull: true
+			},
+			{
+				name: "source",
+				type: "TEXT",
+				notNull: true
+			},
+			{
+				name: "owner_addon",
+				type: "TEXT",
+				notNull: true
+			},
+			{
+				name: "subject_kind",
+				type: "TEXT",
+				notNull: true
+			},
+			{
+				name: "kind",
+				type: "TEXT",
+				notNull: true
+			},
+			{
+				name: "unit",
+				type: "TEXT"
+			},
+			{
+				name: "display_name",
+				type: "TEXT",
+				notNull: true
+			},
+			{
+				name: "ingest",
+				type: "TEXT",
+				notNull: true
+			},
+			{
+				name: "declared_at",
+				type: "INTEGER",
+				notNull: true
+			}
+		]
+	},
+	{
+		namespace: HISTORY_NAMESPACE,
+		collection: COLLECTIONS.series,
+		database: "history",
+		columns: [
+			{
+				name: "id",
+				type: "INTEGER",
+				primaryKey: true
+			},
+			{
+				name: "key",
+				type: "TEXT",
+				notNull: true
+			},
+			{
+				name: "subject",
+				type: "TEXT",
+				notNull: true
+			},
+			{
+				name: "device_id",
+				type: "INTEGER"
+			},
+			{
+				name: "scope",
+				type: "TEXT",
+				notNull: true,
+				defaultValue: ""
+			},
+			{
+				name: "first_ts",
+				type: "INTEGER",
+				notNull: true
+			},
+			{
+				name: "last_ts",
+				type: "INTEGER",
+				notNull: true
+			}
+		],
+		indexes: [{
+			name: "idx_dh_series_identity",
+			columns: [
+				"key",
+				"subject",
+				"scope"
+			],
+			unique: true
+		}, {
+			name: "idx_dh_series_device",
+			columns: ["device_id"]
+		}]
+	},
+	{
+		namespace: HISTORY_NAMESPACE,
+		collection: COLLECTIONS.raw,
+		database: "history",
+		primaryKey: ["series_id", "ts"],
+		withoutRowid: true,
+		columns: [
+			{
+				name: "series_id",
+				type: "INTEGER"
+			},
+			{
+				name: "ts",
+				type: "INTEGER"
+			},
+			{
+				name: "value",
+				type: "REAL",
+				notNull: true
+			}
+		]
+	},
+	rollupDeclaration(COLLECTIONS.rollup5m),
+	rollupDeclaration(COLLECTIONS.rollup1h),
+	rollupDeclaration(COLLECTIONS.rollup1d),
+	{
+		namespace: HISTORY_NAMESPACE,
+		collection: COLLECTIONS.optOuts,
+		columns: [
+			{
+				name: "id",
+				type: "INTEGER",
+				primaryKey: true
+			},
+			{
+				name: "device_id",
+				type: "INTEGER",
+				notNull: true
+			},
+			{
+				name: "opted_out_at",
+				type: "INTEGER",
+				notNull: true
+			}
+		],
+		indexes: [{
+			name: "idx_dh_opt_outs_device",
+			columns: ["device_id"],
+			unique: true
+		}]
+	},
+	{
+		namespace: HISTORY_NAMESPACE,
+		collection: COLLECTIONS.departures,
+		columns: [
+			{
+				name: "id",
+				type: "INTEGER",
+				primaryKey: true
+			},
+			{
+				name: "device_id",
+				type: "INTEGER",
+				notNull: true
+			},
+			{
+				name: "missing_since",
+				type: "INTEGER",
+				notNull: true
+			}
+		],
+		indexes: [{
+			name: "idx_dh_departures_device",
+			columns: ["device_id"],
+			unique: true
+		}]
+	}
+];
+//#endregion
+//#region src/builtins/device-history/store/row-readers.ts
+function readNumber(data, column) {
+	const v = data[column];
+	if (typeof v === "number" && Number.isFinite(v)) return v;
+	throw new Error(`history row: column "${column}" is not a number (${typeof v})`);
+}
+function readNumberOrNull(data, column) {
+	const v = data[column];
+	if (v === null || v === void 0) return null;
+	if (typeof v === "number" && Number.isFinite(v)) return v;
+	throw new Error(`history row: column "${column}" is not a number or null (${typeof v})`);
+}
+function readText(data, column) {
+	const v = data[column];
+	if (typeof v === "string") return v;
+	throw new Error(`history row: column "${column}" is not a string (${typeof v})`);
+}
+function readTextOrNull(data, column) {
+	const v = data[column];
+	if (v === null || v === void 0) return null;
+	if (typeof v === "string") return v;
+	throw new Error(`history row: column "${column}" is not a string or null (${typeof v})`);
+}
+//#endregion
+//#region src/builtins/device-history/store/history-store.ts
+/** Rows per `upsertMany` call: bounds one transaction on the history thread. */
+var WRITE_CHUNK = 1e3;
+/** Operations per `transact`. */
+var TRANSACT_CHUNK = 200;
+/** Rows per read page. */
+var READ_PAGE = 5e3;
+function chunks(items, size) {
+	const out = [];
+	for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+	return out;
+}
+function parseKind(value) {
+	if (value === "gauge" || value === "counter" || value === "boolean") return value;
+	throw new Error(`history row: unknown kind "${value}"`);
+}
+function parseMetric(data) {
+	const source = readText(data, "source");
+	const subjectKind = readText(data, "subject_kind");
+	const ingest = readText(data, "ingest");
+	if (source !== "cap" && source !== "addon") throw new Error(`history row: unknown source "${source}"`);
+	if (subjectKind !== "device" && subjectKind !== "node") throw new Error(`history row: unknown subject_kind "${subjectKind}"`);
+	if (ingest !== "points" && ingest !== "buckets") throw new Error(`history row: unknown ingest "${ingest}"`);
+	return {
+		key: readText(data, "key"),
+		source,
+		ownerAddon: readText(data, "owner_addon"),
+		subjectKind,
+		kind: parseKind(readText(data, "kind")),
+		unit: readTextOrNull(data, "unit"),
+		displayName: readText(data, "display_name"),
+		ingest,
+		declaredAt: readNumber(data, "declared_at")
+	};
+}
+function parseSeries(data) {
+	return {
+		id: readNumber(data, "id"),
+		key: readText(data, "key"),
+		subject: readText(data, "subject"),
+		deviceId: readNumberOrNull(data, "device_id"),
+		scope: readText(data, "scope"),
+		firstTs: readNumber(data, "first_ts"),
+		lastTs: readNumber(data, "last_ts")
+	};
+}
+function parseRollup(data) {
+	return {
+		seriesId: readNumber(data, "series_id"),
+		bucketStart: readNumber(data, "bucket_start"),
+		samples: readNumber(data, "samples"),
+		sum: readNumber(data, "sum"),
+		min: readNumber(data, "min"),
+		max: readNumber(data, "max"),
+		last: readNumberOrNull(data, "last"),
+		lastTs: readNumberOrNull(data, "last_ts"),
+		twSum: readNumberOrNull(data, "tw_sum"),
+		twMs: readNumberOrNull(data, "tw_ms")
+	};
+}
+function rollupData(row) {
+	return {
+		series_id: row.seriesId,
+		bucket_start: row.bucketStart,
+		samples: row.samples,
+		sum: row.sum,
+		min: row.min,
+		max: row.max,
+		last: row.last,
+		last_ts: row.lastTs,
+		tw_sum: row.twSum,
+		tw_ms: row.twMs
+	};
+}
+function collectionOf(tier) {
+	return tier === "raw" ? COLLECTIONS.raw : rollupCollectionOf(tier);
+}
+function orderColumnOf(tier) {
+	return tier === "raw" ? "ts" : "bucket_start";
+}
+var HistoryStore = class {
+	door;
+	constructor(door) {
+		this.door = door;
+	}
+	async declare() {
+		for (const declaration of HISTORY_DECLARATIONS) await this.door.declareCollection.mutate(declaration);
+	}
+	async loadMetrics() {
+		return (await this.door.query.query({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.metrics,
+			filter: { limit: 2e4 }
+		})).map((r) => parseMetric(r.data));
+	}
+	async upsertMetric(metric) {
+		await this.door.upsertMany.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.metrics,
+			conflict: ["key"],
+			records: [{ data: {
+				key: metric.key,
+				source: metric.source,
+				owner_addon: metric.ownerAddon,
+				subject_kind: metric.subjectKind,
+				kind: metric.kind,
+				unit: metric.unit,
+				display_name: metric.displayName,
+				ingest: metric.ingest,
+				declared_at: metric.declaredAt
+			} }]
+		});
+	}
+	/** Series with `id > afterId`, ascending — the boot load pages with this. */
+	async loadSeriesPage(afterId, limit) {
+		return (await this.door.query.query({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.series,
+			filter: {
+				whereBetween: { id: [afterId + 1, Number.MAX_SAFE_INTEGER] },
+				orderBy: {
+					field: "id",
+					direction: "asc"
+				},
+				limit
+			}
+		})).map((r) => parseSeries(r.data));
+	}
+	async findSeries(key, subject, scope) {
+		const first = (await this.door.query.query({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.series,
+			filter: {
+				where: {
+					key,
+					subject,
+					scope
+				},
+				limit: 1
+			}
+		}))[0];
+		return first === void 0 ? null : parseSeries(first.data);
+	}
+	async insertSeries(series) {
+		const { id } = await this.door.insert.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.series,
+			record: { data: {
+				key: series.key,
+				subject: series.subject,
+				device_id: series.deviceId,
+				scope: series.scope,
+				first_ts: series.ts,
+				last_ts: series.ts
+			} }
+		});
+		return {
+			id: typeof id === "number" ? id : Number(id),
+			key: series.key,
+			subject: series.subject,
+			deviceId: series.deviceId,
+			scope: series.scope,
+			firstTs: series.ts,
+			lastTs: series.ts
+		};
+	}
+	async touchSeries(updates) {
+		for (const batch of chunks(updates, TRANSACT_CHUNK)) await this.door.transact.mutate({
+			namespace: HISTORY_NAMESPACE,
+			ops: batch.map((u) => ({
+				op: "update",
+				collection: COLLECTIONS.series,
+				id: String(u.id),
+				data: { last_ts: u.lastTs }
+			}))
+		});
+	}
+	async widenSeriesStart(id, firstTs) {
+		await this.door.update.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.series,
+			id: String(id),
+			data: { first_ts: firstTs }
+		});
+	}
+	async upsertRaw(rows) {
+		for (const batch of chunks(rows, WRITE_CHUNK)) await this.door.upsertMany.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.raw,
+			conflict: ["series_id", "ts"],
+			records: batch.map((r) => ({ data: {
+				series_id: r.seriesId,
+				ts: r.ts,
+				value: r.value
+			} }))
+		});
+	}
+	/** Points of a series in `[from, toInclusive]`, ascending, at most `limit`. */
+	async readRaw(seriesId, from, toInclusive, limit, direction = "asc") {
+		return (await this.door.query.query({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.raw,
+			filter: {
+				where: { series_id: seriesId },
+				whereBetween: { ts: [from, toInclusive] },
+				orderBy: {
+					field: "ts",
+					direction
+				},
+				limit
+			}
+		})).map((r) => ({
+			ts: readNumber(r.data, "ts"),
+			value: readNumber(r.data, "value")
+		}));
+	}
+	/** The newest raw point strictly before `ts`, if any. */
+	async rawBefore(seriesId, ts) {
+		return (await this.readRaw(seriesId, 0, ts - 1, 1, "desc"))[0] ?? null;
+	}
+	async upsertRollups(tier, rows) {
+		for (const batch of chunks(rows, WRITE_CHUNK)) await this.door.upsertMany.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: rollupCollectionOf(tier),
+			conflict: ["series_id", "bucket_start"],
+			records: batch.map((r) => ({ data: rollupData(r) }))
+		});
+	}
+	async readRollups(tier, seriesId, from, toInclusive, limit, direction = "asc") {
+		return (await this.door.query.query({
+			namespace: HISTORY_NAMESPACE,
+			collection: rollupCollectionOf(tier),
+			filter: {
+				where: { series_id: seriesId },
+				whereBetween: { bucket_start: [from, toInclusive] },
+				orderBy: {
+					field: "bucket_start",
+					direction
+				},
+				limit
+			}
+		})).map((r) => parseRollup(r.data));
+	}
+	/** The newest rollup row of `tier` strictly before `bucketStart`, if any. */
+	async rollupBefore(tier, seriesId, bucketStart) {
+		return (await this.readRollups(tier, seriesId, 0, bucketStart - 1, 1, "desc"))[0] ?? null;
+	}
+	/** Delete one series' rows of a tier with the order column in `[lo, hiInclusive]`. */
+	async deleteRange(tier, seriesId, lo, hiInclusive) {
+		const { deleted } = await this.door.deleteWhere.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: collectionOf(tier),
+			filter: {
+				where: { series_id: seriesId },
+				whereBetween: { [orderColumnOf(tier)]: [lo, hiInclusive] }
+			}
+		});
+		return deleted;
+	}
+	/** Delete every row of one series, in every tier, then the series row. */
+	async deleteSeries(seriesId) {
+		for (const tier of [
+			"raw",
+			"5m",
+			"1h",
+			"1d"
+		]) await this.door.deleteWhere.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: collectionOf(tier),
+			filter: { where: { series_id: seriesId } }
+		});
+		await this.door.delete.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.series,
+			key: String(seriesId)
+		});
+	}
+	async countRows(tier) {
+		return this.door.count.query({
+			namespace: HISTORY_NAMESPACE,
+			collection: collectionOf(tier)
+		});
+	}
+	async loadOptOuts() {
+		const rows = await this.door.query.query({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.optOuts,
+			filter: { limit: 2e4 }
+		});
+		return new Set(rows.map((r) => readNumber(r.data, "device_id")));
+	}
+	async setOptOut(deviceId, at) {
+		await this.door.upsertMany.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.optOuts,
+			conflict: ["device_id"],
+			records: [{ data: {
+				device_id: deviceId,
+				opted_out_at: at
+			} }]
+		});
+	}
+	async loadDepartures() {
+		const rows = await this.door.query.query({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.departures,
+			filter: { limit: 2e4 }
+		});
+		return new Map(rows.map((r) => [readNumber(r.data, "device_id"), readNumber(r.data, "missing_since")]));
+	}
+	async markMissing(deviceIds, at) {
+		for (const batch of chunks(deviceIds, WRITE_CHUNK)) await this.door.upsertMany.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.departures,
+			conflict: ["device_id"],
+			records: batch.map((id) => ({ data: {
+				device_id: id,
+				missing_since: at
+			} }))
+		});
+	}
+	async clearMissing(deviceIds) {
+		for (const batch of chunks(deviceIds, WRITE_CHUNK)) await this.door.deleteWhere.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.departures,
+			filter: { whereIn: { device_id: [...batch] } }
+		});
+	}
+	async clearOptOut(deviceId) {
+		await this.door.deleteWhere.mutate({
+			namespace: HISTORY_NAMESPACE,
+			collection: COLLECTIONS.optOuts,
+			filter: { where: { device_id: deviceId } }
+		});
+	}
+};
+//#endregion
+//#region src/builtins/device-history/rollup/rollup-math.ts
+/**
+* Rollup arithmetic (D850, plan §4/§5.5). PURE: rows in, rows out.
+*
+* Two operations, both a RECOMPUTE from the lower tier — never an increment —
+* so running one twice, or after a late write, gives the same answer:
+*
+*  - {@link rawToFiveMinuteRows}: change-only raw points into 5-minute rows,
+*    with the time-weighted sum `tw_sum` (Σ value·ms) a change-only gauge
+*    needs: 4m59s at 50 and 1s at 100 is a time-weighted mean of ~50, not 75.
+*  - {@link combineRows}: rows of the child tier into one row of the next.
+*
+* Held values. A change-only series writes a point only when the value
+* changes, so a quiet bucket has NO row and the value in force across it is
+* the last one before. Both operations take that value in (`carryIn`) and
+* credit the gap with it; without that, an hour that sat at 10 for 55 minutes
+* and jumped to 100 in the last five would be averaged over those five alone.
+* The held value also counts toward `min`/`max` when it was in force at the
+* start of a bucket, because it really was the series' value then.
+*/
+/** One row per 5-minute bucket that has at least one point. */
+function rawToFiveMinuteRows(input) {
+	const rows = [];
+	const { points, seriesId, horizon } = input;
+	let held = input.carryIn === null ? null : input.carryIn.value;
+	let i = 0;
+	while (i < points.length) {
+		const first = points[i];
+		if (first === void 0) break;
+		const bucketStart = floorTo(first.ts, FIVE_MINUTES_MS);
+		const bucketEnd = bucketStart + FIVE_MINUTES_MS;
+		const coverageEnd = Math.min(bucketEnd, Math.max(horizon, bucketStart));
+		let samples = 0;
+		let sum = 0;
+		let min = Number.POSITIVE_INFINITY;
+		let max = Number.NEGATIVE_INFINITY;
+		let twSum = 0;
+		let twMs = 0;
+		let cursor = bucketStart;
+		let value = held;
+		if (value !== null) {
+			min = value;
+			max = value;
+		}
+		let last = first;
+		while (i < points.length) {
+			const p = points[i];
+			if (p === void 0 || p.ts >= bucketEnd) break;
+			if (value !== null) {
+				const dt = p.ts - cursor;
+				twSum += value * dt;
+				twMs += dt;
+			}
+			cursor = p.ts;
+			value = p.value;
+			samples += 1;
+			sum += p.value;
+			if (p.value < min) min = p.value;
+			if (p.value > max) max = p.value;
+			last = p;
+			i += 1;
+		}
+		if (value !== null && coverageEnd > cursor) {
+			twSum += value * (coverageEnd - cursor);
+			twMs += coverageEnd - cursor;
+		}
+		held = last.value;
+		rows.push({
+			seriesId,
+			bucketStart,
+			samples,
+			sum,
+			min,
+			max,
+			last: last.value,
+			lastTs: last.ts,
+			twSum,
+			twMs
+		});
+	}
+	return rows;
+}
+/** One row of the next tier from the child rows of its window; `null` when there are none. */
+function combineRows(input) {
+	const { rows } = input;
+	const lastRow = rows[rows.length - 1];
+	if (lastRow === void 0) return null;
+	const hasTw = rows.some((r) => r.twSum !== null && r.twMs !== null);
+	let samples = 0;
+	let sum = 0;
+	let min = Number.POSITIVE_INFINITY;
+	let max = Number.NEGATIVE_INFINITY;
+	let twSum = 0;
+	let twMs = 0;
+	let held = input.carryIn;
+	let cursor = input.windowStart;
+	for (const row of rows) {
+		samples += row.samples;
+		sum += row.sum;
+		if (row.min < min) min = row.min;
+		if (row.max > max) max = row.max;
+		const gap = row.bucketStart - cursor;
+		if (hasTw && gap > 0 && held !== null) {
+			twSum += held * gap;
+			twMs += gap;
+			if (held < min) min = held;
+			if (held > max) max = held;
+		}
+		if (row.twSum !== null && row.twMs !== null) {
+			twSum += row.twSum;
+			twMs += row.twMs;
+		}
+		cursor = row.bucketStart + input.childWidthMs;
+		held = row.last;
+	}
+	const coverageEnd = Math.min(input.windowEnd, input.horizon);
+	if (hasTw && held !== null && coverageEnd > cursor) {
+		twSum += held * (coverageEnd - cursor);
+		twMs += coverageEnd - cursor;
+	}
+	return {
+		seriesId: input.seriesId,
+		bucketStart: input.windowStart,
+		samples,
+		sum,
+		min,
+		max,
+		last: lastRow.last,
+		lastTs: lastRow.lastTs,
+		twSum: hasTw ? twSum : null,
+		twMs: hasTw ? twMs : null
+	};
+}
+/** How far back a boot rebuilds from raw and re-marks the upper tiers. */
+var BOOT_WINDOW_MS = 3 * HOUR_MS;
+var markVersion = 0;
+function mark(sets, seriesId, bucketStart) {
+	const map = sets.get(seriesId) ?? /* @__PURE__ */ new Map();
+	markVersion += 1;
+	map.set(bucketStart, markVersion);
+	sets.set(seriesId, map);
+}
+/**
+* Clear what a recompute handled — but only a mark that was not RENEWED while the
+* recompute awaited: a late write that re-marked the bucket mid-flight carries a newer
+* version and must be computed again, not erased with the old mark.
+*/
+function settle(sets, seriesId, handled) {
+	const map = sets.get(seriesId);
+	if (map === void 0) return;
+	for (const { bucket, version } of handled) if (map.get(bucket) === version) map.delete(bucket);
+	if (map.size === 0) sets.delete(seriesId);
+}
+/** Buckets further apart than this are recomputed as separate ranges, not one long read. */
+var MAX_RANGE_GAP_MS = HOUR_MS;
+/** `[from, toExclusive)` ranges covering sorted 5-minute bucket starts, split at long gaps. */
+function clusterRanges(sorted) {
+	const ranges = [];
+	for (const start of sorted) {
+		const current = ranges[ranges.length - 1];
+		if (current !== void 0 && start - current[1] <= MAX_RANGE_GAP_MS) current[1] = start + FIVE_MINUTES_MS;
+		else ranges.push([start, start + FIVE_MINUTES_MS]);
+	}
+	return ranges;
+}
+var RollupEngine = class {
+	deps;
+	dirty5m = /* @__PURE__ */ new Map();
+	dirty1h = /* @__PURE__ */ new Map();
+	dirty1d = /* @__PURE__ */ new Map();
+	ticking = null;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	dirtyCounts() {
+		const count = (sets) => [...sets.values()].reduce((n, set) => n + set.size, 0);
+		return {
+			m5: count(this.dirty5m),
+			h1: count(this.dirty1h),
+			d1: count(this.dirty1d)
+		};
+	}
+	/** Raw points landed: their 5-minute buckets (and a late bucket's successor) are dirty. */
+	markPoints(written) {
+		const now = this.deps.clock();
+		for (const { seriesId, timestamps } of written) for (const ts of timestamps) {
+			const bucket = floorTo(ts, FIVE_MINUTES_MS);
+			mark(this.dirty5m, seriesId, bucket);
+			if (bucket + 3e5 + ROLLUP_GRACE_MS["5m"] <= now) mark(this.dirty5m, seriesId, bucket + FIVE_MINUTES_MS);
+		}
+	}
+	/** A 5m row landed (computed, or a producer bucket): its hour is dirty. */
+	markFiveMinuteRow(seriesId, bucketStart) {
+		mark(this.dirty1h, seriesId, bucketStartOf("1h", bucketStart));
+	}
+	/** One pass over the three tiers. Single-flight; errors are counted and the work stays dirty. */
+	tick() {
+		if (this.ticking !== null) return this.ticking;
+		const run = this.doTick().finally(() => {
+			this.ticking = null;
+		});
+		this.ticking = run;
+		return run;
+	}
+	async doTick() {
+		const now = this.deps.clock();
+		await this.guarded("5m", () => this.tickFiveMinute(now));
+		await this.guarded("1h", () => this.tickHour(now));
+		await this.guarded("1d", () => this.tickDay(now));
+	}
+	async guarded(tier, run) {
+		try {
+			await run();
+		} catch (err) {
+			this.deps.counters.rollupErrors += 1;
+			this.deps.logger.warn(`device-history: ${tier} rollup pass failed — work stays dirty`, { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+	}
+	closedBuckets(map, tier, now) {
+		return [...map].filter(([start]) => bucketEndOf(tier, start) + ROLLUP_GRACE_MS[tier] <= now).map(([bucket, version]) => ({
+			bucket,
+			version
+		})).toSorted((a, b) => a.bucket - b.bucket);
+	}
+	/** Forget everything held for a series that was purged. */
+	forgetSeries(seriesId) {
+		this.dirty5m.delete(seriesId);
+		this.dirty1h.delete(seriesId);
+		this.dirty1d.delete(seriesId);
+		this.deps.counters.forgetSeries(seriesId);
+	}
+	async tickFiveMinute(now) {
+		let handled = 0;
+		for (const [seriesId, set] of this.dirty5m) {
+			if (handled >= 400) break;
+			const closed = this.closedBuckets(set, "5m", now);
+			if (closed.length === 0) continue;
+			handled += 1;
+			for (const [from, to] of clusterRanges(closed.map((c) => c.bucket))) await this.recomputeFiveMinute(seriesId, from, to, now);
+			settle(this.dirty5m, seriesId, closed);
+		}
+		if (handled > 0) this.deps.counters.last5mAt = now;
+	}
+	async tickHour(now) {
+		let handled = 0;
+		for (const [seriesId, set] of this.dirty1h) {
+			if (handled >= 400) break;
+			const closed = this.closedBuckets(set, "1h", now);
+			if (closed.length === 0) continue;
+			handled += 1;
+			for (const hour of closed) {
+				await this.recomputeHour(seriesId, hour.bucket, now);
+				settle(this.dirty1h, seriesId, [hour]);
+			}
+		}
+		if (handled > 0) this.deps.counters.last1hAt = now;
+	}
+	async tickDay(now) {
+		let handled = 0;
+		for (const [seriesId, set] of this.dirty1d) {
+			if (handled >= 400) break;
+			const closed = this.closedBuckets(set, "1d", now);
+			if (closed.length === 0) continue;
+			handled += 1;
+			for (const day of closed) {
+				await this.recomputeDay(seriesId, day.bucket, now);
+				settle(this.dirty1d, seriesId, [day]);
+			}
+		}
+		if (handled > 0) this.deps.counters.last1dAt = now;
+	}
+	/** Raw → 5m rows for buckets in `[from, toExclusive)`; writes them and marks their hours. */
+	async recomputeFiveMinute(seriesId, from, toExclusive, horizon) {
+		const { store } = this.deps;
+		const points = [];
+		let cursor = from;
+		for (;;) {
+			const page = await store.readRaw(seriesId, cursor, toExclusive - 1, READ_PAGE);
+			points.push(...page);
+			const last = page[page.length - 1];
+			if (last === void 0 || page.length < 5e3) break;
+			cursor = last.ts + 1;
+		}
+		const rows = rawToFiveMinuteRows({
+			seriesId,
+			points,
+			carryIn: await store.rawBefore(seriesId, from),
+			horizon
+		});
+		if (rows.length === 0) return 0;
+		await store.upsertRollups("5m", rows);
+		this.deps.counters.noteRollupRows("5m", seriesId, rows.map((r) => r.bucketStart));
+		for (const row of rows) this.markFiveMinuteRow(seriesId, row.bucketStart);
+		return rows.length;
+	}
+	async recomputeHour(seriesId, hour, now) {
+		await this.recomputeFrom("5m", "1h", FIVE_MINUTES_MS, seriesId, hour, now);
+	}
+	async recomputeDay(seriesId, day, now) {
+		await this.recomputeFrom("1h", "1d", HOUR_MS, seriesId, day, now);
+	}
+	async recomputeFrom(child, parent, childWidthMs, seriesId, windowStart, now) {
+		const { store } = this.deps;
+		const windowEnd = bucketEndOf(parent, windowStart);
+		const combined = combineRows({
+			seriesId,
+			windowStart,
+			windowEnd,
+			childWidthMs,
+			rows: await store.readRollups(child, seriesId, windowStart, windowEnd - 1, READ_PAGE),
+			carryIn: (await store.rollupBefore(child, seriesId, windowStart))?.last ?? null,
+			horizon: now
+		});
+		if (combined === null) return;
+		await store.upsertRollups(parent, [combined]);
+		this.deps.counters.noteRollupRows(parent, seriesId, [combined.bucketStart]);
+		if (parent === "1h") mark(this.dirty1d, seriesId, bucketStartOf("1d", windowStart));
+	}
+	/**
+	* After a restart the dirty sets are gone. Rebuild the recent window from raw
+	* (the still-open bucket included, time-weighted up to `now`), then mark the
+	* 1h / 1d buckets of that window dirty so the next ticks recompute them.
+	*/
+	async bootRecompute(now) {
+		const windowStart = floorTo(now - BOOT_WINDOW_MS, FIVE_MINUTES_MS);
+		const openBucket = floorTo(now, FIVE_MINUTES_MS);
+		let series = 0;
+		for (const s of this.deps.registry.all()) {
+			if (s.lastTs < windowStart) continue;
+			const metric = this.deps.registry.metric(s.key);
+			series += 1;
+			if (metric?.ingest === "points") {
+				await this.recomputeFiveMinute(s.id, windowStart, openBucket + FIVE_MINUTES_MS, now);
+				mark(this.dirty5m, s.id, openBucket);
+				mark(this.dirty5m, s.id, openBucket - FIVE_MINUTES_MS);
+			}
+			for (let hour = floorTo(windowStart, HOUR_MS); hour <= now; hour += HOUR_MS) mark(this.dirty1h, s.id, hour);
+			mark(this.dirty1d, s.id, bucketStartOf("1d", windowStart));
+			mark(this.dirty1d, s.id, bucketStartOf("1d", now));
+		}
+		return series;
+	}
+};
+//#endregion
+//#region src/builtins/device-history/status/counters.ts
+function deltas(now, before) {
+	const out = {};
+	for (const [k, v] of now) {
+		const d = v - (before.get(k) ?? 0);
+		if (d > 0) out[k] = d;
+	}
+	return out;
+}
+var HistoryCounters = class {
+	eventsSeen = 0;
+	pointsEmitted = 0;
+	pointsWritten = 0;
+	pointsDropped = 0;
+	trailingEmitted = 0;
+	reconciledPoints = 0;
+	reconcileRuns = 0;
+	reconcileFailures = 0;
+	lastReconcileAt = null;
+	lastFlushAt = null;
+	flushFailures = 0;
+	ingestAccepted = 0;
+	rollupErrors = 0;
+	last5mAt = null;
+	last1hAt = null;
+	last1dAt = null;
+	retentionLastRunAt = null;
+	purgedSeries = 0;
+	directoryRefreshAt = null;
+	skipped = /* @__PURE__ */ new Map();
+	refused = /* @__PURE__ */ new Map();
+	deleted = /* @__PURE__ */ new Map();
+	reported = {
+		skipped: /* @__PURE__ */ new Map(),
+		refused: /* @__PURE__ */ new Map(),
+		deleted: /* @__PURE__ */ new Map(),
+		flushFailures: 0
+	};
+	/** Net rows written minus deleted per tier since boot — the estimate behind `getStatus` row counts. */
+	rowDelta = /* @__PURE__ */ new Map();
+	/** Newest bucket seen per (tier, series): a row beyond it is NEW, a rewrite of an older one is not. */
+	newestBucket = /* @__PURE__ */ new Map();
+	skip(reason, count = 1) {
+		this.skipped.set(reason, (this.skipped.get(reason) ?? 0) + count);
+	}
+	refuse(reason, count = 1) {
+		this.refused.set(reason, (this.refused.get(reason) ?? 0) + count);
+	}
+	addDeleted(tier, count) {
+		if (count <= 0) return;
+		this.deleted.set(tier, (this.deleted.get(tier) ?? 0) + count);
+		if (tier === "raw" || tier === "5m" || tier === "1h" || tier === "1d") this.rowDelta.set(tier, (this.rowDelta.get(tier) ?? 0) - count);
+	}
+	addRawRows(count) {
+		this.rowDelta.set("raw", (this.rowDelta.get("raw") ?? 0) + count);
+	}
+	/** Rollup rows written: only a bucket newer than the series' newest known is counted as a new row. */
+	noteRollupRows(tier, seriesId, bucketStarts) {
+		const marker = `${tier}:${seriesId}`;
+		let newest = this.newestBucket.get(marker) ?? Number.NEGATIVE_INFINITY;
+		let added = 0;
+		for (const b of bucketStarts) if (b > newest) {
+			added += 1;
+			newest = b;
+		}
+		this.newestBucket.set(marker, newest);
+		if (added > 0) this.rowDelta.set(tier, (this.rowDelta.get(tier) ?? 0) + added);
+	}
+	rowDeltaOf(tier) {
+		return this.rowDelta.get(tier) ?? 0;
+	}
+	forgetSeries(seriesId) {
+		for (const tier of [
+			"5m",
+			"1h",
+			"1d"
+		]) this.newestBucket.delete(`${tier}:${seriesId}`);
+	}
+	skippedRecord() {
+		return Object.fromEntries(this.skipped);
+	}
+	refusedRecord() {
+		return Object.fromEntries(this.refused);
+	}
+	deletedRecord() {
+		return Object.fromEntries(this.deleted);
+	}
+	/** What was skipped, refused, deleted or failed since the last call; `null` when nothing. */
+	summarySinceLast() {
+		const summary = {
+			skipped: deltas(this.skipped, this.reported.skipped),
+			refused: deltas(this.refused, this.reported.refused),
+			deleted: deltas(this.deleted, this.reported.deleted),
+			flushFailures: this.flushFailures - this.reported.flushFailures
+		};
+		this.reported = {
+			skipped: new Map(this.skipped),
+			refused: new Map(this.refused),
+			deleted: new Map(this.deleted),
+			flushFailures: this.flushFailures
+		};
+		return Object.keys(summary.skipped).length === 0 && Object.keys(summary.refused).length === 0 && Object.keys(summary.deleted).length === 0 && summary.flushFailures === 0 ? null : summary;
+	}
+};
+//#endregion
+//#region src/builtins/device-history/runtime/history-runtime.ts
+var ROLLUP_INTERVAL_MS = 6e4;
+var RECONCILE_INTERVAL_MS = 5 * 6e4;
+var RETENTION_INTERVAL_MS = 10 * 6e4;
+/**
+* ONE exact row count per boot (a `COUNT(*)` is a full scan on the history thread), taken late so
+* boot is not spent scanning the raw table. After it the figures move with the writes and deletes
+* the addon itself makes — an estimate, labelled so in the docs.
+*/
+var FIRST_COUNT_DELAY_MS = 9e4;
+/** Per-row size estimates behind `approxBytes` (WITHOUT ROWID rows incl. page overhead). */
+var APPROX_BYTES_PER_ROW = {
+	raw: 24,
+	"5m": 72,
+	"1h": 72,
+	"1d": 72
+};
+var HistoryRuntime = class {
+	deps;
+	counters = new HistoryCounters();
+	store;
+	registry;
+	directory;
+	rollup;
+	writer;
+	capture;
+	ingest;
+	query;
+	retentionJob;
+	departures;
+	optedOutDevices = /* @__PURE__ */ new Set();
+	tierCounts = /* @__PURE__ */ new Map();
+	startedAt;
+	timers = [];
+	countTimeout = null;
+	ready = false;
+	constructor(deps) {
+		this.deps = deps;
+		const { logger, clock, catalog } = deps;
+		this.startedAt = clock();
+		this.store = new HistoryStore(deps.door);
+		this.registry = new SeriesRegistry(this.store);
+		this.directory = new DeviceDirectory(deps.deviceSource, this.counters, logger, clock);
+		this.rollup = new RollupEngine({
+			store: this.store,
+			registry: this.registry,
+			counters: this.counters,
+			logger,
+			clock
+		});
+		this.writer = new PointWriter({
+			registry: this.registry,
+			store: this.store,
+			counters: this.counters,
+			logger,
+			clock,
+			onWritten: (written) => this.rollup.markPoints(written),
+			onDropped: (dropped) => this.capture.forget(dropped)
+		});
+		const optedOut = () => this.optedOutDevices;
+		this.capture = new CaptureEngine({
+			catalog,
+			registry: this.registry,
+			store: this.store,
+			directory: this.directory,
+			writer: this.writer,
+			optedOut,
+			counters: this.counters,
+			logger,
+			clock
+		});
+		this.ingest = new ProducerIngest({
+			registry: this.registry,
+			store: this.store,
+			directory: this.directory,
+			writer: this.writer,
+			counters: this.counters,
+			logger,
+			clock,
+			optedOut,
+			retention: () => {
+				const policy = deps.retention();
+				return {
+					rawMs: policy.rawDays * DAY_MS,
+					fiveMinuteMs: policy.fiveMinuteDays * DAY_MS
+				};
+			},
+			onBucketWritten: (seriesId, bucketStart) => this.rollup.markFiveMinuteRow(seriesId, bucketStart)
+		});
+		this.query = new HistoryQuery({
+			registry: this.registry,
+			store: this.store,
+			clock,
+			retention: deps.retention,
+			catalog,
+			readCapSlice: deps.readCapSlice
+		});
+		this.departures = new DepartureTracker(this.store, this.registry, logger);
+		this.registry.onRemove((series) => {
+			this.capture.forgetSeries(series);
+			this.ingest.forgetSeries(series);
+			this.rollup.forgetSeries(series.id);
+			this.retentionJob.forgetSeries(series.id);
+		});
+		this.retentionJob = new RetentionJob({
+			store: this.store,
+			registry: this.registry,
+			departures: this.departures,
+			counters: this.counters,
+			logger
+		});
+	}
+	async prepare() {
+		await this.store.declare();
+		await this.registry.load();
+		for (const metric of catalogMetrics(this.deps.catalog, this.deps.clock())) await this.registry.declareMetric(metric);
+		this.optedOutDevices = await this.store.loadOptOuts();
+		await this.departures.load();
+		await this.directory.refresh();
+		await this.capture.seed();
+	}
+	async finishBoot() {
+		const series = await this.rollup.bootRecompute(this.deps.clock());
+		this.deps.logger.info("device-history: recent rollup window rebuilt", { meta: { series } });
+		await this.reconcile();
+	}
+	startTimers() {
+		const every = (ms, run) => {
+			const timer = setInterval(() => {
+				run().catch((err) => {
+					this.deps.logger.warn("device-history: scheduled pass threw", { meta: { error: err instanceof Error ? err.message : String(err) } });
+				});
+			}, ms);
+			timer.unref();
+			this.timers.push(timer);
+		};
+		every(FLUSH_INTERVAL_MS, () => this.flushNow());
+		every(ROLLUP_INTERVAL_MS, async () => {
+			await this.rollup.tick();
+			this.reportWindow();
+		});
+		every(RECONCILE_INTERVAL_MS, async () => {
+			await this.reconcile();
+			this.reportWindow();
+		});
+		every(RETENTION_INTERVAL_MS, async () => {
+			await this.retentionJob.run(this.deps.retention(), this.deps.clock());
+			this.reportWindow();
+		});
+		this.countTimeout = setTimeout(() => {
+			this.refreshCounts().catch(() => void 0);
+		}, FIRST_COUNT_DELAY_MS);
+		this.countTimeout.unref();
+	}
+	async stop() {
+		for (const t of this.timers) clearInterval(t);
+		this.timers = [];
+		if (this.countTimeout !== null) clearTimeout(this.countTimeout);
+		this.countTimeout = null;
+		await this.writer.flush();
+	}
+	/** Emit pending trailing points, then write the buffer. */
+	async flushNow() {
+		this.capture.tickPending(this.deps.clock());
+		await this.writer.flush();
+	}
+	/**
+	* Restore changes a dropped event missed. A FAILED read changes nothing (D49):
+	* it is counted and logged, and the next pass tries again.
+	*/
+	async reconcile() {
+		const { logger, clock } = this.deps;
+		if (await this.directory.refresh()) await this.departures.observe(this.directory.listedIds(), clock());
+		let snapshots;
+		try {
+			snapshots = await this.deps.readSnapshots();
+		} catch (err) {
+			this.counters.reconcileFailures += 1;
+			logger.warn("device-history: reconcile read failed — nothing changed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return;
+		}
+		const now = clock();
+		this.capture.reconcile(snapshots, now);
+		this.counters.reconcileRuns += 1;
+		this.counters.lastReconcileAt = now;
+		this.ready = true;
+	}
+	async refreshCounts() {
+		for (const tier of [
+			"raw",
+			"5m",
+			"1h",
+			"1d"
+		]) {
+			const deltaAtCount = this.counters.rowDeltaOf(tier);
+			const rows = await this.store.countRows(tier);
+			this.tierCounts.set(tier, {
+				rows,
+				countedAt: this.deps.clock(),
+				deltaAtCount
+			});
+		}
+	}
+	/**
+	* ONE aggregated INFO naming what was skipped, refused, deleted or failed since the
+	* previous report (D391) — the counts a per-event line would drown. Silent when
+	* nothing happened.
+	*/
+	reportWindow() {
+		const summary = this.counters.summarySinceLast();
+		if (summary === null) return;
+		this.deps.logger.info("device-history: since the last report", { meta: { ...summary } });
+	}
+	isEnabled(deviceId) {
+		return !this.optedOutDevices.has(deviceId);
+	}
+	async setEnabled(deviceId, enabled) {
+		if (enabled) {
+			await this.store.clearOptOut(deviceId);
+			this.optedOutDevices = new Set([...this.optedOutDevices].filter((id) => id !== deviceId));
+		} else {
+			await this.store.setOptOut(deviceId, this.deps.clock());
+			this.optedOutDevices = new Set([...this.optedOutDevices, deviceId]);
+		}
+		return enabled;
+	}
+	/** Delete the history of a deleted device: its series, opt-out and absence clock. */
+	async removeDevice(deviceId) {
+		const series = await this.retentionJob.purgeDevice(deviceId, this.deps.clock());
+		await this.store.clearOptOut(deviceId);
+		await this.departures.forget(deviceId);
+		this.optedOutDevices = new Set([...this.optedOutDevices].filter((id) => id !== deviceId));
+		return { series };
+	}
+	/** Series held per device, for the admin clean-up listing. */
+	seriesByDevice() {
+		const out = /* @__PURE__ */ new Map();
+		for (const s of this.registry.all()) {
+			if (s.deviceId === null) continue;
+			out.set(s.deviceId, (out.get(s.deviceId) ?? 0) + 1);
+		}
+		return out;
+	}
+	status() {
+		const c = this.counters;
+		const dirty = this.rollup.dirtyCounts();
+		return {
+			startedAt: this.startedAt,
+			ready: this.ready,
+			series: this.registry.all().length,
+			metrics: this.registry.allMetrics().length,
+			optedOutDevices: this.optedOutDevices.size,
+			tiers: [
+				"raw",
+				"5m",
+				"1h",
+				"1d"
+			].map((tier) => {
+				const count = this.tierCounts.get(tier);
+				const rows = count === void 0 ? null : Math.max(0, count.rows + this.counters.rowDeltaOf(tier) - count.deltaAtCount);
+				return {
+					tier,
+					rows,
+					approxBytes: rows === null ? null : rows * APPROX_BYTES_PER_ROW[tier],
+					countedAt: count?.countedAt ?? null
+				};
+			}),
+			capture: {
+				eventsSeen: c.eventsSeen,
+				pointsEmitted: c.pointsEmitted,
+				pointsWritten: c.pointsWritten,
+				pointsDropped: c.pointsDropped,
+				bufferDepth: this.writer.depth(),
+				trailingEmitted: c.trailingEmitted,
+				reconciledPoints: c.reconciledPoints,
+				reconcileRuns: c.reconcileRuns,
+				reconcileFailures: c.reconcileFailures,
+				lastReconcileAt: c.lastReconcileAt,
+				lastFlushAt: c.lastFlushAt,
+				flushFailures: c.flushFailures,
+				skipped: c.skippedRecord()
+			},
+			ingest: {
+				accepted: c.ingestAccepted,
+				refused: c.refusedRecord()
+			},
+			rollup: {
+				last5mAt: c.last5mAt,
+				last1hAt: c.last1hAt,
+				last1dAt: c.last1dAt,
+				errors: c.rollupErrors,
+				dirty5m: dirty.m5,
+				dirty1h: dirty.h1,
+				dirty1d: dirty.d1
+			},
+			retention: {
+				lastRunAt: c.retentionLastRunAt,
+				deleted: c.deletedRecord(),
+				purgedSeries: c.purgedSeries
+			},
+			directory: {
+				devices: this.directory.size(),
+				lastRefreshAt: this.directory.lastRefreshAt()
+			}
+		};
+	}
+};
+//#endregion
+//#region src/builtins/device-history/device-history.addon.ts
+/**
+* device-history — the ONE mechanism for numeric history (D850). Hub-only, its
+* own runner (not grouped, D29): it writes through the settings door into
+* `history.db`, a file with its own serving thread (D851), so a slow rollup can
+* never queue behind — or in front of — configuration reads.
+*
+* This shell only wires: the capability provider, the bus subscription, the
+* timers and the retention settings. The engine is {@link HistoryRuntime}.
+*
+* Boot waits for `onHubReachable` — the settings door and the device manager
+* are hub capabilities, and a forked runner cannot call them from
+* `onInitialize`. Until then the provider answers "starting" rather than an
+* empty history (an unanswered query is not an empty one, D315).
+*/
+var DEFAULT_CONFIG = {
+	rawDays: DEFAULT_RETENTION.rawDays,
+	fiveMinuteDays: DEFAULT_RETENTION.fiveMinuteDays,
+	hourDays: DEFAULT_RETENTION.hourDays,
+	dayDays: 0
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The caller the transport stamped (never in an input schema); `null` when unstamped. */
+function callerOf(input) {
+	if (!isRecord(input)) return null;
+	const raw = input["callerAddonId"];
+	return typeof raw === "string" && raw.length > 0 ? raw : null;
+}
+function positiveOr(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+var DeviceHistoryAddon = class extends require_dist.BaseAddon {
+	runtime = null;
+	unsubscribe = null;
+	removalHook = null;
+	constructor() {
+		super({ ...DEFAULT_CONFIG });
+	}
+	retention() {
+		const c = this.config;
+		return {
+			rawDays: positiveOr(c.rawDays, DEFAULT_RETENTION.rawDays),
+			fiveMinuteDays: positiveOr(c.fiveMinuteDays, DEFAULT_RETENTION.fiveMinuteDays),
+			hourDays: positiveOr(c.hourDays, DEFAULT_RETENTION.hourDays),
+			dayDays: positiveOr(c.dayDays, 0) > 0 ? c.dayDays : null
+		};
+	}
+	requireRuntime() {
+		if (this.runtime === null) throw new Error("device-history is starting — the history store is not open yet");
+		return this.runtime;
+	}
+	async onInitialize() {
+		const provider = {
+			listSeries: async (input) => this.requireRuntime().query.listSeries({
+				kind: "device",
+				deviceId: input.deviceId
+			}),
+			listNodeSeries: async (input) => this.requireRuntime().query.listSeries({
+				kind: "node",
+				nodeId: input.nodeId
+			}),
+			query: async ({ deviceId, ...window }) => this.requireRuntime().query.query({
+				...window,
+				subject: {
+					kind: "device",
+					deviceId
+				}
+			}),
+			queryNode: async ({ nodeId, ...window }) => this.requireRuntime().query.query({
+				...window,
+				subject: {
+					kind: "node",
+					nodeId
+				}
+			}),
+			declareSeries: async (input) => this.requireRuntime().ingest.declareSeries(callerOf(input), input),
+			record: async (input) => this.requireRuntime().ingest.record(callerOf(input), input.points),
+			recordBuckets: async (input) => this.requireRuntime().ingest.recordBuckets(callerOf(input), input.buckets),
+			getDeviceEnabled: async (input) => ({ enabled: this.requireRuntime().isEnabled(input.deviceId) }),
+			setDeviceEnabled: async (input) => ({ enabled: await this.requireRuntime().setEnabled(input.deviceId, input.enabled) }),
+			getStatus: async () => this.requireRuntime().status()
+		};
+		this.ctx.logger.info("Initialized — device-history provider registered (store opens on hub link)");
+		const removalHook = {
+			onDeviceRemoved: async (input) => {
+				const { series } = await this.requireRuntime().removeDevice(input.deviceId);
+				if (series > 0) this.ctx.logger.info("device-history: removed the history of a deleted device", {
+					tags: { deviceId: input.deviceId },
+					meta: {
+						counts: { series },
+						deletedAt: input.deletedAt
+					}
+				});
+				return { counts: { series } };
+			},
+			listDeviceData: async () => [...this.requireRuntime().seriesByDevice()].map(([deviceId, count]) => ({
+				store: "series",
+				deviceId,
+				count
+			}))
+		};
+		this.removalHook = removalHook;
+		return [{
+			capability: require_dist.deviceHistoryCapability,
+			provider
+		}, {
+			capability: require_dist.deviceRemovalHookCapability,
+			provider: removalHook
+		}];
+	}
+	async onHubReachable() {
+		const api = this.ctx.api;
+		const runtime = new HistoryRuntime({
+			door: api.settingsStore,
+			catalog: require_dist.HISTORY_CATALOG,
+			deviceSource: {
+				listAll: async () => {
+					return (await api.deviceManager.listAll.query({ projection: "slim" })).map((d) => ({
+						id: d.id,
+						type: d.type
+					}));
+				},
+				getDevice: async (deviceId) => {
+					const d = await api.deviceManager.getDevice.query({ deviceId });
+					return d === null ? null : {
+						id: d.id,
+						type: d.type
+					};
+				}
+			},
+			readSnapshots: async () => api.deviceState.getAllSnapshots.query({}),
+			readCapSlice: (deviceId, capName) => api.deviceState.getCapSlice.query({
+				deviceId,
+				capName
+			}),
+			retention: () => this.retention(),
+			logger: this.ctx.logger,
+			clock: () => Date.now()
+		});
+		await runtime.prepare();
+		this.unsubscribe = this.ctx.eventBus.subscribe({ category: require_dist.EventCategory.DeviceStateChanged }, (event) => {
+			const data = event.data;
+			if (!isRecord(data)) return;
+			const { deviceId, capName, slice } = data;
+			if (typeof deviceId !== "number" || typeof capName !== "string" || !isRecord(slice)) return;
+			const at = event.timestamp instanceof Date ? event.timestamp.getTime() : Date.now();
+			runtime.capture.handleState(deviceId, capName, slice, at);
+		});
+		this.ctx.addDisposer(async () => this.stopRuntime());
+		this.runtime = runtime;
+		await runtime.finishBoot();
+		runtime.startTimers();
+		const removalHook = this.removalHook;
+		if (removalHook !== null) this.ctx.addDisposer(require_dist.armRemovalReconcile({
+			api: this.ctx.api,
+			logger: this.ctx.logger,
+			remove: (input) => removalHook.onDeviceRemoved(input)
+		}));
+		this.ctx.logger.info("device-history: capturing", { meta: {
+			series: runtime.status().series,
+			metrics: runtime.status().metrics
+		} });
+	}
+	async stopRuntime() {
+		this.unsubscribe?.();
+		this.unsubscribe = null;
+		await this.runtime?.stop();
+	}
+	async onShutdown() {
+		await this.stopRuntime();
+		this.runtime = null;
+	}
+	globalSettingsSchema() {
+		return this.schema({ sections: [{
+			id: "retention",
+			title: "Retention",
+			description: "How long each tier is kept. The raw points feed the 5-minute rollup; the 1-day tier is kept forever unless a number of days is set.",
+			columns: 2,
+			fields: [
+				{
+					type: "number",
+					key: "rawDays",
+					label: "Raw points (days)",
+					min: 1,
+					max: 60,
+					step: 1
+				},
+				{
+					type: "number",
+					key: "fiveMinuteDays",
+					label: "5-minute rollup (days)",
+					min: 1,
+					max: 365,
+					step: 1
+				},
+				{
+					type: "number",
+					key: "hourDays",
+					label: "1-hour rollup (days)",
+					min: 7,
+					max: 3650,
+					step: 1
+				},
+				{
+					type: "number",
+					key: "dayDays",
+					label: "1-day rollup (days, 0 = forever)",
+					min: 0,
+					max: 36500,
+					step: 1
+				}
+			]
+		}] });
+	}
+};
+//#endregion
+exports.DeviceHistoryAddon = DeviceHistoryAddon;
+exports.default = DeviceHistoryAddon;
+exports.callerOf = callerOf;