@camstack/system 1.2.216 → 1.2.218

package/dist/{manifest-system-deps-726RBOX7.mjs → manifest-system-deps-D--wyMD9.mjs}

@@ -13,6 +13,7 @@ import * as os from "node:os";
 import { tmpdir } from "node:os";
 import { createServer } 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";
@@ -511,7 +512,7 @@ var DECISIVE_HEAP_SPACES = ["old_space", "large_object_space"];
 var HEAP_SPACE_REPORT_MIN_MB = 32;
 var BYTES_PER_MB = 1048576;
 /** Whole MB, matching the rest of the `[mem]` line. */
-function mb(bytes) {
+function mb$1(bytes) {
 	return Math.round(bytes / BYTES_PER_MB);
 }
 /** Tenths of an MB — the resolution the SIGUSR2 report has always printed. */
@@ -558,7 +559,7 @@ function heapSpaceField(v8Name) {
 */
 function selectReportedSpaces(spaces, minMb = 32) {
 	const decisive = DECISIVE_HEAP_SPACES.map((name) => spaces.find((space) => space.name === name)).filter((space) => space !== void 0);
-	const rest = spaces.filter((space) => !DECISIVE_HEAP_SPACES.includes(space.name)).filter((space) => mb(space.usedBytes) >= minMb).toSorted((a, b) => b.usedBytes - a.usedBytes || a.name.localeCompare(b.name));
+	const rest = spaces.filter((space) => !DECISIVE_HEAP_SPACES.includes(space.name)).filter((space) => mb$1(space.usedBytes) >= minMb).toSorted((a, b) => b.usedBytes - a.usedBytes || a.name.localeCompare(b.name));
 	return [...decisive, ...rest];
 }
 /**
@@ -573,7 +574,7 @@ function selectReportedSpaces(spaces, minMb = 32) {
 function formatHeapSpaces(spaces, minMb = 32) {
 	const selected = selectReportedSpaces(spaces, minMb);
 	if (selected.length === 0) return "";
-	return ` ${selected.map((s) => `${heapSpaceField(s.name)}=${mb(s.usedBytes)}MB`).join(" ")}`;
+	return ` ${selected.map((s) => `${heapSpaceField(s.name)}=${mb$1(s.usedBytes)}MB`).join(" ")}`;
 }
 var defaultDeps = {
 	readMemory: () => process.memoryUsage(),
@@ -603,6 +604,251 @@ function emitHeapDiagnosticReport(request, deps = defaultDeps) {
 	}
 }
 //#endregion
+//#region src/kernel/array-buffer-census.ts
+/**
+* array-buffer-census — WHAT SHAPE the live ArrayBuffers have, taken by the
+* heartbeat itself when they grow, because nobody can be awake for it.
+*
+* ## The episodes this exists for
+*
+* hub-main, 2026-09-10 (CEST): `arrayBuffers` climbed linearly and released in
+* one instant, twice, with not one line from the process at either boundary —
+* 17:26→18:31 at ~20 MB/min to 1 264 MB, released in one heartbeat; 22:20→23:36
+* at 60–85 MB/min to **4 968 MB**, released between two probes at 23:38. Both
+* were LIVE: a forced compacting GC at 23:36:40 returned 4 968→4 954 MB. The
+* measurement that names their shape had been prepared (D443) and was never
+* run, because it needed a human to run it during the episode, and the
+* episode does not wait. Two hours after the second release the process died
+* on `Ineffective mark-compacts near heap limit`.
+*
+* ## What this is, and what it is NOT
+*
+* `Runtime.queryObjects(ArrayBuffer.prototype)` over an IN-PROCESS inspector
+* session, followed by `Runtime.callFunctionOn` computing a byteLength
+* histogram over the result array, returned BY VALUE. It walks the heap in
+* memory and returns a few hundred bytes of JSON. Nothing is serialised,
+* nothing is written, no file exists afterwards.
+*
+* It is NOT a heap snapshot. `scripts/check-no-heap-dump-command.ts` forbids
+* `writeHeapSnapshot` because a multi-GB serialisation of the heap took the
+* whole host down twice; this module contains no such call and must never
+* grow one. The two look alike only in that both need a GC first.
+*
+* ## What it costs, and why the line says so
+*
+* `queryObjects` forces ONE full garbage collection before it walks — the same
+* stop-the-world the reclaim pass already pays every 10 minutes on this
+* process (~1 s at a 2.5 GB heap). The cost is printed on the line it
+* produces, because a pause with no owner in the log is exactly the kind of
+* stall D181 warns about on the process that mediates every cross-runner call.
+* The gate ({@link createArrayBufferCensusGate}) bounds it: a threshold, held
+* for a sustain window so a burst that dies in the next scavenge never pays,
+* and a generous cooldown so an hour-long episode buys a handful of readings,
+* not one per probe.
+*
+* ## Why the byteLength histogram, and not "who holds them"
+*
+* `queryObjects` returns the objects, not their retainers; a retainer walk is
+* a heap snapshot by another name. But the SIZE distribution already
+* discriminates the candidates that were argued about for a night: 65 536-byte
+* buffers are socket chunks, 8 192-byte ones are Buffer-pool slabs, a few
+* hundred equal multi-megabyte ones are frames or JPEGs, and the count says
+* whether it is thousands of small or dozens of huge. The exact top sizes are
+* printed as well as power-of-two buckets, because "1 462 272 B × 880" names
+* a producer where "≤2 MB: 1.2 GB" does not.
+*/
+/**
+* Take the census once `arrayBuffers` has been at or above this for
+* {@link ARRAY_BUFFER_CENSUS_SUSTAIN_MS}.
+*
+* 512 MB. The two 2026-09-10 episodes crossed it 25 and 8 minutes in; the
+* routine reading in six hours of 2-second samples around them was 18–100 MB
+* with single-sample spikes to 479 MB, and the process's floor after every
+* compaction is 12–18 MB. A dead-buffer sawtooth between major GCs (measured
+* up to 3.65 GB on 2026-08-08 when the heap had 4 GB of headroom) cannot reach
+* it while GC runs every few seconds — and if one did, the census would SAY
+* so: it reports the live total after its own GC next to the raw reading.
+*/
+var ARRAY_BUFFER_CENSUS_THRESHOLD_MB = 512;
+/**
+* How long the reading must stay above the threshold before a census is taken.
+*
+* 60 s = 30 probes at the 2 s cadence. A burst that a scavenge or the next
+* major GC returns never pays a forced GC; an episode climbing at the slowest
+* rate measured (20 MB/min) is still 20 MB higher by the time it is measured,
+* which is nothing against the threshold.
+*/
+var ARRAY_BUFFER_CENSUS_SUSTAIN_MS = 6e4;
+/**
+* Minimum spacing between two censuses.
+*
+* 30 minutes: the second episode ran 76 minutes, so it would have produced
+* three readings — enough to see the shape change (or not) as it grew — at a
+* cost the router already pays six times an hour for the reclaim pass.
+*/
+var ARRAY_BUFFER_CENSUS_COOLDOWN_MS = 30 * 6e4;
+/**
+* A drop of at least this share of the threshold between two consecutive
+* probes, from a reading that had been SUSTAINED above the threshold, is a
+* RELEASE — the boundary both episodes crossed with no line, and the one line
+* that lets the release be correlated with whatever else the process logged
+* that second. Sustained, not merely above: a one-probe spike that the next
+* scavenge sweeps (a 1.3 GB burst in 11 s was measured on 2026-08-29) is not
+* an episode ending, and a WARN for every one of those would bury the line
+* this exists to produce.
+*/
+var ARRAY_BUFFER_RELEASE_MIN_DROP_RATIO = .5;
+/**
+* The pure decision: threshold, sustain, cooldown, release — testable without
+* allocating a gigabyte or forcing a GC.
+*/
+function createArrayBufferCensusGate(options = {}) {
+	const thresholdMb = options.thresholdMb ?? 512;
+	const sustainMs = options.sustainMs ?? 6e4;
+	const cooldownMs = options.cooldownMs ?? 18e5;
+	let aboveSince = null;
+	let lastTakenAt = Number.NEGATIVE_INFINITY;
+	let previousMb = null;
+	let previousAt = null;
+	return { observe(arrayBuffersMb, at) {
+		const previous = previousMb;
+		const previousHeldForMs = previous !== null && previousAt !== null && aboveSince !== null ? previousAt - aboveSince : null;
+		previousMb = arrayBuffersMb;
+		previousAt = at;
+		if (previous !== null && previousHeldForMs !== null && previousHeldForMs >= sustainMs && previous - arrayBuffersMb >= thresholdMb * .5) {
+			aboveSince = null;
+			return {
+				kind: "released",
+				fromMb: previous,
+				toMb: arrayBuffersMb
+			};
+		}
+		if (arrayBuffersMb < thresholdMb) {
+			aboveSince = null;
+			return { kind: "hold" };
+		}
+		aboveSince ??= at;
+		const heldForMs = at - aboveSince;
+		if (heldForMs < sustainMs) return { kind: "hold" };
+		if (at - lastTakenAt < cooldownMs) return { kind: "hold" };
+		lastTakenAt = at;
+		return {
+			kind: "take",
+			reason: `arrayBuffers=${arrayBuffersMb}MB has been >=${thresholdMb}MB for ${heldForMs}ms`
+		};
+	} };
+}
+/**
+* The function evaluated INSIDE the inspector against the `queryObjects`
+* result array (`this`). Kept as source text because that is what the
+* protocol takes; kept small because it runs with the world stopped.
+*/
+var HISTOGRAM_FN = `function () {
+  var byBucket = new Map(), bySize = new Map()
+  var count = 0, bytes = 0, detached = 0
+  for (var i = 0; i < this.length; i++) {
+    var b = this[i].byteLength
+    count++
+    bytes += b
+    if (b === 0) { detached++; continue }
+    var bucket = 1
+    while (bucket < b) bucket *= 2
+    var e = byBucket.get(bucket); if (!e) { e = [0, 0]; byBucket.set(bucket, e) }
+    e[0]++; e[1] += b
+    var s = bySize.get(b); if (!s) { s = [0, 0]; bySize.set(b, s) }
+    s[0]++; s[1] += b
+  }
+  var buckets = []
+  byBucket.forEach(function (v, k) { buckets.push({ upToBytes: k, count: v[0], bytes: v[1] }) })
+  buckets.sort(function (a, b) { return b.bytes - a.bytes })
+  var topSizes = []
+  bySize.forEach(function (v, k) { topSizes.push({ byteLength: k, count: v[0], bytes: v[1] }) })
+  topSizes.sort(function (a, b) { return b.bytes - a.bytes })
+  return { count: count, bytes: bytes, detached: detached,
+    buckets: buckets.slice(0, 6), topSizes: topSizes.slice(0, 5) }
+}`;
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isBucket(value) {
+	return typeof value === "object" && value !== null && isFiniteNumber(Reflect.get(value, "upToBytes")) && isFiniteNumber(Reflect.get(value, "count")) && isFiniteNumber(Reflect.get(value, "bytes"));
+}
+function isExactSize(value) {
+	return typeof value === "object" && value !== null && isFiniteNumber(Reflect.get(value, "byteLength")) && isFiniteNumber(Reflect.get(value, "count")) && isFiniteNumber(Reflect.get(value, "bytes"));
+}
+/** The inspector answers `unknown`; the report is trusted only once it has this shape. */
+function isArrayBufferCensusReport(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const buckets = Reflect.get(value, "buckets");
+	const topSizes = Reflect.get(value, "topSizes");
+	return isFiniteNumber(Reflect.get(value, "count")) && isFiniteNumber(Reflect.get(value, "bytes")) && isFiniteNumber(Reflect.get(value, "detached")) && Array.isArray(buckets) && buckets.every(isBucket) && Array.isArray(topSizes) && topSizes.every(isExactSize);
+}
+function readObjectId(result, path) {
+	let cursor = result;
+	for (const key of path) {
+		if (typeof cursor !== "object" || cursor === null) throw new Error(`inspector reply has no ${path.join(".")}`);
+		cursor = Reflect.get(cursor, key);
+	}
+	if (typeof cursor !== "string") throw new Error(`inspector reply has no ${path.join(".")}`);
+	return cursor;
+}
+/**
+* The real census: an in-process inspector session, opened for the call and
+* closed after it, so no session is left listening between censuses.
+*
+* Every remote object it creates is released before the session closes; a
+* failure anywhere still disconnects. The session is in-process — nothing
+* listens on a port, nothing outside this process can reach it.
+*/
+function createInspectorArrayBufferCensus() {
+	return async () => {
+		const session = new Session();
+		session.connect();
+		try {
+			const prototypeObjectId = readObjectId(await session.post("Runtime.evaluate", { expression: "ArrayBuffer.prototype" }), ["result", "objectId"]);
+			try {
+				const objectId = readObjectId(await session.post("Runtime.queryObjects", { prototypeObjectId }), ["objects", "objectId"]);
+				try {
+					const evaluated = await session.post("Runtime.callFunctionOn", {
+						objectId,
+						functionDeclaration: HISTOGRAM_FN,
+						returnByValue: true
+					});
+					const value = typeof evaluated === "object" && evaluated !== null ? Reflect.get(Reflect.get(evaluated, "result") ?? {}, "value") : void 0;
+					if (!isArrayBufferCensusReport(value)) throw new Error("inspector returned a histogram of an unexpected shape");
+					return value;
+				} finally {
+					await session.post("Runtime.releaseObject", { objectId });
+				}
+			} finally {
+				await session.post("Runtime.releaseObject", { objectId: prototypeObjectId });
+			}
+		} finally {
+			session.disconnect();
+		}
+	};
+}
+var MB$1 = 1048576;
+function mb(bytes) {
+	return Math.round(bytes / MB$1);
+}
+function formatBucket(bucket) {
+	return `<=${bucket.upToBytes >= MB$1 ? `${Math.round(bucket.upToBytes / MB$1)}MB` : bucket.upToBytes >= 1024 ? `${Math.round(bucket.upToBytes / 1024)}KB` : `${bucket.upToBytes}B`}:${bucket.count}x/${mb(bucket.bytes)}MB`;
+}
+function formatExact(size) {
+	return `${size.byteLength}Bx${size.count}=${mb(size.bytes)}MB`;
+}
+/**
+* The census line. `live` is what survived the census's own GC; `raw` is the
+* reading that triggered it — when they disagree by a lot, the growth was dead
+* buffers awaiting a sweep, not a retention, and the line says which.
+*/
+function formatArrayBufferCensus(label, report, context) {
+	const live = mb(report.bytes);
+	const verdict = live < context.rawMb * .5 ? "mostly DEAD buffers awaiting a sweep, not a retention" : "LIVE — something holds them";
+	return `[mem] ${label} arrayBuffer census: live=${live}MB in ${report.count} ArrayBuffers (raw arrayBuffers=${context.rawMb}MB at the trigger → ${verdict}) top sizes: ${report.topSizes.map(formatExact).join(", ") || "(none)"}; buckets: ${report.buckets.map(formatBucket).join(", ") || "(none)"}; detached=${report.detached} took=${context.tookMs}ms — cost: ONE forced full GC (the same pause as a reclaim pass), walked in memory, nothing serialised, nothing written; trigger: ${context.reason}`;
+}
+//#endregion
 //#region src/kernel/heap-watch.ts
 /**
 * heap-watch — hub-main's own memory, on the record, and returned to the OS.
@@ -1288,8 +1534,35 @@ function startHeapWatch(label = HUB_MAIN_HEAP_WATCH_LABEL, sink = consoleSink, i
 			if (previous === "escalated" && mode === "steady") sink.info(`[mem] ${label} heap back to routine — logging every ${intervalMs}ms`);
 			checkRssBudget(sample, at);
 			maybeReclaim(sample);
+			judgeArrayBuffers(sample, at);
 		} catch {}
 	};
+	const censusProbe = probes?.arrayBufferCensus;
+	const censusGate = censusProbe === void 0 ? void 0 : createArrayBufferCensusGate(censusProbe);
+	let censusInFlight = false;
+	const judgeArrayBuffers = (sample, at) => {
+		if (censusProbe === void 0 || censusGate === void 0) return;
+		const verdict = censusGate.observe(sample.arrayBuffersMb, at);
+		if (verdict.kind === "released") {
+			sink.warn(`[mem] ${label} arrayBuffers RELEASED ${verdict.fromMb}MB→${verdict.toMb}MB between two probes ${probeIntervalMs}ms apart — no owner logged this release; whatever held them let go in one instant (a socket that died, a queue that drained, a map that was cleared). Correlate with every line of this process in that window.`);
+			return;
+		}
+		if (verdict.kind !== "take" || censusInFlight) return;
+		censusInFlight = true;
+		const startedAt = now();
+		const rawMb = sample.arrayBuffersMb;
+		censusProbe.census().then((report) => {
+			sink.warn(formatArrayBufferCensus(label, report, {
+				rawMb,
+				tookMs: now() - startedAt,
+				reason: verdict.reason
+			}));
+		}).catch((error) => {
+			sink.warn(`[mem] ${label} arrayBuffer census FAILED after ${now() - startedAt}ms (trigger: ${verdict.reason}) — ${error instanceof Error ? error.message : String(error)}`);
+		}).finally(() => {
+			censusInFlight = false;
+		});
+	};
 	const timer = setInterval(tick, probeIntervalMs);
 	timer.unref?.();
 	tick();
@@ -6868,7 +7141,8 @@ var LocalChildRegistry = class {
 				this.registeredHandler({
 					childId: msg.childId,
 					caps: msg.caps,
-					incarnation
+					incarnation,
+					...msg.customActions !== void 0 ? { customActions: msg.customActions } : {}
 				});
 				return { ok: true };
 			}
@@ -6970,6 +7244,15 @@ var LocalChildClient = class {
 	* subscriptions do), the register carries the real union — even if empty.
 	*/
 	hasDeclaredEventPatterns = false;
+	/**
+	* The custom-action catalogs of every hosted addon, once the runner's init
+	* loop has produced them (`updateCaps(caps, catalogs)` at post-init). `null`
+	* until then, and OMITTED from the register frame while null: the parent
+	* reads absence as "not described yet", and a pre-init register must never
+	* look like "this child declares no actions". Kept on the client so every
+	* later re-register (native-cap change, reconnect) re-carries it unchanged.
+	*/
+	latestCustomActions = null;
 	/** Events and logs queued while the channel is not yet open. */
 	pendingEmits = [];
 	/** Handler for parent→child events. Registered via `onEvent`. */
@@ -7109,12 +7392,7 @@ var LocalChildClient = class {
 			}
 			if (msg.kind === "set-log-level") this.setLogLevelHandler?.(msg.level);
 		});
