@camstack/system 1.2.153 → 1.2.155

package/dist/{manifest-python-deps-QompQxhG.mjs → manifest-python-deps-BiWtkFGY.mjs}

@@ -1,4 +1,4 @@
-import "./dist-BLhrrxIs.mjs";
+import "./dist-D_NyUV6Y.mjs";
 import * as crypto$1 from "node:crypto";
 import { randomBytes, randomUUID } from "node:crypto";
 import { ensureBinary, ensureFfmpeg, ensurePython, installPythonPackages, installPythonRequirements } from "@camstack/types/node";
@@ -150,6 +150,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.
@@ -931,6 +1207,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;
@@ -968,7 +1245,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);
@@ -1035,7 +1312,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);
@@ -4906,6 +5183,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);
@@ -4923,6 +5227,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;
@@ -5007,6 +5312,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));
@@ -5073,14 +5383,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);
@@ -5954,6 +6291,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.
 	*
@@ -9147,4 +9500,4 @@ async function installManifestPythonDeps(declaration, addonDir, deps, logger) {
 	await deps.installPythonRequirements(reqAbs);
 }
 //#endregion
-export { buildNativeCapProxy as $, RUNNER_HEAP_SNAPSHOT_ENV as $t, createParentUnownedCallHandler as A, HUB_MAIN_HEAP_WATCH_LABEL as At, AGENT_CAP_FWD_SERVICE as B, createLoopDelayMeter as Bt, brokerTransportLink as C, runNpm as Ct, HUB_CAP_FWD_ACTION as D, HEAP_RECLAIM_TRIGGER_MB as Dt, localProviderLink as E, HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS as Et, createUdsLoggerWithControl as F, RUNNER_HEAP_WATCH_INTERVAL_MS as Ft, readMoleculerFanoutMode as G, parseRssBudgetMb as Gt, CapRouteError as H, describeRss as Ht, LocalChildClient as I, RUNNER_RSS_BUDGET_ENV as It, UdsLocalTransportServer as J, startHeapWatch as Jt, createLocalTransport as K, reclaimIntervalMs as Kt, LocalChildRegistry as L, ZERO_LOOP_DELAY as Lt, createUdsEventBus as M, HUB_RSS_BUDGET_ENV as Mt, udsChildLogToWorkerEntry as N, RSS_BUDGET_REANNOUNCE_MIN_MS as Nt, HUB_CAP_FWD_SERVICE as O, HEAP_WATCH_INTERVAL_MS as Ot, createUdsLogger as P, RSS_BUDGET_RELEASE_RATIO as Pt, encodeFrame as Q, HEAP_SPACE_REPORT_MIN_MB as Qt, UDS_NO_ROUTE_PREFIX as R, buildHeapSample as Rt, brokerCallForCap as S, resolveNpmInvocation as St, ipcParentLink as T, HEAP_RECLAIM_MIN_INTERVAL_MS as Tt, classifyCapRoute as U, hubMainRssBudget as Ut, CapRouteResolver as V, createV8Reclaimer as Vt, callWithServiceDiscovery as W, nextRssBudgetState as Wt, localEndpointPath as X, strandedMb as Xt, SocketChannel as Y, startRunnerHeapWatch as Yt, FrameDecoder as Z, DECISIVE_HEAP_SPACES as Zt, createKernelHwAccel as _, CapabilityHandle as _t, getWorkerDeviceRegistry as a, selectReportedSpaces as an, setWorkerNativeCapsChangeListener as at, __resetCapUsageRegistryForTests as b, installManifestNativeDeps as bt, setHubConnected as c, createEventPlaneReader as cn, NATIVE_PROVIDER_SERVICE_INFIX as ct, getBrokerEventBus as d, capBareAction as dt, emitHeapDiagnosticReport as en, buildUdsNativeCapProxy as et, getMoleculerEventStats as f, capServiceName as ft, AddonDepsManager as g, DeviceRegistry as gt, subscribePassthrough as h, serializeTypedArrays as ht, createUdsAddonContext as i, readHeapSpaces as in, mountNativeCapService as it, createUdsEventBridge as j, HUB_MAIN_RSS_BUDGET_MB as jt, createHubCapForwardService as k, HEAP_WATCH_WARN_RATIO as kt, EVENT_TOPIC_PREFIX as l, diffEventPlane as ln, capActionName as lt, setNodeEventInterest as m, deserializeTypedArrays as mt, adaptBrokerToCluster as n, heapSnapshotAuthorised as nn, getWorkerNativeCapProvider as nt, getOrInitReadinessRegistry as o, EVENT_PLANE_TOP_N as on, createAddonService as ot, registerEventBusService as p, parseCapAction as pt, UdsLocalTransportClient as q, shouldReclaim as qt, createAddonContext as r, heapSpaceField as rn, getWorkerNativeCapSnapshot as rt, getOrInitReadinessRegistryForClient as s, createEventPlaneMeter as sn, validateProviderRegistrations as st, installManifestPythonDeps as t, formatHeapSpaces as tn, createBrokerDeviceManagerApi as tt, clusterEventTopic as u, formatEventPlane as un, capActionSuffix as ut, resolveHwAccel as v, CapabilityUnavailableError as vt, buildLinkChain as w, createAddonDataPlaneFacility as wt, getCapUsageRegistry as x, resolveAddonClass as xt, CapUsageRegistry as y, copyBundledNativeModules as yt, AGENT_CAP_FWD_ACTION as z, createDeferredHeapWatchSink as zt };
+export { buildNativeCapProxy as $, RUNNER_HEAP_SNAPSHOT_ENV as $t, createParentUnownedCallHandler as A, HUB_MAIN_HEAP_WATCH_LABEL as At, AGENT_CAP_FWD_SERVICE as B, createLoopDelayMeter as Bt, brokerTransportLink as C, runNpm as Ct, HUB_CAP_FWD_ACTION as D, HEAP_RECLAIM_TRIGGER_MB as Dt, localProviderLink as E, HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS as Et, createUdsLoggerWithControl as F, RUNNER_HEAP_WATCH_INTERVAL_MS as Ft, readMoleculerFanoutMode as G, parseRssBudgetMb as Gt, CapRouteError as H, describeRss as Ht, LocalChildClient as I, RUNNER_RSS_BUDGET_ENV as It, UdsLocalTransportServer as J, startHeapWatch as Jt, createLocalTransport as K, reclaimIntervalMs as Kt, LocalChildRegistry as L, ZERO_LOOP_DELAY as Lt, createUdsEventBus as M, HUB_RSS_BUDGET_ENV as Mt, udsChildLogToWorkerEntry as N, RSS_BUDGET_REANNOUNCE_MIN_MS as Nt, HUB_CAP_FWD_SERVICE as O, HEAP_WATCH_INTERVAL_MS as Ot, createUdsLogger as P, RSS_BUDGET_RELEASE_RATIO as Pt, encodeFrame as Q, HEAP_SPACE_REPORT_MIN_MB as Qt, UDS_NO_ROUTE_PREFIX as R, buildHeapSample as Rt, brokerCallForCap as S, formatEventPlane as Sn, resolveNpmInvocation as St, ipcParentLink as T, HEAP_RECLAIM_MIN_INTERVAL_MS as Tt, classifyCapRoute as U, hubMainRssBudget as Ut, CapRouteResolver as V, createV8Reclaimer as Vt, callWithServiceDiscovery as W, nextRssBudgetState as Wt, localEndpointPath as X, strandedMb as Xt, SocketChannel as Y, startRunnerHeapWatch as Yt, FrameDecoder as Z, DECISIVE_HEAP_SPACES as Zt, createKernelHwAccel as _, socketDirectionMessages as _n, CapabilityHandle as _t, getWorkerDeviceRegistry as a, selectReportedSpaces as an, setWorkerNativeCapsChangeListener as at, __resetCapUsageRegistryForTests as b, createEventPlaneReader as bn, installManifestNativeDeps as bt, setHubConnected as c, createSocketPlaneMeter as cn, NATIVE_PROVIDER_SERVICE_INFIX as ct, getBrokerEventBus as d, formatSocketPlane as dn, capBareAction as dt, emitHeapDiagnosticReport as en, buildUdsNativeCapProxy as et, getMoleculerEventStats as f, EMPTY_SOCKET_DIRECTION as fn, capServiceName as ft, AddonDepsManager as g, socketDirectionBytes as gn, DeviceRegistry as gt, subscribePassthrough as h, sampleSocketDirection as hn, serializeTypedArrays as ht, createUdsAddonContext as i, readHeapSpaces as in, mountNativeCapService as it, createUdsEventBridge as j, HUB_MAIN_RSS_BUDGET_MB as jt, createHubCapForwardService as k, HEAP_WATCH_WARN_RATIO as kt, EVENT_TOPIC_PREFIX as l, createSocketPlaneReader as ln, capActionName as lt, setNodeEventInterest as m, recordSocketFrame as mn, deserializeTypedArrays as mt, adaptBrokerToCluster as n, heapSnapshotAuthorised as nn, getWorkerNativeCapProvider as nt, getOrInitReadinessRegistry as o, EMPTY_SOCKET_PLANE_BASELINE as on, createAddonService as ot, registerEventBusService as p, createSocketDirectionCounters as pn, parseCapAction as pt, UdsLocalTransportClient as q, shouldReclaim as qt, createAddonContext as r, heapSpaceField as rn, getWorkerNativeCapSnapshot as rt, getOrInitReadinessRegistryForClient as s, SOCKET_PLANE_TOP_N as sn, validateProviderRegistrations as st, installManifestPythonDeps as t, formatHeapSpaces as tn, createBrokerDeviceManagerApi as tt, clusterEventTopic as u, diffSocketPlane as un, capActionSuffix as ut, resolveHwAccel as v, EVENT_PLANE_TOP_N as vn, CapabilityUnavailableError as vt, buildLinkChain as w, createAddonDataPlaneFacility as wt, getCapUsageRegistry as x, diffEventPlane as xn, resolveAddonClass as xt, CapUsageRegistry as y, createEventPlaneMeter as yn, copyBundledNativeModules as yt, AGENT_CAP_FWD_ACTION as z, createDeferredHeapWatchSink as zt };