@camstack/system 1.2.218 → 1.2.220

package/dist/kernel/gc-census.d.ts

@@ -0,0 +1,144 @@
+/**
+ * gc-census — HOW OFTEN V8 collects, on the ordinary heartbeat.
+ *
+ * ## The question this exists to answer, and why four records could not
+ *
+ * A garbage collector's cost is a product of two independent things: the LIVE
+ * SET (how much there is to mark) and the RATE at which a cycle is triggered.
+ * The `[mem]` line has carried the live set since 2026-08-29 — `heapUsed`,
+ * `oldSpace`, `largeObjectSpace`, `external`, `arrayBuffers` — and has never
+ * carried the rate. So D443, D444, D446 and D456 each read a level, saw it flat
+ * or falling, and could not say whether the GC share they were looking at came
+ * from the size of the heap or from the frequency of the collection. D444 cut
+ * hub-main's live set from 2 491 MB to 714 MB — a factor of 3.5 — and the GC
+ * share did not move. That result was unreadable until the rate was measured.
+ *
+ * Measured on hub-main 2026-09-11 with the observer below, the answer was on
+ * sight: **1.39 major mark-compacts per second against a 602 MB live set whose
+ * old space grew 22 MB/s.** A major GC every 0.7 s cannot be explained by 22
+ * MB/s of heap growth under a 3 264 MB ceiling — V8 was being driven by
+ * EXTERNAL memory pressure (537 MB/s of ArrayBuffer allocation, D458), and each
+ * of those cycles then had to mark the 602 MB live set on four platform
+ * workers. That is 70 % of the process.
+ *
+ * ## Why counts and not a rate of bytes
+ *
+ * An allocation rate sampled from `process.memoryUsage()` on this heartbeat
+ * would be a lie with a number on it. The probe runs every 2 s; external memory
+ * on hub-main cycles many times inside 2 s, so a sum of positive deltas
+ * under-reports it by more than an order of magnitude (a 100 ms sampler already
+ * reported 234 MB/s where a 5 ms one would have said 537). The GC COUNT is
+ * exact at any cadence — V8 reports every cycle — and it is the half of the
+ * product the line was missing. Read against the `oldSpace=` field already on
+ * the line, the two together say which economy is paying:
+ *
+ *  - many majors, little old-space growth between them ⇒ EXTERNAL pressure.
+ *    The fix is an allocation site, and shrinking the live set buys nothing.
+ *  - majors that track old-space growth ⇒ the heap is genuinely filling.
+ *    The fix is retention.
+ *
+ * ## Cost
+ *
+ * One prologue/epilogue callback per GC, into a counter. On hub-main at its
+ * worst that is ~4 entries/s. The observer was run against the live hub three
+ * times for 90 s while this was written, with no measurable effect on the
+ * process; `Profiler.start`, by comparison, stalls it 867 ms (D456).
+ *
+ * Absence is never zero (D393): a runtime that will not give an observer
+ * reports NOTHING on the line, not a census of zero collections.
+ */
+/** One window of collections, as V8 counted them. */
+export interface GcCensusWindow {
+    /** Full mark-compacts. The expensive kind: every one marks the live set. */
+    readonly majors: number;
+    /** Scavenges of the young generation. */
+    readonly minors: number;
+    /** Incremental marking steps on the main thread. */
+    readonly incrementals: number;
+    /** Total MAIN-THREAD pause across the window. Never the concurrent work. */
+    readonly pauseMs: number;
+    /** How long the window was, so a rate can be computed from the line. */
+    readonly windowMs: number;
+}
+/**
+ * A census that accumulates until it is read, then starts a new window.
+ *
+ * Window semantics, not cumulative, for the reason D456 gives: a line printing
+ * a lifetime total says nothing about the minute it describes, and the reader
+ * has to diff two lines by hand to learn anything.
+ */
+export interface GcCensus {
+    /** The window since the previous read. `null` until the first full window. */
+    readonly read: (at: number) => GcCensusWindow | null;
+    readonly stop: () => void;
+}
+/** What the census counts. Node's `PerformanceEntry.detail.kind` values. */
+export interface GcObservation {
+    readonly kind: number;
+    readonly durationMs: number;
+}
+/**
+ * How the census is fed. Injectable so a spec can pose a sequence of
+ * collections without provoking real ones, which is not something a test can
+ * do deterministically.
+ */
+export type GcObserverInstall = (observe: (entry: GcObservation) => void) => (() => void) | undefined;
+/**
+ * V8's kinds, as Node reports them on `detail.kind`.
+ *
+ * Read from `perf_hooks.constants` rather than written as literals: the values
+ * are a Node ABI, and a literal `4` in this file would keep compiling and stop
+ * meaning "major" the release it changed.
+ */
+export interface GcKinds {
+    readonly major: number;
+    readonly minor: number;
+    readonly incremental: number;
+}
+/**
+ * The shortest window a rate may be quoted over.
+ *
+ * One second, and the number comes from the line this field lives on: the boot
+ * line is printed microseconds after the watch starts, and `maj0@0s` there
+ * would be a rate computed over no time at all — indistinguishable on sight
+ * from a process that is genuinely not collecting. Below the floor the census
+ * says NOTHING, which is the same discipline as an unobservable runtime
+ * (D393): a window too short to answer is not an answer of zero.
+ */
+export declare const GC_CENSUS_MIN_WINDOW_MS = 1000;
+/**
+ * Build a census over an injected observer.
+ *
+ * Returns `undefined` when the observer cannot be installed — the caller then
+ * prints nothing, which is the honest reading. It must never degrade into a
+ * census that reports zero collections: a process whose GC is not being
+ * observed and a process that is not collecting look identical on the line, and
+ * they are the two answers furthest apart.
+ */
+export declare function createGcCensus(install: GcObserverInstall, kinds: GcKinds, startedAt: number): GcCensus | undefined;
+/** The real Node observer and the real kind constants, wrapped so they can be replaced in a spec. */
+export interface NodeGcObserver {
+    readonly install: GcObserverInstall;
+    readonly kinds: GcKinds;
+}
+/**
+ * The observer this process actually gets.
+ *
+ * Everything that can fail is inside the try: a runtime without
+ * `perf_hooks`, without the `gc` entry type, or without the kind constants
+ * yields `undefined` from `install`, and {@link createGcCensus} then declines
+ * to exist rather than reporting zeros.
+ */
+export declare function nodeGcObserver(): NodeGcObserver;
+/**
+ * The two fields, APPENDED LAST on the `[mem]` line.
+ *
+ * D446's rule: no existing field moves, so every Loki prefix written since
+ * 2026-08-29 still matches. `gc=` prints even when nothing was collected — a
+ * window with no collections is a reading, and it is the reading that says a
+ * process is idle rather than unobserved. `gcPauseMs=` is the MAIN-THREAD
+ * pause only; the concurrent marking that cost hub-main 70 % of its CPU is on
+ * the platform workers and no in-process counter sees it, which is why the
+ * field is named for the thread it describes (D456, part 4).
+ */
+export declare function formatGcCensus(window: GcCensusWindow | null | undefined): string;

