@camstack/system 1.2.217 → 1.2.218

package/dist/kernel/transport/child-cap-protocol.d.ts

@@ -1,4 +1,4 @@
-import { CustomActionCaller, IReadinessRegistryRecord, LogLevel, LogTags, SystemEvent } from '@camstack/types';
+import { ChildCustomActionCatalogs, CustomActionCaller, IReadinessRegistryRecord, LogLevel, LogTags, SystemEvent } from '@camstack/types';
 /**
  * Routing descriptor a child sends so the parent can route cap calls to it.
  * The provider implementation never crosses the wire — only these keys do.
@@ -35,6 +35,18 @@ export interface RegisterMessage {
      * `EventSubUpdateMessage` for post-boot updates.
      */
     readonly eventPatterns?: readonly string[];
+    /**
+     * Custom-action catalogs of the addons this child hosts, keyed by addon id,
+     * with the Zod schemas stripped — see `CustomActionDescriptor`. Carried IN
+     * the register frame for the same reason as `eventPatterns`: the parent
+     * learns it race-free, at the post-init re-register, FROM THE PROCESS THAT
+     * OWNS THE ADDON. It is never learned by evaluating the addon's bundle in the
+     * parent (D444: ten 9 MB evaluations in hub-main, none of which produced a
+     * catalog, and every one pinned the evicted graph's module-scope state).
+     * OPTIONAL: absent from the pre-init register (the catalogs do not exist yet)
+     * and from a legacy child; absent means "not described yet", never "none".
+     */
+    readonly customActions?: ChildCustomActionCatalogs;
 }
 /**
  * Child → parent, fire-and-forget: the child's category-pattern subscription
@@ -248,6 +260,8 @@ export interface RegisteredChild {
      * one. See docs/decisions/adr-0188-an-unregister-carries-proof-of-ownership.md.
      */
     readonly incarnation: number;
+    /** See {@link RegisterMessage.customActions}. Absent = not described yet. */
+    readonly customActions?: ChildCustomActionCatalogs;
 }
 /** Arguments to route a cap method call (the `cap-call` message minus its discriminant). */
 export type CapCallInput = Omit<CapCallMessage, 'kind'>;

package/dist/kernel/transport/local-child-client.d.ts

@@ -1,4 +1,4 @@
-import { IReadinessRegistryRecord, SystemEvent } from '@camstack/types';
+import { ChildCustomActionCatalogs, IReadinessRegistryRecord, SystemEvent } from '@camstack/types';
 import { AddonCallInput, CapCallInput, ChildCapDescriptor, ChildLogMessage } from './child-cap-protocol.js';
 export interface LocalChildClientOptions {
     /** Parent node id — selects the UDS endpoint this child connects to. */
@@ -56,6 +56,15 @@ export declare class LocalChildClient {
      * subscriptions do), the register carries the real union — even if empty.
      */
     private hasDeclaredEventPatterns;
+    /**
+     * 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.
+     */
+    private latestCustomActions;
     /** Events and logs queued while the channel is not yet open. */
     private readonly pendingEmits;
     /** Handler for parent→child events. Registered via `onEvent`. */
@@ -138,7 +147,14 @@ export declare class LocalChildClient {
      * it (device-restore can race ahead of the UDS connect). After `start()`,
      * the set is sent immediately.
      */
-    updateCaps(caps: readonly ChildCapDescriptor[]): Promise<void>;
+    updateCaps(caps: readonly ChildCapDescriptor[], customActions?: ChildCustomActionCatalogs): Promise<void>;
+    /**
+     * 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).
+     */
+    private registerFrame;
     /**
      * Fire-and-forget: send a system event to the parent for forwarding to the
      * hub event bus. Safe to call before `start()` — events are buffered and

package/dist/{manifest-system-deps-DvY1bY_n.js → manifest-system-deps-Bo92lg5u.js}

@@ -15,6 +15,7 @@ node_os = require_chunk.__toESM(node_os);
 let node_http = require("node:http");
 let node_v8 = require("node:v8");
 node_v8 = require_chunk.__toESM(node_v8);
+let node_inspector_promises = require("node:inspector/promises");
 let node_perf_hooks = require("node:perf_hooks");
 let node_vm = require("node:vm");
 node_vm = require_chunk.__toESM(node_vm);
@@ -514,7 +515,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. */
@@ -561,7 +562,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];
 }
 /**
@@ -576,7 +577,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(),
@@ -606,6 +607,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 node_inspector_promises.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.
@@ -1291,8 +1537,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();
@@ -6871,7 +7144,8 @@ var LocalChildRegistry = class {
 				this.registeredHandler({
 					childId: msg.childId,
 					caps: msg.caps,
-					incarnation
+					incarnation,
+					...msg.customActions !== void 0 ? { customActions: msg.customActions } : {}
 				});
 				return { ok: true };
 			}
@@ -6973,6 +7247,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`. */
@@ -7112,12 +7395,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) {
@@ -7143,16 +7421,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
@@ -9901,6 +10189,30 @@ Object.defineProperty(exports, "AGENT_CAP_FWD_SERVICE", {
 		return AGENT_CAP_FWD_SERVICE;
 	}
 });
