@camstack/system 1.2.288 → 1.2.290

package/dist/{manifest-system-deps-C9T7784z.mjs → manifest-system-deps-D_5UXqDb.mjs}

@@ -1,22 +1,24 @@
+import { C as PEER_BYTES_CHUNK_BYTES } from "./dist-BkjMEa2F.mjs";
 import "./hub-cap-forward-BdT320dq.mjs";
 import * as crypto$1 from "node:crypto";
 import { randomBytes, randomUUID } from "node:crypto";
 import { ensureBinary, ensureFfmpeg, ensurePython, installPythonPackages, installPythonRequirements } from "@camstack/types/node";
-import { unlink } from "node:fs/promises";
+import { mkdir, rm, stat, unlink } from "node:fs/promises";
 import * as path$1 from "node:path";
-import { isAbsolute, join } from "node:path";
+import { dirname, isAbsolute, join } from "node:path";
 import * as fs from "node:fs";
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { createReadStream, createWriteStream, existsSync, readFileSync, readdirSync } from "node:fs";
 import { execFile } from "node:child_process";
 import * as os from "node:os";
 import { tmpdir } from "node:os";
 import { promisify } from "node:util";
-import { createServer } from "node:http";
+import { createServer, request } from "node:http";
 import * as v8 from "node:v8";
 import { Session } from "node:inspector/promises";
 import { monitorEventLoopDelay } from "node:perf_hooks";
 import * as vm from "node:vm";
 import { BOOT_RECOVERY_BACKOFF_MS, DATAPLANE_SECRET_HEADER, DEVICE_CHILDREN_BATCH_MAX, DeviceType, DisposerChain, EventCategory, ReadinessRegistry, asJsonObject, asString, createDeviceProxy, createEventBusSliceSource, deviceOpsCapability, emitReadiness, errMsg, expandCapMethods, readNodePin, scopeKey, sleep, withCapInputDefaults } from "@camstack/types/addon";
+import { once } from "node:events";
 import { connect, createConnection, createServer as createServer$1 } from "node:net";
 import { TRPCClientError, createTRPCClient } from "@trpc/client";
 //#region src/kernel/event-plane-report.ts
@@ -2610,6 +2612,577 @@ function createAddonDataPlaneFacility(args) {
 	};
 }
 //#endregion