package/dist/kernel/heap-watch.d.ts

@@ -1,6 +1,9 @@
 import { EventPlaneReader } from './event-plane-report.js';
-import { SocketPlaneReader } from './socket-plane-report.js';
+import { SocketPlaneCounters, SocketPlaneReader } from './socket-plane-report.js';
+import { MeshPeerQueue, MeshQueueReader } from './moleculer/mesh-queue-report.js';
+import { OutboundQueueGateOptions, OutboundQueueReading } from './outbound-queue-watch.js';
 import { HeapSpaceReader } from './heap-spaces.js';
+import { NodeGcObserver } from './gc-census.js';
 import { ArrayBufferCensus, ArrayBufferCensusGateOptions } from './array-buffer-census.js';
 /**
  * What hub-main calls itself in a `[mem]` line.
@@ -607,6 +610,20 @@ export interface HeapWatchProbes {
      * from the parent's side. Only hub-main and an agent's main pass one.
      */
     readonly socketPlane?: SocketPlaneReader;
+    /**
+     * The write queue of every Moleculer TCP socket to a peer node. No default:
+     * only a process with a broker on a real transporter has one. Those sockets
+     * are UNREF'D by Moleculer, so a sum over `_getActiveHandles()` never listed
+     * them — the hole in the 2026-09-10 exclusion of "every socket queue"
+     * (D446). Read on every probe, judged with the UDS queues below.
+     */
+    readonly meshQueue?: MeshQueueReader;
+    /**
+     * Thresholds for the outbound-queue gate. The gate itself is created
+     * whenever {@link socketPlane} or {@link meshQueue} is given; this only
+     * tunes it (tests, or a process with a different notion of "held").
+     */
+    readonly outboundQueue?: OutboundQueueGateOptions;
     /**
      * The ArrayBuffer census that ARMS ITSELF. No default: it costs a forced
      * full GC when it fires, and only hub-main has an episode on record (two
@@ -617,11 +634,25 @@ export interface HeapWatchProbes {
      * `array-buffer-census.ts` for the gate, the cost and what it is NOT.
      */
     readonly arrayBufferCensus?: ArrayBufferCensusProbe;
