@camstack/addon-pipeline 1.2.140 → 1.2.142

package/dist/stream-broker/index.js

@@ -174,6 +174,25 @@ var CH_RTP = require_dist.declareLogChannel({
 	defaultLevel: "info",
 	perDevice: false
 });
+/**
+* Every channel this addon declares, as a VALUE.
+*
+* `addon.ts` used to reach the declarations through a bare
+* `import './log-channels.js'` — an import with no binding, kept alive only by
+* a comment saying "never drop this as unused". On 2026-08-29 the shipped
+* bundle contained this module TWICE: inlined into `stream-broker/index.mjs`
+* and again in a shared chunk that same entry statically imports. Loading the
+* addon ran `declareLogChannel` twice, the duplicate was refused — correctly,
+* that guard is doing its job — and the whole stream-broker failed to load.
+* The hub had no broker and no live streams until it was rolled back.
+*
+* The duplication has NOT been reproduced since, from a clean dist or a dirty
+* one, so this is not offered as a proven fix: it removes the freedom the
+* bundler took. A value binding must resolve to one module instance; a
+* side-effect import need not. `scripts/check-log-channel-single-declaration.ts`
+* is the part that actually holds, because it reads the artefact.
+*/
+var STREAM_BROKER_LOG_CHANNELS = [CH_WEBRTC, CH_RTP];
 //#endregion
 //#region src/stream-broker/stream-broker/probed-summary.ts
 /**
@@ -1821,15 +1840,32 @@ var DEFAULT_RECORDING_PRE_ROLL_MS = 1e4;
 */
 var PRE_ROLL_UNKNOWN_BITRATE_BYTES = 8 * 1024 * 1024;
 /**
-* Absolute per-stream ceiling on retained pre-roll history.
+* Hard ceiling on the WHOLE source-RTP ring (history + the current GOP).
+*
+* Lives here, next to the pre-roll budget, because the two numbers are one
+* number: a history budget above the ring cap is not a wider window, it is a
+* ring that overflows and calls `resetRtpPreBuffer`, which drops the join
+* bootstrap of EVERY consumer — WebRTC viewers included — for as long as the
+* condition holds. Keeping them in separate files is how they came to disagree.
+* Read by `StreamBroker.captureRtpForPreBuffer`.
+*/
+var RTP_RING_MAX_BYTES = 24 * 1024 * 1024;
+/**
+* Absolute per-stream ceiling on retained pre-roll HISTORY.
 *
 * The bitrate-derived budget is what the window COSTS; this is the most any one
-* stream may spend regardless. 32 MiB is 4x the flat cap it replaces and covers
-* 15 s of a 16 Mbps stream with headroom; past it the operator has configured a
-* window this node cannot afford on that camera, and the broker says so rather
-* than delivering silently less (D192).
+* stream may spend regardless. Past it the operator has configured a window this
+* node cannot afford on that camera, and the broker says so rather than
+* delivering silently less (D192).
+*
+* **DERIVED, not chosen.** It was a free-standing `32 * 1024 * 1024` — 8 MiB
+* ABOVE the ring it has to fit inside. A ≳13 Mbps stream at a 10 s window was
+* therefore authorised to overflow its own ring and cycle `resetRtpPreBuffer`:
+* the pre-roll knob, turned up, would have taken every viewer's join bootstrap
+* with it. Deriving it from {@link RTP_RING_MAX_BYTES} minus the current-GOP
+* reserve makes the inversion unrepresentable rather than merely fixed.
 */
