@camstack/addon-pipeline 1.2.365 → 1.2.367

package/dist/stream-broker/index.js

@@ -3,12 +3,12 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-i4kS_3O7.js");
-const require_node = require("../node-TzgGsCvW.js");
+const require_dist = require("../dist-BmQm6_nm.js");
+const require_node = require("../node-BqTmCMlP.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 const require_retire_root_keys = require("../retire-root-keys-Csb8z2f3.js");
-const require_segment_demux_js = require("../segment-demux-js-C9AYdKkD.js");
+const require_segment_demux_js = require("../segment-demux-js-D1Up0mTP.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");
@@ -22,6 +22,7 @@ let node_fs_promises = require("node:fs/promises");
 let node_url = require("node:url");
 let node_module = require("node:module");
 let _camstack_system_addon_utils = require("@camstack/system/addon-utils");
+let node_v8 = require("node:v8");
 let node_net = require("node:net");
 node_net = require_chunk.__toESM(node_net);
 let node_dgram = require("node:dgram");
@@ -3085,6 +3086,258 @@ var RtpPacketizer = class {
 	}
 };
 //#endregion
+//#region src/stream-broker/stream-broker/broker-mem-probe.ts
+/**
+* broker-mem-probe — what owns the broker runner's NATIVE memory.
+*
+* The runner's `[mem]` heartbeat (`kernel/heap-watch.ts`) says how big the
+* process is; it cannot say who holds it. On the hub, `stream-broker` grew
+* 250 -> 1015 MB in steps while `heapUsed` stayed at ~90 MB and `arrayBuffers`
+* at ~150 MB, so ~600 MB sat outside everything the heartbeat reports. This
+* module is the attribution half: one `[broker-mem]` line every five minutes
+* carrying the kernel's view of the process (RssAnon / RssFile, the `[heap]`
+* brk mapping, the count of anonymous mappings) NEXT TO the broker's own
+* structures (rings, write queues, consumers by kind, egress children), so a
+* step in RSS can be laid against what changed.
+*
+* It is a probe, not a fix: no caps, no allocator tuning, no snapshot. Cost is
+* O(brokers + sessions) per line and O(1) per packet (two integer adds in
+* `copyOwned`). Everything here is a pure function over plain data so the
+* aggregation and the `/proc` parsers are testable on fixture text.
+*/
+var MB = 1024 * 1024;
+/** Cadence of the `[broker-mem]` line — aligned with the runner's `[mem]`. */
+var BROKER_MEM_INTERVAL_MS = 5 * 6e4;
+var copiedPackets = 0;
+var copiedBytes = 0;
+/** O(1) per packet: called by `copyOwned`. No allocation. */
+function recordCopyOwned(bytes) {
+	copiedPackets += 1;
+	copiedBytes += bytes;
+}
+function readCopyOwnedTotals() {
+	return {
+		packets: copiedPackets,
+		bytes: copiedBytes
+	};
+}
+/** `RssAnon:` / `RssFile:` out of `/proc/self/status` text; null when absent. */
+function parseProcStatus(text) {
+	const anon = /^RssAnon:\s+(\d+)\s*kB/m.exec(text);
+	const file = /^RssFile:\s+(\d+)\s*kB/m.exec(text);
+	if (anon === null || file === null) return null;
+	return {
+		rssAnonKb: Number(anon[1]),
+		rssFileKb: Number(file[1])
+	};
+}
+/**
+* Summarise `/proc/self/maps`. Cheaper than `smaps_rollup`'s kernel page walk:
+* the file is one line per mapping and needs no per-page accounting. The
+* `[heap]` figure is the brk extent (virtual), which is the number glibc's
+* main arena grows when fragmented.
+*
+* Line shape: `start-end perms offset dev inode [path]` — an anonymous mapping
+* has no sixth field.
+*/
+function parseProcMaps(text) {
+	let heapBytes = 0;
+	let anonMappings = 0;
+	let anonBytes = 0;
+	let v8PageMaps = 0;
+	let from = 0;
+	while (from < text.length) {
+		let to = text.indexOf("\n", from);
+		if (to === -1) to = text.length;
+		const line = text.slice(from, to);
+		from = to + 1;
+		const dash = line.indexOf("-");
+		const space = line.indexOf(" ");
+		if (dash <= 0 || space <= dash) continue;
+		const size = Number.parseInt(line.slice(dash + 1, space), 16) - Number.parseInt(line.slice(0, dash), 16);
+		if (!Number.isFinite(size)) continue;
+		const path = line.split(/\s+/, 6)[5];
+		if (path === void 0 || path === "") {
+			anonMappings += 1;
+			anonBytes += size;
+			if (size === 262144) v8PageMaps += 1;
+		} else if (path === "[heap]") heapBytes += size;
+	}
+	return {
+		heapBytes,
+		anonMappings,
+		anonBytes,
+		v8PageMaps
+	};
+}
+/** Read the main isolate. Probe tick only: `getHeapSpaceStatistics` walks the spaces. */
+function readV8Heap() {
+	const h = (0, node_v8.getHeapStatistics)();
+	return {
+		totalHeapBytes: h.total_heap_size,
+		physicalBytes: h.total_physical_size,
+		mallocedBytes: h.malloced_memory,
+		peakMallocedBytes: h.peak_malloced_memory,
+		externalBytes: h.external_memory,
+		spaces: (0, node_v8.getHeapSpaceStatistics)().map((x) => ({
+			name: x.space_name,
+			committedBytes: x.space_size
+		}))
+	};
+}
+var SPACE_ABBREVIATIONS = {
+	read_only_space: "ro",
+	old_space: "old",
+	new_space: "new",
+	large_object_space: "lo",
+	new_large_object_space: "nlo",
+	code_space: "code",
+	code_large_object_space: "clo",
+	map_space: "map",
+	shared_space: "shared",
+	shared_large_object_space: "slo",
+	trusted_space: "trusted",
+	trusted_large_object_space: "tlo"
+};
+/** `old:120,new:24,lo:8` — committed MB per space, empty spaces left out. */
+function formatHeapSpaces(spaces) {
+	const parts = spaces.filter((x) => x.committedBytes > 0).map((x) => `${SPACE_ABBREVIATIONS[x.name] ?? x.name}:${Math.round(x.committedBytes / MB)}`);
+	return parts.length === 0 ? "none" : parts.join(",");
+}
+/** Opened/closed consumers since the last reading; `drain()` resets. */
+var ConsumerChurn = class {
+	opened = 0;
+	closed = 0;
+	openedByKind = /* @__PURE__ */ new Map();
+	closedByKind = /* @__PURE__ */ new Map();
+	recordOpen(kind) {
+		this.opened += 1;
+		this.openedByKind.set(kind, (this.openedByKind.get(kind) ?? 0) + 1);
+	}
+	recordClose(kind) {
+		this.closed += 1;
+		this.closedByKind.set(kind, (this.closedByKind.get(kind) ?? 0) + 1);
+	}
+	drain() {
+		const reading = {
+			opened: this.opened,
+			closed: this.closed,
+			openedByKind: Object.fromEntries(this.openedByKind),
+			closedByKind: Object.fromEntries(this.closedByKind)
+		};
+		this.opened = 0;
+		this.closed = 0;
+		this.openedByKind = /* @__PURE__ */ new Map();
+		this.closedByKind = /* @__PURE__ */ new Map();
+		return reading;
+	}
+};
+/** The one churn counter of this process (the broker runner). */
+var consumerChurn = new ConsumerChurn();
+/**
+* Sliding-window limiter for the attach/detach lines. `admit(now)` answers
+* whether this line may be written; the number of lines swallowed since the
+* last admitted one is returned with it so the next line can say so (a branch
+* that drops work names it).
+*/
+function createLineLimiter(maxPerWindow, windowMs) {
+	let windowStart = 0;
+	let inWindow = 0;
+	let suppressed = 0;
+	return (now) => {
+		if (now - windowStart >= windowMs) {
+			windowStart = now;
+			inWindow = 0;
+		}
+		if (inWindow >= maxPerWindow) {
+			suppressed += 1;
+			return {
+				admit: false,
+				suppressedBefore: 0
+			};
+		}
+		inWindow += 1;
+		const suppressedBefore = suppressed;
+		suppressed = 0;
+		return {
+			admit: true,
+			suppressedBefore
+		};
+	};
+}
+var consumerLineLimiter = createLineLimiter(40, 6e4);
+/**
+* One consumer attached to / detached from a broker: counted always (the
+* `[broker-mem]` line reports opened/closed since the last line), written at
+* info under a rate limit so a step in RSS can be matched to an event. The
+* line after a suppressed burst says how many were swallowed.
+*/
+function reportConsumerEvent(logger, event, kind, deviceId, total, now = Date.now()) {
+	if (event === "attach") consumerChurn.recordOpen(kind);
+	else consumerChurn.recordClose(kind);
+	if (logger === void 0 || logger === null) return;
+	const verdict = consumerLineLimiter(now);
+	if (!verdict.admit) return;
+	const suppressed = verdict.suppressedBefore > 0 ? ` suppressedBefore=${verdict.suppressedBefore}` : "";
+	logger.info(`consumer ${event} kind=${kind} total=${total}${suppressed}`, { ...deviceId !== void 0 ? { tags: { deviceId } } : {} });
+}
+function ringBytesOf(s) {
+	return s.preBufferBytes + s.clipBytes + s.rtpRingBytes + s.keyframeCacheBytes;
+}
+function mb(bytes) {
+	return (bytes / MB).toFixed(1);
+}
+function kindList(counts) {
+	const keys = Object.keys(counts).sort();
+	return keys.length === 0 ? "none" : keys.map((k) => `${k}:${counts[k]}`).join(",");
+}
+/** One greppable `key=value` line; no per-device breakdown beyond the top N. */
+function formatBrokerMem(input) {
+	const { samples, proc, churn, copied } = input;
+	const consumers = {};
+	let rtsp = 0;
+	let audio = 0;
+	let pipe = 0;
+	let ingesting = 0;
+	let planes = 0;
+	let pre = 0;
+	let clip = 0;
+	let rtp = 0;
+	let kf = 0;
+	let qSum = 0;
+	let qMax = 0;
+	for (const s of samples) {
+		if (s.ingesting) ingesting += 1;
+		if (s.annexBPlaneActive) planes += 1;
+		rtsp += s.rtspSessions;
+		audio += s.audioSubscribers;
+		pipe += s.pipeClients;
+		pre += s.preBufferBytes;
+		clip += s.clipBytes;
+		rtp += s.rtpRingBytes;
+		kf += s.keyframeCacheBytes;
+		qSum += s.writeQueueSumBytes;
+		if (s.writeQueueMaxBytes > qMax) qMax = s.writeQueueMaxBytes;
+		for (const [kind, n] of Object.entries(s.encodedByKind)) consumers[kind] = (consumers[kind] ?? 0) + n;
+	}
+	const top = [...samples].filter((s) => s.deviceId !== void 0).sort((a, b) => ringBytesOf(b) - ringBytesOf(a)).slice(0, 5).map((s) => `${s.deviceId}:${mb(ringBytesOf(s))}`).join(",");
+	const parts = ["[broker-mem]"];
+	if (proc.status !== null) parts.push(`rssAnonMb=${(proc.status.rssAnonKb / 1024).toFixed(0)}`, `rssFileMb=${(proc.status.rssFileKb / 1024).toFixed(0)}`);
+	if (proc.maps !== null) parts.push(`heapMapMb=${mb(proc.maps.heapBytes)}`, `anonMaps=${proc.maps.anonMappings}`, `anonMapsMb=${mb(proc.maps.anonBytes)}`, `v8PageMaps=${proc.maps.v8PageMaps}`);
+	const v8 = input.v8;
+	if (v8 !== void 0 && v8 !== null) parts.push(`v8TotalHeapMb=${mb(v8.totalHeapBytes)}`, `v8PhysicalMb=${mb(v8.physicalBytes)}`, `v8MallocedMb=${mb(v8.mallocedBytes)}`, `v8PeakMallocedMb=${mb(v8.peakMallocedBytes)}`, `v8ExternalMb=${mb(v8.externalBytes)}`, `spaces=${formatHeapSpaces(v8.spaces)}`);
+	const w = input.worker;
+	if (w !== void 0 && w !== null) parts.push(`workers=${w.workers}`, `workerHeapMb=${mb(w.heapBytes)}`, `workerPhysicalMb=${mb(w.physicalBytes)}`, `workerUsedMb=${mb(w.usedBytes)}`, `workerAgeS=${Math.round(w.maxAgeMs / 1e3)}`, `workerIdleExit=${w.idleTerminates ? "yes" : "never"}`);
+	parts.push(`brokers=${samples.length}`, `ingesting=${ingesting}`, `annexBPlanes=${planes}`, `rtsp=${rtsp}`, `webrtc=${input.webrtcSessions}`, `encoded=${kindList(consumers)}`, `audioSubs=${audio}`, `pipeClients=${pipe}`, `egress=${input.egressTranscodes}`, `children=${input.childProcesses}`, `opened=${churn.opened}`, `closed=${churn.closed}`, `openedKinds=${kindList(churn.openedByKind)}`, `closedKinds=${kindList(churn.closedByKind)}`, `preBufferMb=${mb(pre)}`, `clipMb=${mb(clip)}`, `rtpRingMb=${mb(rtp)}`, `keyframeMb=${mb(kf)}`, `writeQueueSumMb=${mb(qSum)}`, `writeQueueMaxMb=${mb(qMax)}`, `copiedPackets=${copied.packets}`, `copiedMb=${mb(copied.bytes)}`, `topRingMb=${top === "" ? "none" : top}`);
+	return parts.join(" ");
+}
+/** Count entries named `name` in `process.getActiveResourcesInfo()`. */
+function countActiveResources(resources, name) {
+	let n = 0;
+	for (const r of resources) if (r === name) n += 1;
+	return n;
+}
+//#endregion
 //#region src/stream-broker/stream-broker/owned-buffer.ts
 /**
 * Buffers that enter a LONG-LIVED ring own their backing store.
@@ -3144,6 +3397,7 @@ function detachFromPool(buf) {
 function copyOwned(src, start, end) {
 	const owned = Buffer.allocUnsafeSlow(end - start);
 	src.copy(owned, 0, start, end);
+	recordCopyOwned(end - start);
 	return owned;
 }
 //#endregion
@@ -3756,6 +4010,26 @@ var RtspRestreamer = class {
 		for (const session of this.sessions.values()) if (session.isPrestreamIntent()) n += 1;
 		return n;
 	}
+	/**
+	* What this restreamer holds, for the `[broker-mem]` probe: live sessions,
+	* their socket write queues (sum and max) and the keyframe caches. One pass
+	* over the sessions, no allocation beyond the result.
+	*/
+	getMemProbe() {
+		let sum = 0;
+		let max = 0;
+		for (const s of this.sessions.values()) {
+			const q = s.getWriteQueueBytes();
+			sum += q;
+			if (q > max) max = q;
+		}
+		return {
+			sessions: this.sessions.size,
+			writeQueueSumBytes: sum,
+			writeQueueMaxBytes: max,
+			keyframeCacheBytes: this.lastKeyframeNalBytes + this.lastKeyframeRtpBytes
+		};
+	}
 	/** Per-session diagnostic snapshots consumed by `StreamBroker.listClients`. */
 	listSessionInfos() {
 		return [...this.sessions.values()].map((s) => s.getInfo());
@@ -3767,6 +4041,7 @@ var RtspRestreamer = class {
 			streamName: this.streamName,
 			total: this.sessions.size
 		} });
