@camstack/addon-pipeline-orchestrator 1.2.601 → 1.2.602

package/dist/index.js

@@ -5569,7 +5569,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-bZIhUvjd.mjs
+//#region ../types/dist/sleep-BOjuyoPC.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6389,7 +6389,7 @@ async function writeMembers(ctx, children, incoming, stored, pathOf) {
 	for (const [member, node] of children) applyMember(out, member, await writeNode(ctx, node, incoming[member], stored[member], pathOf(member)), stored);
 	return out;
 }
-function rowId$1(row, idKey) {
+function rowId(row, idKey) {
 	const raw = row[idKey];
 	if (typeof raw === "string" && raw.length > 0) return raw;
 	if (typeof raw === "number" && Number.isFinite(raw)) return String(raw);
@@ -6406,7 +6406,7 @@ async function writeArray(ctx, node, incoming, stored, fieldPath) {
 	}
 	const storedById = /* @__PURE__ */ new Map();
 	for (const row of storedRows) {
-		const id = rowId$1(row, node.idKey);
+		const id = rowId(row, node.idKey);
 		if (id !== null) storedById.set(id, row);
 	}
 	const kept = /* @__PURE__ */ new Set();
@@ -6416,13 +6416,13 @@ async function writeArray(ctx, node, incoming, stored, fieldPath) {
 			rows.push(row);
 			continue;
 		}
-		const id = rowId$1(row, node.idKey) ?? ctx.mintId();
+		const id = rowId(row, node.idKey) ?? ctx.mintId();
 		kept.add(id);
 		const withId = {
 			...row,
 			[node.idKey]: row[node.idKey] ?? id
 		};
-		if (rowId$1(withId, node.idKey) === null) withId[node.idKey] = id;
+		if (rowId(withId, node.idKey) === null) withId[node.idKey] = id;
 		const storedRow = storedById.get(id) ?? {};
 		rows.push(await writeMembers(ctx, node.item, withId, storedRow, (member) => arrayItemFieldPath(fieldPath, id, member)));
 	}
@@ -9327,7 +9327,7 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
 }
 //#endregion
-//#region ../types/dist/err-msg--2RrYiLO.mjs
+//#region ../types/dist/err-msg-BXKzRBwg.mjs
 var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["Camera"] = "camera";
 	DeviceType["Hub"] = "hub";
@@ -9419,6 +9419,10 @@ var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	*  native PetKit (`nodepetkit` `FeederDevice`), reusable by other feeder
 	*  integrations sharing the same food/desiccant/hopper surface. */
 	DeviceType["PetFeeder"] = "pet-feeder";
+	/** Built-in dishwasher — program lifecycle, door / remote-start gates,
+	*  salt and rinse-aid levels. Installed with the `dishwasher` cap.
+	*  Sources: native Bosch Home Connect, reusable by similar integrations. */
+	DeviceType["Dishwasher"] = "dishwasher";
 	return DeviceType;
 }({});
 var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
@@ -9676,7 +9680,7 @@ function errMsg$2(err) {
 	return String(err);
 }
 //#endregion
-//#region ../types/dist/composition-DOwQB_Ua.mjs
+//#region ../types/dist/composition-CB6PMT9p.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -14542,8 +14546,13 @@ var AlertSeveritySchema = _enum([
 	"info",
 	"success",
 	"warning",
-	"error"
+	"error",
+	"critical"
 ]);