+    /**
+     * How the GC census observes collections. Defaults to the real Node
+     * observer, for EVERY process — the rate is half of what a GC costs and the
+     * line has never carried it (see `gc-census.ts`). A spec passes its own so a
+     * sequence of collections can be posed; nothing in production passes one.
+     */
+    readonly gcObserver?: NodeGcObserver;
 }
 /** How the census is wired: the census itself plus the gate's thresholds. */
 export interface ArrayBufferCensusProbe extends ArrayBufferCensusGateOptions {
     readonly census: ArrayBufferCensus;
 }
+/**
+ * Every outbound queue the heartbeat can reach, as the gate wants them: the
+ * UDS children (only those whose channel keeps a reading — an unmeasured
+ * peer is not a zero) and the mesh writer sockets, each prefixed with its
+ * plane.
+ */
+export declare function outboundQueueReadings(uds: SocketPlaneCounters | undefined, mesh: readonly MeshPeerQueue[] | undefined): readonly OutboundQueueReading[];
 /**
  * Start the heartbeat. Returns a stop function.
  *

package/dist/kernel/moleculer/mesh-queue-report.d.ts

@@ -0,0 +1,51 @@
+/**
+ * mesh-queue-report — the write queue of every Moleculer TCP socket this
+ * process holds to a peer node, on the `[mem]` line (D446).
+ *
+ * ## Why a separate reader
+ *
+ * The UDS plane is measured on the channel (`SocketChannel.queuedBytes`). The
+ * mesh plane is Moleculer's: `TcpTransporter.writer` is a `TcpWriter` whose
+ * `sockets` map holds one `net.Socket` per peer node, opened lazily on the
+ * first send and — this is the point — `unref()`'d at connect
+ * (`transporters/tcp/tcp-writer.js`). An unref'd handle is not in
+ * `process._getActiveHandles()`, so the 2026-09-10 census that summed
+ * `writableLength` over that list and excluded "every socket queue" could not
+ * have seen a backlog to an agent, however large.
+ *
+ * ## What is read, and how carefully
+ *
+ * `broker.transit.tx.writer.sockets` — an internal path, walked with type
+ * guards and never a cast. Every step that is not the expected shape yields
+ * `undefined` for the WHOLE reading: a test broker (`Fake` transporter), a
+ * broker that does not exist yet, a Moleculer whose internals moved. `undefined`
+ * is "this process has no mesh writer to report", never "the mesh is quiet".
+ * A socket entry without numeric `writableLength`/`bytesWritten` is skipped
+ * on its own.
+ */
+/** One peer node's outbound socket, as the writer holds it. */
+export interface MeshPeerQueue {
+    readonly nodeId: string;
+    /** Bytes handed to the socket that the kernel has not taken yet. */
+    readonly queuedBytes: number;
+    /** Lifetime bytes written on this socket — so a stalled queue can be read
+     *  against the peer's normal rate. */
+    readonly bytesWritten: number;
+}
+/** `undefined` = no mesh writer to report (no broker, `Fake` transporter). */
+export type MeshQueueReader = () => readonly MeshPeerQueue[] | undefined;
+/**
+ * Build a reader over a lazily-resolved broker. Wrapped: a broker mid-teardown
+ * may throw, and a diagnostic that can crash the process it watches is worse
+ * than none.
+ */
+export declare function createMeshQueueReader(getBroker: () => unknown): MeshQueueReader;
+/** At most this many nodes named. A cluster has a handful. */
+export declare const MESH_QUEUE_TOP_N = 3;
+/**
+ * The suffix appended to a `[mem]` line — leading space included, empty when
+ * this process has no mesh writer. `meshQueued` is printed always, at zero
+ * included: a quiet mesh is a reading. `meshQueuedTop` names only nodes with
+ * a queue, largest first — a ranked list of zeros is noise.
+ */
+export declare function formatMeshQueue(peers: readonly MeshPeerQueue[] | undefined): string;