+		reportConsumerEvent(this.logger, "attach", "rtsp", this.deviceId, this.sessions.size);
 		this._onSessionCountChanged?.();
 		this.reconcileSentryAudio();
 		if (this._rtpPassthroughMode) setTimeout(() => this.servePendingSessionsRtp(), 0);
@@ -4231,6 +4506,7 @@ var RtspRestreamer = class {
 			streamName: this.streamName,
 			total: this.sessions.size
 		} });
+		reportConsumerEvent(this.logger, "detach", "rtsp", this.deviceId, this.sessions.size);
 		this._onSessionCountChanged?.();
 		this.reconcileSentryAudio();
 	}
@@ -4500,6 +4776,10 @@ var RtspSession = class {
 			this.onClose?.();
 		});
 	}
+	/** Bytes the socket has accepted but not yet flushed (corked bytes included). */
+	getWriteQueueBytes() {
+		return this.socket.writableLength;
+	}
 	getSessionId() {
 		return this.sessionId;
 	}
@@ -4867,6 +5147,17 @@ var RtspSession = class {
 //#endregion
 //#region src/stream-broker/rtsp/rtsp-listen-server.ts
 /**
+* Attribution of the synthetic consumer a {@link BrokerWarmUp} subscribes:
+* the RTSP listen server holding a cold broker open for a DESCRIBE. Named
+* after that real consumer — it used to subscribe with no attribution and
+* surfaced as `unknown` (45 attach/detach pairs per 5 min on the hub).
+*/
+var RTSP_DESCRIBE_WARMUP_ATTRIBUTION = {
+	kind: "rtsp-listen",
+	label: "describe-warmup",
+	media: "both"
+};
+/**
 * Single TCP server for all RTSP restream connections.
 * Routes clients to the correct RtspRestreamer by a random token path
 * (not the predictable brokerId) for security.
@@ -6453,6 +6744,10 @@ var EgressTranscodeManager = class {
 	/** In-flight starts, keyed by sharing key — concurrent acquires share one. */
 	pending = /* @__PURE__ */ new Map();
 	releaseGraceMs;
+	/** Live egress transcodes (ffmpeg children), for the `[broker-mem]` probe. */
+	activeCount() {
+		return this.entries.size;
+	}
 	constructor(opts) {
 		this.opts = opts;
 		this.releaseGraceMs = opts.releaseGraceMs ?? DEFAULT_RELEASE_GRACE_MS;
@@ -12816,6 +13111,8 @@ var StreamBroker = class StreamBroker {
 	* timeout was chosen against.
 	*/
 	static RTP_ACTIVITY_SWEEP_MS = 1e3;
+	/** A source counts as ingesting when its last video packet is younger than this. */
+	static INGESTING_WITHIN_MS = 1e4;
 	manualStop = false;
 	stopping = false;
 	pipeServer;
@@ -13090,6 +13387,33 @@ var StreamBroker = class StreamBroker {
 		return this.lastPacketAt;
 	}
 	/**
+	* What this broker holds, for the `[broker-mem]` probe (`broker-mem-probe.ts`).
+	* Ring sizes are the rings' own counters (backing-store bytes), so this is
+	* O(sessions + subscribers) and allocates only the result.
+	*/
+	getMemSample(now) {
+		const encodedByKind = {};
+		for (const entry of this.encodedCallbacks.values()) encodedByKind[entry.attribution.kind] = (encodedByKind[entry.attribution.kind] ?? 0) + 1;
+		for (const entry of this.rtpVideoCallbacks.values()) encodedByKind[entry.attribution.kind] = (encodedByKind[entry.attribution.kind] ?? 0) + 1;
+		const rtsp = this.rtspRestreamer.getMemProbe();
+		return {
+			deviceId: this.numericDeviceId,
+			brokerId: this.deviceId,
+			ingesting: this.lastPacketAt > 0 && now - this.lastPacketAt < StreamBroker.INGESTING_WITHIN_MS,
+			preBufferBytes: this.preBuffer.getBufferedBytes(),
+			clipBytes: this.clipBuffer?.getBufferedBytes() ?? 0,
+			rtpRingBytes: this.rtpRingBytes,
+			keyframeCacheBytes: rtsp.keyframeCacheBytes,
+			rtspSessions: rtsp.sessions,
+			writeQueueSumBytes: rtsp.writeQueueSumBytes,
+			writeQueueMaxBytes: rtsp.writeQueueMaxBytes,
+			encodedByKind,
+			audioSubscribers: this.audioChunkPlane.subscriberCount,
+			pipeClients: this.pipeServer.getClientCount(),
+			annexBPlaneActive: this.annexBPlaneActive
+		};
+	}
+	/**
 	* Whether a LAZY publisher is being built right now.
 	*
 	* A consumer deciding whether it is worth waiting for this source needs to
@@ -14052,6 +14376,7 @@ var StreamBroker = class StreamBroker {
 			packetsDelivered: 0
 		};
 		this.encodedCallbacks.set(callback, entry);
+		reportConsumerEvent(this.logger, "attach", attribution.kind, this.numericDeviceId, this.encodedCallbacks.size + this.rtpVideoCallbacks.size);
 		if (this.streamingDebug) this.logger?.info("encoded subscriber added", { meta: {
 			total: this.encodedCallbacks.size,
 			subscriberId: entry.id,
@@ -14062,6 +14387,7 @@ var StreamBroker = class StreamBroker {
 		this.checkDemand();
 		return () => {
 			this.encodedCallbacks.delete(callback);
+			reportConsumerEvent(this.logger, "detach", attribution.kind, this.numericDeviceId, this.encodedCallbacks.size + this.rtpVideoCallbacks.size);
 			if (this.streamingDebug) this.logger?.info("encoded subscriber removed", { meta: {
 				total: this.encodedCallbacks.size,
 				subscriberId: entry.id
@@ -14156,6 +14482,7 @@ var StreamBroker = class StreamBroker {
 			packetsDelivered: 0
 		};
 		this.rtpVideoCallbacks.set(callback, entry);
+		reportConsumerEvent(this.logger, "attach", attribution.kind, this.numericDeviceId, this.encodedCallbacks.size + this.rtpVideoCallbacks.size);
 		if (this.streamingDebug || CH_RTP.on) this.logger?.info("rtp video subscriber added", { meta: {
 			total: this.rtpVideoCallbacks.size,
 			subscriberId: entry.id,
@@ -14165,6 +14492,7 @@ var StreamBroker = class StreamBroker {
 		this.checkDemand();
 		return () => {
 			this.rtpVideoCallbacks.delete(callback);
+			reportConsumerEvent(this.logger, "detach", attribution.kind, this.numericDeviceId, this.encodedCallbacks.size + this.rtpVideoCallbacks.size);
 			if (this.streamingDebug || CH_RTP.on) this.logger?.info("rtp video subscriber removed", { meta: {
 				total: this.rtpVideoCallbacks.size,
 				subscriberId: entry.id
@@ -14565,6 +14893,7 @@ var StreamBroker = class StreamBroker {
 			tag,
 			accept: options?.accept
 		});
+		reportConsumerEvent(this.logger, "attach", "audio-chunks", this.numericDeviceId, this.audioChunkPlane.subscriberCount);
 		this.checkDemand();
 		return result;
 	}
@@ -14575,7 +14904,10 @@ var StreamBroker = class StreamBroker {
 	/** Release an audio-chunk subscription. Returns `true` when it existed. */
 	unsubscribeAudioChunks(subscriptionId) {
 		const released = this.audioChunkPlane.unsubscribe(subscriptionId);
-		if (released) this.checkDemand();
+		if (released) {
+			reportConsumerEvent(this.logger, "detach", "audio-chunks", this.numericDeviceId, this.audioChunkPlane.subscriberCount);
+			this.checkDemand();
+		}
 		return released;
 	}
 	getStats() {
@@ -19402,6 +19734,10 @@ var StreamBrokerManager = class StreamBrokerManager {
 		return { killed: broker.killClient(input.channel, input.handle) };
 	}
 	/** Raw broker instances — internal use only. */
+	/** Live egress transcodes (ffmpeg children) — the `[broker-mem]` probe. */
+	getEgressTranscodeCount() {
+		return this.egressTranscodeManager?.activeCount() ?? 0;
+	}
 	getBrokerInstances() {
 		return [...this.brokers.values()];
 	}
@@ -19668,7 +20004,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 			const sourceBroker = this.brokers.get(sourceBrokerId);
 			if (!sourceBroker) continue;
 			const existingToken = this.persistedTokens.get(profileBrokerId);
-			const warmUp = () => sourceBroker.onEncodedData(() => {});
+			const warmUp = () => sourceBroker.onEncodedData(() => {}, RTSP_DESCRIBE_WARMUP_ATTRIBUTION);
 			const openPrestreamWindow = () => sourceBroker.openPrestreamWindow();
 			this.rtspServer.registerRestreamer(profileBrokerId, sourceBroker.getRtspRestreamer(), warmUp, existingToken, openPrestreamWindow);
 			this.profileRestreamerBindings.set(profileBrokerId, sourceBrokerId);
@@ -21327,7 +21663,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		this.brokers.set(brokerId, broker);
 		this.applyClipRetention(deviceId);
 		const existingToken = this.persistedTokens.get(brokerId);
-		const warmUp = () => broker.onEncodedData(() => {});
+		const warmUp = () => broker.onEncodedData(() => {}, RTSP_DESCRIBE_WARMUP_ATTRIBUTION);
 		const openPrestreamWindow = () => broker.openPrestreamWindow();
 		this.rtspServer.registerRestreamer(brokerId, broker.getRtspRestreamer(), warmUp, existingToken, openPrestreamWindow);
 		if (!existingToken) this.rtspProvider.persistTokens();
@@ -33656,14 +33992,11 @@ function parseWorkerMessage(message) {
 function defaultWorkerFilename() {
 	return (0, node_url.fileURLToPath)(new URL("./demux-worker-child.js", require("url").pathToFileURL(__filename).href));
 }
-/**
-* JS parse that posts each fragment to one process-wide Worker. Concurrent
-* callers are matched by request id; the worker's own event loop serializes
-* mp4box. Live RTP on the parent thread is not waiting on box parsing.
-*/
-function createOffThreadJsParse(deps) {
+/** {@link createOffThreadJsParse} plus the heap accessor the memory probe reads. */
+function createOffThreadDemuxClient(deps) {
 	const Ctor = deps.WorkerCtor;
 	let worker = null;
+	let spawnedAt = 0;
 	let nextId = 1;
 	const pending = /* @__PURE__ */ new Map();
 	const failAll = () => {
@@ -33696,12 +34029,13 @@ function createOffThreadJsParse(deps) {
 			const spawned = new Ctor(deps.workerFilename);
 			attach(spawned);
 			worker = spawned;
+			spawnedAt = Date.now();
 			return spawned;
 		} catch {
 			return null;
 		}
 	};
-	return async (bytes) => {
+	const parse = async (bytes) => {
 		if (!deps.existsSync(deps.workerFilename)) return deps.parseInProcess(bytes);
 		const w = ensureWorker();
 		if (!w) return deps.parseInProcess(bytes);
@@ -33717,9 +34051,36 @@ function createOffThreadJsParse(deps) {
 			w.postMessage(request, [copy.buffer]);
 		});
 	};
+	const readHeaps = async (now = Date.now()) => {
+		const live = worker;
+		const empty = {
+			workers: 0,
+			heapBytes: 0,
+			physicalBytes: 0,
+			usedBytes: 0,
+			maxAgeMs: 0,
+			idleTerminates: false
+		};
+		if (live === null) return empty;
+		const stats = await live.getHeapStatistics?.().catch(() => null);
+		return {
+			...empty,
+			workers: 1,
+			maxAgeMs: Math.max(0, now - spawnedAt),
+			...stats ? {
+				heapBytes: stats.total_heap_size,
+				physicalBytes: stats.total_physical_size,
+				usedBytes: stats.used_heap_size
+			} : {}
+		};
+	};
+	return {
+		parse,
+		readHeaps
+	};
 }
-function defaultOffThreadJsParse() {
-	return createOffThreadJsParse({
+function defaultOffThreadClient() {
+	return createOffThreadDemuxClient({
 		workerFilename: defaultWorkerFilename(),
 		existsSync: node_fs.existsSync,
 		parseInProcess: require_segment_demux_js.demuxSegmentFullJs,
@@ -33729,9 +34090,20 @@ function defaultOffThreadJsParse() {
 var shared;
 /** Process-wide JS parse: one Worker, shared by every WebRTC session. */
 var offThreadJsParse = (bytes) => {
-	shared ??= defaultOffThreadJsParse();
-	return shared(bytes);
+	shared ??= defaultOffThreadClient();
+	return shared.parse(bytes);
 };
+/** Heap of the shared demux worker, for the `[broker-mem]` probe (tick only). */
+async function readDemuxWorkerHeaps(now) {
+	return shared ? shared.readHeaps(now) : {
+		workers: 0,
+		heapBytes: 0,
+		physicalBytes: 0,
+		usedBytes: 0,
+		maxAgeMs: 0,
+		idleTerminates: false
+	};
+}
 /**
 * Drop-in for the session `demuxVideo` hook: JS parse off the live loop,
 * ffmpeg subprocess fallback unchanged.
@@ -35274,6 +35646,7 @@ var BrokerWebrtcServer = class {
 			}
 		};
 		this.sessions.set(sessionId, entry);
+		reportConsumerEvent(this.logger, "attach", `webrtc:${entry.consumerKind}`, entry.rebind?.deviceId, this.sessions.size);
 		session.onClosed = () => this.cleanupSession(sessionId);
 		const locateRecorded = this.locateRecordedSegment;
 		const readRecorded = this.readRecordedSegmentBytes;
@@ -36491,6 +36864,7 @@ var BrokerWebrtcServer = class {
 		const entry = this.sessions.get(sessionId);
 		if (!entry) return;
 		this.sessions.delete(sessionId);
+		reportConsumerEvent(this.logger, "detach", `webrtc:${entry.consumerKind}`, entry.rebind?.deviceId, this.sessions.size);
 		entry.pendingSwitch?.cancel();
 		entry.pendingSwitch = void 0;
 		let brokerStillServed = false;
@@ -37212,6 +37586,47 @@ function dialAnswerFromError(err) {
 	};
 }
 //#endregion
+//#region src/stream-broker/broker-mem-report.ts
+/** Linux only: elsewhere (or on a read error) the native view is simply absent. */
+async function readProc() {
+	if (process.platform !== "linux") return {
+		status: null,
+		maps: null
+	};
+	const [status, maps] = await Promise.all([(0, node_fs_promises.readFile)("/proc/self/status", "utf8").then(parseProcStatus, () => null), (0, node_fs_promises.readFile)("/proc/self/maps", "utf8").then(parseProcMaps, () => null)]);
+	return {
+		status,
+		maps
+	};
+}
+async function emitOnce(deps) {
+	const now = Date.now();
+	const [proc, worker] = await Promise.all([readProc(), readDemuxWorkerHeaps(now)]);
+	const resources = process.getActiveResourcesInfo();
+	const line = formatBrokerMem({
+		samples: deps.manager.getBrokerInstances().map((b) => b.getMemSample(now)),
+		webrtcSessions: deps.webrtcSessions(),
+		egressTranscodes: deps.manager.getEgressTranscodeCount(),
+		childProcesses: countActiveResources(resources, "ProcessWrap"),
+		proc,
+		churn: consumerChurn.drain(),
+		copied: readCopyOwnedTotals(),
+		v8: readV8Heap(),
+		worker
+	});
+	deps.logger.info(line);
+}
+/** Start the five-minute `[broker-mem]` heartbeat; returns its stop function. */
+function startBrokerMemReport(deps) {
+	const timer = setInterval(() => {
+		emitOnce(deps).catch((err) => {
+			deps.logger.warn("broker-mem probe failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		});
+	}, BROKER_MEM_INTERVAL_MS);
+	timer.unref();
+	return () => clearInterval(timer);
+}
+//#endregion
 //#region src/stream-broker/event-loop-stall-monitor.ts
 var DEFAULT_INTERVAL_MS = 100;
 var DEFAULT_THRESHOLD_MS = 250;
@@ -37386,6 +37801,8 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 	*  leaks those sockets and wedges the next runner's werift ICE agent
 	*  (DTLS never connects until a full hub restart). */
 	webrtcServer = null;
+	/** Stops the five-minute `[broker-mem]` attribution heartbeat. */
+	stopBrokerMemReport = null;
 	/** Names this process's event-loop stalls — see onInitialize. */
 	loopStallMonitor = null;
 	/** The `log-channels` provider for this process. Stopped on shutdown so a
@@ -37743,6 +38160,11 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 		this.webrtcServer = webrtcServer;
 		const webrtcSessionProvider = new WebrtcSessionProvider(webrtcServer, this.brokerManager);
 		this.metricsSnapshotTimer = setInterval(() => this.emitBrokerMetricsSnapshot(), BROKER_METRICS_SNAPSHOT_INTERVAL_MS);
+		this.stopBrokerMemReport = startBrokerMemReport({
+			logger: this.ctx.logger,
+			manager: this.brokerManager,
+			webrtcSessions: () => webrtcServer.getSessionCount()
+		});
 		const widgetsProvider = { listWidgets: async () => [{
 			tab: "device-tab",
 			label: "Stream Brokers",
@@ -37847,6 +38269,8 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 	async onShutdown() {
 		this.logChannels?.stop();
 		this.logChannels = null;
+		this.stopBrokerMemReport?.();
+		this.stopBrokerMemReport = null;
 		this.loopStallMonitor?.stop();
 		this.loopStallMonitor = null;
 		this.flushProbeSnapshots(Date.now(), true);