camstack 1.2.60 → 1.2.61

package/dist/cli.js

@@ -38,7 +38,7 @@ async function runServe(args) {
     ...typeof values.data === "string" ? { data: values.data } : {}
   };
   Object.assign(process.env, buildServeEnv(opts));
-  await import("./launcher-CL4LHR6D.js");
+  await import("./launcher-AZ7QXACO.js");
 }
 
 // src/commands/agent.ts
@@ -83,7 +83,7 @@ async function runAgent(args) {
     ...typeof values.port === "string" ? { port: values.port } : {}
   };
   Object.assign(process.env, buildAgentEnv(opts));
-  await import("./launcher-CL4LHR6D.js");
+  await import("./launcher-AZ7QXACO.js");
 }
 
 // src/commands/setup.ts

package/dist/{launcher-CL4LHR6D.js → launcher-AZ7QXACO.js}

@@ -114644,9 +114644,9 @@ var require_dist2 = __commonJS({
   }
 });
 
-// ../system/dist/manifest-python-deps-COeSr7el.js
-var require_manifest_python_deps_COeSr7el = __commonJS({
-  "../system/dist/manifest-python-deps-COeSr7el.js"(exports) {
+// ../system/dist/manifest-python-deps-w48vOhGR.js
+var require_manifest_python_deps_w48vOhGR = __commonJS({
+  "../system/dist/manifest-python-deps-w48vOhGR.js"(exports) {
     "use strict";
     var require_chunk = require_chunk_Cek0wNdY();
     require_dist_BPlfW_CG();
@@ -114755,6 +114755,152 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
       const top = window2.top.map((d) => `${d.childId}:${d.sent}/${d.suppressed}`).join(",");
       return ` fanoutMode=uds:${window2.udsMode}/cross-node:${window2.crossNodeMode} children=${window2.childrenConnected} childrenUndeclared=${window2.childrenUndeclared} fanoutSent=${window2.fanoutSent} fanoutSuppressed=${window2.fanoutSuppressed} crossNodeDelivered=${window2.crossNodeDelivered} crossNodeSuppressed=${window2.crossNodeSuppressed}` + (top.length === 0 ? "" : ` fanoutTop=${top}`);
     }
+    function createSocketDirectionCounters() {
+      return {
+        reqMessages: 0,
+        reqBytes: 0,
+        resMessages: 0,
+        resBytes: 0,
+        evtMessages: 0,
+        evtBytes: 0
+      };
+    }
+    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;
+    }
+    function sampleSocketDirection(counters) {
+      return {
+        reqMessages: counters.reqMessages,
+        reqBytes: counters.reqBytes,
+        resMessages: counters.resMessages,
+        resBytes: counters.resBytes,
+        evtMessages: counters.evtMessages,
+        evtBytes: counters.evtBytes
+      };
+    }
+    var EMPTY_SOCKET_DIRECTION = {
+      reqMessages: 0,
+      reqBytes: 0,
+      resMessages: 0,
+      resBytes: 0,
+      evtMessages: 0,
+      evtBytes: 0
+    };
+    function socketDirectionMessages(sample) {
+      return sample.reqMessages + sample.resMessages + sample.evtMessages;
+    }
+    function socketDirectionBytes(sample) {
+      return sample.reqBytes + sample.resBytes + sample.evtBytes;
+    }
+    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;
+        }
+      };
+    }
+    var SOCKET_PLANE_TOP_N = 5;
+    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
+      };
+    }
+    function peerMessages(delta) {
+      return socketDirectionMessages(delta.tx) + socketDirectionMessages(delta.rx);
+    }
+    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 window2 = diffSocketPlane(baseline, current, topN);
+        baseline = { peers: new Map(current.peers.map((p) => [p.peerId, p])) };
+        return window2;
+      } };
+    }
+    function kb(bytes) {
+      return Math.round(bytes / 1024);
+    }
+    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`;
+    }
+    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))}`;
+    }
+    function formatSocketPlane(window2) {
+      if (window2 === void 0) return "";
+      const top = window2.top.map(formatPeer).join(",");
+      return ` socketPeers=${window2.peersMeasured}/${window2.peersConnected} socketTx=${formatDirection(window2.tx)} socketRx=${formatDirection(window2.rx)}` + (top.length === 0 ? "" : ` socketTop=${top}`);
+    }
     var DECISIVE_HEAP_SPACES = ["old_space", "large_object_space"];
     var HEAP_SPACE_REPORT_MIN_MB = 32;
     var BYTES_PER_MB = 1048576;
