@camstack/system 1.2.446 → 1.2.447

package/dist/builtins/native-metrics/native-metrics.addon.mjs

@@ -688,11 +688,9 @@ var NodeLoadRing = class {
 	* rather than a replay of a timestamp this node has already delivered.
 	*
 	* The return value is not diagnostics. It is the idempotence gate the
-	* DURABLE tier rides on (`load-series-store.ts`): only an accepted sample is
-	* appended to the table, which is what lets that table carry an `INTEGER`
-	* rowid key instead of a composite unique index over two million rows. The
-	* gate is one monotonic comparison in memory; the index it replaces was
-	* measured at ~40 bytes per row.
+	* DURABLE tier rides on this return value (`node-metrics-history-recorder.ts`):
+	* only an accepted sample is sent to device-history. The gate is one monotonic
+	* comparison in memory.
 	*/
 	record(nodeId, atMs, processes) {
 		if (nodeId.length === 0) return false;
@@ -817,197 +815,7 @@ var NodeLoadRing = class {
 		this.lastWriteSeq.delete(nodeId);
 	}
 };
-//#endregion
-//#region src/builtins/native-metrics/container-memory-series.ts
-/**
-* @durable class=audit owner=metrics-native
-*   write="one row per NODE per sample, appended by the HUB's `native-metrics`
-*     off its subscription to `metrics.node-processes-snapshot` — the same
-*     subscription, the same accepted-sample gate and the same timestamps as
-*     `metrics:node-load-samples`, so a memory row and the process rows of the
-*     same instant share an `atMs`. A node with no cgroup writes NOTHING; it
-*     never writes a zeroed row."
-*   retention="The operator's `loadSeriesRetentionHours` by age and
-*     CONTAINER_MEMORY_MAX_ROWS by count, swept in the same pass as the process
-*     table and through the same bounded page. Losing the table loses the cold
-*     window only: the ring keeps serving the last hour."
-*/
-var CONTAINER_MEMORY_COLLECTION = "metrics:node-memory-samples";
-/**
-* Fleet ceiling on the hot ring, in READINGS.
-*
-* One reading per node per sample, so this is simply the per-node ceiling times
-* the partition ceiling the process ring already declares (16). 2 880 readings
-* of ten numbers each is well under a megabyte — the bound exists so a runaway
-* node id space costs a fixed amount, not because the number is large.
-*/
 var CONTAINER_MEMORY_MAX_TOTAL_ROWS = 2880;
-/**
-* Hard ceiling on the durable table, in ROWS. The guarantee behind the
-* retention intention, exactly as `DEFAULT_MAX_ROWS` is for the process table.
-*
-* | cadence | retention | rows (3 nodes) |
-* | --- | --- | --- |
-* | 10 s | 6 h (default) | 6 480 |
-* | 5 s | 6 h | 12 960 |
-* | 5 s | 72 h, 16 nodes | 829 440 — capped here |
-*
-* 50 000 rows is 7.7x the shipped default. This row is strictly narrower than
-* a `metrics:node-load-samples` row — fewer columns, one index, every value an
-* integer varint — and that one was MEASURED at 87 B/row, so 50 000 rows is
-* **under 4.2 MiB** with the real figure lower still. It is not a knob: a
-* guarantee that moves with the hand that raised the intention is not one.
-*/
-var CONTAINER_MEMORY_MAX_ROWS = 5e4;
-var CONTAINER_MEMORY_COLUMNS = [
-	{
-		name: "id",
-		type: "INTEGER",
-		primaryKey: true,
-		notNull: true
-	},
-	{
-		name: "nodeId",
-		type: "TEXT",
-		notNull: true
-	},
-	(
-	/** Shared with the process rows of the same tick — that is the whole point. */
-	{
-		name: "atMs",
-		type: "INTEGER",
-		notNull: true
-	}),
-	{
-		name: "source",
-		type: "TEXT",
-		notNull: true
-	},
-	(
-	/**
-	* Whole MiB, like `rssMib` on the process row and for the same reason: a
-	* byte-exact residency on a value in the tens of gigabytes is precision no
-	* chart can draw, and it costs bytes on every row forever.
-	*/
-	{
-		name: "currentMib",
-		type: "INTEGER",
-		notNull: true
-	}),
-	(
-	/** `NULL` = NO LIMIT. Never a sentinel. */
-	{
-		name: "limitMib",
-		type: "INTEGER"
-	}),
-	(
-	/** `NULL` = UNKNOWN on all four. Never zero. */
-	{
-		name: "anonMib",
-		type: "INTEGER"
-	}),
-	{
-		name: "fileMib",
-		type: "INTEGER"
-	},
-	{
-		name: "shmemMib",
-		type: "INTEGER"
-	},
-	{
-		name: "slabMib",
-		type: "INTEGER"
-	},
-	(
-	/** Host-wide i915 GEM bytes. `NULL` wherever debugfs is not mounted. */
-	{
-		name: "gpuShmemMib",
-		type: "INTEGER"
-	})
-];
-var CONTAINER_MEMORY_INDEXES = [(
-/** The one index, and it serves both the read and the prune — see the
-*  process table's `idx_load_samples_node_at` for the full reasoning. */
-{
-	name: "idx_node_memory_node_at",
-	columns: ["nodeId", "atMs"]
-})];
-var BYTES_PER_MIB$1 = 1048576;
-/** Bytes → whole MiB. `null` stays `null`: unknown is not zero. */
-function toMib(value) {
-	return value === null ? null : Math.round(value / BYTES_PER_MIB$1);
-}
-/** Whole MiB → bytes. `null` stays `null`. */
-function fromMib(value) {
-	return value === null ? null : value * BYTES_PER_MIB$1;
-}
-/** The ONE encode. */
-function snapshotToRow(nodeId, atMs, snapshot) {
-	return {
-		nodeId,
-		atMs,
-		source: snapshot.source,
-		currentMib: Math.round(snapshot.currentBytes / BYTES_PER_MIB$1),
-		limitMib: toMib(snapshot.limitBytes),
-		anonMib: toMib(snapshot.anonBytes),
-		fileMib: toMib(snapshot.fileBytes),
-		shmemMib: toMib(snapshot.shmemBytes),
-		slabMib: toMib(snapshot.slabBytes),
-		gpuShmemMib: toMib(snapshot.gpuShmemBytes)
-	};
-}
-/**
-* The ONE decode. A row whose `source` is not a hierarchy this build knows is
-* skipped rather than coerced — a stored string that no longer means anything
-* must not be charted as though it did.
-*/
-function rowToPoint(row) {
-	if (row.source !== "cgroup-v2" && row.source !== "cgroup-v1") return null;
-	return {
-		atMs: row.atMs,
-		source: row.source,
-		currentBytes: row.currentMib * BYTES_PER_MIB$1,
-		limitBytes: fromMib(row.limitMib),
-		anonBytes: fromMib(row.anonMib),
-		fileBytes: fromMib(row.fileMib),
-		shmemBytes: fromMib(row.shmemMib),
-		slabBytes: fromMib(row.slabMib),
-		gpuShmemBytes: fromMib(row.gpuShmemMib)
-	};
-}
-/** Structural validation on read. A malformed row is skipped, never charted. */
-function recordToMemoryRow(data) {
-	const nodeId = data["nodeId"];
-	const source = data["source"];
-	if (typeof nodeId !== "string" || typeof source !== "string") return null;
-	const atMs = Number(data["atMs"]);
-	const currentMib = Number(data["currentMib"]);
-	if (!Number.isFinite(atMs) || !Number.isFinite(currentMib)) return null;
-	const optional = (raw) => {
-		if (raw === null || raw === void 0) return null;
-		const n = Number(raw);
-		return Number.isFinite(n) ? n : null;
-	};
-	return {
-		nodeId,
-		atMs,
-		source,
-		currentMib,
-		limitMib: optional(data["limitMib"]),
-		anonMib: optional(data["anonMib"]),
-		fileMib: optional(data["fileMib"]),
-		shmemMib: optional(data["shmemMib"]),
-		slabMib: optional(data["slabMib"]),
-		gpuShmemMib: optional(data["gpuShmemMib"])
-	};
-}
-/**
-* The HOT tier — a naming adapter over {@link NodeLoadRing}, not a second ring.
-*
-* One reading per sample, so the ring's "rows" and its samples are the same
-* count and its fleet budget is a sample budget. Every bound, the idle sweep
-* and the monotonic replay gate come from there unchanged.
-*/
 var ContainerMemoryRing = class {
 	ring;
 	constructor(options = {}) {
@@ -1017,17 +825,9 @@ var ContainerMemoryRing = class {
 			...options.now !== void 0 ? { now: options.now } : {}
 		});
 	}
-	/** Retain one reading. `false` = a timestamp this node already delivered. */
 	record(nodeId, atMs, snapshot) {
 		return this.ring.record(nodeId, atMs, [snapshot]);
 	}
-	/**
-	* Read one node's retained readings, oldest-first. `sinceMs` is EXCLUSIVE,
-	* matching every other reader in this subsystem.
-	*
-	* A node nobody has recorded answers EMPTY — which is what "this node has no
-	* cgroup" looks like, and it must stay distinguishable from a zero.
-	*/
 	read(nodeId, sinceMs) {
 		const series = this.ring.read(nodeId, sinceMs);
 		const out = [];
@@ -1042,23 +842,6 @@ var ContainerMemoryRing = class {
 		return out;
 	}
 };
-/**
-* Merge the two tiers and reduce, oldest-first.
-*
-* Dedupe is on `atMs` with the HOT copy winning, exactly as the process reader
-* does: the ring holds the reading as it arrived, the table holds it after the
-* MiB encode.
-*
-* Reduction keeps, for each bucket, the reading with the largest
-* `currentBytes` — WHOLE, every field from that one sample. A per-field
-* maximum would synthesise a row whose parts never coexisted (an `anon` peak
-* and a `file` peak minutes apart, summed into a total that never happened),
-* and a mean would smear away the spike this series exists to find. `atMs`
-* becomes the bucket START so the points lie on the same x-axis as the folded
-* process series, which is the only reason both travel in one answer.
-*
-* An empty bucket stays ABSENT — never zero, never carried forward.
-*/
 function reduceContainerMemory(points, bucketMs, origin) {
 	if (bucketMs <= 0 || points.length === 0) return points;
 	const buckets = /* @__PURE__ */ new Map();
@@ -1072,727 +855,13 @@ function reduceContainerMemory(points, bucketMs, origin) {
 	}
 	return [...buckets.values()].toSorted((a, b) => a.atMs - b.atMs);
 }
-/** Merge cold + hot on `atMs`, hot wins. Exported because dedup is the
-*  property worth testing on its own. */
 function mergeContainerMemory(cold, hot) {
 	const byAt = /* @__PURE__ */ new Map();
 	for (const point of cold) byAt.set(point.atMs, point);
 	for (const point of hot) byAt.set(point.atMs, point);
 	return [...byAt.values()].toSorted((a, b) => a.atMs - b.atMs);
 }
-/**
-* The COLD tier. Append-only, bounded, and never the authority on anything the
-* hot ring can answer.
-*
-* Every method is best-effort and says so in the log rather than throwing at
-* the emitter: a storage hiccup must cost a gap in a chart, never a dropped
-* snapshot on the bus.
-*/
-var ContainerMemoryStore = class {
-	declared = false;
-	store;
-	logger;
-	nowFn;
-	prunePageRows;
-	constructor(deps) {
-		this.store = deps.store;
-		this.logger = deps.logger;
-		this.nowFn = deps.now ?? (() => Date.now());
-		this.prunePageRows = deps.prunePageRows ?? 2e4;
-	}
-	/** Idempotently declare the collection. `false` when the store refused. */
-	async declare() {
-		if (this.declared) return true;
-		try {
-			await this.store.declareCollection.mutate({
-				collection: CONTAINER_MEMORY_COLLECTION,
-				columns: [...CONTAINER_MEMORY_COLUMNS],
-				indexes: CONTAINER_MEMORY_INDEXES.map((i) => ({
-					name: i.name,
-					columns: [...i.columns]
-				}))
-			});
-			this.declared = true;
-			return true;
-		} catch (err) {
-			this.logger.warn("container memory declareCollection failed — nothing will be retained on disk", { meta: {
-				collection: CONTAINER_MEMORY_COLLECTION,
-				error: errMsg(err)
-			} });
-			return false;
-		}
-	}
-	/** Append ONE reading. */
-	async append(nodeId, atMs, snapshot) {
-		if (!await this.declare()) return 0;
-		const record = { ...snapshotToRow(nodeId, atMs, snapshot) };
-		try {
-			const { inserted } = await this.store.insertMany.mutate({
-				collection: CONTAINER_MEMORY_COLLECTION,
-				records: [{ data: record }]
-			});
-			return inserted;
-		} catch (err) {
-			this.logger.warn("container memory reading not retained — this interval will be missing", { meta: {
-				nodeId,
-				atMs,
-				error: errMsg(err)
-			} });
-			return 0;
-		}
-	}
-	/** Read one node's cold readings, oldest-first. `sinceMs` is EXCLUSIVE. */
-	async read(nodeId, sinceMs, limitRows) {
-		if (!await this.declare()) return [];
-		try {
-			const records = await this.store.query.query({
-				collection: CONTAINER_MEMORY_COLLECTION,
-				filter: {
-					where: { nodeId },
-					whereBetween: { atMs: [sinceMs + 1, Number.MAX_SAFE_INTEGER] },
-					orderBy: {
-						field: "atMs",
-						direction: "asc"
-					},
-					limit: limitRows
-				}
-			});
-			const points = [];
-			for (const record of records) {
-				const row = recordToMemoryRow(record.data);
-				if (row === null) continue;
-				const point = rowToPoint(row);
-				if (point !== null) points.push(point);
-			}
-			return points;
-		} catch (err) {
-			this.logger.warn("container memory cold read failed — answering from the hot window only", { meta: {
-				nodeId,
-				sinceMs,
-				error: errMsg(err)
-			} });
-			return [];
-		}
-	}
-	/**
-	* Enforce BOTH bounds, oldest-first, through a bounded page each.
-	*
-	* Not rate-limited here: it is driven by the process store's own prune
-	* cadence, so it runs at most once a minute by construction and a second
-	* timer would be a second thing to get wrong.
-	*/
-	async prune(nodeIds, retention) {
-		if (!await this.declare()) return null;
-		const ageCutoff = this.nowFn() - retention.retentionHours * 36e5;
-		let deletedByAge = 0;
-		let rowsExamined = 0;
-		for (const nodeId of nodeIds) {
-			const outcome = await this.deleteOldestPage(nodeId, ageCutoff, this.prunePageRows);
-			deletedByAge += outcome.deleted;
-			rowsExamined += outcome.examined;
-		}
-		const total = await this.count();
-		const excess = total === null ? 0 : total - CONTAINER_MEMORY_MAX_ROWS;
-		let deletedByCap = 0;
-		if (excess > 0) {
-			let remaining = Math.min(excess, this.prunePageRows);
-			for (const nodeId of nodeIds) {
-				if (remaining <= 0) break;
-				const outcome = await this.deleteOldestPage(nodeId, null, remaining);
-				deletedByCap += outcome.deleted;
-				remaining -= outcome.deleted;
-				rowsExamined += outcome.examined;
-			}
-			this.logger.warn("container memory ROW CAP bit — evicting the oldest readings", { meta: {
-				collection: CONTAINER_MEMORY_COLLECTION,
-				rows: total,
-				cap: CONTAINER_MEMORY_MAX_ROWS,
-				over: excess,
-				deleted: deletedByCap,
-				hint: "lower the retention or the sampling cadence — the cap is the guarantee, not the intention"
-			} });
-		}
-		return {
-			deletedByAge,
-			deletedByCap,
-			rowsExamined,
-			capBit: excess > 0
-		};
-	}
-	/** Total rows, or `null` when the store could not answer. */
-	async count() {
-		if (!await this.declare()) return null;
-		try {
-			return await this.store.count.query({ collection: CONTAINER_MEMORY_COLLECTION });
-		} catch (err) {
-			this.logger.warn("container memory count failed — the row cap is not enforced this pass", { meta: { error: errMsg(err) } });
-			return null;
-		}
-	}
-	/**
-	* Delete this node's oldest rows, at most one page's worth.
-	*
-	* `cutoff === null` means "the oldest rows, whatever their age" — the
-	* row-cap path, which is bounded by `limitRows` instead. Either way the page
-	* is READ FIRST, ordered by the one index, and its last `atMs` becomes the
-	* effective cutoff for a single bounded delete. An unbounded `deleteWhere`
-	* would be one statement and one stalling transaction the first time a
-	* retention is lowered.
-	*/
-	async deleteOldestPage(nodeId, cutoff, limitRows) {
-		if (limitRows <= 0) return {
-			deleted: 0,
-			examined: 0
-		};
-		try {
-			const page = await this.store.query.query({
-				collection: CONTAINER_MEMORY_COLLECTION,
-				filter: {
-					where: { nodeId },
-					...cutoff === null ? {} : { whereBetween: { atMs: [0, cutoff] } },
-					orderBy: {
-						field: "atMs",
-						direction: "asc"
-					},
-					limit: Math.min(limitRows, this.prunePageRows)
-				},
-				columns: ["atMs"]
-			});
-			if (page.length === 0) return {
-				deleted: 0,
-				examined: 0
-			};
-			const effectiveCutoff = Number(page.at(-1)?.data["atMs"]);
-			if (!Number.isFinite(effectiveCutoff)) return {
-				deleted: 0,
-				examined: page.length
-			};
-			const { deleted } = await this.store.deleteWhere.mutate({
-				collection: CONTAINER_MEMORY_COLLECTION,
-				filter: {
-					where: { nodeId },
-					whereBetween: { atMs: [0, effectiveCutoff] }
-				}
-			});
-			return {
-				deleted,
-				examined: page.length
-			};
-		} catch (err) {
-			this.logger.warn("container memory prune failed — the table keeps growing this pass", { meta: {
-				nodeId,
-				cutoff,
-				error: errMsg(err)
-			} });
-			return {
-				deleted: 0,
-				examined: 0
-			};
-		}
-	}
-};
-//#endregion
-//#region src/builtins/native-metrics/load-series-store.ts
-/**
-* @durable class=audit owner=metrics-native
-*   write="one row per process per sample, appended in ONE transaction per
-*     sample (`settingsStore.insertMany`) by the HUB's `native-metrics`, off its
-*     subscription to `metrics.node-processes-snapshot`. Emission is
-*     fixed-cadence, so the write rate is deterministic: nodes x processes /
-*     cadence, 7.6 rows/s on the live fleet at the 10 s default. Only a sample
-*     the in-memory ring ACCEPTED is written, which is what makes the append
-*     idempotent without a unique key."
-*   retention="TWO bounds, swept together at most once a minute. By AGE, the
-*     operator's `loadSeriesRetentionHours` (default 6, the intention); by ROWS,
-*     DEFAULT_MAX_ROWS (the guarantee, which bites regardless of the age knob).
-*     Both prune oldest-first through a bounded page — never a full scan — and
-*     the row cap logs when it bites. Losing the table loses the cold window
-*     only: the ring keeps serving the last hour and the charts keep drawing."
-*/
-var LOAD_SERIES_COLLECTION = "metrics:node-load-samples";
-/**
-* Hard ceiling on the table, in ROWS.
-*
-* The guarantee behind the retention knob. Sized against the shipped default
-* and against the worst configuration the knob can express:
-*
-* | cadence | retention | rows (3 nodes, 76 processes) |
-* | --- | --- | --- |
-* | 10 s | 6 h (default) | 164 160 |
-* | 5 s | 6 h | 328 320 |
-* | 5 s | 72 h | 3 939 840 — capped here |
-*
-* 500 000 rows x the measured 87 B = **41.5 MiB**, roughly 3x what the shipped
-* default needs and far below the 2 M rows a three-day retention would reach.
-* It is deliberately NOT a knob: the point of a guarantee is that it is not
-* subject to the same hand that raised the intention. This is the discipline
-* the in-memory ring already adopted (`DEFAULT_MAX_TOTAL_PROCESS_ROWS`) and
-* the one the RTP pre-roll rings still lack — a maximum per instance and no
-* budget at all for the whole, which reached 898 MB across 47 rings
-* (`docs/architecture/load-ledger.md` #5).
-*/
 var DEFAULT_MAX_ROWS = 5e5;
-var LOAD_SERIES_COLUMNS = [
-	(
-	/** `INTEGER PRIMARY KEY` = SQLite rowid alias: the key IS the row's address,
-	*  so it costs no separate index and no stored string. */
-	{
-		name: "id",
-		type: "INTEGER",
-		primaryKey: true,
-		notNull: true
-	}),
-	{
-		name: "nodeId",
-		type: "TEXT",
-		notNull: true
-	},
-	(
-	/** The EMITTING node's timestamp for the sample this row belongs to. Every
-	*  row of one sample shares it — that is what makes a sample reassemblable. */
-	{
-		name: "atMs",
-		type: "INTEGER",
-		notNull: true
-	}),
-	{
-		name: "pid",
-		type: "INTEGER",
-		notNull: true
-	},
-	(
-	/** `NULL` for a process no addon owns — `root` and `system` both. */
-	{
-		name: "addonId",
-		type: "TEXT"
-	}),
-	{
-		name: "classification",
-		type: "TEXT",
-		notNull: true
-	},
-	(
-	/** `ps pcpu` x 10. A LIFETIME average, not a rate — see `NodeProcess`. */
-	{
-		name: "cpuDeci",
-		type: "INTEGER",
-		notNull: true
-	}),
-	{
-		name: "rssMib",
-		type: "INTEGER",
-		notNull: true
-	},
-	(
-	/** Instantaneous main-thread CPU% x 10. `NULL` = UNKNOWN, never zero. */
-	{
-		name: "cpuMainDeci",
-		type: "INTEGER"
-	}),
-	(
-	/** Instantaneous V8-helper-pool CPU% x 10. `NULL` = UNKNOWN, never zero. */
-	{
-		name: "cpuGcDeci",
-		type: "INTEGER"
-	})
-];
-var LOAD_SERIES_INDEXES = [(
-/**
-* The ONE index, and it serves both jobs.
-*
-* Reads are always "this node, newer than T" — `nodeId` leads so the
-* equality is a range scan and `atMs` supplies the order without a sort.
-* Prunes are always "this node, oldest first" — the same index, walked from
-* the other end. A second index on `atMs` alone was measured and rejected:
-* it cost 23 B/row (196.0 → 172.8 with the two column drops) to serve a
-* cross-node prune that a per-node loop over three nodes already serves.
-*/
-{
-	name: "idx_load_samples_node_at",
-	columns: ["nodeId", "atMs"]
-})];
-var BYTES_PER_MIB = 1048576;
-/** Tenths → percent. `null` stays `null`: unknown is not zero. */
-function fromDeci(value) {
-	return value === null ? null : Math.round(value) / 10;
-}
-/** Percent → tenths, lossless because both producers already round to tenths. */
-function toDeci(value) {
-	return value === null ? null : Math.round(value * 10);
-}
-/** Storage row → the shape a reader gets. The ONE decode. */
-function rowToProcess(row) {
-	return {
-		pid: row.pid,
-		addonId: row.addonId,
-		classification: row.classification,
-		cpuPercent: fromDeci(row.cpuDeci) ?? 0,
-		memoryRssBytes: row.rssMib * BYTES_PER_MIB,
-		cpuMainPercent: fromDeci(row.cpuMainDeci),
-		cpuGcPercent: fromDeci(row.cpuGcDeci)
-	};
-}
-/** The shape a reader gets → the storage row. The ONE encode. */
-function processToRow(nodeId, atMs, process) {
-	return {
-		nodeId,
-		atMs,
-		pid: process.pid,
-		addonId: process.addonId,
-		classification: process.classification,
-		cpuDeci: toDeci(process.cpuPercent) ?? 0,
-		rssMib: Math.round(process.memoryRssBytes / BYTES_PER_MIB),
-		cpuMainDeci: toDeci(process.cpuMainPercent),
-		cpuGcDeci: toDeci(process.cpuGcPercent)
-	};
-}
-/** Group flat rows into samples, oldest-first. A sample is one `atMs`. */
-function rowsToSamples(rows) {
-	const byAt = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const held = byAt.get(row.atMs);
-		if (held === void 0) byAt.set(row.atMs, [rowToProcess(row)]);
-		else held.push(rowToProcess(row));
-	}
-	return [...byAt.entries()].toSorted((a, b) => a[0] - b[0]).map(([atMs, processes]) => ({
-		atMs,
-		processes
-	}));
-}
-/**
-* The cold tier. Append-only, bounded, and never the authority on anything the
-* hot ring can answer.
-*
-* Every method is best-effort and says so in the log rather than throwing at
-* the emitter: a storage hiccup must cost a gap in a chart, never a dropped
-* snapshot on the bus.
-*/
-var LoadSeriesStore = class {
-	declared = false;
-	lastPruneAtMs = 0;
-	store;
-	logger;
-	nowFn;
-	prunePageRows;
-	pruneIntervalMs;
-	constructor(deps) {
-		this.store = deps.store;
-		this.logger = deps.logger;
-		this.nowFn = deps.now ?? (() => Date.now());
-		this.prunePageRows = deps.prunePageRows ?? 2e4;
-		this.pruneIntervalMs = deps.pruneIntervalMs ?? 6e4;
-	}
-	/** Idempotently declare the collection. `false` when the store refused. */
-	async declare() {
-		if (this.declared) return true;
-		try {
-			await this.store.declareCollection.mutate({
-				collection: LOAD_SERIES_COLLECTION,
-				columns: [...LOAD_SERIES_COLUMNS],
-				indexes: LOAD_SERIES_INDEXES.map((i) => ({
-					name: i.name,
-					columns: [...i.columns]
-				}))
-			});
-			this.declared = true;
-			return true;
-		} catch (err) {
-			this.logger.warn("load series declareCollection failed — nothing will be retained on disk", { meta: {
-				collection: LOAD_SERIES_COLLECTION,
-				error: errMsg(err)
-			} });
-			return false;
-		}
-	}
-	/**
-	* Append ONE sample — every process row of it — in ONE transaction.
-	*
-	* Never a write per row. `insertMany` exists for exactly this: at the 10 s
-	* default the fleet produces 7.6 rows/s, and 7.6 separate commits per second
-	* on the connection that also serves every cluster-wide configuration read
-	* is a constant load nobody asked for.
-	*/
-	async append(nodeId, atMs, processes) {
-		if (processes.length === 0) return 0;
-		if (!await this.declare()) return 0;
-		const records = processes.map((p) => ({ data: { ...processToRow(nodeId, atMs, p) } }));
-		try {
-			const { inserted } = await this.store.insertMany.mutate({
-				collection: LOAD_SERIES_COLLECTION,
-				records
-			});
-			return inserted;
-		} catch (err) {
-			this.logger.warn("load series sample not retained — this interval will be missing", { meta: {
-				nodeId,
-				atMs,
-				rows: processes.length,
-				error: errMsg(err)
-			} });
-			return 0;
-		}
-	}
-	/**
-	* Read one node's cold samples, oldest-first.
-	*
-	* `sinceMs` is EXCLUSIVE, matching the ring, so a caller passing the newest
-	* timestamp it holds gets only what it is missing. `limitRows` bounds the
-	* read in ROWS (not samples) because rows are what the query costs.
-	*/
-	async read(nodeId, sinceMs, limitRows) {
-		if (!await this.declare()) return [];
-		try {
-			const records = await this.store.query.query({
-				collection: LOAD_SERIES_COLLECTION,
-				filter: {
-					where: { nodeId },
-					whereBetween: { atMs: [sinceMs + 1, Number.MAX_SAFE_INTEGER] },
-					orderBy: {
-						field: "atMs",
-						direction: "asc"
-					},
-					limit: limitRows
-				}
-			});
-			const rows = [];
-			for (const record of records) {
-				const row = recordToRow(record.data);
-				if (row !== null) rows.push(row);
-			}
-			return rowsToSamples(rows);
-		} catch (err) {
-			this.logger.warn("load series cold read failed — answering from the hot window only", { meta: {
-				nodeId,
-				sinceMs,
-				error: errMsg(err)
-			} });
-			return [];
-		}
-	}
-	/**
-	* Enforce BOTH bounds, oldest-first, through a bounded page each.
-	*
-	* Rate-limited to {@link pruneIntervalMs}: a bound is not a deadline, and the
-	* append path must not pay a sweep on every sample.
-	*/
-	async prune(nodeIds, retention, force = false) {
-		const now = this.nowFn();
-		if (!force && now - this.lastPruneAtMs < this.pruneIntervalMs) return null;
-		this.lastPruneAtMs = now;
-		if (!await this.declare()) return null;
-		let deletedByAge = 0;
-		let deletedByCap = 0;
-		let rowsExamined = 0;
-		const ageCutoff = now - retention.retentionHours * 36e5;
-		for (const nodeId of nodeIds) {
-			const outcome = await this.pruneNodeToCutoff(nodeId, ageCutoff);
-			deletedByAge += outcome.deleted;
-			rowsExamined += outcome.examined;
-		}
-		const total = await this.count();
-		const excess = total === null ? 0 : total - retention.maxRows;
-		if (excess > 0) {
-			const outcome = await this.pruneOldestRows(nodeIds, excess);
-			deletedByCap = outcome.deleted;
-			rowsExamined += outcome.examined;
-			this.logger.warn("load series ROW CAP bit — evicting the oldest samples", { meta: {
-				collection: LOAD_SERIES_COLLECTION,
-				rows: total,
-				cap: retention.maxRows,
-				over: excess,
-				deleted: outcome.deleted,
-				retentionHours: retention.retentionHours,
-				hint: "lower the retention or the sampling cadence — the cap is the guarantee, not the intention"
-			} });
-		}
-		return {
-			deletedByAge,
-			deletedByCap,
-			rowsExamined,
-			capBit: excess > 0
-		};
-	}
-	/** Total rows, or `null` when the store could not answer. */
-	async count() {
-		if (!await this.declare()) return null;
-		try {
-			return await this.store.count.query({ collection: LOAD_SERIES_COLLECTION });
-		} catch (err) {
-			this.logger.warn("load series count failed — the row cap is not enforced this pass", { meta: { error: errMsg(err) } });
-			return null;
-		}
-	}
-	/**
-	* Delete this node's rows older than `cutoff`, at most one page's worth.
-	*
-	* The page is the whole point. `deleteWhere({ atMs: [0, cutoff] })` on its
-	* own is one statement but an UNBOUNDED one — a first pass after a retention
-	* change would delete millions of rows inside a single stalling transaction.
-	* So the page is read first (keys only, ordered by the index), its last
-	* `atMs` becomes the EFFECTIVE cutoff, and the delete is bounded by it.
-	*/
-	async pruneNodeToCutoff(nodeId, cutoff) {
-		try {
-			const page = await this.store.query.query({
-				collection: LOAD_SERIES_COLLECTION,
-				filter: {
-					where: { nodeId },
-					whereBetween: { atMs: [0, cutoff] },
-					orderBy: {
-						field: "atMs",
-						direction: "asc"
-					},
-					limit: this.prunePageRows
-				},
-				columns: ["atMs"]
-			});
-			if (page.length === 0) return {
-				deleted: 0,
-				examined: 0
-			};
-			const effectiveCutoff = Number(page.at(-1)?.data["atMs"]);
-			if (!Number.isFinite(effectiveCutoff)) return {
-				deleted: 0,
-				examined: page.length
-			};
-			const { deleted } = await this.store.deleteWhere.mutate({
-				collection: LOAD_SERIES_COLLECTION,
-				filter: {
-					where: { nodeId },
-					whereBetween: { atMs: [0, effectiveCutoff] }
-				}
-			});
-			return {
-				deleted,
-				examined: page.length
-			};
-		} catch (err) {
-			this.logger.warn("load series age prune failed — the table keeps growing this pass", { meta: {
-				nodeId,
-				cutoff,
-				error: errMsg(err)
-			} });
-			return {
-				deleted: 0,
-				examined: 0
-			};
-		}
-	}
-	/**
-	* Drop the oldest rows across the known nodes until `excess` is covered.
-	*
-	* Same bounded-page technique, walked per node so the one index serves it.
-	* The node holding the oldest rows pays first, which is also the node
-	* producing the pressure when a runaway process count is the cause.
-	*/
-	async pruneOldestRows(nodeIds, excess) {
-		let remaining = Math.min(excess, this.prunePageRows);
-		let deleted = 0;
-		let examined = 0;
-		for (const nodeId of nodeIds) {
-			if (remaining <= 0) break;
-			try {
-				const page = await this.store.query.query({
-					collection: LOAD_SERIES_COLLECTION,
-					filter: {
-						where: { nodeId },
-						orderBy: {
-							field: "atMs",
-							direction: "asc"
-						},
-						limit: remaining
-					},
-					columns: ["atMs"]
-				});
-				examined += page.length;
-				if (page.length === 0) continue;
-				const cutoff = Number(page.at(-1)?.data["atMs"]);
-				if (!Number.isFinite(cutoff)) continue;
-				const result = await this.store.deleteWhere.mutate({
-					collection: LOAD_SERIES_COLLECTION,
-					filter: {
-						where: { nodeId },
-						whereBetween: { atMs: [0, cutoff] }
-					}
-				});
-				deleted += result.deleted;
-				remaining -= result.deleted;
-			} catch (err) {
-				this.logger.warn("load series cap prune failed — the cap is not enforced this pass", { meta: {
-					nodeId,
-					error: errMsg(err)
-				} });
-			}
-		}
-		return {
-			deleted,
-			examined
-		};
-	}
-};
-/** Structural validation on read. A malformed row is skipped, never charted. */
-function recordToRow(data) {
-	const nodeId = data["nodeId"];
-	const classification = data["classification"];
-	if (typeof nodeId !== "string" || typeof classification !== "string") return null;
-	const atMs = Number(data["atMs"]);
-	const pid = Number(data["pid"]);
-	const cpuDeci = Number(data["cpuDeci"]);
-	const rssMib = Number(data["rssMib"]);
-	if (![
-		atMs,
-		pid,
-		cpuDeci,
-		rssMib
-	].every((n) => Number.isFinite(n))) return null;
-	const rawAddon = data["addonId"];
-	const optional = (raw) => {
-		if (raw === null || raw === void 0) return null;
-		const n = Number(raw);
-		return Number.isFinite(n) ? n : null;
-	};
-	return {
-		nodeId,
-		atMs,
-		pid,
-		addonId: typeof rawAddon === "string" ? rawAddon : null,
-		classification,
-		cpuDeci,
-		rssMib,
-		cpuMainDeci: optional(data["cpuMainDeci"]),
-		cpuGcDeci: optional(data["cpuGcDeci"])
-	};
-}
-//#endregion
-//#region src/builtins/native-metrics/load-series-config.ts
-/**
-* The two knobs of the durable load series, and the arithmetic that makes them
-* honest.
-*
-* ## Where they live, and why there
-*
-* In `native-metrics`'s OWN global settings document — the one that already
-* exists and already carries `samplingIntervalMs`. Fields on a document, never
-* a method per knob: `system.getLoggingSettings` / `setLoggingSettings` set
-* that precedent and it holds here.
-*
-* They are NOT in the logging document, and that is a decision rather than an
-* omission. That document is about levels and diagnostic windows; a metrics
-* cadence and a table's retention are neither. Two documents that both claim a
-* knob is how this repo has already shipped a switch nobody read.
-*
-* They are cluster-wide, not per-node. Every node emits on the same cadence or
-* the fleet's series cannot be laid over each other, and the table is single
-* and hub-resident, so a per-node retention would be a promise nothing could
-* keep.
-*
-* ## Refused, not clamped
-*
-* A cadence outside 5-60 s is REFUSED. Clamping would silently store 10 when
-* the operator typed 2 and then report 10 back as though it had been accepted
-* — the failure mode where a knob and its readback agree on a value nobody
-* chose. The schema advertises the bounds; this refuses anything else.
-*/
 /** Why a value was refused — the message an operator is shown verbatim. */
 var LoadSeriesConfigError = class extends Error {
 	constructor(message) {
@@ -1835,7 +904,7 @@ function resolveLoadSeriesConfig(raw) {
 * This is what makes the knob honest: an operator raising retention to three
 * days sees the row count and the megabytes BEFORE applying it, rather than
 * discovering them afterwards. `MEASURED_BYTES_PER_ROW` is measured, not
-* guessed — see `load-series-store.ts`.
+* guessed — see `node-metrics-history-recorder.ts`.
 */
 function projectLoadSeriesCost(input) {
 	const samplesPerNodeWindow = input.config.retentionHours * 3600 / input.config.cadenceSec;
@@ -1861,8 +930,8 @@ function describeLoadSeriesCost(projection) {
 /**
 * The ONE reader over both retention tiers.
 *
-* The hot window is the in-memory ring; the cold one is
-* `metrics:node-load-samples`. A caller never learns which tier a point came
+* The hot window is the in-memory ring; the cold one is device-history raw
+* points. A caller never learns which tier a point came
 * from, and that is a hard requirement rather than a nicety: a second reader
 * is how two charts start disagreeing about the same node, and it is how "the
 * ring says X, the table says Y" becomes a question nobody can answer.
@@ -1950,6 +1019,203 @@ function mergeLoadSeries(input) {
 	};
 }
 //#endregion
+//#region src/builtins/native-metrics/node-metrics-history-recorder.ts
+var ADDON_ID = "metrics-native";
+var NODE_PROCESS_CPU_KEY = `addon:${ADDON_ID}/process-cpu-percent`;
+var NODE_PROCESS_RSS_KEY = `addon:${ADDON_ID}/process-rss-mib`;
+var NODE_CONTAINER_CURRENT_KEY = `addon:${ADDON_ID}/container-current-mib`;
+function nodeMetricsHistoryClient(api) {
+	return {
+		declareSeries: (input) => api.declareSeries.mutate(input),
+		record: (input) => api.record.mutate({ points: [...input.points] }),
+		queryNode: async (input) => {
+			return { series: (await api.queryNode.query(input)).series.map((s) => ({
+				scope: s.scope,
+				points: s.points.map((p) => ({
+					t: p.t,
+					samples: p.samples,
+					value: p.last ?? p.mean
+				}))
+			})) };
+		}
+	};
+}
+var NodeMetricsHistoryRecorder = class {
+	deps;
+	declared = false;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	async declare() {
+		if (this.declared) return;
+		const { deviceHistory } = this.deps;
+		await deviceHistory.declareSeries({
+			name: "process-cpu-percent",
+			subjectKind: "node",
+			kind: "gauge",
+			displayName: "Process CPU %",
+			ingest: "points",
+			unit: "%"
+		});
+		await deviceHistory.declareSeries({
+			name: "process-rss-mib",
+			subjectKind: "node",
+			kind: "gauge",
+			displayName: "Process RSS (MiB)",
+			ingest: "points",
+			unit: "MiB"
+		});
+		await deviceHistory.declareSeries({
+			name: "container-current-mib",
+			subjectKind: "node",
+			kind: "gauge",
+			displayName: "Container memory current (MiB)",
+			ingest: "points",
+			unit: "MiB"
+		});
+		this.declared = true;
+	}
+	async recordSample(nodeId, atMs, processes, containerMemory) {
+		if (!await this.ensureDeclared()) return;
+		const points = [];
+		for (const p of processes) {
+			const scope = String(p.pid);
+			points.push({
+				key: NODE_PROCESS_CPU_KEY,
+				subject: {
+					kind: "node",
+					nodeId
+				},
+				scope,
+				ts: atMs,
+				value: p.cpuPercent
+			});
+			points.push({
+				key: NODE_PROCESS_RSS_KEY,
+				subject: {
+					kind: "node",
+					nodeId
+				},
+				scope,
+				ts: atMs,
+				value: Math.round(p.memoryRssBytes / 1048576)
+			});
+		}
+		if (containerMemory !== null) points.push({
+			key: NODE_CONTAINER_CURRENT_KEY,
+			subject: {
+				kind: "node",
+				nodeId
+			},
+			scope: "",
+			ts: atMs,
+			value: Math.round(containerMemory.currentBytes / 1048576)
+		});
+		if (points.length === 0) return;
+		try {
+			await this.deps.deviceHistory.record({ points });
+		} catch (err) {
+			this.deps.logger.warn("node metrics history sample not stored", { meta: {
+				nodeId,
+				atMs,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+		}
+	}
+	async readContainerPoints(nodeId, sinceMs, maxPoints) {
+		if (!await this.ensureDeclared()) return [];
+		const result = await this.deps.deviceHistory.queryNode({
+			nodeId,
+			key: NODE_CONTAINER_CURRENT_KEY,
+			from: sinceMs + 1,
+			to: Date.now(),
+			resolution: "raw",
+			maxPoints
+		});
+		const out = [];
+		for (const s of result.series) for (const p of s.points) {
+			if (p.value === null || !Number.isFinite(p.value)) continue;
+			out.push({
+				atMs: p.t,
+				source: "cgroup-v2",
+				currentBytes: p.value * 1048576,
+				limitBytes: null,
+				anonBytes: null,
+				fileBytes: null,
+				shmemBytes: null,
+				slabBytes: null,
+				gpuShmemBytes: null
+			});
+		}
+		return out.toSorted((a, b) => a.atMs - b.atMs);
+	}
+	async readProcessSamples(nodeId, sinceMs, maxPoints) {
+		if (!await this.ensureDeclared()) return [];
+		const to = Date.now();
+		const [cpuResult, rssResult] = await Promise.all([this.deps.deviceHistory.queryNode({
+			nodeId,
+			key: NODE_PROCESS_CPU_KEY,
+			from: sinceMs + 1,
+			to,
+			resolution: "raw",
+			maxPoints
+		}), this.deps.deviceHistory.queryNode({
+			nodeId,
+			key: NODE_PROCESS_RSS_KEY,
+			from: sinceMs + 1,
+			to,
+			resolution: "raw",
+			maxPoints
+		})]);
+		const byAt = /* @__PURE__ */ new Map();
+		const ingest = (series, field) => {
+			for (const s of series) {
+				const pid = Number(s.scope);
+				if (!Number.isFinite(pid)) continue;
+				for (const p of s.points) {
+					if (p.value === null || !Number.isFinite(p.value)) continue;
+					let perPid = byAt.get(p.t);
+					if (perPid === void 0) {
+						perPid = /* @__PURE__ */ new Map();
+						byAt.set(p.t, perPid);
+					}
+					const base = perPid.get(pid) ?? {
+						pid,
+						addonId: null,
+						classification: "managed",
+						cpuPercent: 0,
+						memoryRssBytes: 0,
+						cpuMainPercent: null,
+						cpuGcPercent: null
+					};
+					perPid.set(pid, field === "cpuPercent" ? {
+						...base,
+						cpuPercent: p.value
+					} : {
+						...base,
+						memoryRssBytes: p.value * 1048576
+					});
+				}
+			}
+		};
+		ingest(cpuResult.series, "cpuPercent");
+		ingest(rssResult.series, "memoryRssBytes");
+		return [...byAt.entries()].toSorted((a, b) => a[0] - b[0]).map(([atMs, perPid]) => ({
+			atMs,
+			processes: [...perPid.values()]
+		}));
+	}
+	async ensureDeclared() {
+		try {
+			await this.declare();
+			return true;
+		} catch (err) {
+			this.deps.logger.warn("node metrics history declare failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return false;
+		}
+	}
+};
+//#endregion
 //#region src/builtins/native-metrics/gpu-probe.ts
 /**
 * The Linux GPU probe, forking only when there is something to fork.
@@ -2998,7 +2264,7 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 	* the `settings-store` singleton would ship its rows over Moleculer, once
 	* per sample, to reach that very same table.
 	*/
-	loadStore = null;
+	metricsHistory = null;
 	/**
 	* The container's OWN memory, sampled on the process-snapshot tick.
 	*
@@ -3010,10 +2276,8 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 	*/
 	memoryProbe = null;
 	pidsProbe = null;
-	/** Hot tier for the container reading. Bounds in `container-memory-series.ts`. */
+	/** Hot tier for the container reading. Bounds in `container-memory-ring.ts`. */
 	memoryRing = new ContainerMemoryRing();
-	/** Cold tier, HUB only — same reasoning as `loadStore`. */
-	memoryStore = null;
 	/** The resolved knobs. Re-resolved on every settings write. */
 	loadConfig = {
 		cadenceSec: 10,
@@ -3086,13 +2350,12 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 		};
 		this.applyLoadSeriesConfig();
 		if (this.isHub) {
-			this.loadStore = new LoadSeriesStore({
-				store: this.ctx.api.settingsStore,
-				logger: this.ctx.logger.child("LoadSeries")
+			this.metricsHistory = new NodeMetricsHistoryRecorder({
+				deviceHistory: nodeMetricsHistoryClient(this.ctx.api.deviceHistory),
+				logger: this.ctx.logger.child("NodeMetricsHistory")
 			});
-			this.memoryStore = new ContainerMemoryStore({
-				store: this.ctx.api.settingsStore,
-				logger: this.ctx.logger.child("ContainerMemory")
+			this.metricsHistory.declare().catch((err) => {
+				this.ctx.logger.warn("node metrics history declare failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 			});
 		}
 		this.memoryProbe = new ContainerMemoryProbe({ logger: this.ctx.logger.child("ContainerMemory") });
@@ -3113,7 +2376,7 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 	* this node has already delivered, and only an accepted sample reaches the
 	* table. That is what makes the append idempotent without a unique index
 	* over two million rows — the composite key it replaces was measured at ~40
-	* bytes per row (`load-series-store.ts`).
+	* bytes per row (measured on the old SQLite tier; see D850).
 	*
 	* The durable append is fire-and-forget: a storage stall must cost a gap in
 	* the cold window, never a blocked event-bus handler. Every failure logs.
@@ -3123,26 +2386,9 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 		if (!this.loadRing.record(nodeId, atMs, retained)) return;
 		this.observedRowsByNode.set(nodeId, retained.length);
 		if (containerMemory !== null) this.memoryRing.record(nodeId, atMs, containerMemory);
-		const store = this.loadStore;
-		if (store === null) return;
-		store.append(nodeId, atMs, retained).then(() => store.prune([...this.observedRowsByNode.keys()], this.loadConfig)).then(async (outcome) => {
-			if (outcome === null) return;
-			await this.memoryStore?.prune([...this.observedRowsByNode.keys()], this.loadConfig);
-		}).catch((err) => {
-			this.ctx.logger.warn("durable load series write failed", { meta: {
-				nodeId,
-				atMs,
-				error: err instanceof Error ? err.message : String(err)
-			} });
-		});
-		if (containerMemory === null) return;
-		this.memoryStore?.append(nodeId, atMs, containerMemory).catch((err) => {
-			this.ctx.logger.warn("durable container memory write failed", { meta: {
-				nodeId,
-				atMs,
-				error: err instanceof Error ? err.message : String(err)
-			} });
-		});
+		const history = this.metricsHistory;
+		if (history === null) return;
+		history.recordSample(nodeId, atMs, retained, containerMemory);
 	}
 	/**
 	* The ONE reader, over both tiers.
@@ -3161,9 +2407,9 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 			atMs: sample.atMs,
 			processes: sample.processes
 		}));
-		const store = this.loadStore;
+		const history = this.metricsHistory;
 		const merged = mergeLoadSeries({
-			cold: store === null ? [] : await store.read(params.forNodeId, sinceMs, this.loadConfig.maxRows),
+			cold: history === null ? [] : await history.readProcessSamples(params.forNodeId, sinceMs, this.loadConfig.maxRows),
 			hot: hotSamples,
 			cadenceMs,
 			...params.maxPoints !== void 0 ? { maxPoints: params.maxPoints } : {}
@@ -3183,7 +2429,7 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 			retainedSamples: merged.retainedSamples,
 			oldestAtMs: merged.oldestAtMs,
 			cadenceMs,
-			durable: store !== null
+			durable: history !== null
 		};
 	}
 	/**
@@ -3199,8 +2445,8 @@ var NativeMetricsAddon = class NativeMetricsAddon extends BaseAddon {
 	*/
 	async readContainerMemory(params) {
 		const hot = this.memoryRing.read(params.forNodeId, params.exclusiveSinceMs);
-		const store = this.memoryStore;
-		const merged = mergeContainerMemory(store === null ? [] : await store.read(params.forNodeId, params.sinceMs, CONTAINER_MEMORY_MAX_ROWS), hot);
+		const history = this.metricsHistory;
+		const merged = mergeContainerMemory(history === null ? [] : await history.readContainerPoints(params.forNodeId, params.sinceMs, 5e3), hot);
 		if (params.bucketMs <= params.cadenceMs) return merged;
 		return reduceContainerMemory(merged, params.bucketMs, params.origin ?? 0);
 	}