@camstack/system 1.2.445 → 1.2.447

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.445",
+  "version": "1.2.447",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",

package/dist/builtins/native-metrics/container-memory-series.d.ts

@@ -1,260 +0,0 @@
-/**
-* Retention for the container-memory reading — the same two tiers, the same
-* bounds and the same reader as the per-process load series, because it is the
-* same question asked at the other end.
-*
-* ## Why it is retained at all
-*
-* A single hand reading of `memory.stat` says what the container holds RIGHT
-* NOW and nothing about direction. That is exactly the failure this exists to
-* fix: on 2026-08-29 six of the hub's twenty-three gigabytes had no owner among
-* the processes, and there was no way to say whether page cache was steady or
-* climbing — so the difference was read as a leak. A number you cannot trend is
-* a number you will misread.
-*
-* ## Why it is not the same TABLE
-*
-* `metrics:node-load-samples` is one row PER PROCESS per sample. A
-* container-memory reading is one row per NODE per sample — 76x fewer rows on
-* the live fleet. Folding it into that table would mean either repeating the
-* same ten numbers on every process row of a sample, or inventing a synthetic
-* process that is not a process. Both are lies with a storage cost. It is its
-* own collection, keyed the same way, pruned by the same knobs and read in the
-* same call.
-*
-* ## Why it is not its own RING
-*
-* {@link NodeLoadRing} is already a fixed-capacity partitioned ring with
-* per-node capacity, a fleet-wide row budget, an idle-partition sweep and a
-* monotonic idempotence gate — all of it measured and tested. It is generic
-* over its payload and reads only the node id and the timestamp off an
-* envelope. A second ring implementation would be a second set of bounds to
-* get wrong. {@link ContainerMemoryRing} is a naming adapter over it, nothing
-* more: one reading per sample, so one "row" per sample.
-*/
-import type { ContainerMemoryPoint, ContainerMemorySnapshot, IScopedLogger, SettingsStoreClient } from "@camstack/types";
-import type { LoadSeriesRetention } from "./load-series-store.js";
-/**
-* @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."
-*/
-export declare const CONTAINER_MEMORY_COLLECTION = "metrics:node-memory-samples";
-/**
-* Per-node ceiling on the HOT ring, in samples.
-*
-* Deliberately the same 180 as the process ring — one hour at the 20 s cadence,
-* six at the 10 s default's own reckoning — because the two series are read
-* together and a memory window shorter than the process window would silently
-* truncate the comparison the pair exists to support.
-*/
-export declare const CONTAINER_MEMORY_SAMPLES_PER_NODE = 180;
-/**
-* 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.
-*/
-export declare const CONTAINER_MEMORY_MAX_TOTAL_ROWS: number;
-/**
-* 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.
-*/
-export declare const CONTAINER_MEMORY_MAX_ROWS = 5e4;
-/** Rows one prune pass may remove. Bounded, never a full scan. */
-export declare const CONTAINER_MEMORY_PRUNE_PAGE_ROWS = 2e4;
-export declare const CONTAINER_MEMORY_COLUMNS: readonly [{
-	readonly name: "id";
-	readonly type: "INTEGER";
-	readonly primaryKey: true;
-	readonly notNull: true;
-}, {
-	readonly name: "nodeId";
-	readonly type: "TEXT";
-	readonly notNull: true;
-}, {
-	readonly name: "atMs";
-	readonly type: "INTEGER";
-	readonly notNull: true;
-}, {
-	readonly name: "source";
-	readonly type: "TEXT";
-	readonly notNull: true;
-}, {
-	readonly name: "currentMib";
-	readonly type: "INTEGER";
-	readonly notNull: true;
-}, {
-	readonly name: "limitMib";
-	readonly type: "INTEGER";
-}, {
-	readonly name: "anonMib";
-	readonly type: "INTEGER";
-}, {
-	readonly name: "fileMib";
-	readonly type: "INTEGER";
-}, {
-	readonly name: "shmemMib";
-	readonly type: "INTEGER";
-}, {
-	readonly name: "slabMib";
-	readonly type: "INTEGER";
-}, {
-	readonly name: "gpuShmemMib";
-	readonly type: "INTEGER";
-}];
-export declare const CONTAINER_MEMORY_INDEXES: readonly [{
-	readonly name: "idx_node_memory_node_at";
-	readonly columns: readonly ["nodeId", "atMs"];
-}];
-/** One stored row, in the units the table stores them in. */
-export interface ContainerMemoryRow {
-	readonly nodeId: string;
-	readonly atMs: number;
-	readonly source: string;
-	readonly currentMib: number;
-	readonly limitMib: number | null;
-	readonly anonMib: number | null;
-	readonly fileMib: number | null;
-	readonly shmemMib: number | null;
-	readonly slabMib: number | null;
-	readonly gpuShmemMib: number | null;
-}
-/** The ONE encode. */
-export declare function snapshotToRow(nodeId: string, atMs: number, snapshot: ContainerMemorySnapshot): ContainerMemoryRow;
-/**
-* 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.
-*/
-export declare function rowToPoint(row: ContainerMemoryRow): ContainerMemoryPoint | null;
-/** Structural validation on read. A malformed row is skipped, never charted. */
-export declare function recordToMemoryRow(data: Record<string, unknown>): ContainerMemoryRow | null;
-export interface ContainerMemoryRingOptions {
-	readonly samplesPerNode?: number;
-	/**
-	* Injectable clock, forwarded to the ring's idle-partition sweep. Tests
-	* drive eviction without sleeping for an hour; production uses `Date.now`.
-	*/
-	readonly now?: () => number;
-}
-/**
-* 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.
-*/
-export declare class ContainerMemoryRing {
-	private readonly ring;
-	constructor(options?: ContainerMemoryRingOptions);
-	/** Retain one reading. `false` = a timestamp this node already delivered. */
-	record(nodeId: string, atMs: number, snapshot: ContainerMemorySnapshot): boolean;
-	/**
-	* 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: string, sinceMs?: number): readonly ContainerMemoryPoint[];
-}
-/**
-* 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.
-*/
-export declare function reduceContainerMemory(points: readonly ContainerMemoryPoint[], bucketMs: number, origin: number): readonly ContainerMemoryPoint[];
-/** Merge cold + hot on `atMs`, hot wins. Exported because dedup is the
-*  property worth testing on its own. */
-export declare function mergeContainerMemory(cold: readonly ContainerMemoryPoint[], hot: readonly ContainerMemoryPoint[]): readonly ContainerMemoryPoint[];
-export interface ContainerMemoryStoreDeps {
-	readonly store: SettingsStoreClient;
-	readonly logger: IScopedLogger;
-	readonly now?: () => number;
-	readonly prunePageRows?: number;
-}
-/** What one prune pass did. Returned so a test can assert the bound held. */
-export interface ContainerMemoryPruneOutcome {
-	readonly deletedByAge: number;
-	readonly deletedByCap: number;
-	readonly rowsExamined: number;
-	readonly capBit: boolean;
-}
-/**
-* 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.
-*/
-export declare class ContainerMemoryStore {
-	private declared;
-	private readonly store;
-	private readonly logger;
-	private readonly nowFn;
-	private readonly prunePageRows;
-	constructor(deps: ContainerMemoryStoreDeps);
-	/** Idempotently declare the collection. `false` when the store refused. */
-	declare(): Promise<boolean>;
-	/** Append ONE reading. */
-	append(nodeId: string, atMs: number, snapshot: ContainerMemorySnapshot): Promise<number>;
-	/** Read one node's cold readings, oldest-first. `sinceMs` is EXCLUSIVE. */
-	read(nodeId: string, sinceMs: number, limitRows: number): Promise<readonly ContainerMemoryPoint[]>;
-	/**
-	* 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.
-	*/
-	prune(nodeIds: readonly string[], retention: LoadSeriesRetention): Promise<ContainerMemoryPruneOutcome | null>;
-	/** Total rows, or `null` when the store could not answer. */
-	count(): Promise<number | 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.
-	*/
-	private deleteOldestPage;
-}

package/dist/builtins/native-metrics/load-series-store.d.ts

@@ -1,293 +0,0 @@
-/**
-* Durable retention for the per-node load series — the COLD window behind the
-* in-memory ring's hot one.
-*
-* ## One table, and what that decides
-*
-* One row per process per sample, in `metrics:node-load-samples`, declared the
-* way every other typed collection in this repo is declared: explicit columns,
-* explicit indexes, read by `where`/`whereBetween`/`orderBy`/`limit`. There is
-* no dimension table, no per-addon pre-aggregate and no bucket tier. The
-* consequence is that the row count is DETERMINISTIC and large, and the honest
-* thing to do with a large number is to publish it rather than to design it
-* away — see `docs/architecture/load-ledger.md` § "2026-08-27 (night) — the load
-* series reaches disk, and what it costs".
-*
-* ## Measured cost, not estimated
-*
-* `scripts/measure-load-series-cost.mts` writes the real payload shape through
-* the real `SqliteSettingsBackend` and the real `declareCollection` DDL, then
-* reads `page_count × page_size` off the resulting file. The answer is
-* **{@link MEASURED_BYTES_PER_ROW} bytes per row**, flat from 164 k rows to
-* 3.9 M rows — table plus its one index, after a truncating WAL checkpoint.
-*
-* That number is why the columns look the way they do. Four decisions, each
-* paid for in bytes measured on the same harness:
-*
-* | shape | B/row |
-* | --- | --- |
-* | naive: `TEXT` id, 2 indexes, every `NodeProcess` field | 196.0 |
-* | one index, drop `threadCount` + `uptimeSec` | 172.8 |
-* | + base36 in the composite id | 159.6 |
-* | + CPU as integer tenths, RSS as integer MiB | 140.3 |
-* | + `INTEGER` rowid-alias key (this file) | **86.9** |
-*
-* - **`command` is not stored.** It is the fattest field in a `NodeProcess` and
-*   it is the same ~100-character string on every runner — the runner id
-*   travels in the environment, not in argv, so `ps` reports one identical
-*   command line for all of them. `addonId` is the short identifier that
-*   already exists, and nothing that reads this series reads `command`.
-* - **CPU is stored as integer tenths.** Losslessly: `ps pcpu` is rounded to
-*   one decimal by `runPs`, and the thread sampler rounds to one decimal too
-*   (`Math.round(x * 1000) / 10`). A SQLite `REAL` is 8 bytes always; the same
-*   value as an integer varint is 1-2.
-* - **RSS is stored in whole MiB.** A byte-exact residency on a value in the
-*   hundreds of megabytes is precision no chart can draw, and it costs 3 bytes
-*   a row.
-* - **The key is an `INTEGER` rowid alias.** A composite `TEXT` key cost ~40
-*   B/row — the string in the row plus its own B-tree — for an idempotence
-*   this table gets for free somewhere better: {@link NodeLoadRing.record}
-*   already refuses a sample at or before the newest it holds, and only an
-*   ACCEPTED sample is written here. The gate is one monotonic comparison in
-*   memory instead of a unique index on two million rows.
-*
-* ## Retention is an intention; the row cap is the guarantee
-*
-* {@link LoadSeriesRetention.retentionHours} is what the operator asked to
-* keep. {@link DEFAULT_MAX_ROWS} is what the table is allowed to become. They
-* are different promises on purpose: an operator who raises retention to three
-* days must not be able to take this table to two million rows with nothing
-* stopping it. When the cap bites, the OLDEST rows go and a line says so.
-*/
-import type { IScopedLogger, SettingsStoreClient } from "@camstack/types";
-/**
-* @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."
-*/
-export declare const LOAD_SERIES_COLLECTION = "metrics:node-load-samples";
-/**
-* Bytes one stored row costs on disk, MEASURED — table plus index, after a
-* truncating checkpoint. Used to project the cost of a configuration for the
-* operator BEFORE they apply it, so the knob is honest.
-*/
-export declare const MEASURED_BYTES_PER_ROW = 87;
-/**
-* Sampling cadence bounds, in seconds. Outside this range a cadence is
-* REFUSED — see {@link resolveLoadSeriesConfig}.
-*/
-export declare const MIN_CADENCE_SEC = 5;
-export declare const MAX_CADENCE_SEC = 60;
-export declare const DEFAULT_CADENCE_SEC = 10;
-/** Retention the operator asked for, in hours. Six is the shipped default. */
-export declare const DEFAULT_RETENTION_HOURS = 6;
-export declare const MIN_RETENTION_HOURS = 1;
-export declare const MAX_RETENTION_HOURS = 72;
-/**
-* 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).
-*/
-export declare const DEFAULT_MAX_ROWS = 5e5;
-/**
-* Rows a single prune pass may remove.
-*
-* The prune is BOUNDED, never a full scan. It reads at most this many keys
-* oldest-first through `idx_load_samples_node_at`, takes the last one's `atMs`
-* as the effective cutoff and issues ONE `deleteWhere` up to it. A backlog
-* larger than a page is worked off across passes rather than in one stall —
-* which is the defect corrected in the recorder the same week, where
-* `accountingForLocations` visited 6.7 M rows twice a minute.
-*/
-export declare const PRUNE_PAGE_ROWS = 2e4;
-/** How often a prune pass may run. A bound, not a deadline. */
-export declare const PRUNE_INTERVAL_MS = 6e4;
-export declare const LOAD_SERIES_COLUMNS: readonly [{
-	readonly name: "id";
-	readonly type: "INTEGER";
-	readonly primaryKey: true;
-	readonly notNull: true;
-}, {
-	readonly name: "nodeId";
-	readonly type: "TEXT";
-	readonly notNull: true;
-}, {
-	readonly name: "atMs";
-	readonly type: "INTEGER";
-	readonly notNull: true;
-}, {
-	readonly name: "pid";
-	readonly type: "INTEGER";
-	readonly notNull: true;
-}, {
-	readonly name: "addonId";
-	readonly type: "TEXT";
-}, {
-	readonly name: "classification";
-	readonly type: "TEXT";
-	readonly notNull: true;
-}, {
-	readonly name: "cpuDeci";
-	readonly type: "INTEGER";
-	readonly notNull: true;
-}, {
-	readonly name: "rssMib";
-	readonly type: "INTEGER";
-	readonly notNull: true;
-}, {
-	readonly name: "cpuMainDeci";
-	readonly type: "INTEGER";
-}, {
-	readonly name: "cpuGcDeci";
-	readonly type: "INTEGER";
-}];
-export declare const LOAD_SERIES_INDEXES: readonly [{
-	readonly name: "idx_load_samples_node_at";
-	readonly columns: readonly ["nodeId", "atMs"];
-}];
-/** One stored process row, in the units the table stores them in. */
-export interface LoadSeriesRow {
-	readonly nodeId: string;
-	readonly atMs: number;
-	readonly pid: number;
-	readonly addonId: string | null;
-	readonly classification: string;
-	readonly cpuDeci: number;
-	readonly rssMib: number;
-	readonly cpuMainDeci: number | null;
-	readonly cpuGcDeci: number | null;
-}
-/** The process shape both tiers hand back — the series' own row, not `ps`'s. */
-export interface RetainedProcess {
-	readonly pid: number;
-	readonly addonId: string | null;
-	readonly classification: string;
-	readonly cpuPercent: number;
-	readonly memoryRssBytes: number;
-	readonly cpuMainPercent: number | null;
-	readonly cpuGcPercent: number | null;
-}
-/** One retained sample: when it was taken, and the processes in it. */
-export interface RetainedSample {
-	readonly atMs: number;
-	readonly processes: readonly RetainedProcess[];
-}
-/** Storage row → the shape a reader gets. The ONE decode. */
-export declare function rowToProcess(row: LoadSeriesRow): RetainedProcess;
-/** The shape a reader gets → the storage row. The ONE encode. */
-export declare function processToRow(nodeId: string, atMs: number, process: RetainedProcess): LoadSeriesRow;
-/** Group flat rows into samples, oldest-first. A sample is one `atMs`. */
-export declare function rowsToSamples(rows: readonly LoadSeriesRow[]): readonly RetainedSample[];
-/** The two bounds in force. */
-export interface LoadSeriesRetention {
-	readonly retentionHours: number;
-	readonly maxRows: number;
-}
-export interface LoadSeriesStoreDeps {
-	readonly store: SettingsStoreClient;
-	readonly logger: IScopedLogger;
-	readonly now?: () => number;
-	readonly prunePageRows?: number;
-	readonly pruneIntervalMs?: number;
-}
-/** What one prune pass did. Returned so a test can assert the bound held. */
-export interface PruneOutcome {
-	readonly deletedByAge: number;
-	readonly deletedByCap: number;
-	/** Rows read to find the cutoffs — the number that must stay bounded. */
-	readonly rowsExamined: number;
-	readonly capBit: boolean;
-}
-/**
-* 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.
-*/
-export declare class LoadSeriesStore {
-	private declared;
-	private lastPruneAtMs;
-	private readonly store;
-	private readonly logger;
-	private readonly nowFn;
-	private readonly prunePageRows;
-	private readonly pruneIntervalMs;
-	constructor(deps: LoadSeriesStoreDeps);
-	/** Idempotently declare the collection. `false` when the store refused. */
-	declare(): Promise<boolean>;
-	/**
-	* 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.
-	*/
-	append(nodeId: string, atMs: number, processes: readonly RetainedProcess[]): Promise<number>;
-	/**
-	* 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.
-	*/
-	read(nodeId: string, sinceMs: number, limitRows: number): Promise<readonly RetainedSample[]>;
-	/**
-	* 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.
-	*/
-	prune(nodeIds: readonly string[], retention: LoadSeriesRetention, force?: boolean): Promise<PruneOutcome | null>;
-	/** Total rows, or `null` when the store could not answer. */
-	count(): Promise<number | 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.
-	*/
-	private pruneNodeToCutoff;
-	/**
-	* 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.
-	*/
-	private pruneOldestRows;
-}
-/** Structural validation on read. A malformed row is skipped, never charted. */
-export declare function recordToRow(data: Record<string, unknown>): LoadSeriesRow | null;