@camstack/addon-pipeline 1.2.364 → 1.2.365

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-CGOb--t-.js");
-const require_node = require("../node-UBMRK8SK.js");
+const require_dist = require("../dist-i4kS_3O7.js");
+const require_node = require("../node-TzgGsCvW.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-PkDP-xQg.js");
+const require_segment_demux_js = require("../segment-demux-js-C9AYdKkD.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");
@@ -3085,6 +3085,68 @@ var RtpPacketizer = class {
 	}
 };
 //#endregion
+//#region src/stream-broker/stream-broker/owned-buffer.ts
+/**
+* Buffers that enter a LONG-LIVED ring own their backing store.
+*
+* Node serves `Buffer.from(...)`, `Buffer.allocUnsafe(n)` and `Buffer.concat`
+* below `Buffer.poolSize >>> 1` (4 KiB) as views of shared 8 KiB pool slabs.
+* That is the right choice for the ingest path — a start code, a 4-byte
+* interleave header, a 1.3 KB RTP packet that is fanned out and forgotten
+* within a tick — and the wrong one for anything RETAINED: a 600-byte NAL kept
+* for 60 s in a clip ring pins its whole slab, and with it every short-lived
+* packet that happened to be allocated beside it. On the hub that held
+* 550–980 MB of ArrayBuffers for ~150–250 MB of payload, and the full GCs the
+* pinned slabs caused ran every 0.2–0.5 s at 40–65 % of a core.
+*
+* The ring byte caps counted payload bytes, so they never saw it. Both rings
+* now pass every entry through {@link detachFromPool} on the way in and
+* account it with {@link backingStoreBytes}, so the cap measures what the
+* entry costs. Short-lived traffic stays pooled.
+*/
+/** True when `buf` is the whole of its ArrayBuffer — nothing else shares it. */
+function ownsBackingStore(buf) {
+	return buf.byteOffset === 0 && buf.buffer.byteLength === buf.length;
+}
+/**
+* What retaining `buf` really costs: its own length when it owns its
+* ArrayBuffer, the whole shared slab when it is a view of one.
+*/
+function backingStoreBytes(buf) {
+	return ownsBackingStore(buf) ? buf.length : buf.buffer.byteLength;
+}
+/**
+* `buf` itself when it already owns its ArrayBuffer (decided by inspecting the
+* buffer, never by its size: whether a large `allocUnsafe` is pooled is a Node
+* runtime detail), else a copy that does. One copy, never two: a buffer that is
+* already unpooled is returned as-is.
+*/
+function detachFromPool(buf) {
+	if (ownsBackingStore(buf)) return buf;
+	const owned = Buffer.allocUnsafeSlow(buf.length);
+	buf.copy(owned);
+	return owned;
+}
+/**
+* A copy of `src[start, end)` that OWNS its backing store — the shape a reader
+* hands out when the packet it cuts from its socket buffer is going to be
+* retained anyway.
+*
+* Every source video packet is: `captureRtpForPreBuffer` keeps it for the life
+* of a GOP, and the restreamer's keyframe cache keeps the keyframe ones. With
+* the readers cutting packets as `Buffer.from(subarray)` — a pooled view — the
+* ring then had to copy each one a second time to own it: two copies of every
+* packet on the ingest path (measured 15.1 + 14.8 MB/s on the hub's load).
+* Cutting the packet owned up front makes the ring's and the cache's
+* `detachFromPool` an identity, so the packet is copied once and shared by the
+* reader's fan-out, the ring, the cache and every session's write queue.
+*/
+function copyOwned(src, start, end) {
+	const owned = Buffer.allocUnsafeSlow(end - start);
+	src.copy(owned, 0, start, end);
+	return owned;
+}
+//#endregion
 //#region src/stream-broker/rtsp/sdp-builder.ts
 function buildSdp(options) {
 	const { codec, parameterSets, streamName } = options;
@@ -3755,7 +3817,7 @@ var RtspRestreamer = class {
 		if (this.collectingKeyframeRtp && !isKeyframe && !isParameterSet) this.collectingKeyframeRtp = false;
 		if (this.collectingKeyframeRtp) {
 			this.lastKeyframeRtpPackets.push({
-				data: Buffer.from(rtpData),
+				data: detachFromPool(rtpData),
 				marker: rtpPacket.marker
 			});
 			this.lastKeyframeRtpBytes += rtpData.length;
@@ -4357,6 +4419,19 @@ var RtspSession = class {
 	lastRtpAt = 0;
 	/** Total video RTP bytes written to the socket. */
 	bytesSent = 0;
+	/**
+	* The socket is corked for the access unit in progress — see
+	* {@link writeInterleaved}. Cleared by the packet that ends the picture (RTP
+	* marker, or any audio packet) or by the next-tick safety net, whichever
+	* comes first.
+	*/
+	accessUnitCorked = false;
+	/** Flush the access unit in progress. Idempotent: the marker and the safety net both call it. */
+	uncorkAccessUnit = () => {
+		if (!this.accessUnitCorked) return;
+		this.accessUnitCorked = false;
+		this.socket.uncork();
+	};
 	/** Client `User-Agent` (from the first request that carries one). Lets the
 	*  broker panel identify a consumer by purpose — e.g. the recorder sets
 	*  `-user_agent recorder` on its RTSP pull — instead of a bare address. */
@@ -4604,7 +4679,7 @@ var RtspSession = class {
 				return "dropped-backlog";
 			}
 		}
-		this.writeInterleaved(this.tracks[0].rtpChannel, packet.data);
+		this.writeInterleaved(this.tracks[0].rtpChannel, packet.data, packet.marker);
 		this.missedKeyframes = 0;
 		return "written";
 	}
@@ -4613,7 +4688,7 @@ var RtspSession = class {
 		if (!this.playing || this.closed || this.muted) return "not-playing";
 		if (this.tracks.length < 2) return "not-playing";
 		if (this.socket.writableLength > 2097152) return "dropped-backlog";
-		this.writeInterleaved(this.tracks[1].rtpChannel, packet.data);
+		this.writeInterleaved(this.tracks[1].rtpChannel, packet.data, true);
 		return "written";
 	}
 	/**
@@ -4635,14 +4710,13 @@ var RtspSession = class {
 	* ## Why sharing the payload is safe, and what would make it unsafe
 	*
 	* The payload buffer handed here 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 broker's `rtpRing` keeps its OWN copy of a pooled packet —
-	* `detachFromPool`, so a ring entry never pins a shared pool slab — so the
-	* ring no longer vouches for THIS object's lifetime, and it does not need
-	* to: a pending write holds its own reference, and the rule below is about
+	* `copyOwned(readBuffer, …)` in the readers' `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 same object
+	* is what the broker's `rtpRing` and the restreamer's keyframe cache retain —
+	* it owns its backing store, so `detachFromPool` keeps it as is — and that is
+	* fine: a pending write holds its own reference, and the rule below is about
 	* mutation, not retention.)
 	*
 	* The rule to keep: **`socket.write` forbids MUTATION before the write
@@ -4652,18 +4726,36 @@ var RtspSession = class {
 	* 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.
+	* ## One cork per ACCESS UNIT, not per packet
+	*
+	* The pair used to be corked and uncorked on its own: one `writev` per RTP
+	* packet per session, so a 4K keyframe fragmented into a hundred packets and
+	* fanned out to three sessions was three hundred syscalls for one picture no
+	* decoder can use before it is whole. The socket is corked on the first write
+	* of an access unit and uncorked by the packet that ENDS it
+	* (`endOfAccessUnit`: the RTP marker on video, every audio packet), so the
+	* picture leaves in one `writev`. A `process.nextTick` safety net uncorks
+	* whatever is still open before the tick yields to I/O — a marker-less camera
+	* or a lost marker degrades to one `writev` per tick, never to a socket held
+	* corked across a read.
+	*
+	* Backpressure sees through the cork: `writableLength` counts corked bytes,
+	* so the `MAX_WRITE_BUFFER` gate, the latch and the missed-keyframe close
+	* (D447) judge exactly what they judged per packet.
 	*/
-	writeInterleaved(channel, payload) {
+	writeInterleaved(channel, payload, endOfAccessUnit) {
 		const header = Buffer.allocUnsafe(4);
 		header[0] = 36;
 		header[1] = channel;
 		header.writeUInt16BE(payload.length, 2);
-		this.socket.cork();
+		if (!this.accessUnitCorked) {
+			this.accessUnitCorked = true;
+			this.socket.cork();
+			process.nextTick(this.uncorkAccessUnit);
+		}
 		this.socket.write(header);
 		this.socket.write(payload);
-		this.socket.uncork();
+		if (endOfAccessUnit) this.uncorkAccessUnit();
 		this.lastRtpAt = Date.now();
 		this.bytesSent += 4 + payload.length;
 	}
@@ -10087,7 +10179,7 @@ var Rfc4571Reader = class {
 		while (this.readBuffer.length >= 2) {
 			const length = this.readBuffer.readUInt16BE(0);
 			if (this.readBuffer.length < 2 + length) return;
-			const rtpPacket = Buffer.from(this.readBuffer.subarray(2, 2 + length));
+			const rtpPacket = copyOwned(this.readBuffer, 2, 2 + length);
 			this.readBuffer = this.readBuffer.subarray(2 + length);
 			this.dispatchRtp(rtpPacket);
 		}
@@ -10148,6 +10240,93 @@ function totalFragmentBytes(fragments) {
 	for (const fragment of fragments) total += fragment.length;
 	return total;
 }
+/** H.264: single NAL by its type; STAP-A by every aggregated type; FU-A by the FU header. */
+function classifyH264Payload(payload) {
+	const nalType = payload[0] & 31;
+	if (nalType === H264_NAL_STAP_A) {
+		let keyframe = false;
+		let parameterSet = false;
+		let offset = 1;
+		while (offset + 2 <= payload.length) {
+			const nalSize = payload.readUInt16BE(offset);
+			offset += 2;
+			if (nalSize === 0 || offset + nalSize > payload.length) break;
+			const type = payload[offset] & 31;
+			keyframe ||= type === H264_NAL_IDR;
+			parameterSet ||= type === H264_NAL_SPS || type === H264_NAL_PPS;
+			offset += nalSize;
+		}
+		return {
+			keyframe,
+			parameterSet
+		};
+	}
+	if (nalType === 28) {
+		if (payload.length < 2) return NO_PAYLOAD_CLASS;
+		return {
+			keyframe: (payload[1] & 31) === H264_NAL_IDR,
+			parameterSet: false
+		};
+	}
+	return {
+		keyframe: nalType === H264_NAL_IDR,
+		parameterSet: nalType === H264_NAL_SPS || nalType === H264_NAL_PPS
+	};
+}
+/** H.265: single NAL by its type; AP by every aggregated type; FU by the FU header. */
+function classifyH265Payload(payload) {
+	if (payload.length < 2) return NO_PAYLOAD_CLASS;
+	const nalType = payload[0] >> 1 & 63;
+	if (nalType === H265_NAL_AP) {
+		let keyframe = false;
+		let parameterSet = false;
+		let offset = 2;
+		while (offset + 2 <= payload.length) {
+			const nalSize = payload.readUInt16BE(offset);
+			offset += 2;
+			if (nalSize === 0 || offset + nalSize > payload.length) break;
+			const type = payload[offset] >> 1 & 63;
+			keyframe ||= isH265IrapType(type);
+			parameterSet ||= isH265ParameterSetType(type);
+			offset += nalSize;
+		}
+		return {
+			keyframe,
+			parameterSet
+		};
+	}
+	if (nalType === 49) {
+		if (payload.length < 3) return NO_PAYLOAD_CLASS;
+		return {
+			keyframe: isH265IrapType(payload[2] & 63),
+			parameterSet: false
+		};
+	}
+	return {
+		keyframe: isH265IrapType(nalType),
+		parameterSet: isH265ParameterSetType(nalType)
+	};
+}
+/**
+* Classify one raw RTP packet (12-byte header + payload) by what it carries —
+* the per-packet half of {@link RtpDepacketizer.processPacket}, without the
+* reassembly half. Pure: reads the headers, allocates nothing, keeps no state.
+* `null` for a packet too short to be RTP with a payload.
+*/
+function classifyRtpPacket(codec, rtpData) {
+	if (rtpData.length < 12) return null;
+	const marker = (rtpData[1] & 128) !== 0;
+	const timestamp = rtpData.readUInt32BE(4);
+	const payload = rtpData.subarray(12);
+	if (payload.length === 0) return null;
+	const carried = codec === "h264" ? classifyH264Payload(payload) : classifyH265Payload(payload);
+	return {
+		timestamp,
+		marker,
+		keyframe: carried.keyframe,
+		parameterSet: carried.parameterSet
+	};
+}
 /**
 * RTP → Annex-B NAL depacketizer.
 *
@@ -10192,87 +10371,22 @@ var RtpDepacketizer = class {
 	* short to be RTP with a payload.
 	*/
 	processPacket(rtpData) {
-		if (rtpData.length < 12) return null;
-		const marker = (rtpData[1] & 128) !== 0;
-		const timestamp = rtpData.readUInt32BE(4);
+		const carried = this.classifyPacket(rtpData);
+		if (carried === null) return null;
 		const payload = rtpData.subarray(12);
-		if (payload.length === 0) return null;
-		const carried = this.codec === "h264" ? this.classifyH264Payload(payload) : this.classifyH265Payload(payload);
-		if (this.codec === "h264") this.processH264(payload, timestamp, marker);
-		else this.processH265(payload, timestamp, marker);
-		return {
-			timestamp,
-			marker,
-			keyframe: carried.keyframe,
-			parameterSet: carried.parameterSet
-		};
+		if (this.codec === "h264") this.processH264(payload, carried.timestamp, carried.marker);
+		else this.processH265(payload, carried.timestamp, carried.marker);
+		return carried;
 	}
-	/** H.264: single NAL by its type; STAP-A by every aggregated type; FU-A by the FU header. */
-	classifyH264Payload(payload) {
-		const nalType = payload[0] & 31;
-		if (nalType === H264_NAL_STAP_A) {
-			let keyframe = false;
-			let parameterSet = false;
-			let offset = 1;
-			while (offset + 2 <= payload.length) {
-				const nalSize = payload.readUInt16BE(offset);
-				offset += 2;
-				if (nalSize === 0 || offset + nalSize > payload.length) break;
-				const type = payload[offset] & 31;
-				keyframe ||= type === H264_NAL_IDR;
-				parameterSet ||= type === H264_NAL_SPS || type === H264_NAL_PPS;
-				offset += nalSize;
-			}
-			return {
-				keyframe,
-				parameterSet
-			};
-		}
-		if (nalType === 28) {
-			if (payload.length < 2) return NO_PAYLOAD_CLASS;
-			return {
-				keyframe: (payload[1] & 31) === H264_NAL_IDR,
-				parameterSet: false
-			};
-		}
-		return {
-			keyframe: nalType === H264_NAL_IDR,
-			parameterSet: nalType === H264_NAL_SPS || nalType === H264_NAL_PPS
-		};
-	}
-	/** H.265: single NAL by its type; AP by every aggregated type; FU by the FU header. */
-	classifyH265Payload(payload) {
-		if (payload.length < 2) return NO_PAYLOAD_CLASS;
-		const nalType = payload[0] >> 1 & 63;
-		if (nalType === H265_NAL_AP) {
-			let keyframe = false;
-			let parameterSet = false;
-			let offset = 2;
-			while (offset + 2 <= payload.length) {
-				const nalSize = payload.readUInt16BE(offset);
-				offset += 2;
-				if (nalSize === 0 || offset + nalSize > payload.length) break;
-				const type = payload[offset] >> 1 & 63;
-				keyframe ||= isH265IrapType(type);
-				parameterSet ||= isH265ParameterSetType(type);
-				offset += nalSize;
-			}
-			return {
-				keyframe,
-				parameterSet
-			};
-		}
-		if (nalType === 49) {
-			if (payload.length < 3) return NO_PAYLOAD_CLASS;
-			return {
-				keyframe: isH265IrapType(payload[2] & 63),
-				parameterSet: false
-			};
-		}
-		return {
-			keyframe: isH265IrapType(nalType),
-			parameterSet: isH265ParameterSetType(nalType)
-		};
+	/**
+	* What this packet CARRIES, and nothing else: no NAL is reassembled, no buffer
+	* allocated, no reassembly state touched. The same verdict `processPacket`
+	* returns, for a broker whose Annex-B plane has no consumer — the source-RTP
+	* ring, the restreamer's keyframe cache and the stats need exactly this and
+	* none of the copies.
+	*/
+	classifyPacket(rtpData) {
+		return classifyRtpPacket(this.codec, rtpData);
 	}
 	processH264(payload, timestamp, marker) {
 		const nalType = payload[0] & 31;
@@ -10452,11 +10566,13 @@ var RtpAccessUnitTracker = class {
 		const keyframeContent = packet.keyframe || packet.parameterSet;
 		const keyframeAuStart = keyframeContent && !this.keyframeAu;
 		if (keyframeContent) this.keyframeAu = true;
+		const pictureStart = !packet.parameterSet && !this.pictureSeen;
 		if (!packet.parameterSet) this.pictureSeen = true;
 		return {
 			auStart,
 			keyframeAu: this.keyframeAu,
 			keyframeAuStart,
+			pictureStart,
 			parameterSet: packet.parameterSet
 		};
 	}
@@ -10782,7 +10898,7 @@ var NativeRtspClient = class {
 			const channel = this.readBuffer[1];
 			const length = this.readBuffer.readUInt16BE(2);
 			if (this.readBuffer.length < 4 + length) return;
-			const payload = Buffer.from(this.readBuffer.subarray(4, 4 + length));
+			const payload = copyOwned(this.readBuffer, 4, 4 + length);
 			this.readBuffer = this.readBuffer.subarray(4 + length);
 			this.handleInterleavedPacket(channel, payload);
 		} else {
@@ -11518,49 +11634,6 @@ var AudioCodecSession = class {
 	}
 };
 //#endregion
-//#region src/stream-broker/stream-broker/owned-buffer.ts
-/**
-* Buffers that enter a LONG-LIVED ring own their backing store.
-*
-* Node serves `Buffer.from(...)`, `Buffer.allocUnsafe(n)` and `Buffer.concat`
-* below `Buffer.poolSize >>> 1` (4 KiB) as views of shared 8 KiB pool slabs.
-* That is the right choice for the ingest path — a start code, a 4-byte
-* interleave header, a 1.3 KB RTP packet that is fanned out and forgotten
-* within a tick — and the wrong one for anything RETAINED: a 600-byte NAL kept
-* for 60 s in a clip ring pins its whole slab, and with it every short-lived
-* packet that happened to be allocated beside it. On the hub that held
-* 550–980 MB of ArrayBuffers for ~150–250 MB of payload, and the full GCs the
-* pinned slabs caused ran every 0.2–0.5 s at 40–65 % of a core.
-*
-* The ring byte caps counted payload bytes, so they never saw it. Both rings
-* now pass every entry through {@link detachFromPool} on the way in and
-* account it with {@link backingStoreBytes}, so the cap measures what the
-* entry costs. Short-lived traffic stays pooled.
-*/
-/** True when `buf` is the whole of its ArrayBuffer — nothing else shares it. */
-function ownsBackingStore(buf) {
-	return buf.byteOffset === 0 && buf.buffer.byteLength === buf.length;
-}
-/**
-* What retaining `buf` really costs: its own length when it owns its
-* ArrayBuffer, the whole shared slab when it is a view of one.
-*/
-function backingStoreBytes(buf) {
-	return ownsBackingStore(buf) ? buf.length : buf.buffer.byteLength;
-}
-/**
-* `buf` itself when it already owns its ArrayBuffer (decided by inspecting the
-* buffer, never by its size: whether a large `allocUnsafe` is pooled is a Node
-* runtime detail), else a copy that does. One copy, never two: a buffer that is
-* already unpooled is returned as-is.
-*/
-function detachFromPool(buf) {
-	if (ownsBackingStore(buf)) return buf;
-	const owned = Buffer.allocUnsafeSlow(buf.length);
-	buf.copy(owned);
-	return owned;
-}
-//#endregion
 //#region src/stream-broker/stream-broker/encoded-ring-buffer.ts
 /**
 * Time-based ring buffer for encoded video packets.
@@ -12500,9 +12573,6 @@ var StreamBroker = class StreamBroker {
 	*/
 	ffmpegBinaryPathSource = () => null;
 	rtpDepacketizer = null;
-	/** Flag-only depacketizer for the `push-rtp` source-RTP pre-buffer path
-	*  (sets keyframe/param-set flags without re-emitting AnnexB packets). */
-	pushRtpFlagDepacketizer = null;
 	audioRtpDecoder = null;
 	audioCodecSession = null;
 	/**
@@ -12870,10 +12940,24 @@ var StreamBroker = class StreamBroker {
 	*  log alongside `audioRtpSeen`, so a wake-up cycle that brings audio
 	*  back but never video is observable from the structured logs. */
 	videoRtpSeen = 0;
-	/** Tracking flags set synchronously by the RTP depacketizer callback. */
+	/**
+	* What the source RTP packet being handled CARRIES (keyframe / parameter-set
+	* content, read from its payload headers by `classifyRtpPacket`) — the flags
+	* `captureRtpForPreBuffer` reads. Per packet, not per completed NAL: every
+	* fragment of a fragmented IDR carries them, and the ring marks one keyframe
+	* AU for the lot.
+	*/
 	_lastNalKeyframe = false;
 	_lastNalParamSet = false;
 	/**
+	* Whether the Annex-B plane (NAL reassembly + access-unit assembly →
+	* `EncodedPacket`) is being BUILT for this stream. False while nothing
+	* consumes it: the source-RTP path then classifies each packet and copies
+	* nothing. Armed at the next keyframe access unit once a consumer attaches
+	* (`needsAnnexBPlane`), so the first packet it emits is decodable.
+	*/
+	annexBPlaneActive = false;
+	/**
 	* Source-RTP pre-buffer: a ring of raw source RTP packets trimmed to
 	* begin at the most recent keyframe access unit — i.e. the current GOP so
 	* far. A late-joining WebRTC viewer on the repacketizer path replays this
@@ -13949,26 +14033,7 @@ var StreamBroker = class StreamBroker {
 				return;
 			}
 		}
-		if (packet.type === "video") {
-			this.packetCount++;
-			this.totalBytes += packet.data.length;
-			this.bytesInWindow += packet.data.length;
-			this.packetsInWindow++;
-			this.lastPacketAt = Date.now();
-			const now = Date.now();
-			const windowMs = now - this.windowStartMs;
-			if (windowMs >= 2e3) {
-				this.bitrateKbps = Math.round(this.bytesInWindow * 8 / windowMs);
-				this.encodedInputFps = this.packetsInWindow / windowMs * 1e3;
-				this.bytesInWindow = 0;
-				this.packetsInWindow = 0;
-				this.windowStartMs = now;
-			}
-			if (packet.keyframe) {
-				if (this.lastKeyframeMs > 0) this.idrIntervalMs = now - this.lastKeyframeMs;
-				this.lastKeyframeMs = now;
-			}
-		}
+		if (packet.type === "video" && this.rtpDepacketizer === null) this.recordVideoStats(packet.data.length, true, packet.keyframe);
 		if (packet.type === "video" && !this.isRtpSource()) this.preBuffer.push(packet);
 		if (packet.type === "video" && this.clipBuffer && packet.isPlaceholder !== true) this.clipBuffer.push(packet);
 		this.fanOutEncoded(packet);
@@ -14159,8 +14224,8 @@ var StreamBroker = class StreamBroker {
 					index: auStart,
 					ts: auPacket.readUInt32BE(4)
 				});
+				this.trimRtpRingToPreRollWindow();
 			}
-			this.trimRtpRingToPreRollWindow();
 			this.rtpRingHasKeyframe = true;
 		}
 		this.rtpRingPrevMarker = marker;
@@ -14429,10 +14494,10 @@ var StreamBroker = class StreamBroker {
 	*
 	* `push-rtp` providers deliver AnnexB-equivalents separately via
 	* `pushEncodedPacket()` (see `IStreamBroker` contract) — so this path
-	* does NOT re-emit EncodedPackets; it only derives the per-packet
-	* keyframe/param-set flags the pre-buffer capture needs (via a
-	* flag-only depacketizer that never touches the AnnexB plane), keeping
-	* the AnnexB consumers (pipe, restreamer) single-fed by the provider.
+	* does NOT re-emit EncodedPackets; it only classifies each packet for the
+	* keyframe/param-set flags the pre-buffer capture needs
+	* (`classifyRtpPacket`, no reassembly), keeping the AnnexB consumers
+	* (pipe, restreamer) single-fed by the provider.
 	*
 	* The pre-buffer is captured even with zero subscribers attached — a
 	* viewer that connects mid-GOP must be able to replay the GOP that
@@ -14442,9 +14507,9 @@ var StreamBroker = class StreamBroker {
 	pushVideoRtp(rtpData) {
 		if (this.stopping) return;
 		this.kickRtpActivityWatchdog();
-		this._lastNalKeyframe = false;
-		this._lastNalParamSet = false;
-		this.ensurePushRtpFlagDepacketizer().processPacket(rtpData);
+		const carried = classifyRtpPacket(this.detectedCodec === "h265" ? "h265" : "h264", rtpData);
+		this._lastNalKeyframe = carried?.keyframe ?? false;
+		this._lastNalParamSet = carried?.parameterSet ?? false;
 		this.captureRtpForPreBuffer(rtpData);
 		if (this.rtpVideoCallbacks.size === 0) return;
 		for (const [cb, entry] of this.rtpVideoCallbacks) try {
@@ -14454,27 +14519,6 @@ var StreamBroker = class StreamBroker {
 			this.logger?.warn("rtp video subscriber threw", { meta: { error: require_dist.errMsg(err) } });
 		}
 	}
-	/**
-	* Lazily build a flag-only RTP depacketizer for the `push-rtp` source
-	* path. Unlike the native reader's depacketizer (which emits AnnexB
-	* EncodedPackets via `handleDepacketizedNal`), this callback ONLY sets
-	* `_lastNalKeyframe`/`_lastNalParamSet` — the push provider owns the
-	* AnnexB plane through `pushEncodedPacket`, so re-emitting here would
-	* double-feed the pipe/restreamer. push-rtp has no SDP `onVideoTrack`,
-	* so the codec comes from the source declaration (`detectedCodec`, seeded
-	* in `start()`). Dropped on teardown (`resetRtpPipeline`) so a redial
-	* starts with clean FU reassembly state.
-	*/
-	ensurePushRtpFlagDepacketizer() {
-		if (!this.pushRtpFlagDepacketizer) {
-			const codec = this.detectedCodec === "h265" ? "h265" : "h264";
-			this.pushRtpFlagDepacketizer = new RtpDepacketizer(codec, ({ keyframe, parameterSet }) => {
-				if (keyframe) this._lastNalKeyframe = true;
-				if (parameterSet) this._lastNalParamSet = true;
-			});
-		}
-		return this.pushRtpFlagDepacketizer;
-	}
 	/** Toggle the per-device streaming debug flag. */
 	setStreamingDebug(enabled) {
 		this.streamingDebug = enabled;
@@ -14917,10 +14961,17 @@ var StreamBroker = class StreamBroker {
 					seq: this.videoRtpSeen,
 					bytes: rtpData.length
 				} });
-				this._lastNalKeyframe = false;
-				this._lastNalParamSet = false;
-				const carried = this.rtpDepacketizer?.processPacket(rtpData) ?? null;
+				const wantPlane = this.needsAnnexBPlane();
+				if (!wantPlane && this.annexBPlaneActive) this.idleAnnexBPlane();
+				const carried = this.annexBPlaneActive ? this.rtpDepacketizer?.processPacket(rtpData) ?? null : this.rtpDepacketizer?.classifyPacket(rtpData) ?? null;
+				this._lastNalKeyframe = carried?.keyframe ?? false;
+				this._lastNalParamSet = carried?.parameterSet ?? false;
 				const auFlags = carried ? this.rtpAuTracker.classify(carried) : null;
+				if (wantPlane && !this.annexBPlaneActive && auFlags?.keyframeAuStart === true) {
+					this.armAnnexBPlane();
+					this.rtpDepacketizer?.processPacket(rtpData);
+				}
+				if (auFlags) this.recordVideoStats(rtpData.length, auFlags.pictureStart, auFlags.keyframeAu);
 				this.rtspRestreamer.pushRtpPassthrough(rtpData, auFlags?.keyframeAu ?? false, auFlags?.parameterSet ?? false);
 				this.captureRtpForPreBuffer(rtpData);
 				if (this.rtpVideoCallbacks.size > 0) for (const [cb, entry] of this.rtpVideoCallbacks) try {
@@ -15136,11 +15187,83 @@ var StreamBroker = class StreamBroker {
 	* not fed from here.
 	*/
 	handleDepacketizedNal(depacketized) {
-		if (depacketized.keyframe) this._lastNalKeyframe = true;
-		if (depacketized.parameterSet) this._lastNalParamSet = true;
 		this.annexBAssembler.push(depacketized);
 	}
 	/**
+	* Does anything consume the Annex-B plane right now? An encoded subscriber
+	* (WebRTC Annex-B, fragments, a decode session), a pipe client, a clip ring
+	* (it retains access units continuously, so it needs them built even with
+	* nobody attached), or a restreamer still in Annex-B mode (no camera SDP yet).
+	* The RTSP restream and the WebRTC RTP path are served from the source RTP
+	* and never count. Cheap — four field reads — because it runs per packet.
+	*/
+	needsAnnexBPlane() {
+		return this.encodedCallbacks.size > 0 || this.clipBuffer !== null || this.pipeServer.getClientCount() > 0 || !this.rtspRestreamer.rtpPassthroughMode;
+	}
+	/** The consumers that want the plane, for the arm/idle lines. */
+	annexBPlaneConsumers() {
+		return {
+			encodedSubscribers: this.encodedCallbacks.size,
+			clipRing: this.clipBuffer !== null,
+			pipeClients: this.pipeServer.getClientCount(),
+			restreamerAnnexB: !this.rtspRestreamer.rtpPassthroughMode
+		};
+	}
+	/**
+	* Start building access units from the keyframe AU the current packet opens.
+	* The depacketizer and the assembler are clean here (reset when the plane
+	* went idle, or never used), so nothing stale precedes that keyframe.
+	*/
+	armAnnexBPlane() {
+		this.annexBPlaneActive = true;
+		this.logger?.info("annex-b plane armed at a keyframe access unit", {
+			tags: { deviceId: this.numericDeviceId },
+			meta: this.annexBPlaneConsumers()
+		});
+	}
+	/**
+	* Stop building access units: the last consumer left. The picture in
+	* progress is dropped, not flushed — there is nobody to hand it to, and a
+	* partial picture must never reach the next consumer's clean start. Logged,
+	* once per transition: a plane that is idle on purpose must not read as a
+	* stream that stopped.
+	*/
+	idleAnnexBPlane() {
+		this.annexBPlaneActive = false;
+		this.rtpDepacketizer?.reset();
+		this.annexBAssembler.reset();
+		this.logger?.info("annex-b plane idle — no consumer, NAL reassembly skipped", { tags: { deviceId: this.numericDeviceId } });
+	}
+	/**
+	* One place for the input stats, fed from whichever path owns the pictures:
+	* the source RTP packets while the native reader is up (`onVideoRtp`), the
+	* `EncodedPacket`s otherwise (`pushEncodedPacket`). `bytes` accumulate per
+	* call; `inputFps`, `packetCount` and the IDR interval advance once per
+	* picture — the window is closed on a picture start so a window of N frames
+	* reads N, exactly as it did when every call was one access unit.
+	*/
+	recordVideoStats(bytes, pictureStart, keyframe) {
+		this.totalBytes += bytes;
+		this.bytesInWindow += bytes;
+		if (!pictureStart) return;
+		this.packetCount++;
+		this.packetsInWindow++;
+		const now = Date.now();
+		this.lastPacketAt = now;
+		const windowMs = now - this.windowStartMs;
+		if (windowMs >= 2e3) {
+			this.bitrateKbps = Math.round(this.bytesInWindow * 8 / windowMs);
+			this.encodedInputFps = this.packetsInWindow / windowMs * 1e3;
+			this.bytesInWindow = 0;
+			this.packetsInWindow = 0;
+			this.windowStartMs = now;
+		}
+		if (keyframe) {
+			if (this.lastKeyframeMs > 0) this.idrIntervalMs = now - this.lastKeyframeMs;
+			this.lastKeyframeMs = now;
+		}
+	}
+	/**
 	* One assembled access unit → one `EncodedPacket` for every Annex-B
 	* consumer (prebuffer, clip ring, pipe, WebRTC). A keyframe packet is
 	* self-contained (VPS/SPS/PPS + every IDR slice), which is what a decoder
@@ -15561,10 +15684,7 @@ var StreamBroker = class StreamBroker {
 		this.annexBAssembler.flush();
 		this.annexBAssembler.reset();
 		this.rtpAuTracker.reset();
-		if (this.pushRtpFlagDepacketizer) {
-			this.pushRtpFlagDepacketizer.reset();
-			this.pushRtpFlagDepacketizer = null;
-		}
+		this.annexBPlaneActive = false;
 		this.resetRtpPreBuffer();
 		if (this.audioRtpDecoder) {
 			this.audioRtpDecoder.flush();