-		const register = {
-			kind: "register",
-			childId: this.options.childId,
-			caps: this.latestCaps,
-			...this.hasDeclaredEventPatterns ? { eventPatterns: this.latestEventPatterns } : {}
-		};
+		const register = this.registerFrame(this.latestCaps);
 		try {
 			await channel.request(register);
 		} catch (err) {
@@ -7140,16 +7418,26 @@ var LocalChildClient = class {
 	* it (device-restore can race ahead of the UDS connect). After `start()`,
 	* the set is sent immediately.
 	*/
-	async updateCaps(caps) {
+	async updateCaps(caps, customActions) {
 		this.latestCaps = caps;
+		if (customActions !== void 0) this.latestCustomActions = customActions;
 		if (this.channel === null) return;
-		const register = {
+		await this.channel.request(this.registerFrame(caps));
+	}
+	/**
+	* The register frame: caps, plus everything a re-register must atomically
+	* re-carry so no separate re-sync can be missed — the subscription union
+	* (omitted if nothing ever declared, which keeps the fail-open shape) and the
+	* custom-action catalogs (omitted until the init loop produced them).
+	*/
+	registerFrame(caps) {
+		return {
 			kind: "register",
 			childId: this.options.childId,
 			caps,
-			...this.hasDeclaredEventPatterns ? { eventPatterns: this.latestEventPatterns } : {}
+			...this.hasDeclaredEventPatterns ? { eventPatterns: this.latestEventPatterns } : {},
+			...this.latestCustomActions !== null ? { customActions: this.latestCustomActions } : {}
 		};
-		await this.channel.request(register);
 	}
 	/**
 	* Fire-and-forget: send a system event to the parent for forwarding to the
@@ -9886,4 +10174,4 @@ async function defaultRun(command, args) {
 	await execFileAsync(command, [...args], { timeout: INSTALL_TIMEOUT_MS });
 }
 //#endregion
-export { buildUdsNativeCapProxy as $, formatHeapSpaces as $t, createUdsLoggerWithControl as A, HUB_MAIN_RSS_BUDGET_MB as At, readMoleculerFanoutMode as B, createV8Reclaimer as Bt, ipcParentLink as C, createAddonDataPlaneFacility as Ct, createUdsEventBus as D, HEAP_WATCH_INTERVAL_MS as Dt, createUdsEventBridge as E, HEAP_RECLAIM_TRIGGER_MB as Et, AGENT_CAP_FWD_SERVICE as F, RUNNER_RSS_BUDGET_ENV as Ft, createLocalTransport as G, reclaimIntervalMs as Gt, PARENT_ROUTED_PROVIDER_ADDON_ID as H, hubMainRssBudget as Ht, CapRouteResolver as I, ZERO_LOOP_DELAY as It, SocketChannel as J, startRunnerHeapWatch as Jt, UdsLocalTransportClient as K, shouldReclaim as Kt, CapRouteError as L, buildHeapSample as Lt, LocalChildRegistry as M, RSS_BUDGET_REANNOUNCE_MIN_MS as Mt, UDS_NO_ROUTE_PREFIX as N, RSS_BUDGET_RELEASE_RATIO as Nt, udsChildLogToWorkerEntry as O, HEAP_WATCH_WARN_RATIO as Ot, AGENT_CAP_FWD_ACTION as P, RUNNER_HEAP_WATCH_INTERVAL_MS as Pt, buildNativeCapProxy as Q, emitHeapDiagnosticReport as Qt, classifyCapRoute as R, createDeferredHeapWatchSink as Rt, buildLinkChain as S, runNpm as St, createParentUnownedCallHandler as T, HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS as Tt, __resetCapUsageRegistryForTests as U, nextRssBudgetState as Ut, CapUsageRegistry as V, describeRss as Vt, getCapUsageRegistry as W, parseRssBudgetMb as Wt, FrameDecoder as X, DECISIVE_HEAP_SPACES as Xt, localEndpointPath as Y, strandedMb as Yt, encodeFrame as Z, HEAP_SPACE_REPORT_MIN_MB as Zt, AddonDepsManager as _, createEventPlaneReader as _n, CapabilityUnavailableError as _t, createUdsAddonContext as a, createSocketPlaneMeter as an, createAddonService as at, brokerCallForCap as b, resolveAddonClass as bt, getOrInitReadinessRegistryForClient as c, formatSocketPlane as cn, capActionName as ct, clusterEventTopic as d, recordSocketFrame as dn, capServiceName as dt, heapSpaceField as en, createBrokerDeviceManagerApi as et, getBrokerEventBus as f, sampleSocketDirection as fn, parseCapAction as ft, subscribePassthrough as g, createEventPlaneMeter as gn, CapabilityHandle as gt, setNodeEventInterest as h, EVENT_PLANE_TOP_N as hn, DeviceRegistry as ht, createAddonContext as i, SOCKET_PLANE_TOP_N as in, setWorkerNativeCapsChangeListener as it, LocalChildClient as j, HUB_RSS_BUDGET_ENV as jt, createUdsLogger as k, HUB_MAIN_HEAP_WATCH_LABEL as kt, setHubConnected as l, EMPTY_SOCKET_DIRECTION as ln, capActionSuffix as lt, registerEventBusService as m, socketDirectionMessages as mn, serializeTypedArrays as mt, installManifestPythonDeps as n, selectReportedSpaces as nn, getWorkerNativeCapSnapshot as nt, getWorkerDeviceRegistry as o, createSocketPlaneReader as on, validateProviderRegistrations as ot, getMoleculerEventStats as p, socketDirectionBytes as pn, deserializeTypedArrays as pt, UdsLocalTransportServer as q, startHeapWatch as qt, adaptBrokerToCluster as r, EMPTY_SOCKET_PLANE_BASELINE as rn, mountNativeCapService as rt, getOrInitReadinessRegistry as s, diffSocketPlane as sn, NATIVE_PROVIDER_SERVICE_INFIX as st, installManifestSystemDeps as t, readHeapSpaces as tn, getWorkerNativeCapProvider as tt, EVENT_TOPIC_PREFIX as u, createSocketDirectionCounters as un, capBareAction as ut, createKernelHwAccel as v, diffEventPlane as vn, copyBundledNativeModules as vt, localProviderLink as w, HEAP_RECLAIM_MIN_INTERVAL_MS as wt, brokerTransportLink as x, resolveNpmInvocation as xt, resolveHwAccel as y, formatEventPlane as yn, installManifestNativeDeps as yt, callWithServiceDiscovery as z, createLoopDelayMeter as zt };
+export { buildUdsNativeCapProxy as $, ARRAY_BUFFER_RELEASE_MIN_DROP_RATIO as $t, createUdsLoggerWithControl as A, HUB_MAIN_RSS_BUDGET_MB as At, readMoleculerFanoutMode as B, createV8Reclaimer as Bt, ipcParentLink as C, EVENT_PLANE_TOP_N as Cn, createAddonDataPlaneFacility as Ct, createUdsEventBus as D, formatEventPlane as Dn, HEAP_WATCH_INTERVAL_MS as Dt, createUdsEventBridge as E, diffEventPlane as En, HEAP_RECLAIM_TRIGGER_MB as Et, AGENT_CAP_FWD_SERVICE as F, RUNNER_RSS_BUDGET_ENV as Ft, createLocalTransport as G, reclaimIntervalMs as Gt, PARENT_ROUTED_PROVIDER_ADDON_ID as H, hubMainRssBudget as Ht, CapRouteResolver as I, ZERO_LOOP_DELAY as It, SocketChannel as J, startRunnerHeapWatch as Jt, UdsLocalTransportClient as K, shouldReclaim as Kt, CapRouteError as L, buildHeapSample as Lt, LocalChildRegistry as M, RSS_BUDGET_REANNOUNCE_MIN_MS as Mt, UDS_NO_ROUTE_PREFIX as N, RSS_BUDGET_RELEASE_RATIO as Nt, udsChildLogToWorkerEntry as O, HEAP_WATCH_WARN_RATIO as Ot, AGENT_CAP_FWD_ACTION as P, RUNNER_HEAP_WATCH_INTERVAL_MS as Pt, buildNativeCapProxy as Q, ARRAY_BUFFER_CENSUS_THRESHOLD_MB as Qt, classifyCapRoute as R, createDeferredHeapWatchSink as Rt, buildLinkChain as S, socketDirectionMessages as Sn, runNpm as St, createParentUnownedCallHandler as T, createEventPlaneReader as Tn, HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS as Tt, __resetCapUsageRegistryForTests as U, nextRssBudgetState as Ut, CapUsageRegistry as V, describeRss as Vt, getCapUsageRegistry as W, parseRssBudgetMb as Wt, FrameDecoder as X, ARRAY_BUFFER_CENSUS_COOLDOWN_MS as Xt, localEndpointPath as Y, strandedMb as Yt, encodeFrame as Z, ARRAY_BUFFER_CENSUS_SUSTAIN_MS as Zt, AddonDepsManager as _, EMPTY_SOCKET_DIRECTION as _n, CapabilityUnavailableError as _t, createUdsAddonContext as a, HEAP_SPACE_REPORT_MIN_MB as an, createAddonService as at, brokerCallForCap as b, sampleSocketDirection as bn, resolveAddonClass as bt, getOrInitReadinessRegistryForClient as c, heapSpaceField as cn, capActionName as ct, clusterEventTopic as d, EMPTY_SOCKET_PLANE_BASELINE as dn, capServiceName as dt, createArrayBufferCensusGate as en, createBrokerDeviceManagerApi as et, getBrokerEventBus as f, SOCKET_PLANE_TOP_N as fn, parseCapAction as ft, subscribePassthrough as g, formatSocketPlane as gn, CapabilityHandle as gt, setNodeEventInterest as h, diffSocketPlane as hn, DeviceRegistry as ht, createAddonContext as i, DECISIVE_HEAP_SPACES as in, setWorkerNativeCapsChangeListener as it, LocalChildClient as j, HUB_RSS_BUDGET_ENV as jt, createUdsLogger as k, HUB_MAIN_HEAP_WATCH_LABEL as kt, setHubConnected as l, readHeapSpaces as ln, capActionSuffix as lt, registerEventBusService as m, createSocketPlaneReader as mn, serializeTypedArrays as mt, installManifestPythonDeps as n, formatArrayBufferCensus as nn, getWorkerNativeCapSnapshot as nt, getWorkerDeviceRegistry as o, emitHeapDiagnosticReport as on, validateProviderRegistrations as ot, getMoleculerEventStats as p, createSocketPlaneMeter as pn, deserializeTypedArrays as pt, UdsLocalTransportServer as q, startHeapWatch as qt, adaptBrokerToCluster as r, isArrayBufferCensusReport as rn, mountNativeCapService as rt, getOrInitReadinessRegistry as s, formatHeapSpaces as sn, NATIVE_PROVIDER_SERVICE_INFIX as st, installManifestSystemDeps as t, createInspectorArrayBufferCensus as tn, getWorkerNativeCapProvider as tt, EVENT_TOPIC_PREFIX as u, selectReportedSpaces as un, capBareAction as ut, createKernelHwAccel as v, createSocketDirectionCounters as vn, copyBundledNativeModules as vt, localProviderLink as w, createEventPlaneMeter as wn, HEAP_RECLAIM_MIN_INTERVAL_MS as wt, brokerTransportLink as x, socketDirectionBytes as xn, resolveNpmInvocation as xt, resolveHwAccel as y, recordSocketFrame as yn, installManifestNativeDeps as yt, callWithServiceDiscovery as z, createLoopDelayMeter as zt };

package/dist/{retired-settings-keys-BBrgMHDy.mjs → retired-settings-keys-vK_U-CG2.mjs}

@@ -1,4 +1,4 @@
-import { in as asJsonObject } from "./dist-MtqqwJVI.mjs";
+import { an as asJsonObject } from "./dist-DigmGsQS.mjs";
 //#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-CXLIB19R.js → retired-settings-keys-xEAlYnv7.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-DYWqXngV.js");
+const require_dist = require("./dist-BOlMCOeT.js");
 //#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.216",
+  "version": "1.2.218",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",