+var AlertActionSchema = object({
+	label: string(),
+	href: string().optional()
+});
 var AlertStatusSchema = _enum([
 	"active",
 	"in-progress",
@@ -14561,6 +14570,7 @@ var AlertSchema = object({
 	severity: AlertSeveritySchema,
 	title: string(),
 	message: string(),
+	action: AlertActionSchema.optional(),
 	status: AlertStatusSchema,
 	progress: number().optional(),
 	read: boolean(),
@@ -55483,7 +55493,7 @@ var BatteryStatusSchema = object({
 	*/
 	binary: boolean().optional()
 });
-DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, method(object({
+DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, method(object({
 	deviceId: number(),
 	/** Bound on the wait. Sensible range 3000–10000ms. */
 	timeoutMs: number().int().min(500).max(3e4).default(8e3)
@@ -56359,6 +56369,98 @@ object({
 	deviceId: number(),
 	status: DeviceStatusSchema
 });
+/**
+* Smart-dishwasher cap — program lifecycle, door / remote-start gates,
+* consumable levels (salt, rinse aid) and common program options.
+*
+* Sources: native Bosch Home Connect (`dishwasher` device type). Reusable
+* by any integration that exposes the same program / option surface.
+*
+* `kind: 'poll'` — cloud REST APIs typically have no push channel; the
+* provider refreshes the slice on an interval and eagerly after commands.
+*/
+var DishwasherStateSchema = _enum([
+	"idle",
+	"running",
+	"paused",
+	"finished",
+	"error",
+	"unavailable"
+]);
+var DishwasherConsumableLevelSchema = _enum([
+	"ok",
+	"low",
+	"empty"
+]);
+object({
+	state: DishwasherStateSchema,
+	/** Active program id/name, or null when none selected / unknown. */
+	program: string().nullable(),
+	/** Program tokens the hardware accepts — drives the UI selector. */
+	availablePrograms: array(string()),
+	/** Minutes remaining on the active cycle, or null when not running. */
+	remainingMinutes: number().int().nonnegative().nullable(),
+	/** Cycle completion 0..100, or null when not applicable. */
+	progressPercent: number().min(0).max(100).nullable(),
+	/** True when the door is reported open. */
+	doorOpen: boolean(),
+	/** True when remote start is allowed (door closed, power on, etc.). */
+	remoteStartAllowed: boolean(),
+	/** Main power / switched-on state. */
+	powerOn: boolean(),
+	saltLevel: DishwasherConsumableLevelSchema.nullable(),
+	rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
+	halfLoad: boolean(),
+	hygienePlus: boolean(),
+	errorCode: number().nullable(),
+	errorLabel: string().nullable(),
+	lastFetchedAt: number()
+});
+DeviceType.Dishwasher, method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "protected"
+}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "protected"
+}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "protected"
+}), method(object({
+	deviceId: number().int().nonnegative(),
+	program: string().min(1)
+}), _void(), {
+	kind: "mutation",
+	auth: "protected"
+}), method(object({
+	deviceId: number().int().nonnegative(),
+	on: boolean()
+}), _void(), {
+	kind: "mutation",
+	auth: "protected"
+}), method(object({
+	deviceId: number().int().nonnegative(),
+	on: boolean()
+}), _void(), {
+	kind: "mutation",
+	auth: "protected"
+}), method(object({
+	deviceId: number().int().nonnegative(),
+	on: boolean()
+}), _void(), {
+	kind: "mutation",
+	auth: "protected"
+}), method(object({
+	deviceId: number().int().nonnegative(),
+	key: string().min(1),
+	value: union([
+		boolean(),
+		string(),
+		number()
+	])
+}), _void(), {
+	kind: "mutation",
+	auth: "protected"
+});
 object({
 	/** Ms epoch of the last press. null = never observed since this provider started. */
 	lastPressedAt: number().nullable(),
@@ -56924,6 +57026,13 @@ object({
 	lastChangedAt: number()
 });
 DeviceType.Sensor;
+object({
+	/** Radiator valve opening 0 (closed) .. 100 (open). Null = not yet known. */
+	position: number().min(0).max(100).nullable(),
+	/** Ms epoch when the slice was last updated (push or poll). */
+	lastFetchedAt: number()
+});
+DeviceType.Thermostat;
 object({
 	/** Whether the humidifier is currently on. */
 	on: boolean(),
@@ -64109,7 +64218,7 @@ var AccessoryKind = {
 	PrivacyMask: DeviceRole.PrivacyMask
 };
 AccessoryKind.Siren, AccessoryKind.Floodlight, AccessoryKind.Spotlight, AccessoryKind.PirSensor, AccessoryKind.Chime, AccessoryKind.Autotrack, AccessoryKind.Nightvision, AccessoryKind.PrivacyMask;
-DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder;
+DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher;
 new Set(Object.values(DeviceType));
 Object.freeze({
 	"accessories.getStatus": {
@@ -66530,6 +66639,60 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"dishwasher.getStatus": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
+	"dishwasher.pause": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"dishwasher.setHalfLoad": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"dishwasher.setHygienePlus": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"dishwasher.setOption": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"dishwasher.setPower": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"dishwasher.setProgram": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"dishwasher.start": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
+	"dishwasher.stop": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"doorbell.getStatus": {
 		capName: "doorbell",
 		capScope: "device",
@@ -66740,6 +66903,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"heatingValve.getStatus": {
+		capName: "heating-valve",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"humidifier.getStatus": {
 		capName: "humidifier",
 		capScope: "device",
@@ -72327,7 +72496,7 @@ Object.freeze({
 		access: "create"
 	}
 });
-DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder;
+DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.Dishwasher;
 /**
 * Heuristic check — `device.features?.includes(profile.when.hasFeature)`.
 */
@@ -73179,6 +73348,51 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"dishwasher.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dishwasher.pause": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dishwasher.setHalfLoad": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dishwasher.setHygienePlus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dishwasher.setOption": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dishwasher.setPower": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dishwasher.setProgram": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dishwasher.start": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
+	"dishwasher.stop": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"doorbell.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -73248,6 +73462,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"heatingValve.getStatus": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"humidifier.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -75071,6 +75290,103 @@ Object.freeze({
 	"network-access": "ingress",
 	"smtp-provider": "email"
 });
+/** Width of a bucket the history store accepts. */
+var HISTORY_BUCKET_MS = 5 * 6e4;
+function bucketStartOf(at) {
+	return Math.floor(at / HISTORY_BUCKET_MS) * HISTORY_BUCKET_MS;
+}
+function subjectId(subject) {
+	return subject.kind === "device" ? `d:${subject.deviceId}` : `n:${subject.nodeId}`;
+}
+function seriesIdentity(key, subject, scope) {
+	return `${key}\u0000${subjectId(subject)}\u0000${scope}`;
+}
+function toClosed(b) {
+	return {
+		key: b.key,
+		subject: b.subject,
+		scope: b.scope,
+		bucketStart: b.bucketStart,
+		samples: b.samples,
+		sum: b.sum,
+		min: b.min,
+		max: b.max,
+		last: b.last,
+		lastTs: b.lastTs
+	};
+}
+var BucketAccumulator = class {
+	open = /* @__PURE__ */ new Map();
+	requeued = /* @__PURE__ */ new Map();
+	/** Add one observation. A non-finite value or timestamp is ignored (never counted as 0). */
+	note(key, subject, scope, value, at) {
+		if (!Number.isFinite(value) || !Number.isFinite(at)) return;
+		const bucketStart = bucketStartOf(at);
+		const id = `${seriesIdentity(key, subject, scope)}\u0000${bucketStart}`;
+		const existing = this.open.get(id);
+		if (existing === void 0) {
+			this.open.set(id, {
+				key,
+				subject,
+				scope,
+				bucketStart,
+				samples: 1,
+				sum: value,
+				min: value,
+				max: value,
+				last: value,
+				lastTs: at
+			});
+			return;
+		}
+		existing.samples += 1;
+		existing.sum += value;
+		if (value < existing.min) existing.min = value;
+		if (value > existing.max) existing.max = value;
+		if (at >= existing.lastTs) {
+			existing.last = value;
+			existing.lastTs = at;
+		}
+	}
+	/**
+	* Buckets whose window ended at or before `now`, oldest first, requeued ones
+	* included. They leave the accumulator: delivery is the caller's.
+	*/
+	takeClosed(now) {
+		const out = [];
+		for (const [id, bucket] of this.open) if (bucket.bucketStart + 3e5 <= now) {
+			out.push(toClosed(bucket));
+			this.open.delete(id);
+		}
+		for (const list of this.requeued.values()) out.push(...list);
+		this.requeued.clear();
+		return out.toSorted((a, b) => a.bucketStart - b.bucketStart);
+	}
+	/**
+	* Put undelivered buckets back for the next `takeClosed`. Keeps the newest
+	* {@link MAX_REQUEUED_BUCKETS_PER_SERIES} per series and returns the buckets
+	* it dropped (empty when none).
+	*/
+	requeue(buckets) {
+		const dropped = [];
+		for (const bucket of buckets) {
+			const id = seriesIdentity(bucket.key, bucket.subject, bucket.scope);
+			const list = [...this.requeued.get(id) ?? [], bucket].toSorted((a, b) => a.bucketStart - b.bucketStart);
+			while (list.length > 12) {
+				const oldest = list.shift();
+				if (oldest !== void 0) dropped.push(oldest);
+			}
+			this.requeued.set(id, list);
+		}
+		return dropped;
+	}
+	/** Buckets currently held (open plus requeued) — for a gauge in the producer's own status. */
+	pendingBucketCount() {
+		let n = this.open.size;
+		for (const list of this.requeued.values()) n += list.length;
+		return n;
+	}
+};
 DeviceType.Camera;
 var G711_SCALE_CORRECTION_DB = {
 	PCMU: 20 * Math.log10(4),
@@ -88699,430 +89015,127 @@ var NodeStressController = class NodeStressController {
 	}
 };
 //#endregion
-//#region src/durable/lts-aggregator.ts
-/** Wall-clock bucket width. Five minutes, matching HA's statistics tier. */
-var LTS_BUCKET_MS = 5 * 6e4;
-/** 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"
-	}),
+//#region src/node-stress-history-producer.ts
+var SERIES_KEYS = {
+	"node-score": "addon:pipeline-orchestrator/node-score",
+	"node-queue-pressure": "addon:pipeline-orchestrator/node-queue-pressure",
+	"node-drop-ratio": "addon:pipeline-orchestrator/node-drop-ratio",
+	"node-fps-deficit": "addon:pipeline-orchestrator/node-fps-deficit"
+};
+function nodeStressHistoryClient(api) {
+	return {
+		declareSeries: (input) => api.declareSeries.mutate(input),
+		recordBuckets: (input) => api.recordBuckets.mutate({ buckets: [...input.buckets] }),
+		queryNode: async (input) => {
+			return { series: (await api.queryNode.query(input)).series.map((s) => ({
+				scope: s.scope,
+				points: s.points.flatMap((p) => {
+					if (p.mean === null) return [];
+					return [{
+						t: p.t,
+						samples: p.samples,
+						sum: p.mean * p.samples,
+						min: p.min,
+						max: p.max
+					}];
+				})
+			})) };
+		}
+	};
+}
+var SERIES_META = [
 	{
-		name: "samples",
-		type: "INTEGER",
-		notNull: true
+		name: "node-score",
+		displayName: "Node stress score"
 	},
 	{
-		name: "sum",
-		type: "REAL",
-		notNull: true
+		name: "node-queue-pressure",
+		displayName: "Node queue pressure"
 	},
 	{
-		name: "min",
-		type: "REAL",
-		notNull: true
+		name: "node-drop-ratio",
+		displayName: "Node drop ratio"
 	},
 	{
-		name: "max",
-		type: "REAL",
-		notNull: true
+		name: "node-fps-deficit",
+		displayName: "Node FPS deficit"
 	}
 ];
-/**
-* 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;
+var NodeStressHistoryProducer = class {
+	accum = new BucketAccumulator();
+	deviceHistory;
 	logger;
 	nowFn;
-	bucketMs;
-	maxRows;
+	declared = false;
 	constructor(deps) {
-		this.collection = deps.collection;
-		this.store = deps.store;
+		this.deviceHistory = deps.deviceHistory;
 		this.logger = deps.logger;
 		this.nowFn = deps.now ?? (() => Date.now());
-		this.bucketMs = deps.bucketMs ?? 3e5;
-		this.maxRows = deps.maxRowsPerSeries ?? 105120;
-	}
-	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;
+	async declare() {
+		if (this.declared) return;
+		for (const meta of SERIES_META) await this.deviceHistory.declareSeries({
+			name: meta.name,
+			subjectKind: "node",
+			kind: "gauge",
+			displayName: meta.displayName,
+			ingest: "buckets"
+		});
+		this.declared = true;
 	}
-	/**
-	* 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) {
+	noteSignals(nodeId, signals, at) {
+		const subject = {
+			kind: "node",
+			nodeId
+		};
+		this.accum.note(SERIES_KEYS["node-score"], subject, "", signals.score, at);
+		this.accum.note(SERIES_KEYS["node-queue-pressure"], subject, "", signals.queuePressure, at);
+		this.accum.note(SERIES_KEYS["node-drop-ratio"], subject, "", signals.dropRatio, at);
+		this.accum.note(SERIES_KEYS["node-fps-deficit"], subject, "", signals.fpsDeficit, at);
+	}
+	async flushDue(now) {
+		const closed = this.accum.takeClosed(now ?? this.nowFn());
+		if (closed.length === 0) return 0;
 		try {
-			await this.upsert(batch);
-			for (const bucket of batch) this.groups.add(groupKey(bucket.subject, bucket.series, bucket.scope));
-			return batch.length;
+			return (await this.deviceHistory.recordBuckets({ buckets: closed })).accepted;
 		} 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)
-				}
-			});
+			const dropped = this.accum.requeue(closed);
+			this.logger.warn("node-stress history flush failed — requeued", { meta: {
+				buckets: closed.length,
+				dropped: dropped.length,
+				error: err instanceof Error ? err.message : 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
-			}
+	async read(input) {
+		const nodeId = input.subject;
+		if (nodeId === void 0 || input.series === void 0) return [];
+		const key = SERIES_KEYS[input.series];
+		if (key === void 0) return [];
+		const result = await this.deviceHistory.queryNode({
+			nodeId,
+			key,
+			from: input.from ?? 0,
+			to: input.to ?? Date.now(),
+			resolution: "5m",
+			...input.maxPoints !== void 0 ? { maxPoints: input.maxPoints } : {}
 		});
 		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/node-stress-lts.ts
-/**
-* @durable class=ledger owner=pipeline-orchestrator
-*   write="one row per (node, series, 5-min bucket), written ONCE when the bucket closes; a node reporting no samples writes nothing"
-*   retention="row CAP per (subject, series, scope) — 105,120 rows ≈ one year of 5-minute buckets. Not an age sweep: an LTS row summarises an interval and has no owner to be orphaned from."
-*/
-var NODE_STRESS_LTS_COLLECTION = "pipeline-orchestrator:stats-5m-v2";
-var NodeStressLts = class {
-	lts;
-	constructor(deps) {
-		this.lts = new LtsAggregator({
-			collection: NODE_STRESS_LTS_COLLECTION,
-			store: deps.store,
-			logger: deps.logger,
-			...deps.now !== void 0 ? { now: deps.now } : {}
-		});
-	}
-	static declare(store) {
-		return LtsAggregator.declare(store, NODE_STRESS_LTS_COLLECTION);
-	}
-	/** Fold one sweep's verdict for one node into the open buckets. */
-	noteSignals(nodeId, signals, at) {
-		this.lts.note({
-			subject: nodeId,
-			series: "node-score",
-			value: signals.score,
-			at
-		});
-		this.lts.note({
-			subject: nodeId,
-			series: "node-queue-pressure",
-			value: signals.queuePressure,
-			at
-		});
-		this.lts.note({
+		for (const s of result.series) for (const p of s.points) rows.push({
 			subject: nodeId,
-			series: "node-drop-ratio",
-			value: signals.dropRatio,
-			at
-		});
-		this.lts.note({
-			subject: nodeId,
-			series: "node-fps-deficit",
-			value: signals.fpsDeficit,
-			at
+			series: input.series,
+			scope: s.scope,
+			bucketStart: p.t,
+			samples: p.samples,
+			sum: p.sum,
+			min: p.min,
+			max: p.max
 		});
-	}
-	flushDue(now) {
-		return this.lts.flushDue(now);
-	}
-	read(query) {
-		return this.lts.read(query);
+		return rows;
 	}
 	openBuckets() {
-		return this.lts.openBuckets();
+		return [];
 	}
 };
 //#endregion
@@ -95073,9 +95086,9 @@ async function buildOrchestratorControllers(deps) {
 		kind: orchestratorRecords.kind(orchestratorRecordKinds["node-stress-moves"]),
 		logger: deps.ctx().logger.child("node-stress")
 	});
-	const nodeStressLts = new NodeStressLts({
-		store: deps.ctx().api.settingsStore,
-		logger: deps.ctx().logger.child("node-stress-lts")
+	const nodeStressLts = new NodeStressHistoryProducer({
+		deviceHistory: nodeStressHistoryClient(deps.ctx().api.deviceHistory),
+		logger: deps.ctx().logger.child("node-stress-history")
 	});
 	const nodeStress = new NodeStressController({
 		ledger,
@@ -95093,7 +95106,7 @@ async function buildOrchestratorControllers(deps) {
 	await nodeStress.hydrate().catch((err) => {
 		deps.ctx().logger.warn("node-stress move history unavailable — this boot starts cold", { meta: { error: errMsg$2(err) } });
 	});
-	await NodeStressLts.declare(deps.ctx().api.settingsStore).catch((err) => {
+	await nodeStressLts.declare().catch((err) => {
 		deps.ctx().logger.warn("node-stress statistics unavailable — no baseline this boot", { meta: { error: errMsg$2(err) } });
 	});
 	const nodeStressLtsTimer = setInterval(() => {
@@ -97804,7 +97817,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 	/** Periodic auto-rebalance sweep timer (drift correction under hysteresis). */
 	autoRebalanceTimer = null;
 	/** Node-stress five-minute statistics + its flush timer (see
-	*  `node-stress-lts.ts`). `observe` mode's first durable output. */
+	*  `node-stress-history-producer.ts`). `observe` mode's first durable output. */
 	nodeStressLts = null;
 	nodeStressLtsTimer = null;
 	initTimestamp = 0;
@@ -99774,7 +99787,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 		return this.isSessionCamera(deviceId) && !this.session.hasActiveSession(deviceId);
 	}
 };
-/** The derived mean for one statistics row — see `node-stress-lts.ts`. */
+/** The derived mean for one closed bucket — see `node-stress-history-producer.ts`. */
 function withStatsMean(row) {
 	return {
 		...row,