@camstack/system 1.2.154 → 1.2.156

package/dist/{manifest-python-deps-COeSr7el.js → manifest-python-deps-DVODn-qc.js}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-Cek0wNdY.js");
-require("./dist-BPlfW-CG.js");
+require("./dist-CDgIzo82.js");
 let node_crypto = require("node:crypto");
 node_crypto = require_chunk.__toESM(node_crypto);
 let _camstack_types_node = require("@camstack/types/node");
@@ -154,6 +154,282 @@ function formatEventPlane(window) {
 	return ` fanoutMode=uds:${window.udsMode}/cross-node:${window.crossNodeMode} children=${window.childrenConnected} childrenUndeclared=${window.childrenUndeclared} fanoutSent=${window.fanoutSent} fanoutSuppressed=${window.fanoutSuppressed} crossNodeDelivered=${window.crossNodeDelivered} crossNodeSuppressed=${window.crossNodeSuppressed}` + (top.length === 0 ? "" : ` fanoutTop=${top}`);
 }
 //#endregion
+//#region src/kernel/transport/socket-traffic.ts
+function createSocketDirectionCounters() {
+	return {
+		reqMessages: 0,
+		reqBytes: 0,
+		resMessages: 0,
+		resBytes: 0,
+		evtMessages: 0,
+		evtBytes: 0
+	};
+}
+/**
+* The hot-path write. Two additions and at most two string comparisons against
+* interned literals — no allocation, no branch on anything the caller has to
+* compute, and nothing that can throw.
+*
+* Measured on Node 24.17, 20 M iterations, three runs: **2.37–2.41 ns/call**
+* against an empty loop. Its neighbours on the same path, measured in the same
+* run: `encodeFrame` on a 0.33 KB body 1948–1975 ns, `FrameDecoder.push`
+* 1156–1166 ns, `process.memoryUsage()` 920–945 ns. The counter is **0.12 % of
+* `encodeFrame`** — and `encodeFrame` is followed by a syscall.
+*
+* Together with the decoder's per-frame size write (0.06–0.13 ns, see
+* `frame-codec.ts`) the whole instrument adds **~2.5 ns per frame**: at 44 000
+* frames/s that is 107–111 µs/s, i.e. **0.011 % of one core**. An instrument
+* that changes what it measures is not an instrument, and this one cannot.
+*/
+function recordSocketFrame(counters, kind, bytes) {
+	if (kind === "evt") {
+		counters.evtMessages += 1;
+		counters.evtBytes += bytes;
+		return;
+	}
+	if (kind === "req") {
+		counters.reqMessages += 1;
+		counters.reqBytes += bytes;
+		return;
+	}
+	counters.resMessages += 1;
+	counters.resBytes += bytes;
+}
+/** Copy out. Called once per heartbeat line, never on the frame path. */
+function sampleSocketDirection(counters) {
+	return {
+		reqMessages: counters.reqMessages,
+		reqBytes: counters.reqBytes,
+		resMessages: counters.resMessages,
+		resBytes: counters.resBytes,
+		evtMessages: counters.evtMessages,
+		evtBytes: counters.evtBytes
+	};
+}
+/** A direction that has seen nothing. */
+var EMPTY_SOCKET_DIRECTION = {
+	reqMessages: 0,
+	reqBytes: 0,
+	resMessages: 0,
+	resBytes: 0,
+	evtMessages: 0,
+	evtBytes: 0
+};
+/** Total messages across the three kinds. */
+function socketDirectionMessages(sample) {
+	return sample.reqMessages + sample.resMessages + sample.evtMessages;
+}
+/** Total on-the-wire bytes across the three kinds. */
+function socketDirectionBytes(sample) {
+	return sample.reqBytes + sample.resBytes + sample.evtBytes;
+}
+//#endregion
+//#region src/kernel/socket-plane-report.ts
+/**
+* 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.
+*/
+/**
+* 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.
+*/
+function createSocketPlaneReader(sources) {
+	return () => {
+		try {
+			const registry = sources.registry();
+			if (registry === null) return void 0;
+			const listed = registry.listChildren();
+			const peers = [];
+			for (const child of listed) {
+				const traffic = registry.getChildSocketTraffic(child.childId);
+				if (traffic === null) continue;
+				peers.push({
+					peerId: child.childId,
+					tx: traffic.tx,
+					rx: traffic.rx
+				});
+			}
+			return {
+				peers,
+				peersConnected: listed.length
+			};
+		} catch {
+			return;
+		}
+	};
+}
+/**
+* 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.
+*/
+var SOCKET_PLANE_TOP_N = 5;
+/** A process that has never read the plane. */
+var EMPTY_SOCKET_PLANE_BASELINE = { peers: /* @__PURE__ */ new Map() };
+function diffDirection(current, before) {
+	const previous = before ?? EMPTY_SOCKET_DIRECTION;
+	return {
+		reqMessages: Math.max(0, current.reqMessages - previous.reqMessages),
+		reqBytes: Math.max(0, current.reqBytes - previous.reqBytes),
+		resMessages: Math.max(0, current.resMessages - previous.resMessages),
+		resBytes: Math.max(0, current.resBytes - previous.resBytes),
+		evtMessages: Math.max(0, current.evtMessages - previous.evtMessages),
+		evtBytes: Math.max(0, current.evtBytes - previous.evtBytes)
+	};
+}
+function addDirection(into, add) {
+	return {
+		reqMessages: into.reqMessages + add.reqMessages,
+		reqBytes: into.reqBytes + add.reqBytes,
+		resMessages: into.resMessages + add.resMessages,
+		resBytes: into.resBytes + add.resBytes,
+		evtMessages: into.evtMessages + add.evtMessages,
+		evtBytes: into.evtBytes + add.evtBytes
+	};
+}
+/** Total messages a peer moved in the window, both directions. */
+function peerMessages(delta) {
+	return socketDirectionMessages(delta.tx) + socketDirectionMessages(delta.rx);
+}
+/** Subtract the previous cumulative reading from the current one. */
+function diffSocketPlane(baseline, current, topN = 5) {
+	const deltas = [];
+	let tx = EMPTY_SOCKET_DIRECTION;
+	let rx = EMPTY_SOCKET_DIRECTION;
+	for (const sample of current.peers) {
+		const before = baseline.peers.get(sample.peerId);
+		const delta = {
+			peerId: sample.peerId,
+			tx: diffDirection(sample.tx, before?.tx),
+			rx: diffDirection(sample.rx, before?.rx)
+		};
+		tx = addDirection(tx, delta.tx);
+		rx = addDirection(rx, delta.rx);
+		if (peerMessages(delta) > 0) deltas.push(delta);
+	}
+	return {
+		peersConnected: current.peersConnected,
+		peersMeasured: current.peers.length,
+		tx,
+		rx,
+		top: deltas.toSorted((a, b) => peerMessages(b) - peerMessages(a) || a.peerId.localeCompare(b.peerId)).slice(0, topN)
+	};
+}
+function createSocketPlaneMeter(reader, topN = 5) {
+	let baseline = EMPTY_SOCKET_PLANE_BASELINE;
+	return { read: () => {
+		const current = reader();
+		if (current === void 0) return void 0;
+		const window = diffSocketPlane(baseline, current, topN);
+		baseline = { peers: new Map(current.peers.map((p) => [p.peerId, p])) };
+		return window;
+	} };
+}
+/** Bytes → whole kB. The plane moves 180–330 MB/min; raw bytes would put
+*  nine-digit numbers on a line that has to stay readable. */
+function kb(bytes) {
+	return Math.round(bytes / 1024);
+}
+/** `req:<msgs>/<kB>,res:<msgs>/<kB>,evt:<msgs>/<kB>` — every kind, always,
+*  including at zero: a kind that went quiet is a reading, not a blank. */
+function formatDirection(sample) {
+	return `req:${sample.reqMessages}/${kb(sample.reqBytes)}kB,res:${sample.resMessages}/${kb(sample.resBytes)}kB,evt:${sample.evtMessages}/${kb(sample.evtBytes)}kB`;
+}
+/** `<peer>:tx=<req>/<res>/<evt>:rx=<req>/<res>/<evt>:kB=<tx>/<rx>` — the whole
+*  peer×kind cross for one peer, which is the question in one token. */
+function formatPeer(delta) {
+	return `${delta.peerId}:tx=${delta.tx.reqMessages}/${delta.tx.resMessages}/${delta.tx.evtMessages}:rx=${delta.rx.reqMessages}/${delta.rx.resMessages}/${delta.rx.evtMessages}:kB=${kb(socketDirectionBytes(delta.tx))}/${kb(socketDirectionBytes(delta.rx))}`;
+}
+/**
+* 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 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.
+*/
+function formatSocketPlane(window) {
+	if (window === void 0) return "";
+	const top = window.top.map(formatPeer).join(",");
+	return ` socketPeers=${window.peersMeasured}/${window.peersConnected} socketTx=${formatDirection(window.tx)} socketRx=${formatDirection(window.rx)}` + (top.length === 0 ? "" : ` socketTop=${top}`);
+}
+//#endregion
 //#region src/kernel/heap-spaces.ts
 /**
 * heap-spaces — WHERE in the V8 heap the bytes are, on the ordinary heartbeat.
@@ -935,6 +1211,7 @@ function format(label, s, loop, budgetMb, suffix) {
 function startHeapWatch(label = HUB_MAIN_HEAP_WATCH_LABEL, sink = consoleSink, intervalMs = HEAP_WATCH_INTERVAL_MS, reclaimOptions, loopDelay = createLoopDelayMeter(), execArgv = process.execArgv, announceCeilingOrigin = true, rssBudget, probes) {
 	const readSpaces = probes?.readSpaces ?? readHeapSpaces;
 	const eventPlane = probes?.eventPlane === void 0 ? void 0 : createEventPlaneMeter(probes.eventPlane);
+	const socketPlane = probes?.socketPlane === void 0 ? void 0 : createSocketPlaneMeter(probes.socketPlane);
 	const readMemory = reclaimOptions?.readMemory ?? (() => process.memoryUsage());
 	const now = reclaimOptions?.now ?? (() => Date.now());
 	const triggerMb = reclaimOptions?.triggerMb ?? 1024;
@@ -972,7 +1249,7 @@ function startHeapWatch(label = HUB_MAIN_HEAP_WATCH_LABEL, sink = consoleSink, i
 			return;
 		}
 		const after = read();
-		sink.info(`[mem] reclaim ${label} stranded=${strandedMb(sample)}MB rss=${sample.rssMb}MB→${after.rssMb}MB freed=${sample.rssMb - after.rssMb}MB arrayBuffers=${sample.arrayBuffersMb}MB→${after.arrayBuffersMb}MB took=${now() - startedAt}ms`);
+		sink.info(`[mem] reclaim ${label} stranded=${strandedMb(sample)}MB rss=${sample.rssMb}MB→${after.rssMb}MB freed=${sample.rssMb - after.rssMb}MB arrayBuffers=${sample.arrayBuffersMb}MB→${after.arrayBuffersMb}MB took=${now() - startedAt}ms heapUsed=${sample.heapUsedMb}MB→${after.heapUsedMb}MB`);
 		if (passesAtFloor >= 6 && !steadyStateAnnounced) {
 			steadyStateAnnounced = true;
 			const nextFloorMs = reclaimIntervalMs(passesAtFloor, minIntervalMs, steadyStateIntervalMs);
@@ -1039,7 +1316,7 @@ function startHeapWatch(label = HUB_MAIN_HEAP_WATCH_LABEL, sink = consoleSink, i
 			const due = at - lastLoggedAt >= intervalMs;
 			if (mode === "escalated" || due) {
 				lastLoggedAt = at;
-				const line = format(label, sample, loopDelay?.read(), budgetMb, `${formatHeapSpaces(readSpaces())}${formatEventPlane(eventPlane?.read())}`);
+				const line = format(label, sample, loopDelay?.read(), budgetMb, `${formatHeapSpaces(readSpaces())}${formatEventPlane(eventPlane?.read())}` + formatSocketPlane(socketPlane?.read()));
 				if (sample.nearLimit) sink.warn(`${line} — APPROACHING HEAP LIMIT`);
 				else if (mode === "escalated") sink.warn(`${line} — heap elevated, sampling every ${probeIntervalMs}ms`);
 				else sink.info(line);
@@ -4910,6 +5187,33 @@ var FrameDecoder = class {
 	chunks = [];
 	/** Sum of `chunks[i].byteLength` — tracked so length checks cost nothing. */
 	buffered = 0;
