@camstack/system 1.2.389 → 1.2.391

package/dist/kernel/settings-view-types.d.ts

@@ -1,105 +1,110 @@
-import { AddonStoreRead, StoredKeyRead } from '@camstack/types';
+/**
+* The settings-view and sync-store contracts `ConfigManager` serves. Split out
+* of `config-manager.ts` (D675) so that file stays one class; every name is
+* re-exported from there, so importers are unchanged.
+*/
+import type { AddonStoreRead, StoredKeyRead } from "@camstack/types";
 export interface AddonSettingsView {
-    readAddonStore(): Promise<Record<string, unknown>>;
-    /** See `IAddonContext['settings'].readAddonStoreResult` (D651). */
-    readAddonStoreResult?(): Promise<AddonStoreRead>;
-    /** See `IAddonContext['settings'].readAddonStoreKeyResult` (D675). */
-    readAddonStoreKeyResult?(key: string): Promise<StoredKeyRead>;
-    writeAddonStore(patch: Record<string, unknown>): Promise<void>;
-    readDeviceStore(deviceId: number): Promise<Record<string, unknown>>;
-    /** See `IAddonContext['settings'].readDeviceStoreBatch` — optional there and
-     *  here for the same reason: only the door-backed view can answer it in one
-     *  range scan, and a caller must fall back rather than refuse. */
-    readDeviceStoreBatch?(deviceIds: readonly number[]): Promise<ReadonlyMap<number, Record<string, unknown>>>;
-    writeDeviceStore(deviceId: number, patch: Record<string, unknown>): Promise<void>;
-    clearDeviceStore(deviceId: number): Promise<void>;
-    getSection(section: string): Promise<Record<string, unknown>>;
-    setSection(section: string, patch: Record<string, unknown>): Promise<void>;
-    /**
-     * Per-device runtime state — separate namespace from
-     * `readDeviceStore` / `writeDeviceStore` (which is the addon's
-     * config blob: host, password, deviceCache, …). Holds mutable
-     * runtime signals discovered after boot: battery snapshot, sleep
-     * flag, last-seen timestamps. Stored under a kernel-internal
-     * `__device-state` namespace so the device's config schema
-     * never has to know about it (clean separation of operator
-     * intent from runtime telemetry).
-     *
-     * Patch semantics: shallow merge. Pass the FULL persistent slice
-     * each call (the kernel doesn't try to compute deltas) — concrete
-     * implementations of `DeviceRuntimeState` already coalesce in
-     * memory, so the kernel just persists the latest blob.
-     */
-    readDeviceRuntimeState(deviceId: number): Promise<Record<string, unknown>>;
-    writeDeviceRuntimeState(deviceId: number, data: Record<string, unknown>): Promise<void>;
-    clearDeviceRuntimeState(deviceId: number): Promise<void>;
+	readAddonStore(): Promise<Record<string, unknown>>;
+	/** See `IAddonContext['settings'].readAddonStoreResult` (D651). */
+	readAddonStoreResult?(): Promise<AddonStoreRead>;
+	/** See `IAddonContext['settings'].readAddonStoreKeyResult` (D675). */
+	readAddonStoreKeyResult?(key: string): Promise<StoredKeyRead>;
+	writeAddonStore(patch: Record<string, unknown>): Promise<void>;
+	readDeviceStore(deviceId: number): Promise<Record<string, unknown>>;
+	/** See `IAddonContext['settings'].readDeviceStoreBatch` — optional there and
+	*  here for the same reason: only the door-backed view can answer it in one
+	*  range scan, and a caller must fall back rather than refuse. */
+	readDeviceStoreBatch?(deviceIds: readonly number[]): Promise<ReadonlyMap<number, Record<string, unknown>>>;
+	writeDeviceStore(deviceId: number, patch: Record<string, unknown>): Promise<void>;
+	clearDeviceStore(deviceId: number): Promise<void>;
+	getSection(section: string): Promise<Record<string, unknown>>;
+	setSection(section: string, patch: Record<string, unknown>): Promise<void>;
+	/**
+	* Per-device runtime state — separate namespace from
+	* `readDeviceStore` / `writeDeviceStore` (which is the addon's
+	* config blob: host, password, deviceCache, …). Holds mutable
+	* runtime signals discovered after boot: battery snapshot, sleep
+	* flag, last-seen timestamps. Stored under a kernel-internal
+	* `__device-state` namespace so the device's config schema
+	* never has to know about it (clean separation of operator
+	* intent from runtime telemetry).
+	*
+	* Patch semantics: shallow merge. Pass the FULL persistent slice
+	* each call (the kernel doesn't try to compute deltas) — concrete
+	* implementations of `DeviceRuntimeState` already coalesce in
+	* memory, so the kernel just persists the latest blob.
+	*/
+	readDeviceRuntimeState(deviceId: number): Promise<Record<string, unknown>>;
+	writeDeviceRuntimeState(deviceId: number, data: Record<string, unknown>): Promise<void>;
+	clearDeviceRuntimeState(deviceId: number): Promise<void>;
 }
 /**
- * A CONCRETE backend behind {@link ConfigManager.createSettingsView} — the
- * sync-`ISettingsStore` one or the async-door one.
- *
- * `readDeviceStoreBatch` is required here and optional on
- * {@link AddonSettingsView} because both of these can answer it, so the view
- * the kernel hands an addon never has to decide whether the method exists.
- * The optionality on the public interface stays for the implementation that
- * genuinely cannot batch: a forked runner's UDS-backed view.
- */
+* A CONCRETE backend behind {@link ConfigManager.createSettingsView} — the
+* sync-`ISettingsStore` one or the async-door one.
+*
+* `readDeviceStoreBatch` is required here and optional on
+* {@link AddonSettingsView} because both of these can answer it, so the view
+* the kernel hands an addon never has to decide whether the method exists.
+* The optionality on the public interface stays for the implementation that
+* genuinely cannot batch: a forked runner's UDS-backed view.
+*/
 export interface SettingsViewBackend extends AddonSettingsView {
-    readDeviceStoreBatch(deviceIds: readonly number[]): Promise<ReadonlyMap<number, Record<string, unknown>>>;
-    readAddonStoreKeyResult(key: string): Promise<StoredKeyRead>;
+	readDeviceStoreBatch(deviceIds: readonly number[]): Promise<ReadonlyMap<number, Record<string, unknown>>>;
+	readAddonStoreKeyResult(key: string): Promise<StoredKeyRead>;
 }
 export interface ISettingsStore {
-    getSystem(key: string): unknown;
-    setSystem(key: string, value: unknown): void;
-    getAllSystem(): Record<string, unknown>;
-    /** Addon-level global settings (apply to every device unless overridden). */
-    getAllAddon(addonId: string): Record<string, unknown>;
-    setAllAddon(addonId: string, config: Record<string, unknown>): void;
-    /** Legacy per-provider settings (used by some older wiring paths). */
-    getAllProvider(providerId: string): Record<string, unknown>;
-    setProvider(providerId: string, key: string, value: unknown): void;
-    /** Legacy flat per-device settings. Kept for backward compatibility
-     *  with pre-addon wiring; new code should use the addon-device API. */
-    getAllDevice(deviceId: string): Record<string, unknown>;
-    setDevice(deviceId: string, key: string, value: unknown): void;
-    /**
-     * Multi-level addon settings: per-device overrides for a specific addon.
-     *
-     * Resolution chain when the frontend asks for the effective value of a
-     * field on a given device:
-     *   1. schema default (from `ConfigUISchema.field.default`)
-     *   2. `getAllAddon(addonId)`           — addon global value
-     *   3. `getAddonDevice(addonId, devId)` — per-device override (wins)
-     *
-     * Only fields declared with `scope: 'device'` in the addon's
-     * `ConfigUISchema` should ever be persisted here.
-     */
-    getAddonDevice(addonId: string, deviceId: string): Record<string, unknown>;
-    setAddonDevice(addonId: string, deviceId: string, values: Record<string, unknown>): void;
-    clearAddonDevice(addonId: string, deviceId: string): void;
-    /**
-     * Per-device runtime state — the whole cap-slice map as ONE row in the
-     * `device-runtime-state` collection.
-     *
-     * These are separate from `getAddonDevice`/`setAddonDevice` because runtime
-     * state is not an addon's config: it belongs to the device, it is replaced
-     * wholesale on every flush, and it is written orders of magnitude more often.
-     * It USED to share that keyspace under a synthetic `__device-state` addonId,
-     * which cost one row (and one INSERT) per cap slice per flush and left the
-     * collection it is named for empty on every installation. The backend keeps
-     * reading the legacy prefix; see `SqliteSettingsBackend.getDeviceRuntimeState`.
-     */
-    getDeviceRuntimeState(deviceId: string): Record<string, unknown>;
-    setDeviceRuntimeState(deviceId: string, blob: Record<string, unknown>): void;
-    clearDeviceRuntimeState(deviceId: string): void;
+	getSystem(key: string): unknown;
+	setSystem(key: string, value: unknown): void;
+	getAllSystem(): Record<string, unknown>;
+	/** Addon-level global settings (apply to every device unless overridden). */
+	getAllAddon(addonId: string): Record<string, unknown>;
+	setAllAddon(addonId: string, config: Record<string, unknown>): void;
+	/** Legacy per-provider settings (used by some older wiring paths). */
+	getAllProvider(providerId: string): Record<string, unknown>;
+	setProvider(providerId: string, key: string, value: unknown): void;
+	/** Legacy flat per-device settings. Kept for backward compatibility
+	*  with pre-addon wiring; new code should use the addon-device API. */
+	getAllDevice(deviceId: string): Record<string, unknown>;
+	setDevice(deviceId: string, key: string, value: unknown): void;
+	/**
+	* Multi-level addon settings: per-device overrides for a specific addon.
+	*
+	* Resolution chain when the frontend asks for the effective value of a
+	* field on a given device:
+	*   1. schema default (from `ConfigUISchema.field.default`)
+	*   2. `getAllAddon(addonId)`           — addon global value
+	*   3. `getAddonDevice(addonId, devId)` — per-device override (wins)
+	*
+	* Only fields declared with `scope: 'device'` in the addon's
+	* `ConfigUISchema` should ever be persisted here.
+	*/
+	getAddonDevice(addonId: string, deviceId: string): Record<string, unknown>;
+	setAddonDevice(addonId: string, deviceId: string, values: Record<string, unknown>): void;
+	clearAddonDevice(addonId: string, deviceId: string): void;
+	/**
+	* Per-device runtime state — the whole cap-slice map as ONE row in the
+	* `device-runtime-state` collection.
+	*
+	* These are separate from `getAddonDevice`/`setAddonDevice` because runtime
+	* state is not an addon's config: it belongs to the device, it is replaced
+	* wholesale on every flush, and it is written orders of magnitude more often.
+	* It USED to share that keyspace under a synthetic `__device-state` addonId,
+	* which cost one row (and one INSERT) per cap slice per flush and left the
+	* collection it is named for empty on every installation. The backend keeps
+	* reading the legacy prefix; see `SqliteSettingsBackend.getDeviceRuntimeState`.
+	*/
+	getDeviceRuntimeState(deviceId: string): Record<string, unknown>;
+	setDeviceRuntimeState(deviceId: string, blob: Record<string, unknown>): void;
+	clearDeviceRuntimeState(deviceId: string): void;
 }
 /**
- * The settings view `ConfigManager.createSettingsView` returns. Its three-way
- * reads are REQUIRED here (optional on the public {@link AddonSettingsView}
- * only for a forked runner's UDS view), so a caller holding a `ConfigManager`
- * never has to decide whether they exist.
- */
+* The settings view `ConfigManager.createSettingsView` returns. Its three-way
+* reads are REQUIRED here (optional on the public {@link AddonSettingsView}
+* only for a forked runner's UDS view), so a caller holding a `ConfigManager`
+* never has to decide whether they exist.
+*/
 export interface KernelAddonSettingsView extends AddonSettingsView {
-    readAddonStoreResult(): Promise<AddonStoreRead>;
-    readAddonStoreKeyResult(key: string): Promise<StoredKeyRead>;
+	readAddonStoreResult(): Promise<AddonStoreRead>;
+	readAddonStoreKeyResult(key: string): Promise<StoredKeyRead>;
 }

package/dist/kernel/socket-plane-report.d.ts

@@ -1,179 +1,240 @@
-import { CapActionReading, CapActionWindow } from './transport/cap-action-census.js';
-import { SocketDirectionSample, SocketTrafficSample } from './transport/socket-traffic.js';
+/**
+* socket-plane-report — which PEER, exchanging what KIND of message, accounts
+* for hub-main's ~44 000 socket syscalls per second.
+*
+* ## Why this exists, and why it is not the fan-out report
+*
+* `event-plane-report.ts` surfaced the counters the cluster had always kept and
+* never read. It answered its own question and, in answering it, sharpened this
+* one: measured 2026-08-29, **the event plane is 4 % of hub-main's socket
+* traffic**. The remaining 96 % — ~22 000 reads/s and ~22 500 writes/s at a
+* 0.33 KB mean, on the process that mediates every cross-runner call — had no
+* instrument at all, and no instrument was obtainable:
+*
+*  - `/proc/<pid>/io` gives ONE `rchar`/`wchar` pair for the whole process.
+*    There is no per-socket breakdown anywhere in `/proc`.
+*  - The strongest attribution available was a correlation — 78–82 % of
+*    hub-main's outbound bytes moving with `hub/pipeline-analytics`, in both
+*    measured windows — computed from that runner's own `rchar`, which also
+*    counts page-cache file reads on a runner that owns a vector store. A
+*    correlation this stable is worth one counter to settle; it is not itself
+*    an answer.
+*  - Three separate inferences about this traffic were closed early on
+*    2026-08-29 and were wrong. The point of this module is that the next pass
+*    is evidence.
+*
+* ## What it reports, and why each field is load-bearing
+*
+* Per kind, per direction, cluster-wide, plus the top peers:
+*
+*  - **`evt`** scales with the number of RUNNERS, not with anything an operator
+*    asked for — an idle `hub/ml` still reads 82 messages/s. If `evt` dominates,
+*    the cost is the plane's own shape and the fix is the fan-out gate.
+*  - **`req`** scales with work. If `req` dominates, some caller is chatty and
+*    the fix is that caller.
+*  - **`res`** is where a large payload can hide (a GOP crosses hub-main as a
+*    msgpack `Uint8Array` inside a `res`). **This is the falsifier**: the
+*    "message-RATE, not media" conclusion of
+*    `docs/design/2026-08-29-hub-main-memory-what-crosses-it.md` §4 rests on a
+*    0.33/0.40 KB mean, and `res` bytes dominating at a large mean breaks it and
+*    re-opens the D9/D18 question. Bytes are reported beside messages on every
+*    kind precisely so the mean can be read off the line.
+*
+* ## Deltas, never totals
+*
+* The channel counters are cumulative for the life of the channel. A cumulative
+* number on a heartbeat answers "how much since boot", which nobody asked; the
+* question is a rate. So the meter is read ONCE PER LINE and reports the window
+* since the previous read — the same discipline the loop-delay histogram and
+* the fan-out counters already follow, for the same reason.
+*
+* A peer whose runner RESPAWNED reconnects under the same id with a fresh
+* channel and counters that went backwards. Clamping at 0 reports that window
+* as quiet rather than negative: its traffic is genuinely unknown, and a
+* negative number on a rate reads as a broken meter.
+*
+* ## What this is NOT
+*
+* It is not a bound, a budget or a throttle. Nothing here changes a default,
+* drops a frame or tunes a socket. It counts what already crosses, so that the
+* thing that eventually gets fixed is chosen from evidence.
+*/
+import { type CapActionReading, type CapActionWindow } from "./transport/cap-action-census.js";
+import { type SocketDirectionSample, type SocketTrafficSample } from "./transport/socket-traffic.js";
 /** One peer's cumulative traffic, as the channel keeps it, plus its outbound
- *  queue depth at the instant of the read. */
+*  queue depth at the instant of the read. */
 export interface SocketPeerSample {
-    readonly peerId: string;
-    readonly tx: SocketDirectionSample;
-    readonly rx: SocketDirectionSample;
-    /**
-     * Bytes written to this peer that it has not yet taken — `writableLength`
-     * on the channel, read live (D446). `null` when the channel keeps no such
-     * reading: a measurement that failed is null, never 0 (D393), and the
-     * window counts it as unmeasured rather than as empty.
-     */
-    readonly queuedBytes: number | null;
+	readonly peerId: string;
+	readonly tx: SocketDirectionSample;
+	readonly rx: SocketDirectionSample;
+	/**
+	* Bytes written to this peer that it has not yet taken — `writableLength`
+	* on the channel, read live (D446). `null` when the channel keeps no such
+	* reading: a measurement that failed is null, never 0 (D393), and the
+	* window counts it as unmeasured rather than as empty.
+	*/
+	readonly queuedBytes: number | null;
 }
 /** What `LocalChildRegistry` exposes, structurally — the kernel's heartbeat
- *  must not depend on the transport layer's class. */
+*  must not depend on the transport layer's class. */
 export interface SocketPlaneRegistryChild {
-    readonly childId: string;
+	readonly childId: string;
 }
 /**
- * How many child→sibling cap calls the parent forwarded without reading
- * their args (`raw`) against how many it decoded — see
- * `transport/local-child-registry.ts` `ForwardCensus`. Cumulative on the
- * registry; a delta on the window.
- */
+* How many child→sibling cap calls the parent forwarded without reading
+* their args (`raw`) against how many it decoded — see
+* `transport/local-child-registry.ts` `ForwardCensus`. Cumulative on the
+* registry; a delta on the window.
+*/
 export interface SocketForwardCensus {
-    readonly raw: number;
-    readonly decoded: number;
+	readonly raw: number;
+	readonly decoded: number;
 }
 export interface SocketPlaneRegistry {
-    readonly listChildren: () => readonly SocketPlaneRegistryChild[];
-    readonly getChildSocketTraffic: (childId: string) => SocketTrafficSample | null;
-    /** Live outbound queue depth to one child, or `null` when unmeasured. */
-    readonly getChildQueuedBytes: (childId: string) => number | null;
-    /**
-     * The raw-forward census, when the registry keeps one. OPTIONAL: a registry
-     * that predates raw-forward has no such number, and the line must then omit
-     * the field rather than print a zero that reads as "nothing was forwarded".
-     */
-    readonly readForwardCensus?: () => SocketForwardCensus;
-    /**
-     * The per-ACTION byte census, when the registry keeps one (D456).
-     *
-     * OPTIONAL on the same terms as {@link readForwardCensus}: a registry whose
-     * channels carry no byte counters has nothing to attribute, and the line
-     * must omit the fields rather than print a `0/0` that reads as "the plane
-     * moved nothing" instead of "nobody measured".
-     */
-    readonly readActionCensus?: () => CapActionReading;
+	readonly listChildren: () => readonly SocketPlaneRegistryChild[];
+	readonly getChildSocketTraffic: (childId: string) => SocketTrafficSample | null;
+	/** Live outbound queue depth to one child, or `null` when unmeasured. */
+	readonly getChildQueuedBytes: (childId: string) => number | null;
+	/**
+	* The raw-forward census, when the registry keeps one. OPTIONAL: a registry
+	* that predates raw-forward has no such number, and the line must then omit
+	* the field rather than print a zero that reads as "nothing was forwarded".
+	*/
+	readonly readForwardCensus?: () => SocketForwardCensus;
+	/**
+	* The per-ACTION byte census, when the registry keeps one (D456).
+	*
+	* OPTIONAL on the same terms as {@link readForwardCensus}: a registry whose
+	* channels carry no byte counters has nothing to attribute, and the line
+	* must omit the fields rather than print a `0/0` that reads as "the plane
+	* moved nothing" instead of "nobody measured".
+	*/
+	readonly readActionCensus?: () => CapActionReading;
 }
 /** One cumulative reading of every measured peer. */
 export interface SocketPlaneCounters {
-    readonly peers: readonly SocketPeerSample[];
-    /** Connected children, INCLUDING any whose channel keeps no counters. */
-    readonly peersConnected: number;
-    /** Cumulative forward census, absent when the registry keeps none. */
-    readonly forward?: SocketForwardCensus;
-    /** Cumulative per-action census, absent when the registry keeps none. */
-    readonly actions?: CapActionReading;
+	readonly peers: readonly SocketPeerSample[];
+	/** Connected children, INCLUDING any whose channel keeps no counters. */
+	readonly peersConnected: number;
+	/** Cumulative forward census, absent when the registry keeps none. */
+	readonly forward?: SocketForwardCensus;
+	/** Cumulative per-action census, absent when the registry keeps none. */
+	readonly actions?: CapActionReading;
 }
 /** `undefined` = this process has no local socket plane to report (every forked
- *  runner, and hub-main before the registry exists). */
+*  runner, and hub-main before the registry exists). */
 export type SocketPlaneReader = () => SocketPlaneCounters | undefined;
 /** Where a reader gets its registry. Late-bound, because the heartbeat starts
- *  before the registry exists. */
+*  before the registry exists. */
 export interface SocketPlaneSources {
-    readonly registry: () => SocketPlaneRegistry | null;
+	readonly registry: () => SocketPlaneRegistry | null;
 }
 /**
- * Build a reader over the child registry.
- *
- * Returns `undefined` until the registry exists — the heartbeat starts as the
- * FIRST statement of `bootstrap()` and `LocalChildRegistry` is built hundreds
- * of lines later. Printing zeros in that window would report a silent plane
- * where there is no plane at all.
- *
- * Wrapped: a registry mid-teardown may throw, and a diagnostic that can crash
- * the process it watches is worse than none.
- */
+* Build a reader over the child registry.
+*
+* Returns `undefined` until the registry exists — the heartbeat starts as the
+* FIRST statement of `bootstrap()` and `LocalChildRegistry` is built hundreds
+* of lines later. Printing zeros in that window would report a silent plane
+* where there is no plane at all.
+*
+* Wrapped: a registry mid-teardown may throw, and a diagnostic that can crash
+* the process it watches is worse than none.
+*/
 export declare function createSocketPlaneReader(sources: SocketPlaneSources): SocketPlaneReader;
 /**
- * How many peers get named on the line.
- *
- * Five, matching `EVENT_PLANE_TOP_N` for the same reason: the measured
- * distribution is not flat — one peer accounted for 78–82 % of outbound bytes
- * and the runner-up for ~6 % — so five names the dominant peer, its challenger
- * and enough of the tail to see the shape change. Naming all ~38 would put a
- * kilobyte-long line in the hub's shared log every minute, which is how a log
- * stops being read.
- */
+* How many peers get named on the line.
+*
+* Five, matching `EVENT_PLANE_TOP_N` for the same reason: the measured
+* distribution is not flat — one peer accounted for 78–82 % of outbound bytes
+* and the runner-up for ~6 % — so five names the dominant peer, its challenger
+* and enough of the tail to see the shape change. Naming all ~38 would put a
+* kilobyte-long line in the hub's shared log every minute, which is how a log
+* stops being read.
+*/
 export declare const SOCKET_PLANE_TOP_N = 5;
 /** One peer's traffic over the window since the previous read. */
 export interface SocketPeerDelta {
-    readonly peerId: string;
-    readonly tx: SocketDirectionSample;
-    readonly rx: SocketDirectionSample;
+	readonly peerId: string;
+	readonly tx: SocketDirectionSample;
+	readonly rx: SocketDirectionSample;
 }
 /** One peer holding an outbound queue at the instant of the read. */
 export interface SocketPeerQueue {
-    readonly peerId: string;
-    readonly bytes: number;
+	readonly peerId: string;
+	readonly bytes: number;
 }
 /**
- * The outbound queues at the instant of the read — NOT a delta: a queue is a
- * level, and the level is the reading (D446).
- */
+* The outbound queues at the instant of the read — NOT a delta: a queue is a
+* level, and the level is the reading (D446).
+*/
 export interface SocketQueueReading {
-    /** Summed over every peer with a reading. */
-    readonly totalBytes: number;
-    /** Peers whose channel keeps no queue reading. Never folded into the total. */
-    readonly unmeasured: number;
-    /** Peers holding a queue, largest first, at most {@link SOCKET_QUEUE_TOP_N}. */
-    readonly top: readonly SocketPeerQueue[];
+	/** Summed over every peer with a reading. */
+	readonly totalBytes: number;
+	/** Peers whose channel keeps no queue reading. Never folded into the total. */
+	readonly unmeasured: number;
+	/** Peers holding a queue, largest first, at most {@link SOCKET_QUEUE_TOP_N}. */
+	readonly top: readonly SocketPeerQueue[];
 }
 /** The whole plane over one heartbeat window. */
 export interface SocketPlaneWindow {
-    readonly peersConnected: number;
-    /** Peers that reported counters. Below `peersConnected` ⇒ unmeasured channels. */
-    readonly peersMeasured: number;
-    /** Summed over every measured peer. */
-    readonly tx: SocketDirectionSample;
-    readonly rx: SocketDirectionSample;
-    /** Busiest first (tx+rx messages), at most {@link SOCKET_PLANE_TOP_N}. */
-    readonly top: readonly SocketPeerDelta[];
-    /**
-     * Heaviest first (tx+rx BYTES), at most {@link SOCKET_PLANE_TOP_N}.
-     *
-     * A separate ranking rather than a replacement, because the two questions
-     * have different answers and both are live: `top` names the peer paying for
-     * round trips (`audio-codec` at 8 379 calls/min of small frames), `topBytes`
-     * names the peer paying for copies and GC. A peer that moves FEW, HUGE
-     * frames is absent from `top` by construction — measured 2026-09-11, the
-     * five peers named by messages left 116 MB/min of hub-main's outbound bytes
-     * with no name on them (D454).
-     */
-    readonly topBytes: readonly SocketPeerDelta[];
-    readonly queued: SocketQueueReading;
-    /** Forwards in this window, absent when the registry keeps no census. */
-    readonly forward?: SocketForwardCensus;
-    /**
-     * The per-action census over this window, absent when none is kept.
-     *
-     * This is the field that survives raw-forward. Once 85.7 % of sibling calls
-     * cross hub-main without being read (D448, measured on 1.2.270), the bytes
-     * a peer moves stop being the proxy for what hub-main PAYS — a forwarded
-     * body costs a memcpy, a decoded one costs msgpack plus the garbage. So the
-     * entry carries the raw/decoded split BESIDE the bytes, per method, and the
-     * two questions are read off one row.
-     */
-    readonly actions?: CapActionWindow;
+	readonly peersConnected: number;
+	/** Peers that reported counters. Below `peersConnected` ⇒ unmeasured channels. */
+	readonly peersMeasured: number;
+	/** Summed over every measured peer. */
+	readonly tx: SocketDirectionSample;
+	readonly rx: SocketDirectionSample;
+	/** Busiest first (tx+rx messages), at most {@link SOCKET_PLANE_TOP_N}. */
+	readonly top: readonly SocketPeerDelta[];
+	/**
+	* Heaviest first (tx+rx BYTES), at most {@link SOCKET_PLANE_TOP_N}.
+	*
+	* A separate ranking rather than a replacement, because the two questions
+	* have different answers and both are live: `top` names the peer paying for
+	* round trips (`audio-codec` at 8 379 calls/min of small frames), `topBytes`
+	* names the peer paying for copies and GC. A peer that moves FEW, HUGE
+	* frames is absent from `top` by construction — measured 2026-09-11, the
+	* five peers named by messages left 116 MB/min of hub-main's outbound bytes
+	* with no name on them (D454).
+	*/
+	readonly topBytes: readonly SocketPeerDelta[];
+	readonly queued: SocketQueueReading;
+	/** Forwards in this window, absent when the registry keeps no census. */
+	readonly forward?: SocketForwardCensus;
+	/**
+	* The per-action census over this window, absent when none is kept.
+	*
+	* This is the field that survives raw-forward. Once 85.7 % of sibling calls
+	* cross hub-main without being read (D448, measured on 1.2.270), the bytes
+	* a peer moves stop being the proxy for what hub-main PAYS — a forwarded
+	* body costs a memcpy, a decoded one costs msgpack plus the garbage. So the
+	* entry carries the raw/decoded split BESIDE the bytes, per method, and the
+	* two questions are read off one row.
+	*/
+	readonly actions?: CapActionWindow;
 }
 /** How many queue-holding peers get named. Three: a queue is an exception,
- *  and the line already carries five names for traffic. */
+*  and the line already carries five names for traffic. */
 export declare const SOCKET_QUEUE_TOP_N = 3;
 /**
- * How many (peer, action) pairs get named.
- *
- * Five, matching {@link SOCKET_PLANE_TOP_N}, and for the same measured reason:
- * the distribution is not flat. Queried on this hub 2026-09-11, the heaviest
- * peer's top THREE caps were 2 077 of its 2 141 calls/min — five names the
- * dominant action, its challenger, and enough of the tail to see the shape
- * change. The map behind it keeps every action (see `cap-action-census.ts` on
- * why the bound that matters is the line's width, not the map's size); this
- * constant governs only what is printed.
- */
+* How many (peer, action) pairs get named.
+*
+* Five, matching {@link SOCKET_PLANE_TOP_N}, and for the same measured reason:
+* the distribution is not flat. Queried on this hub 2026-09-11, the heaviest
+* peer's top THREE caps were 2 077 of its 2 141 calls/min — five names the
+* dominant action, its challenger, and enough of the tail to see the shape
+* change. The map behind it keeps every action (see `cap-action-census.ts` on
+* why the bound that matters is the line's width, not the map's size); this
+* constant governs only what is printed.
+*/
 export declare const SOCKET_ACTION_TOP_N = 5;
 /** The queue reading over the current counters — a level, so no baseline. */
 export declare function readSocketQueues(current: SocketPlaneCounters): SocketQueueReading;
 /** Previous cumulative reading, kept between lines. */
 export interface SocketPlaneBaseline {
-    readonly peers: ReadonlyMap<string, SocketPeerSample>;
-    readonly forward?: SocketForwardCensus;
-    /** Previous per-action reading; absent = nothing has been read yet. */
-    readonly actions?: CapActionReading;
+	readonly peers: ReadonlyMap<string, SocketPeerSample>;
+	readonly forward?: SocketForwardCensus;
+	/** Previous per-action reading; absent = nothing has been read yet. */
+	readonly actions?: CapActionReading;
 }
 /** A process that has never read the plane. */
 export declare const EMPTY_SOCKET_PLANE_BASELINE: SocketPlaneBaseline;