@@ -114968,6 +115114,7 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
     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;
@@ -115003,7 +115150,7 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
           return;
         }
         const after = read();
-        sink.info(`[mem] reclaim ${label} stranded=${strandedMb(sample)}MB rss=${sample.rssMb}MB\u2192${after.rssMb}MB freed=${sample.rssMb - after.rssMb}MB arrayBuffers=${sample.arrayBuffersMb}MB\u2192${after.arrayBuffersMb}MB took=${now() - startedAt}ms`);
+        sink.info(`[mem] reclaim ${label} stranded=${strandedMb(sample)}MB rss=${sample.rssMb}MB\u2192${after.rssMb}MB freed=${sample.rssMb - after.rssMb}MB arrayBuffers=${sample.arrayBuffersMb}MB\u2192${after.arrayBuffersMb}MB took=${now() - startedAt}ms heapUsed=${sample.heapUsedMb}MB\u2192${after.heapUsedMb}MB`);
         if (passesAtFloor >= 6 && !steadyStateAnnounced) {
           steadyStateAnnounced = true;
           const nextFloorMs = reclaimIntervalMs(passesAtFloor, minIntervalMs, steadyStateIntervalMs);
@@ -115045,7 +115192,7 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
           const due = at - lastLoggedAt >= intervalMs;
           if (mode === "escalated" || due) {
             lastLoggedAt = at;
-            const line = format2(label, sample, loopDelay?.read(), budgetMb, `${formatHeapSpaces(readSpaces())}${formatEventPlane(eventPlane?.read())}`);
+            const line = format2(label, sample, loopDelay?.read(), budgetMb, `${formatHeapSpaces(readSpaces())}${formatEventPlane(eventPlane?.read())}` + formatSocketPlane(socketPlane?.read()));
             if (sample.nearLimit) sink.warn(`${line} \u2014 APPROACHING HEAP LIMIT`);
             else if (mode === "escalated") sink.warn(`${line} \u2014 heap elevated, sampling every ${probeIntervalMs}ms`);
             else sink.info(line);
@@ -118259,6 +118406,33 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
       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);
@@ -118276,6 +118450,7 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
             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;
@@ -118355,6 +118530,11 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
       };
       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));
@@ -118422,14 +118602,41 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
         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);