package/dist/kernel/outbound-queue-watch.d.ts

@@ -0,0 +1,94 @@
+/**
+ * outbound-queue-watch — an outbound socket queue that HOLDS is named, and its
+ * release is timestamped (D446).
+ *
+ * ## The blind spot this closes
+ *
+ * On 2026-09-10 hub-main's `arrayBuffers` climbed twice at a constant rate
+ * (20 MB/min to 1 264 MB; 63 MB/min for 77 min to 4 968 MB), LIVE across a
+ * forced compaction, with ~4 % of JS heap alongside, and each time released in
+ * one instant with no line from any owner. The investigation excluded "every
+ * socket write queue" by summing `writableLength` over
+ * `process._getActiveHandles()` — 84 MB, all of it the phone's WebSocket.
+ *
+ * `_getActiveHandles()` lists only handles that keep the loop alive. An
+ * UNREF'D socket is not one of them, and Moleculer's `TcpWriter.connect`
+ * unrefs every socket it opens to a peer node (`transporters/tcp/tcp-writer.js`,
+ * `socket.unref()`). So the one outbound plane that writes to another MACHINE
+ * — where a reader that stops draining is the ordinary failure — was never in
+ * the sum. The UDS children were in it, but only as a total, at one instant,
+ * by hand.
+ *
+ * ## What this is
+ *
+ * A pure gate over per-peer queue depths the heartbeat reads on every probe:
+ * the UDS children's `socket.writableLength` (`SocketChannel.queuedBytes`) and
+ * the mesh writer sockets' (`mesh-queue-report.ts`). It says three things and
+ * nothing else:
+ *
+ *  - a peer whose queue has been at or above {@link OUTBOUND_QUEUE_THRESHOLD_BYTES}
+ *    for {@link OUTBOUND_QUEUE_SUSTAIN_MS} is NAMED, with its current and peak
+ *    depth and how long it has held — at most once per
+ *    {@link OUTBOUND_QUEUE_COOLDOWN_MS};
+ *  - a named peer whose queue then falls under half the threshold, or that
+ *    vanishes from the readings (its socket died — which is how a queue is
+ *    dropped in one instant), is reported as RELEASED with its peak and the
+ *    hold, so the release the episodes never logged has a line and a peer;
+ *  - a burst that drains inside the sustain window says nothing. Backpressure
+ *    measures LIVENESS, not identity (D444): a peer momentarily behind is
+ *    coming back.
+ *
+ * ## What it is NOT
+ *
+ * Not a bound. It terminates nothing: a UDS child whose channel is destroyed
+ * loses every in-flight call, and a mesh socket Moleculer reconnects on its
+ * own terms. The WS guard (`ws-slow-consumer-guard.ts`) bounds the one plane
+ * whose client is expendable. Here the line is the deliverable; what to do
+ * about a peer that holds is decided with the peer named, not before.
+ */
+/** 64 MiB. Below this a queue is a burst on a busy peer (the orchestrator's
+ *  channel moves ~1.5 MB/s of audio responses); above it, and held, it is
+ *  retention with a name. */
+export declare const OUTBOUND_QUEUE_THRESHOLD_BYTES: number;
+/** Matches the ArrayBuffer census sustain: a minute above the bound. */
+export declare const OUTBOUND_QUEUE_SUSTAIN_MS = 60000;
+/** A held queue is re-named every ten minutes, not every probe. */
+export declare const OUTBOUND_QUEUE_COOLDOWN_MS: number;
+/** One outbound channel's queue depth at one probe. `peerId` carries its
+ *  plane as a prefix (`uds:<childId>`, `mesh:<nodeId>`). */
+export interface OutboundQueueReading {
+    readonly peerId: string;
+    readonly bytes: number;
+}
+export type OutboundQueueVerdict = {
+    readonly kind: 'sustained';
+    readonly peerId: string;
+    readonly bytes: number;
+    readonly peakBytes: number;
+    readonly heldForMs: number;
+} | {
+    readonly kind: 'released';
+    readonly peerId: string;
+    readonly peakBytes: number;
+    readonly toBytes: number;
+    readonly heldForMs: number;
+    /** The peer left the readings altogether — its socket is gone. */
+    readonly gone: boolean;
+};
+export interface OutboundQueueGateOptions {
+    readonly thresholdBytes?: number;
+    readonly sustainMs?: number;
+    readonly cooldownMs?: number;
+}
+export interface OutboundQueueGate {
+    /** Judge one probe's readings. Every peer is judged on its own. */
+    readonly observe: (readings: readonly OutboundQueueReading[], at: number) => readonly OutboundQueueVerdict[];
+}
+/**
+ * The pure decision — threshold, sustain, cooldown, release, gone — testable
+ * without a socket.
+ */
+export declare function createOutboundQueueGate(options?: OutboundQueueGateOptions): OutboundQueueGate;
+/** The line for one verdict. Both carry the peer, the bytes and the hold;
+ *  the sustained one also says why the older census could not see it. */
+export declare function formatOutboundQueueVerdict(label: string, verdict: OutboundQueueVerdict): string;

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