@@ -181,27 +242,27 @@ export declare const EMPTY_SOCKET_PLANE_BASELINE: SocketPlaneBaseline;
 export declare function diffSocketPlane(baseline: SocketPlaneBaseline, current: SocketPlaneCounters, topN?: number): SocketPlaneWindow;
 /** Reads the delta since the PREVIOUS read. Same contract as the loop meter. */
 export interface SocketPlaneMeter {
-    readonly read: () => SocketPlaneWindow | undefined;
+	readonly read: () => SocketPlaneWindow | undefined;
 }
 export declare function createSocketPlaneMeter(reader: SocketPlaneReader, topN?: number): SocketPlaneMeter;
 /**
- * The suffix appended to a `[mem]` line — leading space included, empty when
- * this process has no local socket plane.
- *
- * Only the processes that OWN a child registry have one (hub-main, and an
- * agent's main), so these fields never appear on the ~38 runner lines that
- * share the same log stream. On the ones that do, every field is printed on
- * every line including at zero — `socketPeers` because measured-below-connected
- * is the only way to see an unmeasured channel, and the per-kind splits because
- * "the plane went quiet for a minute" is a reading.
- *
- * `socketTop` is a conditional field — a ranked list of nothing is noise — and
- * it is a single comma-separated value so the field COUNT does not change from
- * line to line.
- *
- * `socketTopBytes` is the other one, and its PRESENCE is the reading: it is
- * printed only when ranking by bytes names a peer that ranking by messages
- * does not. A line without it says the two rankings agree; a line with it says
- * a peer is moving few, heavy frames and names it (D454).
- */
+* The suffix appended to a `[mem]` line — leading space included, empty when
+* this process has no local socket plane.
+*
+* Only the processes that OWN a child registry have one (hub-main, and an
+* agent's main), so these fields never appear on the ~38 runner lines that
+* share the same log stream. On the ones that do, every field is printed on
+* every line including at zero — `socketPeers` because measured-below-connected
+* is the only way to see an unmeasured channel, and the per-kind splits because
+* "the plane went quiet for a minute" is a reading.
+*
+* `socketTop` is a conditional field — a ranked list of nothing is noise — and
+* it is a single comma-separated value so the field COUNT does not change from
+* line to line.
+*
+* `socketTopBytes` is the other one, and its PRESENCE is the reading: it is
+* printed only when ranking by bytes names a peer that ranking by messages
+* does not. A line without it says the two rankings agree; a line with it says
+* a peer is moving few, heavy frames and names it (D454).
+*/
 export declare function formatSocketPlane(window: SocketPlaneWindow | undefined): string;