+	/** Backing store for {@link lastFrameBytes}; see that getter. */
+	sizes = [];
+	/**
+	* On-the-wire byte length (4-byte prefix included) of each frame returned by
+	* the most recent {@link push}, index-aligned with the returned array.
+	*
+	* It exists because the frames come back DECODED, and a decoded value has no
+	* memory of how many bytes it cost — so a caller counting received bytes per
+	* message kind (`SocketChannel`, feeding the `[mem]` line's per-peer socket
+	* attribution) could otherwise only charge a whole `data` chunk, which may
+	* hold several frames of different kinds, or half of one.
+	*
+	* **Only the first `frames.length` entries are meaningful**, and the array is
+	* never truncated. That is deliberate and it was measured on Node 24.17:
+	* `sizes.length = 0` + `push` costs **35.1–35.9 ns** per call — V8 shrinks the
+	* backing store and the next call re-grows it — which is 3 % of
+	* `FrameDecoder.push` itself and 15× the counter it feeds. Writing in place
+	* costs **0.06–0.13 ns**. On a path that runs ~22 000 times a second, an
+	* instrument may not be the most expensive thing on the line it measures.
+	*
+	* Read it immediately after the `push` that produced it — it is a window onto
+	* the decoder, not a value. Safe because `push` is only ever driven by a
+	* socket `data` event, which Node never delivers re-entrantly.
+	*/
+	get lastFrameBytes() {
+		return this.sizes;
+	}
 	push(chunk) {
 		if (chunk.byteLength > 0) {
 			this.chunks.push(chunk);
@@ -4927,6 +5231,7 @@ var FrameDecoder = class {
 				body = Buffer.allocUnsafeSlow(len);
 				frame.copy(body, 0, HEADER_BYTES);
 			} else body = frame.subarray(HEADER_BYTES);
+			this.sizes[frames.length] = total;
 			frames.push(decode(body));
 		}
 		return frames;
@@ -5011,6 +5316,11 @@ var SocketChannel = class {
 	closeHandler = () => {};
 	closed = false;
 	closeFired = false;
+	/** Frames written to the peer, cumulative, split by kind. See
+	*  {@link readTraffic} and `transport/socket-traffic.ts`. */
+	txCounters = createSocketDirectionCounters();
+	/** Frames read from the peer, cumulative, split by kind. */
+	rxCounters = createSocketDirectionCounters();
 	constructor(socket) {
 		this.socket = socket;
 		socket.on("data", (chunk) => this.onData(chunk));
@@ -5077,14 +5387,41 @@ var SocketChannel = class {
 		this.closed = true;
 		this.socket.destroy();
 	}
+	/**
+	* This channel's cumulative traffic, both directions, split by frame kind.
+	*
+	* Cumulative for the life of the channel: the reporting layer subtracts the
+	* previous reading, because the question is a RATE ("which peer receives the
+	* 22 500 writes/s") and not a total since boot.
+	*/
+	readTraffic() {
+		return {
+			tx: sampleSocketDirection(this.txCounters),
+			rx: sampleSocketDirection(this.rxCounters)
+		};
+	}
 	send(frame) {
 		if (this.closed) return;
-		this.socket.write(encodeFrame(frame));
+		const encoded = encodeFrame(frame);
+		recordSocketFrame(this.txCounters, frame.k, encoded.byteLength);
+		this.socket.write(encoded);
 	}
 	onData(chunk) {
-		for (const f of this.decoder.push(chunk)) this.handleFrame(f);
+		const frames = this.decoder.push(chunk);
+		const sizes = this.decoder.lastFrameBytes;
+		for (let i = 0; i < frames.length; i += 1) this.handleFrame(frames[i], sizes[i] ?? 0);
 	}
-	async handleFrame(frame) {
+	/**
+	* `wireBytes` is the frame's on-the-wire length, counted HERE rather than in
+	* `onData` on purpose: a peer that sends a frame this decoder can parse but
+	* whose shape is not a `Frame` throws on `frame.k`, and inside this async
+	* method that stays the rejected promise it has always been. Reading `.k`
+	* one frame earlier, synchronously in the socket's `data` handler, would
+	* turn the same malformed frame into an uncaught exception on the transport
+	* — a diagnostic that can crash the process it watches.
+	*/
+	async handleFrame(frame, wireBytes) {
+		recordSocketFrame(this.rxCounters, frame.k, wireBytes);
 		if (frame.k === "req") {
 			try {
 				const result = await this.requestHandler(frame.body);
@@ -5958,6 +6295,22 @@ var LocalChildRegistry = class {
 		};
 	}
 	/**
+	* This child's socket traffic — bytes and messages, both directions, split by
+	* frame kind — or `null` when the child is gone or its channel keeps no
+	* counters (an in-process or test transport).
+	*
+	* The event counters above cover ONE kind of frame and, once surfaced on
+	* 2026-08-29, accounted for 4% of hub-main's ~44 000 socket syscalls/s. This
+	* is the same question asked of every frame the channel moves, and it is the
+	* only per-peer attribution that exists: `/proc` reports one `rchar`/`wchar`
+	* pair for the whole process and has no per-socket breakdown.
+	*/
+	getChildSocketTraffic(childId) {
+		const entry = this.children.get(childId);
+		if (entry === void 0) return null;
+		return entry.channel.readTraffic?.() ?? null;
+	}
+	/**
 	* The regime the counters above were produced under, read once from
 	* `CAMSTACK_UDS_EVENT_FANOUT` at construction.
 	*
@@ -9211,6 +9564,18 @@ Object.defineProperty(exports, "DeviceRegistry", {
 		return DeviceRegistry;
 	}
 });
+Object.defineProperty(exports, "EMPTY_SOCKET_DIRECTION", {
+	enumerable: true,
+	get: function() {
+		return EMPTY_SOCKET_DIRECTION;
+	}
+});
+Object.defineProperty(exports, "EMPTY_SOCKET_PLANE_BASELINE", {
+	enumerable: true,
+	get: function() {
+		return EMPTY_SOCKET_PLANE_BASELINE;
+	}
+});
 Object.defineProperty(exports, "EVENT_PLANE_TOP_N", {
 	enumerable: true,
 	get: function() {
@@ -9343,6 +9708,12 @@ Object.defineProperty(exports, "RUNNER_RSS_BUDGET_ENV", {
 		return RUNNER_RSS_BUDGET_ENV;
 	}
 });
+Object.defineProperty(exports, "SOCKET_PLANE_TOP_N", {
+	enumerable: true,
+	get: function() {
+		return SOCKET_PLANE_TOP_N;
+	}
+});
 Object.defineProperty(exports, "SocketChannel", {
 	enumerable: true,
 	get: function() {
@@ -9541,6 +9912,24 @@ Object.defineProperty(exports, "createParentUnownedCallHandler", {
 		return createParentUnownedCallHandler;
 	}
 });
+Object.defineProperty(exports, "createSocketDirectionCounters", {
+	enumerable: true,
+	get: function() {
+		return createSocketDirectionCounters;
+	}
+});
+Object.defineProperty(exports, "createSocketPlaneMeter", {
+	enumerable: true,
+	get: function() {
+		return createSocketPlaneMeter;
+	}
+});
+Object.defineProperty(exports, "createSocketPlaneReader", {
+	enumerable: true,
+	get: function() {
+		return createSocketPlaneReader;
+	}
+});
 Object.defineProperty(exports, "createUdsAddonContext", {
 	enumerable: true,
 	get: function() {
@@ -9595,6 +9984,12 @@ Object.defineProperty(exports, "diffEventPlane", {
 		return diffEventPlane;
 	}
 });
+Object.defineProperty(exports, "diffSocketPlane", {
+	enumerable: true,
+	get: function() {
+		return diffSocketPlane;
+	}
+});
 Object.defineProperty(exports, "emitHeapDiagnosticReport", {
 	enumerable: true,
 	get: function() {
@@ -9619,6 +10014,12 @@ Object.defineProperty(exports, "formatHeapSpaces", {
 		return formatHeapSpaces;
 	}
 });
+Object.defineProperty(exports, "formatSocketPlane", {
+	enumerable: true,
+	get: function() {
+		return formatSocketPlane;
+	}
+});
 Object.defineProperty(exports, "getBrokerEventBus", {
 	enumerable: true,
 	get: function() {
@@ -9757,6 +10158,12 @@ Object.defineProperty(exports, "reclaimIntervalMs", {
 		return reclaimIntervalMs;
 	}
 });
+Object.defineProperty(exports, "recordSocketFrame", {
+	enumerable: true,
+	get: function() {
+		return recordSocketFrame;
+	}
+});
 Object.defineProperty(exports, "registerEventBusService", {
 	enumerable: true,
 	get: function() {
@@ -9787,6 +10194,12 @@ Object.defineProperty(exports, "runNpm", {
 		return runNpm;
 	}
 });
+Object.defineProperty(exports, "sampleSocketDirection", {
+	enumerable: true,
+	get: function() {
+		return sampleSocketDirection;
+	}
+});
 Object.defineProperty(exports, "selectReportedSpaces", {
 	enumerable: true,
 	get: function() {
@@ -9823,6 +10236,18 @@ Object.defineProperty(exports, "shouldReclaim", {
 		return shouldReclaim;
 	}
 });
+Object.defineProperty(exports, "socketDirectionBytes", {
+	enumerable: true,
+	get: function() {
+		return socketDirectionBytes;
+	}
+});
+Object.defineProperty(exports, "socketDirectionMessages", {
+	enumerable: true,
+	get: function() {
+		return socketDirectionMessages;
+	}
+});
 Object.defineProperty(exports, "startHeapWatch", {
 	enumerable: true,
 	get: function() {

package/dist/{retired-settings-keys-DBY6ebwV.js → retired-settings-keys-BfAzWvPC.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-BPlfW-CG.js");
+const require_dist = require("./dist-CDgIzo82.js");
 //#region src/builtins/sqlite-storage/retired-settings-keys.ts
 /**
 * Is THIS node the one whose settings store is the cluster's authority?

package/dist/{retired-settings-keys-Bq1Tb84I.mjs → retired-settings-keys-CV4QVdXj.mjs}

@@ -1,4 +1,4 @@
-import { zt as asJsonObject } from "./dist-D_NyUV6Y.mjs";
+import { zt as asJsonObject } from "./dist-LvKus-mT.mjs";
 //#region src/builtins/sqlite-storage/retired-settings-keys.ts
 /**
 * Is THIS node the one whose settings store is the cluster's authority?

package/package.json

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