@camstack/addon-pipeline 1.1.39 → 1.1.40

package/dist/stream-broker/index.js

@@ -3,20 +3,20 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_model_download_service_C_IHWnXx = require("../model-download-service-C-IHWnXx-DxM2DSns.js");
-const require_dist = require("../dist-DbGdZ8Nr.js");
-const require_frame_handle_plane = require("../frame-handle-plane-B7jMIZc2.js");
+const require_dist = require("../dist-BJTPkJFw.js");
+const require_frame_handle_plane = require("../frame-handle-plane-BP8YV4sF.js");
 let node_crypto = require("node:crypto");
 node_crypto = require_model_download_service_C_IHWnXx.__toESM(node_crypto);
+let node_child_process = require("node:child_process");
+let node_url = require("node:url");
 let node_fs = require("node:fs");
 node_fs = require_model_download_service_C_IHWnXx.__toESM(node_fs);
 let node_path = require("node:path");
 node_path = require_model_download_service_C_IHWnXx.__toESM(node_path);
 let node_os = require("node:os");
 node_os = require_model_download_service_C_IHWnXx.__toESM(node_os);
-let node_child_process = require("node:child_process");
 let node_dns_promises = require("node:dns/promises");
 let node_module = require("node:module");
-let node_url = require("node:url");
 let node_net = require("node:net");
 node_net = require_model_download_service_C_IHWnXx.__toESM(node_net);
 let net = require("net");