@@ -1,24 +1,64 @@
+import { CapActionReading, CapActionWindow } from './transport/cap-action-census.js';
 import { SocketDirectionSample, SocketTrafficSample } from './transport/socket-traffic.js';
-/** One peer's cumulative traffic, as the channel keeps it. */
+/** One peer's cumulative traffic, as the channel keeps it, plus its outbound
+ *  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;
 }
 /** What `LocalChildRegistry` exposes, structurally — the kernel's heartbeat
  *  must not depend on the transport layer's class. */
 export interface SocketPlaneRegistryChild {
     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.
+ */
+export interface SocketForwardCensus {
+    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;
 }
 /** 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;
 }
 /** `undefined` = this process has no local socket plane to report (every forked
  *  runner, and hub-main before the registry exists). */
@@ -57,6 +97,23 @@ export interface SocketPeerDelta {
     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;
+}
+/**
+ * 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[];
+}
 /** The whole plane over one heartbeat window. */
 export interface SocketPlaneWindow {
     readonly peersConnected: number;
@@ -67,10 +124,56 @@ export interface SocketPlaneWindow {
     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. */
+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.
+ */
+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;
 }
 /** A process that has never read the plane. */
 export declare const EMPTY_SOCKET_PLANE_BASELINE: SocketPlaneBaseline;
@@ -92,8 +195,13 @@ export declare function createSocketPlaneMeter(reader: SocketPlaneReader, topN?:
  * 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 the one 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.
+ * `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;