-var PRE_ROLL_ABSOLUTE_MAX_BYTES = 32 * 1024 * 1024;
+var PRE_ROLL_ABSOLUTE_MAX_BYTES = RTP_RING_MAX_BYTES - 8 * 1024 * 1024;
 /**
 * Headroom over the OBSERVED mean bitrate.
 *
@@ -1859,7 +1895,7 @@ function preRollBudgetBytes(windowMs, observedKbps) {
 		clamped: false
 	};
 	const raw = Math.round(windowMs * observedKbps * PRE_ROLL_BITRATE_HEADROOM / 8);
-	if (raw > 33554432) return {
+	if (raw > 16777216) return {
 		bytes: PRE_ROLL_ABSOLUTE_MAX_BYTES,
 		clamped: true
 	};
@@ -2868,6 +2904,12 @@ var RtspRestreamer = class {
 	*/
 	servePendingSessionsRtp() {
 		if (this.pendingKeyframe.size === 0) return;
+		const ready = [];
+		for (const sessionId of this.pendingKeyframe) {
+			if (this.activeReplays.has(sessionId)) continue;
+			if (this.sessions.get(sessionId)?.isPlaying()) ready.push(sessionId);
+		}
+		if (ready.length === 0) return;
 		const ringPackets = this.rtpPreBufferSupplier?.() ?? [];
 		const fromRing = ringPackets.length > 0;
 		const primePackets = fromRing ? ringPackets.map((data) => ({
@@ -2877,12 +2919,6 @@ var RtspRestreamer = class {
 		if (primePackets.length === 0) return;
 		const firstTs = primePackets[0].data.readUInt32BE(4);
 		const spanMs = (primePackets[primePackets.length - 1].data.readUInt32BE(4) - firstTs | 0) / 90;
-		const ready = [];
-		for (const sessionId of this.pendingKeyframe) {
-			if (this.activeReplays.has(sessionId)) continue;
-			if (this.sessions.get(sessionId)?.isPlaying()) ready.push(sessionId);
-		}
-		if (ready.length === 0) return;
 		const preRollPlans = /* @__PURE__ */ new Map();
 		const bound = this.currentPrimeBound();
 		/**
@@ -3509,15 +3545,7 @@ var RtspSession = class {
 				return "closed-backlog";
 			}
 		}
-		const channel = this.tracks[0].rtpChannel;
-		const frame = Buffer.allocUnsafe(4 + packet.data.length);
-		frame[0] = 36;
-		frame[1] = channel;
-		frame.writeUInt16BE(packet.data.length, 2);
-		packet.data.copy(frame, 4);
-		this.socket.write(frame);
-		this.lastRtpAt = Date.now();
-		this.bytesSent += frame.length;
+		this.writeInterleaved(this.tracks[0].rtpChannel, packet.data);
 		return "written";
 	}
 	/** Send an audio RTP packet via TCP interleaved framing on the audio track channel. */
@@ -3528,17 +3556,60 @@ var RtspSession = class {
 			this.close();
 			return "closed-backlog";
 		}
-		const channel = this.tracks[1].rtpChannel;
-		const frame = Buffer.allocUnsafe(4 + packet.data.length);
-		frame[0] = 36;
-		frame[1] = channel;
-		frame.writeUInt16BE(packet.data.length, 2);
-		packet.data.copy(frame, 4);
-		this.socket.write(frame);
-		this.lastRtpAt = Date.now();
-		this.bytesSent += frame.length;
+		this.writeInterleaved(this.tracks[1].rtpChannel, packet.data);
 		return "written";
 	}
+	/**
+	* Write ONE interleaved frame as a 4-byte header plus the caller's payload,
+	* **shared by reference** — the payload is never copied.
+	*
+	* ## Why this is the whole point
+	*
+	* This used to be `Buffer.allocUnsafe(4 + payload.length)` + `payload.copy()`:
+	* a FULL copy of every packet, once per connected session, to prepend four
+	* constant bytes. At ~3 000 pps ingest and 2–3 sessions per broker (detection
+	* dial, recording dial, egress legs) that is ~6 000–9 000 full-packet
+	* allocations per second, and `stream-broker` was measured at 95.5 % of a core
+	* with **68 % of it in GC**. Scrypted's prebuffer — same fundamental ring
+	* design — writes the header and the shared payload as two writes and does
+	* exactly one allocation per packet, total, for every consumer. This closes
+	* that gap. N connected clients now cause ONE payload allocation (the ingest
+	* copy), not N.
+	*
+	* ## Why sharing the payload is safe, and what would make it unsafe
+	*
+	* The payload buffer handed here is ALREADY retained, by reference, in the
+	* broker's `rtpRing` for the life of a GOP (`captureRtpForPreBuffer` pushes
+	* the same object). A pending `socket.write` cannot outlive that, so the
+	* lifetime requirement this adds is strictly weaker than one the broker
+	* already meets. Its provenance is a private allocation per packet —
+	* `Buffer.from(readBuffer.subarray(...))` in `rtsp-client.ts`'s `onData`, for
+	* video and audio alike — never a view of the reader's socket buffer, which
+	* advances on the next read. Nothing in the broker writes into a captured
+	* packet: every mutation in this path targets a freshly allocated buffer.
+	*
+	* The rule to keep: **`socket.write` forbids MUTATION before the write
+	* completes, not retention.** So the header, which IS built per call, must
+	* stay a fresh allocation — a reused 4-byte scratch buffer would be rewritten
+	* under an in-flight write and corrupt the frame length of a packet already
+	* queued. Four bytes from the Buffer pool is a pointer bump; the copy this
+	* replaces was ~1.4 KB.
+	*
+	* `cork`/`uncork` keeps the pair a single `writev` syscall, so removing the
+	* copy does not buy an extra write syscall per packet.
+	*/
+	writeInterleaved(channel, payload) {
+		const header = Buffer.allocUnsafe(4);
+		header[0] = 36;
+		header[1] = channel;
+		header.writeUInt16BE(payload.length, 2);
+		this.socket.cork();
+		this.socket.write(header);
+		this.socket.write(payload);
+		this.socket.uncork();
+		this.lastRtpAt = Date.now();
+		this.bytesSent += 4 + payload.length;
+	}
 	close() {
 		if (this.closed) return;
 		this.closed = true;
@@ -8550,8 +8621,6 @@ var Rfc4571Reader = class {
 		}
 	}
 };
-//#endregion
-//#region src/stream-broker/rtsp/rtp-depacketizer.ts
 var H264_NAL_SPS = 7;
 var H264_NAL_PPS = 8;
 var H264_NAL_IDR = 5;
@@ -8563,6 +8632,29 @@ var H265_NAL_IRAP_MIN = 16;
 var H265_NAL_IRAP_MAX = 21;
 var H265_NAL_AP = 48;
 /**
+* Allocate a NAL buffer of `byteLength` payload bytes with the 4-byte Annex-B
+* start code already written into reserved leading headroom.
+*
+* The caller fills from {@link ANNEXB_START_CODE_LENGTH} onwards. This is the
+* single place a start code is produced on the ingest path — the broker used to
+* build one with `Buffer.from([0, 0, 0, 1])` per NAL and then concat it onto a
+* NAL this function had already allocated, which copied every NAL twice.
+*/
+function allocAnnexBNal(byteLength) {
+	const buf = Buffer.allocUnsafe(4 + byteLength);
+	buf[0] = 0;
+	buf[1] = 0;
+	buf[2] = 0;
+	buf[3] = 1;
+	return buf;
+}
+/** Total byte length of the reassembly fragments, without allocating a closure. */
+function totalFragmentBytes(fragments) {
+	let total = 0;
+	for (const fragment of fragments) total += fragment.length;
+	return total;
+}
+/**
 * RTP → Annex-B NAL depacketizer.
 *
 * Takes raw RTP packets (as received from TCP interleaved RTSP) and
@@ -8614,7 +8706,7 @@ var RtpDepacketizer = class {
 	}
 	processH264(payload, timestamp, marker) {
 		const nalType = payload[0] & 31;
-		if (nalType >= 1 && nalType <= 23) this.emitNal(payload, timestamp, marker);
+		if (nalType >= 1 && nalType <= 23) this.emitNal(this.copyIntoAnnexB(payload), timestamp, marker);
 		else if (nalType === H264_NAL_STAP_A) this.processH264StapA(payload, timestamp, marker);
 		else if (nalType === 28) this.processH264FuA(payload, timestamp, marker);
 	}
@@ -8625,7 +8717,8 @@ var RtpDepacketizer = class {
 			const nalSize = payload.readUInt16BE(offset);
 			offset += 2;
 			if (offset + nalSize > payload.length) break;
-			const nal = Buffer.from(payload.subarray(offset, offset + nalSize));
+			const nal = allocAnnexBNal(nalSize);
+			payload.copy(nal, 4, offset, offset + nalSize);
 			offset += nalSize;
 			this.emitNal(nal, timestamp, marker && offset >= payload.length);
 		}
@@ -8645,10 +8738,9 @@ var RtpDepacketizer = class {
 		} else if (this.fuBuffer.length > 0 && this.fuTimestamp === timestamp) {
 			this.fuBuffer.push(payload.subarray(2));
 			if (isEnd) {
-				const totalSize = this.fuBuffer.reduce((sum, b) => sum + b.length, 0);
-				const nal = Buffer.allocUnsafe(1 + totalSize);
-				nal[0] = this.fuFirstByte;
-				let offset = 1;
+				const nal = allocAnnexBNal(1 + totalFragmentBytes(this.fuBuffer));
+				nal[4] = this.fuFirstByte;
+				let offset = 5;
 				for (const fragment of this.fuBuffer) {
 					fragment.copy(nal, offset);
 					offset += fragment.length;
@@ -8661,7 +8753,7 @@ var RtpDepacketizer = class {
 	processH265(payload, timestamp, marker) {
 		if (payload.length < 2) return;
 		const nalType = payload[0] >> 1 & 63;
-		if (nalType < 48) this.emitNal(payload, timestamp, marker);
+		if (nalType < 48) this.emitNal(this.copyIntoAnnexB(payload), timestamp, marker);
 		else if (nalType === H265_NAL_AP) this.processH265Ap(payload, timestamp, marker);
 		else if (nalType === 49) this.processH265Fu(payload, timestamp, marker);
 	}
@@ -8672,7 +8764,8 @@ var RtpDepacketizer = class {
 			const nalSize = payload.readUInt16BE(offset);
 			offset += 2;
 			if (offset + nalSize > payload.length) break;
-			const nal = Buffer.from(payload.subarray(offset, offset + nalSize));
+			const nal = allocAnnexBNal(nalSize);
+			payload.copy(nal, 4, offset, offset + nalSize);
 			offset += nalSize;
 			this.emitNal(nal, timestamp, marker && offset >= payload.length);
 		}
@@ -8694,10 +8787,9 @@ var RtpDepacketizer = class {
 		} else if (this.fuBuffer.length > 0 && this.fuTimestamp === timestamp) {
 			this.fuBuffer.push(payload.subarray(3));
 			if (isEnd && this.fuH265Header) {
-				const totalSize = this.fuBuffer.reduce((sum, b) => sum + b.length, 0);
-				const nal = Buffer.allocUnsafe(2 + totalSize);
-				this.fuH265Header.copy(nal, 0);
-				let offset = 2;
+				const nal = allocAnnexBNal(2 + totalFragmentBytes(this.fuBuffer));
+				this.fuH265Header.copy(nal, 4);
+				let offset = 6;
 				for (const fragment of this.fuBuffer) {
 					fragment.copy(nal, offset);
 					offset += fragment.length;
@@ -8711,11 +8803,24 @@ var RtpDepacketizer = class {
 			this.fuH265Header = null;
 		}
 	}
-	emitNal(nal, timestamp, marker) {
+	/** Copy a payload view into a fresh Annex-B buffer (start code + payload). */
+	copyIntoAnnexB(payload) {
+		const buf = allocAnnexBNal(payload.length);
+		payload.copy(buf, 4);
+		return buf;
+	}
+	/**
+	* @param annexB the NAL WITH its 4-byte start code already in front — every
+	* caller builds it that way via {@link allocAnnexBNal}, so `nal` below is a
+	* free view rather than a second allocation.
+	*/
+	emitNal(annexB, timestamp, marker) {
+		const nal = annexB.subarray(4);
 		const keyframe = this.codec === "h264" ? this.isH264Keyframe(nal) : this.isH265Keyframe(nal);
 		const parameterSet = this.codec === "h264" ? this.isH264ParameterSet(nal) : this.isH265ParameterSet(nal);
 		this.onNal({
 			nal,
+			annexB,
 			keyframe,
 			parameterSet,
 			timestamp,
@@ -11054,6 +11159,8 @@ var StreamBroker = class StreamBroker {
 	* consumer reads from. `null` until a consumer subscribes.
 	*/
 	frameHandlePlane = null;
+	/** One-shot latch for the "seed ring not filled" line — see `pushEncodedPacket`. */
+	seedRingSkipLogged = false;
 	decoderApi;
 	audioCodecApi;
 	logger;
@@ -11257,7 +11364,20 @@ var StreamBroker = class StreamBroker {
 	* packet; push / RTMP (provider-driven) sources sit out because they have
 	* no native reader to tear down.
 	*/
-	rtpActivityWatchdog;
+	rtpActivitySweep;
+	/**
+	* Wall-clock ms of the most recent source-RTP packet, or `0` while the
+	* watchdog is disarmed.
+	*
+	* This is the whole of the per-packet work. The watchdog used to re-arm a
+	* `setTimeout` on EVERY packet (`clearTimeout` + `setTimeout`), and the
+	* comment here called that "negligible". It was not: at 30 cameras and
+	* 80-100 packets/s each, that is ~3 000 `Timeout` objects allocated,
+	* inserted into and removed from libuv's timer heap every second, in the
+	* process that already spends 68% of a full core in GC. Writing a number
+	* allocates nothing; one sweep timer per broker replaces ~100 arms/s.
+	*/
+	lastRtpActivityAt = 0;
 	/** Number of times the activity watchdog fired in this broker's lifetime
 	*  (incremented on expiry, NOT on arm/cancel). Surfaced via the test
 	*  seam so unit tests can assert recovery behavior without inspecting
@@ -11269,6 +11389,16 @@ var StreamBroker = class StreamBroker {
 	*  real stall is detected before Chrome's ~15s ICE-disconnect timer
 	*  has any chance to fire. */
 	static RTP_ACTIVITY_TIMEOUT_MS = 8e3;
+	/**
+	* How often the single sweep timer checks {@link lastRtpActivityAt}.
+	*
+	* The stall is still declared at exactly `RTP_ACTIVITY_TIMEOUT_MS` of
+	* silence; this only bounds how late that verdict can be observed (one
+	* sweep, so ≤ 9s worst case rather than exactly 8s). That slack is far
+	* inside Chrome's ~15s ICE-disconnect timer, which is the deadline the
+	* timeout was chosen against.
+	*/
+	static RTP_ACTIVITY_SWEEP_MS = 1e3;
 	manualStop = false;
 	stopping = false;
 	pipeServer;
@@ -11429,10 +11559,6 @@ var StreamBroker = class StreamBroker {
 	joinBurstBound = DEFAULT_PRIME_BURST_BOUND;
 	/** Per-message throttle state for {@link reportThrottled}. */
 	throttledReports = /* @__PURE__ */ new Map();
-	/** Memory ceiling for the RTP ring. A GOP that exceeds this (pathological
-	*  long-GOP high-bitrate stream) drops the bootstrap rather than balloon
-	*  memory — late joiners fall back to waiting for the next keyframe. */
-	static RTP_RING_MAX_BYTES = 24 * 1024 * 1024;
 	/** Last budget printed by {@link reportPreRollClamp}, so the line fires on a
 	*  TRANSITION rather than on every keyframe. */
 	preRollClampLogged = false;
@@ -12200,9 +12326,18 @@ var StreamBroker = class StreamBroker {
 			}
 		}
 		if (packet.type === "video" && this.firstKeyframeReceived) {
-			const decoderPacket = this.decoderPacketWithParamSets(packet);
-			this.decoderSeedBuffer.push(decoderPacket);
-			this.frameHandlePlane?.pushPacket(decoderPacket);
+			const plane = this.frameHandlePlane;
+			if (plane) {
+				const decoderPacket = this.decoderPacketWithParamSets(packet);
+				this.decoderSeedBuffer.push(decoderPacket);
+				plane.pushPacket(decoderPacket);
+			} else if (!this.seedRingSkipLogged) {
+				this.seedRingSkipLogged = true;
+				this.logger?.info("decoder seed ring not filled — no frame-handle consumer on this broker", {
+					tags: { deviceId: this.numericDeviceId },
+					meta: { seedSec: StreamBroker.DECODER_SEED_BUFFER_SEC }
+				});
+			}
 		}
 	}
 	/**
@@ -12426,11 +12561,11 @@ var StreamBroker = class StreamBroker {
 			this.rtpRingHasKeyframe = true;
 		}
 		this.rtpRingPrevMarker = marker;
-		if (this.rtpRingBytes > StreamBroker.RTP_RING_MAX_BYTES) {
+		if (this.rtpRingBytes > 25165824) {
 			this.reportThrottled("rtp pre-buffer ring exceeded cap — join bootstrap dropped", {
 				bytes: this.rtpRingBytes,
 				packets: this.rtpRing.length,
-				capBytes: StreamBroker.RTP_RING_MAX_BYTES
+				capBytes: RTP_RING_MAX_BYTES
 			});
 			this.resetRtpPreBuffer();
 		}
@@ -12793,7 +12928,7 @@ var StreamBroker = class StreamBroker {
 	*/
 	getRtpActivityWatchdogStatus() {
 		return {
-			armed: this.rtpActivityWatchdog !== void 0,
+			armed: this.rtpActivitySweep !== void 0,
 			firedCount: this.rtpActivityWatchdogFiredCount
 		};
 	}
@@ -13492,28 +13627,16 @@ var StreamBroker = class StreamBroker {
 		const isH264 = codec === "h264";
 		const nalType = isH264 ? nal[0] & 31 : (nal[0] & 126) >> 1;
 		if (isH264 ? nalType === 7 || nalType === 8 : nalType === 32 || nalType === 33 || nalType === 34) {
-			const startCode = Buffer.from([
-				0,
-				0,
-				0,
-				1
-			]);
-			this.pendingParamNals.push(Buffer.concat([startCode, nal]));
+			this.pendingParamNals.push(depacketized.annexB);
 			return;
 		}
-		const startCode = Buffer.from([
-			0,
-			0,
-			0,
-			1
-		]);
 		const hadParamSets = this.pendingParamNals.length > 0;
 		let annexBData;
 		if (hadParamSets) {
-			this.pendingParamNals.push(Buffer.concat([startCode, nal]));
+			this.pendingParamNals.push(depacketized.annexB);
 			annexBData = Buffer.concat(this.pendingParamNals);
 			this.pendingParamNals = [];
-		} else annexBData = Buffer.concat([startCode, nal]);
+		} else annexBData = depacketized.annexB;
 		const pts = Math.floor(timestamp / 90);
 		const packet = {
 			type: "video",
@@ -13656,22 +13779,38 @@ var StreamBroker = class StreamBroker {
 	* sources stay covered by the same arm/cancel lifecycle (the expiry
 	* path is reader-aware — it does nothing when no reader is alive).
 	*
-	* Cheap (clearTimeout + setTimeout); called at ~50-100Hz on a healthy
-	* stream — the overhead is negligible compared to the depacketize and
-	* fan-out work each packet already does.
+	* ALLOCATION-FREE per packet: it stamps {@link lastRtpActivityAt} and
+	* arms ONE {@link StreamBroker.RTP_ACTIVITY_SWEEP_MS} interval the first
+	* time. Do not turn this back into a per-packet `clearTimeout` +
+	* `setTimeout` — that is a `Timeout` allocation and two libuv timer-heap
+	* operations on the highest-frequency path in the busiest process.
 	*/
 	kickRtpActivityWatchdog() {
 		if (this.manualStop || this.stopping || this._suspended) return;
-		if (this.rtpActivityWatchdog) clearTimeout(this.rtpActivityWatchdog);
-		this.rtpActivityWatchdog = setTimeout(() => {
-			this.onRtpActivityWatchdogExpired();
-		}, StreamBroker.RTP_ACTIVITY_TIMEOUT_MS);
+		this.lastRtpActivityAt = Date.now();
+		if (this.rtpActivitySweep !== void 0) return;
+		this.rtpActivitySweep = setInterval(() => {
+			this.sweepRtpActivity();
+		}, StreamBroker.RTP_ACTIVITY_SWEEP_MS);
+		this.rtpActivitySweep.unref?.();
+	}
+	/**
+	* One sweep: declare the stall only once the full
+	* {@link StreamBroker.RTP_ACTIVITY_TIMEOUT_MS} of silence has actually
+	* elapsed since the last packet.
+	*/
+	sweepRtpActivity() {
+		if (this.lastRtpActivityAt === 0) return;
+		if (Date.now() - this.lastRtpActivityAt < StreamBroker.RTP_ACTIVITY_TIMEOUT_MS) return;
+		this.cancelRtpActivityWatchdog();
+		this.onRtpActivityWatchdogExpired();
 	}
 	/** Cancel the rolling RTP activity watchdog. Idempotent. */
 	cancelRtpActivityWatchdog() {
-		if (!this.rtpActivityWatchdog) return;
-		clearTimeout(this.rtpActivityWatchdog);
-		this.rtpActivityWatchdog = void 0;
+		this.lastRtpActivityAt = 0;
+		if (this.rtpActivitySweep === void 0) return;
+		clearInterval(this.rtpActivitySweep);
+		this.rtpActivitySweep = void 0;
 	}
 	/**
 	* Activity watchdog expiry: source RTP went silent for longer than
@@ -13686,7 +13825,6 @@ var StreamBroker = class StreamBroker {
 	* their own `PUSH_STALL_TIMEOUT_MS` path.
 	*/
 	onRtpActivityWatchdogExpired() {
-		this.rtpActivityWatchdog = void 0;
 		this.rtpActivityWatchdogFiredCount++;
 		if (this.manualStop || this.stopping || this._suspended) return;
 		const meta = {
@@ -29298,6 +29436,7 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 		}
 	}
 	async onInitialize() {
+		this.ctx.logger.info("log channels declared", { meta: { channels: STREAM_BROKER_LOG_CHANNELS.map((c) => c.descriptor.name) } });
 		this.logChannels = require_dist.createLogChannelsProvider(this.ctx.logger.child("log-channels"));
 		const logChannelsRegistration = {
 			capability: require_dist.logChannelsCapability,