@@ -4752,6 +4752,14 @@ var RtspSession = class {
 	userAgent = null;
 	/** When true, this session receives video-only (no audio RTP). */
 	muted;
+	/**
+	* Latch for a `muted` (local-decoder loopback) session that has started
+	* dropping video packets on socket backlog. While set, every non-keyframe
+	* packet is dropped — even after the backlog clears — until the next keyframe
+	* access unit, so the decoder always resumes on a clean GOP boundary instead
+	* of mid-GOP with reference-broken (missing P-frame) packets.
+	*/
+	droppingUntilKeyframe = false;
 	constructor(socket, sdp, onClose, muted) {
 		this.socket = socket;
 		this.sdp = sdp;
@@ -4801,13 +4809,35 @@ var RtspSession = class {
 			bytesSent: this.bytesSent
 		};
 	}
-	/** Send a video RTP packet via TCP interleaved framing. */
-	sendRtp(packet) {
+	/**
+	* Send a video RTP packet via TCP interleaved framing.
+	*
+	* `prime` marks a packet from the current-GOP catch-up burst replayed on
+	* join — written unconditionally (bounded one-shot the local decoder drains
+	* fast; dropping mid-burst would break frame references). A prime burst
+	* starts at a keyframe by construction, so it also clears the
+	* `droppingUntilKeyframe` latch.
+	*
+	* `isKeyframe` marks a packet that begins a keyframe access unit — the clean
+	* GOP boundary at which a latched `muted` session resumes sending.
+	*/
+	sendRtp(packet, prime = false, isKeyframe = false) {
 		if (!this.playing || this.closed) return;
 		if (this.tracks.length === 0) return;
-		if (this.socket.writableLength > 2097152) {
-			this.close();
-			return;
+		if (prime) this.droppingUntilKeyframe = false;
+		else {
+			if (this.droppingUntilKeyframe) {
+				if (!isKeyframe) return;
+				this.droppingUntilKeyframe = false;
+			}
+			if (this.socket.writableLength > 2097152) {
+				if (this.muted) {
+					this.droppingUntilKeyframe = true;
+					return;
+				}
+				this.close();
+				return;
+			}
 		}
 		const channel = this.tracks[0].rtpChannel;
 		const frame = Buffer.allocUnsafe(4 + packet.data.length);
@@ -5532,6 +5562,16 @@ function appendAudioMediaBlock(videoSdp, audioBlock) {
 //#endregion
 //#region src/stream-broker/rtsp/rtsp-restreamer.ts
 /**
+* Max age (ms) of a prime burst a MUTED (local-decoder loopback) session will
+* accept. A muted decoder must anchor at the LIVE edge — a full-GOP catch-up
+* burst (2-3s old) makes libav base its pts 2-3s in the past and, with ~zero
+* decode headroom, it never drains that backlog. So a muted session only joins
+* off a burst already near live (span ≤ this); otherwise it is left pending to
+* begin at the next live keyframe. Non-muted sessions (viewer / recorder) still
+* get the full-GOP burst for an instant picture.
+*/
+var LIVE_EDGE_MAX_SPAN_MS = 500;
+/**
 * Per-broker RTSP restreamer.
 *
 * Operates in two modes:
@@ -5577,9 +5617,22 @@ var RtspRestreamer = class {
 	collectingKeyframeRtp = false;
 	logger = null;
 	_onSessionCountChanged = null;
+	/**
+	* Supplies the broker's current-GOP source-RTP snapshot (keyframe..now) so a
+	* joining decoder is primed with the WHOLE recent GOP as a burst and
+	* fast-forwards to the live edge — instead of a lone keyframe up to a GOP old
+	* followed by reference-broken live packets. Mirrors Scrypted's
+	* prebuffer/findSyncFrame. Returns [] until a keyframe is seen (falls back to
+	* the single cached keyframe AU).
+	*/
+	rtpPreBufferSupplier = null;
 	constructor(streamName) {
 		this.streamName = streamName;
 	}
+	/** Wire the broker's current-GOP RTP snapshot supplier (see field doc). */
+	setRtpPreBufferSupplier(supplier) {
+		this.rtpPreBufferSupplier = supplier;
+	}
 	/** True when using RTP passthrough (native client) instead of Annex-B re-packetization. */
 	get rtpPassthroughMode() {
 		return this._rtpPassthroughMode;
@@ -5665,9 +5718,8 @@ var RtspRestreamer = class {
 			total: this.sessions.size
 		} });
 		this._onSessionCountChanged?.();
-		if (this._rtpPassthroughMode) {
-			if (this.lastKeyframeRtpPackets.length > 0) setTimeout(() => this.servePendingSessionsRtp(), 0);
-		} else if (this.lastKeyframeNals.length > 0 && this.packetizer) setTimeout(() => this.servePendingSessions(), 0);
+		if (this._rtpPassthroughMode) setTimeout(() => this.servePendingSessionsRtp(), 0);
+		else if (this.lastKeyframeNals.length > 0 && this.packetizer) setTimeout(() => this.servePendingSessions(), 0);
 	}
 	/**
 	* Set the camera's SDP directly (from DESCRIBE response).
@@ -5699,6 +5751,7 @@ var RtspRestreamer = class {
 			data: rtpData,
 			marker: (rtpData[1] & 128) !== 0
 		};
+		const keyframeAuStart = (isKeyframe || isParameterSet) && !this.collectingKeyframeRtp;
 		if (isKeyframe || isParameterSet) {
 			if (!this.collectingKeyframeRtp) {
 				this.collectingKeyframeRtp = true;
@@ -5714,23 +5767,49 @@ var RtspRestreamer = class {
 		}
 		if (this.sessions.size === 0) return;
 		this.servePendingSessionsRtp();
+		if (keyframeAuStart) for (const session of this.sessions.values()) {
+			if (!session.isMuted() || !session.isPlaying()) continue;
+			this.pendingKeyframe.delete(session.getSessionId());
+		}
 		for (const session of this.sessions.values()) {
 			if (this.pendingKeyframe.has(session.getSessionId())) continue;
-			if (session.isPlaying()) session.sendRtp(rtpPacket);
+			if (session.isPlaying()) session.sendRtp(rtpPacket, false, isKeyframe || isParameterSet);
 		}
 	}
 	/** Send cached keyframe RTP packets to sessions that transitioned to PLAY. */
 	servePendingSessionsRtp() {
 		if (this.pendingKeyframe.size === 0) return;
-		if (this.lastKeyframeRtpPackets.length === 0) return;
+		const ringPackets = this.rtpPreBufferSupplier?.() ?? [];
+		const fromRing = ringPackets.length > 0;
+		const primePackets = fromRing ? ringPackets.map((data) => ({
+			data,
+			marker: (data[1] & 128) !== 0
+		})) : this.lastKeyframeRtpPackets;
+		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.sessions.get(sessionId)?.isPlaying()) ready.push(sessionId);
 		if (ready.length === 0) return;
-		for (const rtpPacket of this.lastKeyframeRtpPackets) for (const sessionId of ready) {
+		const served = [];
+		for (const sessionId of ready) {
+			const session = this.sessions.get(sessionId);
+			if (!session) continue;
+			if (session.isMuted() && (!fromRing || spanMs > LIVE_EDGE_MAX_SPAN_MS)) continue;
+			served.push(sessionId);
+		}
+		if (served.length === 0) return;
+		this.logger?.info("restream prime (lat-probe)", { meta: {
+			source: fromRing ? "gop-burst" : "keyframe-only",
+			packets: primePackets.length,
+			spanMs: Math.round(spanMs),
+			clients: served.length
+		} });
+		for (const rtpPacket of primePackets) for (const sessionId of served) {
 			const session = this.sessions.get(sessionId);
-			if (session?.isPlaying()) session.sendRtp(rtpPacket);
+			if (session?.isPlaying()) session.sendRtp(rtpPacket, true);
 		}
-		for (const id of ready) this.pendingKeyframe.delete(id);
+		for (const id of served) this.pendingKeyframe.delete(id);
 	}
 	/**
 	* Push a raw audio RTP packet from the native RTSP client.
@@ -8640,6 +8719,38 @@ var AudioCodecSession = class {
 			sessionId: this.sessionId
 		};
 	}
+	/**
+	* Tear down the upstream decode session + 40ms poll loop WITHOUT
+	* permanently closing this handle. The broker calls this from its
+	* audio-consumer demand-gate: when audio consumers drop to zero the
+	* upstream decoder session and its poll loop are pure waste, so we
+	* release them. Unlike {@link close} this leaves the handle reusable —
+	* the next pushed packet re-creates the session lazily via
+	* `ensureSession()`. Safe to call repeatedly.
+	*/
+	async idle() {
+		if (this.closed) return;
+		if (this.creating) await this.creating;
+		if (this.closed) return;
+		if (this.pollTimer) {
+			clearInterval(this.pollTimer);
+			this.pollTimer = null;
+		}
+		if (!this.sessionId) return;
+		const sid = this.sessionId;
+		const nodeId = this.sessionNodeId ?? void 0;
+		this.sessionId = null;
+		this.sessionNodeId = null;
+		try {
+			await this.api.closeSession({
+				sessionId: sid,
+				...nodeId ? { nodeId } : {}
+			});
+		} catch (err) {
+			this.logger?.warn("audio-codec: idle closeSession failed", { meta: { error: require_dist.errMsg(err) } });
+		}
+		this.logger?.info("audio-codec: decode session idled (no audio consumer)", { meta: { sessionId: sid } });
+	}
 	async close() {
 		if (this.closed) return;
 		this.closed = true;
@@ -8867,12 +8978,25 @@ var EncodedRingBuffer = class {
 	clear() {
 		this.packets.length = 0;
 	}
-	/** Remove packets older than maxDurationMs based on PTS. */
+	/**
+	* Remove packets older than maxDurationMs based on PTS.
+	*
+	* PTS here is the source RTP timestamp (90kHz → ms), which is NOT
+	* monotonic across the buffer's lifetime: an RTSP/rfc4571 redial re-bases
+	* it to a fresh random value (RFC 3550) and the 32-bit field wraps every
+	* ~13.25h. A purely `pts < cutoff` head-trim stalls forever whenever the
+	* newest packet's pts drops below the stale head's — the buffer then
+	* retains the entire pre-discontinuity history (an unbounded native-memory
+	* leak of full-bitrate AnnexB copies). So we also evict any head packet
+	* whose pts is GREATER than the newest packet's: it can only belong to a
+	* prior, higher-based epoch that the source has since jumped away from.
+	*/
 	evict() {
 		if (this.packets.length === 0) return;
-		const cutoff = this.packets[this.packets.length - 1].pts - this.maxDurationMs;
+		const newest = this.packets[this.packets.length - 1].pts;
+		const cutoff = newest - this.maxDurationMs;
 		let removeCount = 0;
-		while (removeCount < this.packets.length && this.packets[removeCount].pts < cutoff) removeCount++;
+		while (removeCount < this.packets.length && (this.packets[removeCount].pts < cutoff || this.packets[removeCount].pts > newest)) removeCount++;
 		if (removeCount > 0) this.packets.splice(0, removeCount);
 	}
 };
@@ -9152,6 +9276,14 @@ var INITIAL_RECONNECT_DELAY_MS = 1e3;
 var MAX_RECONNECT_DELAY_MS = 3e4;
 /** Grace period before suspending after last consumer leaves. */
 var SUSPEND_GRACE_MS = 5e3;
+/**
+* Grace window before an idle audio-codec decode session is torn down
+* after the last audio consumer detaches. Mirrors the frame-handle /
+* suspend occupancy-linger pattern: a brief gap between consumers (e.g.
+* a WebRTC renegotiation or an analyzer re-subscribe) must not thrash
+* the upstream decode session create/destroy.
+*/
+var AUDIO_CONSUMER_LINGER_MS = 5e3;
 /** Timeout for push-mode sources: if no packet arrives within this window, emit error placeholder. */
 var PUSH_STALL_TIMEOUT_MS = 15e3;
 var StreamBroker = class StreamBroker {
@@ -9227,6 +9359,12 @@ var StreamBroker = class StreamBroker {
 	pushRtpFlagDepacketizer = null;
 	audioRtpDecoder = null;
 	audioCodecSession = null;
+	/**
+	* Pending occupancy-linger teardown of {@link audioCodecSession} after
+	* the last audio consumer detached. Cancelled when a consumer returns
+	* within {@link AUDIO_CONSUMER_LINGER_MS}. See {@link reconcileAudioConsumer}.
+	*/
+	audioConsumerLingerTimer;
 	audioRtpSeen = 0;
 	/** Detected audio codec from RTSP DESCRIBE (e.g. 'PCMU', 'PCMA'). */
 	audioCodec = null;
@@ -9440,6 +9578,7 @@ var StreamBroker = class StreamBroker {
 		this.pipeServer = new StreamPipeServer(logger?.child("pipe-server"));
 		this.rtspRestreamer = new RtspRestreamer(deviceId);
 		if (logger) this.rtspRestreamer.setLogger(logger.child("rtsp"));
+		this.rtspRestreamer.setRtpPreBufferSupplier(() => this.getRtpPreBuffer());
 		this.preBuffer = new EncodedRingBuffer(StreamBroker.DEFAULT_PRE_BUFFER_SEC);
 		this.decoderSeedBuffer = new EncodedRingBuffer(StreamBroker.DECODER_SEED_BUFFER_SEC);
 		this.audioChunkPlane = new AudioChunkPlane(logger?.child("audio-chunk-plane"));
@@ -9688,11 +9827,54 @@ var StreamBroker = class StreamBroker {
 		return false;
 	}
 	/**
+	* True when at least one consumer needs DECODED audio. The audio-specific
+	* subset of {@link hasDemand} — deliberately excludes the video
+	* frame-handle plane so a video-only viewer never spins up the
+	* AAC/Opus decode chain. `encodedCallbacks` covers WebRTC (its G.711
+	* egress needs decoded PCM); `audioChunkPlane` covers the analyzer.
+	*/
+	hasAudioConsumer() {
+		return this.encodedCallbacks.size > 0 || this.audioChunkPlane.subscriberCount > 0;
+	}
+	/**
+	* Demand-gate the audio-codec decode session lifecycle. Called from
+	* every consumer add/remove edge (via {@link checkDemand}). While an
+	* audio consumer exists, cancel any pending linger-close. When
+	* consumers drop to zero, arm a short linger timer that tears the
+	* upstream decode session + 40ms poll loop down (via
+	* `AudioCodecSession.idle`) so a momentary gap between consumers
+	* doesn't thrash create/destroy. The next gated packet re-arms the
+	* session lazily through `ensureSession()`. No-op when no session is
+	* armed (native PCMU/PCMA cameras never build one).
+	*/
+	reconcileAudioConsumer() {
+		if (!this.audioCodecSession) return;
+		if (this.hasAudioConsumer()) {
+			if (this.audioConsumerLingerTimer) {
+				clearTimeout(this.audioConsumerLingerTimer);
+				this.audioConsumerLingerTimer = void 0;
+			}
+			return;
+		}
+		if (this.audioConsumerLingerTimer) return;
+		this.audioConsumerLingerTimer = setTimeout(() => {
+			this.audioConsumerLingerTimer = void 0;
+			if (this.hasAudioConsumer()) return;
+			const session = this.audioCodecSession;
+			if (!session) return;
+			session.idle().catch((err) => {
+				this.logger?.warn("audio-codec: idle teardown failed", { meta: { error: require_dist.errMsg(err) } });
+			});
+		}, AUDIO_CONSUMER_LINGER_MS);
+		if (typeof this.audioConsumerLingerTimer.unref === "function") this.audioConsumerLingerTimer.unref();
+	}
+	/**
 	* Check demand and schedule suspend/resume. Called after every subscriber
 	* add/remove and after pre-buffer enable/disable.
 	*/
 	checkDemand() {
 		if (this.manualStop || this.stopping) return;
+		this.reconcileAudioConsumer();
 		if (this.hasDemand()) {
 			if (!this.demandActive) {
 				this.demandActive = true;
@@ -9838,7 +10020,7 @@ var StreamBroker = class StreamBroker {
 		if (packet.type === "audio" && this.source?.type === "push" && this.audioCodecSession) {
 			const codec = packet.codec.toLowerCase();
 			if (codec !== "pcmu" && codec !== "pcma") {
-				this.audioCodecSession.pushRawFrame(packet.data);
+				if (this.hasAudioConsumer()) this.audioCodecSession.pushRawFrame(packet.data);
 				return;
 			}
 		}
@@ -10279,7 +10461,8 @@ var StreamBroker = class StreamBroker {
 			logger: this.logger?.child("frame-handle-plane"),
 			resolveStreamInfo: () => this.resolveFrameHandleStreamInfo(),
 			localNodeId: this.localNodeId,
-			getSeedPackets: () => this.decoderSeedBuffer.getPackets()
+			getSeedPackets: () => this.decoderSeedBuffer.getPackets(),
+			isDebugEnabled: () => this.streamingDebug
 		});
 		return this.frameHandlePlane;
 	}
@@ -10361,6 +10544,17 @@ var StreamBroker = class StreamBroker {
 			subscribedAt: entry.subscribedAt,
 			packetsDelivered: entry.packetsDelivered
 		});
+		if (this._preBufferEnabled && encoded.length === 0) encoded.push({
+			id: "prebuffer-hold",
+			channel: "annexb",
+			attribution: {
+				kind: "warmup",
+				userAgent: "prebuffer",
+				media: "video"
+			},
+			subscribedAt: this.startedAt,
+			packetsDelivered: 0
+		});
 		return {
 			rtsp: this.rtspRestreamer.listSessionInfos(),
 			decoded: (this.frameHandlePlane?.listSubscribers() ?? []).map((s) => ({
@@ -10726,7 +10920,7 @@ var StreamBroker = class StreamBroker {
 					hasCodecSession: this.audioCodecSession !== null
 				} });
 				this.audioRtpDecoder?.processPacket(rtpData);
-				this.audioCodecSession?.processPacket(rtpData);
+				if (this.hasAudioConsumer()) this.audioCodecSession?.processPacket(rtpData);
 				if ((this.audioCodec === "PCMU" || this.audioCodec === "PCMA") && this.encodedCallbacks.size > 0 && rtpData.length > 12) {
 					const payload = rtpData.subarray(12);
 					if (payload.length > 0) {
@@ -11207,6 +11401,10 @@ var StreamBroker = class StreamBroker {
 			this.audioRtpDecoder.flush();
 			this.audioRtpDecoder = null;
 		}
+		if (this.audioConsumerLingerTimer) {
+			clearTimeout(this.audioConsumerLingerTimer);
+			this.audioConsumerLingerTimer = void 0;
+		}
 		if (this.audioCodecSession) {
 			const session = this.audioCodecSession;
 			this.audioCodecSession = null;
@@ -14257,6 +14455,11 @@ var StreamBrokerManager = class {
 			break;
 		}
 		this.assignments.set(deviceId, nextAssignment);
+		if (current.map.high !== newMap.high) for (const camStreamId of [current.map.high, newMap.high]) {
+			if (!camStreamId) continue;
+			const broker = this.brokers.get(brokerIdFor(deviceId, camStreamId));
+			if (broker) this.applyPreBufferConfig(broker, deviceId, camStreamId);
+		}
 		for (const [camId, prevCount] of oldPushConsumers) if ((newPushConsumers.get(camId) ?? 0) === 0 && prevCount > 0) this.emitCamStreamIdle(deviceId, camId);
 		for (const [camId, nextCount] of newPushConsumers) if ((oldPushConsumers.get(camId) ?? 0) === 0 && nextCount > 0) {
 			let triggerProfile = "mid";
@@ -14462,7 +14665,7 @@ var StreamBrokerManager = class {
 		broker.setRestreamers(this.restreamers);
 		broker.setRestreamUrlResolver(() => this.rtspProvider.getEntry(brokerId)?.mutedUrl ?? null);
 		broker.setFfmpegBinaryPath(this.ffmpegConfig.binaryPath);
-		this.applyPreBufferConfig(broker, deviceId, camStreamId, cam);
+		this.applyPreBufferConfig(broker, deviceId, camStreamId);
 		if (this.deviceOverrides.get(deviceId)?.streamingDebug) broker.setStreamingDebug(true);
 		broker.setSourceProvider(() => {
 			const latest = this.cameraStreams.get(deviceId)?.get(camStreamId);
@@ -14598,34 +14801,48 @@ var StreamBrokerManager = class {
 		};
 	}
 	/**
+	* Whether a stream is warmed BY DEFAULT (no explicit override): the device's
+	* `high` profile, on a non-battery camera. Single source of truth used by both
+	* the broker-config default (`applyPreBufferConfig`) and the settings-patch
+	* override synthesis (`defaultStreamPreBuffer`) so a seconds-only patch never
+	* silently disables the high-profile warm default.
+	*/
+	isDefaultWarm(deviceId, camStreamId) {
+		return findProfileForStream(this.assignments.get(deviceId)?.map ?? {}, camStreamId) === "high" && !this.deviceHasFeature(deviceId, require_dist.DeviceFeature.BatteryOperated);
+	}
+	/**
 	* Default `StreamPreBuffer` for a brand-new override entry — mirrors
-	* the UI-side default in `getDeviceSettingsContribution`. Pre-buffer
-	* is OFF by default for every stream. Operators opt in per-stream
-	* via the device-settings sub-tabs; detection / recording paths
-	* pass `forceForDetection` to `getEffectivePreBufferSec` when they
-	* need a buffered window irrespective of the operator toggle.
+	* the effective broker default: `enabled` reflects the high-profile warm
+	* default (`isDefaultWarm`), so a seconds-only patch on a warm high stream
+	* inherits `enabled: true` instead of silently forcing it OFF. Operators
+	* still override explicitly per-stream via the device-settings sub-tabs;
+	* detection / recording paths pass `forceForDetection` to
+	* `getEffectivePreBufferSec` when they need a buffered window irrespective
+	* of the operator toggle.
 	*/
-	defaultStreamPreBuffer(_deviceId, _camStreamId) {
+	defaultStreamPreBuffer(deviceId, camStreamId) {
 		return {
-			enabled: false,
+			enabled: this.isDefaultWarm(deviceId, camStreamId),
 			seconds: this.defaultPreBufferSec
 		};
 	}
 	/**
 	* Apply the effective pre-buffer config to a fresh broker instance.
-	* Default behaviour is OFF for every cam stream — keeps RAM and the
-	* upstream reader idle until the operator opts in or a detection /
-	* recording subscriber attaches.
+	* Default behaviour: the HIGH profile stream is warm (see below);
+	* every other stream stays OFF — idle until the operator opts in or
+	* a detection / recording subscriber attaches. An explicit per-stream
+	* operator override always wins over both defaults.
 	*/
-	applyPreBufferConfig(broker, deviceId, camStreamId, _cam) {
+	applyPreBufferConfig(broker, deviceId, camStreamId) {
 		const perStream = this.deviceOverrides.get(deviceId)?.preBuffer?.[camStreamId];
 		if (perStream) {
 			broker.setPreBufferEnabled(perStream.enabled);
 			broker.setPreBufferDuration(perStream.enabled ? perStream.seconds : 0);
 			return;
 		}
-		broker.setPreBufferEnabled(false);
-		broker.setPreBufferDuration(0);
+		const defaultWarm = this.isDefaultWarm(deviceId, camStreamId);
+		broker.setPreBufferEnabled(defaultWarm);
+		broker.setPreBufferDuration(defaultWarm ? this.defaultPreBufferSec : 0);
 	}
 	async fanOutRegistration(deviceId, brokerId, cam, broker) {
 		const log = this.logger.withTags({
@@ -17410,6 +17627,15 @@ var BROKER_METRICS_HEARTBEAT_MS = 3e4;
 /** Throttle for persisting the per-stream probe map — bounds writes regardless
 *  of streaming churn while keeping the durable copy recent enough for restart. */
 var PROBE_SNAPSHOTS_PERSIST_INTERVAL_MS = 6e4;
+/**
+* Defensive timeout for the per-session `networkQuality.getDeviceStats` poll.
+* The stat is an OPTIONAL input to the adaptive downgrade ladder — never worth
+* blocking the loop for. When the hub-resident provider is transiently
+* undiscoverable the child's unowned-cap routing falls to the Moleculer
+* broker-fallback, whose discovery wait is ~30s; without this bound a single
+* poll would stall the adaptive loop for that long. On timeout we simply treat
+* the sample as absent (the RTCP Receiver-Report path drives the ladder anyway). */
+var NETWORK_QUALITY_STATS_TIMEOUT_MS = 2e3;
 var StreamBrokerAddon = class extends require_dist.BaseAddon {
 	brokerManager = null;
 	/** ffmpeg binary path from the `ffmpeg` config section, mirrored here so the
@@ -17738,10 +17964,14 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 				}
 			},
 			clientLossPct: async (deviceId) => {
+				const ctrl = new AbortController();
+				const timer = setTimeout(() => ctrl.abort(), NETWORK_QUALITY_STATS_TIMEOUT_MS);
 				try {
-					return (await this.ctx.api.networkQuality.getDeviceStats.query({ deviceId }))?.client?.packetLossPercent ?? null;
+					return (await this.ctx.api.networkQuality.getDeviceStats.query({ deviceId }, { signal: ctrl.signal }))?.client?.packetLossPercent ?? null;
 				} catch {
 					return null;
+				} finally {
+					clearTimeout(timer);
 				}
 			},
 			resolveTranscodeDecodeHwAccel: () => this.resolveTranscodeDecodeHwAccel(),