+//#region src/kernel/moleculer/addon-peer-bytes-facility.ts
+/**
+* Kernel side of the addon→addon **byte transport** (`ctx.peerBytes`, D613).
+*
+* See {@link AddonPeerBytes} for what this exists for and what it deliberately
+* does not do. This file is the mechanism:
+*
+* - **One lazy loopback listener per addon process.** Bound on the first
+*   `offer()`, never before, so an addon that never offers pays no port.
+* - **One token per offer.** 24 random bytes, base64url, ONE `GET`. A replay
+*   is `offer-used` (410) for as long as the original ticket would have lived,
+*   so a second take is told what happened rather than "no such thing".
+*   `HEAD` answers the headers and consumes nothing.
+* - **Outstanding offers are bounded and swept on every mint**, which is also
+*   what makes a per-frame misuse of this facility refuse by name instead of
+*   working slowly.
+* - **Every write honours `write()`'s return and awaits `drain`** (D447), and
+*   a peer that has taken nothing for {@link PEER_BYTES_STALL_MS} is cut. Every
+*   exit — offered, taken, sent, cut, stalled, refused, disposed — is one log
+*   line, carrying `tags: { deviceId }` when the offer named a device.
+* - **The consumer's response is handed over PAUSED**, which is the whole
+*   reason `open()` lives in the framework rather than in each consumer: see
+*   {@link PeerBytesBody}.
+*/
+/** The HOST a node id belongs to. `hub` → `hub`; `hub/runner-3` → `hub`. */
+function hostNodeIdOf(nodeId) {
+	const slash = nodeId.indexOf("/");
+	return slash === -1 ? nodeId : nodeId.slice(0, slash);
+}
+/** A body chunk, without a cast. A readable in binary mode yields Buffers; in
+*  string mode, strings. Anything else is a broken stream and says so. */
+function asBuffer(chunk) {
+	if (Buffer.isBuffer(chunk)) return chunk;
+	if (typeof chunk === "string") return Buffer.from(chunk);
+	throw new Error("peer-bytes: a body chunk was neither a Buffer nor a string");
+}
+function tokenOf(req) {
+	const raw = req.url ?? "/";
+	const query = raw.indexOf("?");
+	return (query === -1 ? raw : raw.slice(0, query)).replace(/^\/+/, "");
+}
+/**
+* Write `bytes` to `res` in bounded chunks, honouring backpressure.
+*
+* D447, the consuming half stated from the producing side: a raw HTTP stream
+* writes no chunk the socket has not taken. `write()` returning false means the
+* kernel buffer is full and everything further is heap in THIS process — so we
+* wait for `drain`, and a peer that never drains within `stallMs` is cut rather
+* than held. Returns how many bytes reached the socket and why it stopped.
+*/
+async function writeBufferWithBackpressure(res, bytes, stallMs) {
+	const waitForDrain = () => new Promise((resolve) => {
+		const settle = (outcome) => {
+			clearTimeout(timer);
+			res.off("drain", onDrain);
+			res.off("close", onClose);
+			resolve(outcome);
+		};
+		const onDrain = () => {
+			settle("drained");
+		};
+		const onClose = () => {
+			settle("closed");
+		};
+		const timer = setTimeout(() => {
+			settle("stalled");
+		}, stallMs);
+		timer.unref();
+		res.on("drain", onDrain);
+		res.on("close", onClose);
+	});
+	let sent = 0;
+	while (sent < bytes.byteLength) {
+		if (res.destroyed || res.writableEnded) return {
+			sent,
+			outcome: "peer-gone"
+		};
+		const end = Math.min(sent + PEER_BYTES_CHUNK_BYTES, bytes.byteLength);
+		const took = res.write(bytes.subarray(sent, end));
+		sent = end;
+		if (took) continue;
+		const waited = await waitForDrain();
+		if (waited === "drained") continue;
+		return {
+			sent,
+			outcome: waited === "closed" ? "peer-gone" : "stalled"
+		};
+	}
+	return {
+		sent,
+		outcome: "sent"
+	};
+}
+function createAddonPeerBytesFacility(args) {
+	const now = args.now ?? (() => Date.now());
+	const ttlMs = args.ttlMs ?? 3e4;
+	const maxOutstanding = args.maxOutstanding ?? 64;
+	const stallMs = args.stallMs ?? 15e3;
+	const host = args.host ?? "127.0.0.1";
+	const hostNodeId = hostNodeIdOf(args.nodeId);
+	const offers = /* @__PURE__ */ new Map();
+	/** Tokens already taken, kept for their TTL so a replay is `offer-used`. */
+	const taken = /* @__PURE__ */ new Map();
+	let server = null;
+	let baseUrl = null;
+	let listening = null;
+	const sweep = () => {
+		const at = now();
+		for (const [token, offer] of offers) if (offer.expiresAtMs <= at) {
+			offers.delete(token);
+			args.logger.info("peer-bytes: an offer expired untaken", {
+				...offer.deviceId !== void 0 ? { tags: { deviceId: offer.deviceId } } : {},
+				meta: {
+					label: offer.label,
+					outstanding: offers.size
+				}
+			});
+		}
+		for (const [token, expiresAtMs] of taken) if (expiresAtMs <= at) taken.delete(token);
+	};
+	const route = (req, res) => {
+		const token = tokenOf(req);
+		const offer = offers.get(token);
+		if (offer === void 0) {
+			const status = taken.has(token) ? 410 : 404;
+			res.writeHead(status, { "x-camstack-peer-bytes": status === 410 ? "offer-used" : "no-offer" });
+			res.end();
+			return;
+		}
+		if (offer.expiresAtMs <= now()) {
+			offers.delete(token);
+			res.writeHead(410, { "x-camstack-peer-bytes": "offer-expired" }).end();
+			return;
+		}
+		if (req.method === "GET") {
+			offers.delete(token);
+			taken.set(token, offer.expiresAtMs);
+			args.logger.info("peer-bytes: an offer was taken", {
+				...offer.deviceId !== void 0 ? { tags: { deviceId: offer.deviceId } } : {},
+				meta: {
+					label: offer.label,
+					outstanding: offers.size
+				}
+			});
+		}
+		Promise.resolve(offer.handler(req, res)).catch((err) => {
+			args.logger.warn("peer-bytes: an offer handler threw", {
+				...offer.deviceId !== void 0 ? { tags: { deviceId: offer.deviceId } } : {},
+				meta: {
+					label: offer.label,
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+			if (!res.headersSent) res.writeHead(500);
+			res.end();
+		});
+	};
+	const listen = () => {
+		if (listening !== null) return listening;
+		listening = new Promise((resolve, reject) => {
+			const created = createServer((req, res) => {
+				route(req, res);
+			});
+			created.on("error", (err) => {
+				listening = null;
+				reject(err);
+			});
+			created.listen(0, host, () => {
+				const address = created.address();
+				if (address === null || typeof address === "string") {
+					created.close();
+					listening = null;
+					reject(/* @__PURE__ */ new Error("the peer-bytes listener bound no TCP port"));
+					return;
+				}
+				server = created;
+				baseUrl = `http://${host}:${address.port}`;
+				args.logger.info("peer-bytes: listener bound", { meta: {
+					addonId: args.addonId,
+					host,
+					port: address.port,
+					hostNodeId,
+					ttlMs
+				} });
+				resolve(baseUrl);
+			});
+		});
+		return listening;
+	};
+	const mint = async (options) => {
+		sweep();
+		const deviceTags = options.deviceId !== void 0 ? { tags: { deviceId: options.deviceId } } : {};
+		if (offers.size >= maxOutstanding) {
+			args.logger.warn("peer-bytes: offer refused — too many outstanding", {
+				...deviceTags,
+				meta: {
+					label: options.label,
+					outstanding: offers.size,
+					maxOutstanding
+				}
+			});
+			return {
+				kind: "refused",
+				code: "offer-exhausted",
+				detail: `${String(offers.size)} offers outstanding against a bound of ${String(maxOutstanding)}`
+			};
+		}
+		let base;
+		try {
+			base = baseUrl ?? await listen();
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			args.logger.warn("peer-bytes: offer refused — no listener", {
+				...deviceTags,
+				meta: {
+					label: options.label,
+					error: detail
+				}
+			});
+			return {
+				kind: "refused",
+				code: "listener-failed",
+				detail
+			};
+		}
+		const token = randomBytes(24).toString("base64url");
+		const expiresAtMs = now() + (options.ttlMs ?? ttlMs);
+		offers.set(token, {
+			handler: options.handler,
+			label: options.label,
+			deviceId: options.deviceId,
+			expiresAtMs
+		});
+		args.logger.info("peer-bytes: offer minted", {
+			...deviceTags,
+			meta: {
+				label: options.label,
+				declaredBytes: options.declaredBytes ?? null,
+				expiresInMs: expiresAtMs - now(),
+				outstanding: offers.size
+			}
+		});
+		return {
+			kind: "ticket",
+			ticket: {
+				url: `${base}/${token}`,
+				hostNodeId,
+				expiresAtMs,
+				declaredBytes: options.declaredBytes ?? null
+			}
+		};
+	};
+	const peerBytes = {
+		hostNodeId,
+		get outstanding() {
+			sweep();
+			return offers.size;
+		},
+		offer: mint,
+		offerBuffer: async (options) => {
+			const deviceTags = options.deviceId !== void 0 ? { tags: { deviceId: options.deviceId } } : {};
+			const handler = async (req, res) => {
+				res.writeHead(200, {
+					"content-type": options.contentType,
+					"content-length": String(options.bytes.byteLength),
+					"accept-ranges": "none"
+				});
+				if (req.method === "HEAD") {
+					res.end();
+					return;
+				}
+				const startedAt = now();
+				const result = await writeBufferWithBackpressure(res, options.bytes, stallMs);
+				if (result.outcome === "sent") {
+					res.end();
+					args.logger.info("peer-bytes: body sent", {
+						...deviceTags,
+						meta: {
+							label: options.label,
+							bytes: result.sent,
+							tookMs: now() - startedAt,
+							source: "buffer"
+						}
+					});
+					return;
+				}
+				args.logger.warn("peer-bytes: body cut before it was complete", {
+					...deviceTags,
+					meta: {
+						label: options.label,
+						branch: result.outcome,
+						sent: result.sent,
+						of: options.bytes.byteLength,
+						stallMs,
+						source: "buffer"
+					}
+				});
+				res.destroy();
+			};
+			return await mint({
+				handler,
+				label: options.label,
+				declaredBytes: options.bytes.byteLength,
+				...options.deviceId !== void 0 ? { deviceId: options.deviceId } : {},
+				...options.ttlMs !== void 0 ? { ttlMs: options.ttlMs } : {}
+			});
+		},
+		offerFile: async (options) => {
+			const deviceTags = options.deviceId !== void 0 ? { tags: { deviceId: options.deviceId } } : {};
+			let declaredBytes = null;
+			try {
+				declaredBytes = (await stat(options.path)).size;
+			} catch {
+				declaredBytes = null;
+			}
+			const handler = async (req, res) => {
+				const headers = {
+					"content-type": options.contentType,
+					"accept-ranges": "none"
+				};
+				if (declaredBytes !== null) headers["content-length"] = String(declaredBytes);
+				if (req.method === "HEAD") {
+					res.writeHead(200, headers).end();
+					return;
+				}
+				const startedAt = now();
+				let stream;
+				try {
+					stream = createReadStream(options.path);
+					await once(stream, "open");
+				} catch (err) {
+					const detail = err instanceof Error ? err.message : String(err);
+					args.logger.warn("peer-bytes: the offered file could not be opened", {
+						...deviceTags,
+						meta: {
+							label: options.label,
+							error: detail
+						}
+					});
+					if (!res.headersSent) res.writeHead(503, { "x-camstack-peer-bytes": "file-unreadable" });
+					res.end();
+					return;
+				}
+				res.writeHead(200, headers);
+				let sent = 0;
+				let lastProgressAt = now();
+				stream.pipe(res);
+				stream.on("data", (chunk) => {
+					sent += typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.byteLength;
+					lastProgressAt = now();
+				});
+				const stallTimer = setInterval(() => {
+					if (now() - lastProgressAt < stallMs) return;
+					clearInterval(stallTimer);
+					args.logger.warn("peer-bytes: body cut before it was complete", {
+						...deviceTags,
+						meta: {
+							label: options.label,
+							branch: "stalled",
+							sent,
+							stallMs,
+							source: "file"
+						}
+					});
+					stream.destroy();
+					res.destroy();
+				}, Math.max(1e3, Math.floor(stallMs / 4)));
+				stallTimer.unref();
+				const ended = await Promise.race([once(stream, "end").then(() => true), once(res, "close").then(() => false)]).catch(() => false);
+				clearInterval(stallTimer);
+				if (ended) {
+					args.logger.info("peer-bytes: body sent", {
+						...deviceTags,
+						meta: {
+							label: options.label,
+							bytes: sent,
+							tookMs: now() - startedAt,
+							source: "file"
+						}
+					});
+					return;
+				}
+				stream.destroy();
+				args.logger.warn("peer-bytes: body cut before it was complete", {
+					...deviceTags,
+					meta: {
+						label: options.label,
+						branch: "peer-gone",
+						sent,
+						of: declaredBytes,
+						source: "file"
+					}
+				});
+			};
+			return await mint({
+				handler,
+				label: options.label,
+				...declaredBytes !== null ? { declaredBytes } : {},
+				...options.deviceId !== void 0 ? { deviceId: options.deviceId } : {},
+				...options.ttlMs !== void 0 ? { ttlMs: options.ttlMs } : {}
+			});
+		},
+		open: async (ticket) => {
+			if (ticket.hostNodeId !== hostNodeId) {
+				args.logger.warn("peer-bytes: refusing a ticket minted on another node", { meta: {
+					mintedOn: ticket.hostNodeId,
+					here: hostNodeId
+				} });
+				return {
+					kind: "refused",
+					code: "cross-node",
+					detail: `this ticket was minted on node "${ticket.hostNodeId}" and this process runs on "${hostNodeId}" — peer-bytes is loopback only, so there is nothing to dial`
+				};
+			}
+			if (ticket.expiresAtMs <= now()) return {
+				kind: "refused",
+				code: "ticket-expired",
+				detail: `this ticket expired ${String(now() - ticket.expiresAtMs)} ms ago`
+			};
+			let url;
+			try {
+				url = new URL(ticket.url);
+			} catch {
+				return {
+					kind: "refused",
+					code: "ticket-malformed",
+					detail: `"${ticket.url}" is not a URL`
+				};
+			}
+			if (url.protocol !== "http:") return {
+				kind: "refused",
+				code: "ticket-malformed",
+				detail: `peer-bytes dials http, not "${url.protocol}"`
+			};
+			const req = request({
+				hostname: url.hostname,
+				port: url.port,
+				path: url.pathname,
+				method: "GET"
+			});
+			let response;
+			try {
+				response = await new Promise((resolve, reject) => {
+					req.once("response", resolve);
+					req.once("error", reject);
+					req.end();
+				});
+			} catch (err) {
+				const detail = err instanceof Error ? err.message : String(err);
+				req.destroy();
+				args.logger.warn("peer-bytes: the dial failed", { meta: { error: detail } });
+				return {
+					kind: "refused",
+					code: "unreachable",
+					detail
+				};
+			}
+			response.pause();
+			const status = response.statusCode ?? 0;
+			if (status < 200 || status >= 300) {
+				const reason = response.headers["x-camstack-peer-bytes"];
+				response.resume();
+				req.destroy();
+				return {
+					kind: "refused",
+					code: "producer-refused",
+					detail: typeof reason === "string" ? `the producer answered ${String(status)} (${reason})` : `the producer answered ${String(status)}`,
+					status
+				};
+			}
+			const lengthHeader = response.headers["content-length"];
+			const declaredBytes = typeof lengthHeader === "string" && /^\d+$/.test(lengthHeader) ? Number(lengthHeader) : null;
+			const contentTypeHeader = response.headers["content-type"];
+			const stream = response;
+			return {
+				kind: "body",
+				body: {
+					status,
+					contentType: typeof contentTypeHeader === "string" ? contentTypeHeader : null,
+					declaredBytes,
+					stream,
+					cancel: (reason) => {
+						args.logger.info("peer-bytes: the consumer gave up on a body", { meta: { reason } });
+						response.destroy();
+						req.destroy();
+					},
+					writeToFile: async (path, options) => {
+						await mkdir(dirname(path), { recursive: true });
+						const sink = createWriteStream(path);
+						const discard = async () => {
+							sink.destroy();
+							if (!sink.closed) await once(sink, "close").catch(() => void 0);
+							await rm(path, { force: true });
+						};
+						let written = 0;
+						let overrun = false;
+						try {
+							for await (const chunk of stream) {
+								const buf = asBuffer(chunk);
+								written += buf.byteLength;
+								if (written > options.maxBytes) {
+									overrun = true;
+									break;
+								}
+								if (!sink.write(buf)) await once(sink, "drain");
+							}
+						} catch (err) {
+							const detail = err instanceof Error ? err.message : String(err);
+							response.destroy();
+							req.destroy();
+							await discard();
+							return {
+								kind: "refused",
+								code: "transfer-failed",
+								detail,
+								bytes: written
+							};
+						}
+						if (overrun) {
+							response.destroy();
+							req.destroy();
+							await discard();
+							return {
+								kind: "refused",
+								code: "too-large",
+								detail: `the body passed ${String(options.maxBytes)} bytes and was aborted`,
+								bytes: written
+							};
+						}
+						try {
+							sink.end();
+							await once(sink, "close");
+						} catch (err) {
+							const detail = err instanceof Error ? err.message : String(err);
+							await discard();
+							return {
+								kind: "refused",
+								code: "write-failed",
+								detail,
+								bytes: written
+							};
+						}
+						return {
+							kind: "written",
+							bytes: written
+						};
+					}
+				}
+			};
+		}
+	};
+	const dispose = async () => {
+		offers.clear();
+		taken.clear();
+		const open = server;
+		server = null;
+		baseUrl = null;
+		listening = null;
+		if (open === null) return;
+		await new Promise((resolve) => {
+			open.close(() => resolve());
+			open.closeAllConnections();
+		});
+		args.logger.info("peer-bytes: listener closed", { meta: { addonId: args.addonId } });
+	};
+	return {
+		peerBytes,
+		dispose
+	};
+}
+//#endregion
 //#region src/kernel/deps/npm-command.ts
 /**
 * npm invocation resolver — makes "is npm available?" a solved problem for
@@ -11187,6 +11760,12 @@ async function buildAddonContext(runtime, declaration, dataDir, options) {
 		...options?.dataPlaneSink !== void 0 ? { sink: options.dataPlaneSink } : {}
 	});
 	workerDisposerChain.add(() => dataPlaneFacility.dispose());
+	const peerBytesFacility = createAddonPeerBytesFacility({
+		addonId,
+		logger: scopedLogger,
+		nodeId
+	});
+	workerDisposerChain.add(() => peerBytesFacility.dispose());
 	return {
 		id: addonId,
 		logger: scopedLogger,
@@ -11195,6 +11774,7 @@ async function buildAddonContext(runtime, declaration, dataDir, options) {
 		dataDir: addonDataDir,
 		nodeDataDir,
 		dataPlane: dataPlaneFacility.dataPlane,
+		peerBytes: peerBytesFacility.peerBytes,
 		api,
 		deps: new AddonDepsManager(addonDataDir, scopedLogger),
 		settings: settingsView,
@@ -11691,4 +12271,4 @@ async function defaultRun(command, args) {
 	await execFileAsync(command, [...args], { timeout: INSTALL_TIMEOUT_MS });
 }
 //#endregion
-export { buildNativeCapProxy as $, ARRAY_BUFFER_CENSUS_SUSTAIN_MS as $t, createUdsLogger as A, createSocketDirectionCounters as An, HEAP_WATCH_WARN_RATIO as At, UDS_NO_ROUTE_PREFIX as B, createCapActionCensus as Bn, createDeferredHeapWatchSink as Bt, deviceCapResolverLink as C, SOCKET_QUEUE_TOP_N as Cn, resolveNpmInvocation as Ct, createUdsEventBridge as D, formatSocketPlane as Dn, HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS as Dt, createParentUnownedCallHandler as E, diffSocketPlane as En, HEAP_RECLAIM_MIN_INTERVAL_MS as Et, callWithServiceDiscovery as F, CAP_ACTION_OVERFLOW_LABEL as Fn, RSS_BUDGET_RELEASE_RATIO as Ft, getCapUsageRegistry as G, diffEventPlane as Gn, nextRssBudgetState as Gt, CapUsageRegistry as H, EVENT_PLANE_TOP_N as Hn, createV8Reclaimer as Ht, CapRouteError as I, CAP_ACTION_UNLABELLED as In, RUNNER_HEAP_WATCH_INTERVAL_MS as It, UdsLocalTransportServer as J, shouldReclaim as Jt, createLocalTransport as K, formatEventPlane as Kn, parseRssBudgetMb as Kt, classifyCapRoute as L, EMPTY_CAP_ACTION_READING as Ln, RUNNER_RSS_BUDGET_ENV as Lt, AGENT_CAP_FWD_ACTION as M, sampleSocketDirection as Mn, HUB_MAIN_RSS_BUDGET_MB as Mt, AGENT_CAP_FWD_SERVICE as N, socketDirectionBytes as Nn, HUB_RSS_BUDGET_ENV as Nt, createUdsEventBus as O, readSocketQueues as On, HEAP_RECLAIM_TRIGGER_MB as Ot, CapRouteResolver as P, socketDirectionMessages as Pn, RSS_BUDGET_REANNOUNCE_MIN_MS as Pt, encodeFrame as Q, ARRAY_BUFFER_CENSUS_COOLDOWN_MS as Qt, LocalChildClient as R, MAX_CAP_ACTIONS_PER_PEER as Rn, ZERO_LOOP_DELAY as Rt, buildLinkChain as S, SOCKET_PLANE_TOP_N as Sn, buildNpmChildEnv as St, localProviderLink as T, createSocketPlaneReader as Tn, createAddonDataPlaneFacility as Tt, PARENT_ROUTED_PROVIDER_ADDON_ID as U, createEventPlaneMeter as Un, describeRss as Ut, readMoleculerFanoutMode as V, diffCapActionCensus as Vn, createLoopDelayMeter as Vt, __resetCapUsageRegistryForTests as W, createEventPlaneReader as Wn, hubMainRssBudget as Wt, localEndpointPath as X, startRunnerHeapWatch as Xt, SocketChannel as Y, startHeapWatch as Yt, FrameDecoder as Z, strandedMb as Zt, AddonDepsManager as _, formatOutboundQueueVerdict as _n, CapabilityHandle as _t, createUdsAddonContext as a, isArrayBufferCensusReport as an, setWorkerNativeCapsChangeListener as at, brokerCallForCap as b, formatMeshQueue as bn, installManifestNativeDeps as bt, getOrInitReadinessRegistryForClient as c, emitHeapDiagnosticReport as cn, NATIVE_PROVIDER_SERVICE_INFIX as ct, clusterEventTopic as d, readHeapSpaces as dn, capBareAction as dt, ARRAY_BUFFER_CENSUS_THRESHOLD_MB as en, buildUdsNativeCapProxy as et, getBrokerEventBus as f, selectReportedSpaces as fn, capServiceName as ft, subscribePassthrough as g, createOutboundQueueGate as gn, DeviceRegistry as gt, setNodeEventInterest as h, OUTBOUND_QUEUE_THRESHOLD_BYTES as hn, serializeTypedArrays as ht, createAddonContext as i, formatArrayBufferCensus as in, mountNativeCapService as it, createUdsLoggerWithControl as j, recordSocketFrame as jn, HUB_MAIN_HEAP_WATCH_LABEL as jt, udsChildLogToWorkerEntry as k, EMPTY_SOCKET_DIRECTION as kn, HEAP_WATCH_INTERVAL_MS as kt, setHubConnected as l, formatHeapSpaces as ln, capActionName as lt, registerEventBusService as m, OUTBOUND_QUEUE_SUSTAIN_MS as mn, deserializeTypedArrays as mt, installManifestPythonDeps as n, createArrayBufferCensusGate as nn, getWorkerNativeCapProvider as nt, getWorkerDeviceRegistry as o, DECISIVE_HEAP_SPACES as on, createAddonService as ot, getMoleculerEventStats as p, OUTBOUND_QUEUE_COOLDOWN_MS as pn, parseCapAction as pt, UdsLocalTransportClient as q, reclaimIntervalMs as qt, adaptBrokerToCluster as r, createInspectorArrayBufferCensus as rn, getWorkerNativeCapSnapshot as rt, getOrInitReadinessRegistry as s, HEAP_SPACE_REPORT_MIN_MB as sn, validateProviderRegistrations as st, installManifestSystemDeps as t, ARRAY_BUFFER_RELEASE_MIN_DROP_RATIO as tn, createBrokerDeviceManagerApi as tt, EVENT_TOPIC_PREFIX as u, heapSpaceField as un, capActionSuffix as ut, createKernelHwAccel as v, MESH_QUEUE_TOP_N as vn, CapabilityUnavailableError as vt, ipcParentLink as w, createSocketPlaneMeter as wn, runNpm as wt, brokerTransportLink as x, EMPTY_SOCKET_PLANE_BASELINE as xn, resolveAddonClass as xt, resolveHwAccel as y, createMeshQueueReader as yn, copyBundledNativeModules as yt, LocalChildRegistry as z, capActionLabel as zn, buildHeapSample as zt };
+export { buildNativeCapProxy as $, strandedMb as $t, createUdsLogger as A, readSocketQueues as An, HEAP_RECLAIM_TRIGGER_MB as At, UDS_NO_ROUTE_PREFIX as B, MAX_CAP_ACTIONS_PER_PEER as Bn, ZERO_LOOP_DELAY as Bt, deviceCapResolverLink as C, EMPTY_SOCKET_PLANE_BASELINE as Cn, resolveNpmInvocation as Ct, createUdsEventBridge as D, createSocketPlaneReader as Dn, createAddonDataPlaneFacility as Dt, createParentUnownedCallHandler as E, createSocketPlaneMeter as En, hostNodeIdOf as Et, callWithServiceDiscovery as F, socketDirectionBytes as Fn, HUB_RSS_BUDGET_ENV as Ft, getCapUsageRegistry as G, createEventPlaneMeter as Gn, describeRss as Gt, CapUsageRegistry as H, createCapActionCensus as Hn, createDeferredHeapWatchSink as Ht, CapRouteError as I, socketDirectionMessages as In, RSS_BUDGET_REANNOUNCE_MIN_MS as It, UdsLocalTransportServer as J, formatEventPlane as Jn, parseRssBudgetMb as Jt, createLocalTransport as K, createEventPlaneReader as Kn, hubMainRssBudget as Kt, classifyCapRoute as L, CAP_ACTION_OVERFLOW_LABEL as Ln, RSS_BUDGET_RELEASE_RATIO as Lt, AGENT_CAP_FWD_ACTION as M, createSocketDirectionCounters as Mn, HEAP_WATCH_WARN_RATIO as Mt, AGENT_CAP_FWD_SERVICE as N, recordSocketFrame as Nn, HUB_MAIN_HEAP_WATCH_LABEL as Nt, createUdsEventBus as O, diffSocketPlane as On, HEAP_RECLAIM_MIN_INTERVAL_MS as Ot, CapRouteResolver as P, sampleSocketDirection as Pn, HUB_MAIN_RSS_BUDGET_MB as Pt, encodeFrame as Q, startRunnerHeapWatch as Qt, LocalChildClient as R, CAP_ACTION_UNLABELLED as Rn, RUNNER_HEAP_WATCH_INTERVAL_MS as Rt, buildLinkChain as S, formatMeshQueue as Sn, buildNpmChildEnv as St, localProviderLink as T, SOCKET_QUEUE_TOP_N as Tn, createAddonPeerBytesFacility as Tt, PARENT_ROUTED_PROVIDER_ADDON_ID as U, diffCapActionCensus as Un, createLoopDelayMeter as Ut, readMoleculerFanoutMode as V, capActionLabel as Vn, buildHeapSample as Vt, __resetCapUsageRegistryForTests as W, EVENT_PLANE_TOP_N as Wn, createV8Reclaimer as Wt, localEndpointPath as X, shouldReclaim as Xt, SocketChannel as Y, reclaimIntervalMs as Yt, FrameDecoder as Z, startHeapWatch as Zt, AddonDepsManager as _, OUTBOUND_QUEUE_THRESHOLD_BYTES as _n, CapabilityHandle as _t, createUdsAddonContext as a, createInspectorArrayBufferCensus as an, setWorkerNativeCapsChangeListener as at, brokerCallForCap as b, MESH_QUEUE_TOP_N as bn, installManifestNativeDeps as bt, getOrInitReadinessRegistryForClient as c, DECISIVE_HEAP_SPACES as cn, NATIVE_PROVIDER_SERVICE_INFIX as ct, clusterEventTopic as d, formatHeapSpaces as dn, capBareAction as dt, ARRAY_BUFFER_CENSUS_COOLDOWN_MS as en, buildUdsNativeCapProxy as et, getBrokerEventBus as f, heapSpaceField as fn, capServiceName as ft, subscribePassthrough as g, OUTBOUND_QUEUE_SUSTAIN_MS as gn, DeviceRegistry as gt, setNodeEventInterest as h, OUTBOUND_QUEUE_COOLDOWN_MS as hn, serializeTypedArrays as ht, createAddonContext as i, createArrayBufferCensusGate as in, mountNativeCapService as it, createUdsLoggerWithControl as j, EMPTY_SOCKET_DIRECTION as jn, HEAP_WATCH_INTERVAL_MS as jt, udsChildLogToWorkerEntry as k, formatSocketPlane as kn, HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS as kt, setHubConnected as l, HEAP_SPACE_REPORT_MIN_MB as ln, capActionName as lt, registerEventBusService as m, selectReportedSpaces as mn, deserializeTypedArrays as mt, installManifestPythonDeps as n, ARRAY_BUFFER_CENSUS_THRESHOLD_MB as nn, getWorkerNativeCapProvider as nt, getWorkerDeviceRegistry as o, formatArrayBufferCensus as on, createAddonService as ot, getMoleculerEventStats as p, readHeapSpaces as pn, parseCapAction as pt, UdsLocalTransportClient as q, diffEventPlane as qn, nextRssBudgetState as qt, adaptBrokerToCluster as r, ARRAY_BUFFER_RELEASE_MIN_DROP_RATIO as rn, getWorkerNativeCapSnapshot as rt, getOrInitReadinessRegistry as s, isArrayBufferCensusReport as sn, validateProviderRegistrations as st, installManifestSystemDeps as t, ARRAY_BUFFER_CENSUS_SUSTAIN_MS as tn, createBrokerDeviceManagerApi as tt, EVENT_TOPIC_PREFIX as u, emitHeapDiagnosticReport as un, capActionSuffix as ut, createKernelHwAccel as v, createOutboundQueueGate as vn, CapabilityUnavailableError as vt, ipcParentLink as w, SOCKET_PLANE_TOP_N as wn, runNpm as wt, brokerTransportLink as x, createMeshQueueReader as xn, resolveAddonClass as xt, resolveHwAccel as y, formatOutboundQueueVerdict as yn, copyBundledNativeModules as yt, LocalChildRegistry as z, EMPTY_CAP_ACTION_READING as zn, RUNNER_RSS_BUDGET_ENV as zt };