@@ -119150,6 +119357,22 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
         };
       }
       /**
+      * 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.
       *
@@ -121645,6 +121868,18 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
         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() {
@@ -121777,6 +122012,12 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
         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() {
@@ -121975,6 +122216,24 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
         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() {
@@ -122029,6 +122288,12 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
         return diffEventPlane;
       }
     });
+    Object.defineProperty(exports, "diffSocketPlane", {
+      enumerable: true,
+      get: function() {
+        return diffSocketPlane;
+      }
+    });
     Object.defineProperty(exports, "emitHeapDiagnosticReport", {
       enumerable: true,
       get: function() {
@@ -122053,6 +122318,12 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
         return formatHeapSpaces;
       }
     });
+    Object.defineProperty(exports, "formatSocketPlane", {
+      enumerable: true,
+      get: function() {
+        return formatSocketPlane;
+      }
+    });
     Object.defineProperty(exports, "getBrokerEventBus", {
       enumerable: true,
       get: function() {
@@ -122191,6 +122462,12 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
         return reclaimIntervalMs;
       }
     });
+    Object.defineProperty(exports, "recordSocketFrame", {
+      enumerable: true,
+      get: function() {
+        return recordSocketFrame;
+      }
+    });
     Object.defineProperty(exports, "registerEventBusService", {
       enumerable: true,
       get: function() {
@@ -122221,6 +122498,12 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
         return runNpm;
       }
     });
+    Object.defineProperty(exports, "sampleSocketDirection", {
+      enumerable: true,
+      get: function() {
+        return sampleSocketDirection;
+      }
+    });
     Object.defineProperty(exports, "selectReportedSpaces", {
       enumerable: true,
       get: function() {
@@ -122257,6 +122540,18 @@ var require_manifest_python_deps_COeSr7el = __commonJS({
         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() {
@@ -126121,7 +126416,7 @@ var require_dist3 = __commonJS({
     var require_builtins_winston_logging_index = require_winston_logging();
     var require_file_data_plane = require_file_data_plane_DO8KbxCe();
     var require_tls$1 = require_tls_BxQlomxd();
-    var require_manifest_python_deps = require_manifest_python_deps_COeSr7el();
+    var require_manifest_python_deps = require_manifest_python_deps_w48vOhGR();
     var require_resource_monitor = require_resource_monitor_CdnzxBLP();
     var require_custom_action_registry = require_custom_action_registry_jY0NOZK8();
     var zod = require_zod();
@@ -206502,6 +206797,8 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.DeviceManagerAddon = require_builtins_device_manager_device_manager_addon.DeviceManagerAddon;
     exports.DeviceRegistry = require_manifest_python_deps.DeviceRegistry;
     exports.DeviceStore = require_builtins_sqlite_storage_index.DeviceStore$1;
+    exports.EMPTY_SOCKET_DIRECTION = require_manifest_python_deps.EMPTY_SOCKET_DIRECTION;
+    exports.EMPTY_SOCKET_PLANE_BASELINE = require_manifest_python_deps.EMPTY_SOCKET_PLANE_BASELINE;
     exports.EVENT_PLANE_TOP_N = require_manifest_python_deps.EVENT_PLANE_TOP_N;
     exports.EVENT_TOPIC_PREFIX = require_manifest_python_deps.EVENT_TOPIC_PREFIX;
     exports.EngineManagerResolver = EngineManagerResolver;
@@ -206575,6 +206872,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.ReplEngine = ReplEngine;
     exports.RingBuffer = RingBuffer;
     exports.SERVER_AUTH_OID = require_tls$1.SERVER_AUTH_OID;
+    exports.SOCKET_PLANE_TOP_N = require_manifest_python_deps.SOCKET_PLANE_TOP_N;
     exports.ScopedLogger = ScopedLogger;
     exports.ScopedTokenManager = require_builtins_local_auth_local_auth_addon.ScopedTokenManager;
     exports.SocketChannel = require_manifest_python_deps.SocketChannel;
@@ -206660,6 +206958,9 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.createReadinessService = createReadinessService;
     exports.createReadinessServiceForRegistry = createReadinessServiceForRegistry;
     exports.createScopedProcessManager = createScopedProcessManager;
+    exports.createSocketDirectionCounters = require_manifest_python_deps.createSocketDirectionCounters;
+    exports.createSocketPlaneMeter = require_manifest_python_deps.createSocketPlaneMeter;
+    exports.createSocketPlaneReader = require_manifest_python_deps.createSocketPlaneReader;
     exports.createStreamProbeBrokerService = createStreamProbeBrokerService;
     exports.createUdsAddonContext = require_manifest_python_deps.createUdsAddonContext;
     exports.createUdsEventBridge = require_manifest_python_deps.createUdsEventBridge;
@@ -206673,6 +206974,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.describeRss = require_manifest_python_deps.describeRss;
     exports.detectWorkspacePackagesDir = detectWorkspacePackagesDir;
     exports.diffEventPlane = require_manifest_python_deps.diffEventPlane;
+    exports.diffSocketPlane = require_manifest_python_deps.diffSocketPlane;
     Object.defineProperty(exports, "downloadBinary", {
       enumerable: true,
       get: function() {
@@ -206720,6 +207022,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.formatEventPlane = require_manifest_python_deps.formatEventPlane;
     exports.formatHeapSpaces = require_manifest_python_deps.formatHeapSpaces;
     exports.formatLogLine = require_formatter.formatLogLine;
+    exports.formatSocketPlane = require_manifest_python_deps.formatSocketPlane;
     exports.getBrokerEventBus = require_manifest_python_deps.getBrokerEventBus;
     exports.getCapUsageRegistry = require_manifest_python_deps.getCapUsageRegistry;
     Object.defineProperty(exports, "getFfmpegDownloadUrl", {
@@ -206799,6 +207102,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.readTlsMode = require_tls$1.readTlsMode;
     exports.readinessKey = require_dist10.readinessKey;
     exports.reclaimIntervalMs = require_manifest_python_deps.reclaimIntervalMs;
+    exports.recordSocketFrame = require_manifest_python_deps.recordSocketFrame;
     exports.registerEventBusService = require_manifest_python_deps.registerEventBusService;
     exports.registerLanHttpHandler = require_tls$1.registerLanHttpHandler;
     exports.reissueTlsLeaf = require_tls$1.reissueTlsLeaf;
@@ -206807,6 +207111,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.resolveNpmInvocation = require_manifest_python_deps.resolveNpmInvocation;
     exports.runHubAddonBoot = runHubAddonBoot;
     exports.runNpm = require_manifest_python_deps.runNpm;
+    exports.sampleSocketDirection = require_manifest_python_deps.sampleSocketDirection;
     exports.scheduleSelfRestart = scheduleSelfRestart;
     exports.scopeKey = require_dist10.scopeKey;
     exports.scopesAllowAddon = require_dist10.scopesAllowAddon;
@@ -206817,6 +207122,8 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.setHubConnected = require_manifest_python_deps.setHubConnected;
     exports.setNodeEventInterest = require_manifest_python_deps.setNodeEventInterest;
     exports.shouldReclaim = require_manifest_python_deps.shouldReclaim;
+    exports.socketDirectionBytes = require_manifest_python_deps.socketDirectionBytes;
+    exports.socketDirectionMessages = require_manifest_python_deps.socketDirectionMessages;
     exports.startHeapWatch = require_manifest_python_deps.startHeapWatch;
     exports.startRunnerHeapWatch = require_manifest_python_deps.startRunnerHeapWatch;
     exports.strandedMb = require_manifest_python_deps.strandedMb;
@@ -421823,6 +422130,17 @@ var require_main4 = __commonJS({
             return broker === void 0 ? null : (0, system_1.getMoleculerEventStats)(broker);
           },
           crossNodeMode: () => (0, system_1.readMoleculerFanoutMode)()
+        }),
+        // The fan-out counters above answered their own question and sharpened
+        // this one: the event plane is 4% of this process's ~44 000 socket
+        // syscalls/s. The other 96% had no instrument — `/proc` reports one
+        // rchar/wchar pair per PROCESS and has no per-socket breakdown, so the
+        // best attribution available was a correlation with `hub/pipeline-
+        // analytics` computed from a runner whose rchar also counts page-cache
+        // reads. These counters live on the channel itself, so the attribution is
+        // per peer and per frame kind. Same lazy registry, same reason.
+        socketPlane: (0, system_1.createSocketPlaneReader)({
+          registry: () => moleculerForEventPlane?.childRegistry ?? null
         })
       });
       cleanupOrphanProcesses();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camstack",
-  "version": "1.2.60",
+  "version": "1.2.61",
   "description": "CLI tool for managing and running CamStack server",
   "keywords": [
     "camstack",