+Object.defineProperty(exports, "ARRAY_BUFFER_CENSUS_COOLDOWN_MS", {
+	enumerable: true,
+	get: function() {
+		return ARRAY_BUFFER_CENSUS_COOLDOWN_MS;
+	}
+});
+Object.defineProperty(exports, "ARRAY_BUFFER_CENSUS_SUSTAIN_MS", {
+	enumerable: true,
+	get: function() {
+		return ARRAY_BUFFER_CENSUS_SUSTAIN_MS;
+	}
+});
+Object.defineProperty(exports, "ARRAY_BUFFER_CENSUS_THRESHOLD_MB", {
+	enumerable: true,
+	get: function() {
+		return ARRAY_BUFFER_CENSUS_THRESHOLD_MB;
+	}
+});
+Object.defineProperty(exports, "ARRAY_BUFFER_RELEASE_MIN_DROP_RATIO", {
+	enumerable: true,
+	get: function() {
+		return ARRAY_BUFFER_RELEASE_MIN_DROP_RATIO;
+	}
+});
 Object.defineProperty(exports, "AddonDepsManager", {
 	enumerable: true,
 	get: function() {
@@ -10231,6 +10543,12 @@ Object.defineProperty(exports, "createAddonService", {
 		return createAddonService;
 	}
 });
+Object.defineProperty(exports, "createArrayBufferCensusGate", {
+	enumerable: true,
+	get: function() {
+		return createArrayBufferCensusGate;
+	}
+});
 Object.defineProperty(exports, "createBrokerDeviceManagerApi", {
 	enumerable: true,
 	get: function() {
@@ -10255,6 +10573,12 @@ Object.defineProperty(exports, "createEventPlaneReader", {
 		return createEventPlaneReader;
 	}
 });
+Object.defineProperty(exports, "createInspectorArrayBufferCensus", {
+	enumerable: true,
+	get: function() {
+		return createInspectorArrayBufferCensus;
+	}
+});
 Object.defineProperty(exports, "createKernelHwAccel", {
 	enumerable: true,
 	get: function() {
@@ -10369,6 +10693,12 @@ Object.defineProperty(exports, "encodeFrame", {
 		return encodeFrame;
 	}
 });
+Object.defineProperty(exports, "formatArrayBufferCensus", {
+	enumerable: true,
+	get: function() {
+		return formatArrayBufferCensus;
+	}
+});
 Object.defineProperty(exports, "formatEventPlane", {
 	enumerable: true,
 	get: function() {
@@ -10471,6 +10801,12 @@ Object.defineProperty(exports, "ipcParentLink", {
 		return ipcParentLink;
 	}
 });
+Object.defineProperty(exports, "isArrayBufferCensusReport", {
+	enumerable: true,
+	get: function() {
+		return isArrayBufferCensusReport;
+	}
+});
 Object.defineProperty(exports, "localEndpointPath", {
 	enumerable: true,
 	get: function() {