@camstack/addon-pipeline 1.2.362 → 1.2.364

package/dist/stream-broker/demux-worker-child.mjs

@@ -1,4 +1,4 @@
-import { t as demuxSegmentFullJs } from "../segment-demux-js-C5IOs4lZ.mjs";
+import { t as demuxSegmentFullJs } from "../segment-demux-js-BhnT__dA.mjs";
 import { parentPort } from "node:worker_threads";
 //#region src/stream-broker/recorded/demux-worker-child.ts
 /**

package/dist/stream-broker/{hostInit-CZ_HBwki.mjs → hostInit-D_DBY5wu.mjs}

@@ -36,7 +36,7 @@ async function r() {
 				}
 			},
 			"@camstack/types": {
-				version: "1.2.358",
+				version: "1.2.360",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,
@@ -81,7 +81,7 @@ async function r() {
 				}
 			},
 			"@camstack/ui-library": {
-				version: "1.2.282",
+				version: "1.2.284",
 				scope: "default",
 				shareConfig: {
 					singleton: !0,

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-tclsRHCk.js");
-const require_node = require("../node-BYrYuZdh.js");
+const require_dist = require("../dist-CGOb--t-.js");
+const require_node = require("../node-UBMRK8SK.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-B9EqRfBi.js");
+const require_segment_demux_js = require("../segment-demux-js-PkDP-xQg.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");
@@ -3731,7 +3731,12 @@ var RtspRestreamer = class {
 	* Forwarded directly to all connected RTSP sessions — zero re-packetization.
 	*
 	* @param rtpData Complete RTP packet (header + payload)
-	* @param isKeyframe True if this packet is part of a keyframe access unit
+	* @param isKeyframe True if this packet is part of a keyframe ACCESS UNIT —
+	*   judged per picture by the broker's `RtpAccessUnitTracker`: every
+	*   fragment of a fragmented IDR and a prefix SEI inside the picture carry
+	*   it, not only the packet that completed an IRAP NAL. The keyframe cache
+	*   below collects exactly that run, and the transition into it is the
+	*   once-per-picture `keyframeAuStart` the sessions resume and count on.
 	* @param isParameterSet True if this packet contains SPS/PPS/VPS
 	*/
 	pushRtpPassthrough(rtpData, isKeyframe, isParameterSet) {
@@ -3747,14 +3752,14 @@ var RtspRestreamer = class {
 				this.lastKeyframeRtpBytes = 0;
 			}
 		}
+		if (this.collectingKeyframeRtp && !isKeyframe && !isParameterSet) this.collectingKeyframeRtp = false;
 		if (this.collectingKeyframeRtp) {
 			this.lastKeyframeRtpPackets.push({
 				data: Buffer.from(rtpData),
 				marker: rtpPacket.marker
 			});
 			this.lastKeyframeRtpBytes += rtpData.length;
-			if (!isKeyframe && !isParameterSet) this.collectingKeyframeRtp = false;
-			else if (this.lastKeyframeRtpBytes > MAX_KEYFRAME_CACHE_BYTES) {
+			if (this.lastKeyframeRtpBytes > MAX_KEYFRAME_CACHE_BYTES) {
 				this.warnCacheCapExceeded("rtp", this.lastKeyframeRtpBytes, this.lastKeyframeRtpPackets.length);
 				this.lastKeyframeRtpPackets = [];
 				this.lastKeyframeRtpBytes = 0;
@@ -3767,17 +3772,16 @@ var RtspRestreamer = class {
 			if (!session.isPlaying()) continue;
 			this.pendingKeyframe.delete(session.getSessionId());
 		}
-		const keyframeAu = isKeyframe || isParameterSet;
 		for (const session of this.sessions.values()) {
 			const sessionId = session.getSessionId();
 			if (this.activeReplays.get(sessionId)?.enqueue({
 				packet: rtpPacket,
 				prime: false,
-				keyframeAuStart: keyframeAu
+				keyframeAuStart
 			})) continue;
 			if (this.pendingKeyframe.has(sessionId)) continue;
 			if (!session.isPlaying()) continue;
-			this.recordLiveOutcome(session.sendRtp(rtpPacket, false, keyframeAu));
+			this.recordLiveOutcome(session.sendRtp(rtpPacket, false, keyframeAuStart));
 		}
 	}
 	/**
@@ -4630,15 +4634,16 @@ var RtspSession = class {
 	*
 	* ## 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 —
+	* 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
+	* mutation, not retention.)
 	*
 	* The rule to keep: **`socket.write` forbids MUTATION before the write
 	* completes, not retention.** So the header, which IS built per call, must
@@ -10127,6 +10132,16 @@ function allocAnnexBNal(byteLength) {
 	buf[3] = 1;
 	return buf;
 }
+var NO_PAYLOAD_CLASS = {
+	keyframe: false,
+	parameterSet: false
+};
+function isH265IrapType(type) {
+	return type >= H265_NAL_IRAP_MIN && type <= H265_NAL_IRAP_MAX;
+}
+function isH265ParameterSetType(type) {
+	return type === H265_NAL_VPS || type === H265_NAL_SPS || type === H265_NAL_PPS;
+}
 /** Total byte length of the reassembly fragments, without allocating a closure. */
 function totalFragmentBytes(fragments) {
 	let total = 0;
@@ -10172,16 +10187,92 @@ var RtpDepacketizer = class {
 	}
 	/**
 	* Process a raw RTP packet (including 12-byte RTP header).
-	* Emits zero or more complete NAL units via the callback.
+	* Emits zero or more complete NAL units via the callback and returns what
+	* THIS packet carried ({@link RtpPacketClass}) — `null` for a packet too
+	* short to be RTP with a payload.
 	*/
 	processPacket(rtpData) {
-		if (rtpData.length < 12) return;
+		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;
+		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
+		};
+	}
+	/** 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)
+		};
 	}
 	processH264(payload, timestamp, marker) {
 		const nalType = payload[0] & 31;
@@ -10327,6 +10418,138 @@ var RtpDepacketizer = class {
 	}
 };
 //#endregion
+//#region src/stream-broker/rtsp/rtp-access-unit-tracker.ts
+/**
+* Tracks access-unit membership across the source RTP packets of ONE stream.
+*
+* The RTSP restreamer forwards source RTP untouched and must know, per
+* packet, whether it is part of a keyframe picture: that is what its keyframe
+* cache collects and what a backlog-latched session resumes on. The
+* depacketizer can only say so about a NAL that COMPLETED, so the fragments of
+* a fragmented IDR before the last one, and a prefix SEI between the parameter
+* sets and the slice, were reported as plain packets: the cache latch closed
+* on them and re-opened on the final fragment, and a backlogged session
+* counted every IRAP slice as a missed keyframe. Here a packet is classified
+* by what it carries ({@link RtpPacketClass}) and the verdict is carried
+* across the whole picture, bounded by the RTP timestamp and marker bit.
+*
+* A parameter-set-only run is not a picture: a camera that stamps SPS/PPS
+* with the previous timestamp still announces ONE keyframe, so the keyframe
+* verdict carries over into the slice that follows instead of starting twice.
+*/
+var RtpAccessUnitTracker = class {
+	timestamp = -1;
+	previousMarker = true;
+	keyframeAu = false;
+	/** The picture in progress has received something other than a parameter set. */
+	pictureSeen = false;
+	classify(packet) {
+		const auStart = this.previousMarker || packet.timestamp !== this.timestamp;
+		if (auStart && this.pictureSeen) this.keyframeAu = false;
+		if (auStart) this.pictureSeen = false;
+		this.timestamp = packet.timestamp;
+		this.previousMarker = packet.marker;
+		const keyframeContent = packet.keyframe || packet.parameterSet;
+		const keyframeAuStart = keyframeContent && !this.keyframeAu;
+		if (keyframeContent) this.keyframeAu = true;
+		if (!packet.parameterSet) this.pictureSeen = true;
+		return {
+			auStart,
+			keyframeAu: this.keyframeAu,
+			keyframeAuStart,
+			parameterSet: packet.parameterSet
+		};
+	}
+	/** A redial re-bases the clock; nothing carries over. */
+	reset() {
+		this.timestamp = -1;
+		this.previousMarker = true;
+		this.keyframeAu = false;
+		this.pictureSeen = false;
+	}
+};
+//#endregion
+//#region src/stream-broker/stream-broker/access-unit-assembler.ts
+/**
+* Groups depacketized NALs into ACCESS UNITS — one per picture.
+*
+* The broker's `EncodedPacket` is one access unit, and every consumer judges it
+* that way: `keyframe` gates where a clip ring widens to, where a late joiner
+* can start, how the pre-roll window is cut; the stats count it as one picture
+* and time the GOP from one `keyframe` to the next. A multi-slice camera (a
+* Hikvision G2 main stream is 3 slices per picture) used to hand each slice —
+* and each prefix SEI — down as its own "frame": 75 input fps on a 25 fps
+* camera, an 8–34 ms "GOP", a clip ring that widened to the LAST IRAP slice
+* (a third of the picture, without its parameter sets), and a prefix SEI that
+* inherited the welded VPS/SPS/PPS instead of the IDR.
+*
+* Boundary rule (RFC 3550 / 6184 / 7798): the RTP marker bit closes the
+* picture it ends — flushed on the spot, so a single-slice stream pays no
+* latency — and a timestamp change closes the one before it, for cameras that
+* never set the marker. Parameter sets are held and welded onto the picture
+* that follows them, so a keyframe access unit is self-contained
+* (VPS/SPS/PPS + IDR) exactly as before; a prefix SEI stays inside its
+* picture and is never a frame of its own.
+*/
+var AccessUnitAssembler = class {
+	onAccessUnit;
+	/** Parameter sets seen since the last picture closed; welded onto the next one. */
+	pendingParamNals = [];
+	/** NALs of the picture in progress (parameter sets first when welded). */
+	pictureNals = [];
+	pictureTimestamp = 0;
+	pictureKeyframe = false;
+	constructor(onAccessUnit) {
+		this.onAccessUnit = onAccessUnit;
+	}
+	push(depacketized) {
+		const { annexB, keyframe, parameterSet, timestamp, marker } = depacketized;
+		if (this.pictureNals.length > 0 && timestamp !== this.pictureTimestamp) this.flush();
+		if (parameterSet) {
+			this.pendingParamNals.push(annexB);
+			return;
+		}
+		if (this.pictureNals.length === 0) {
+			this.pictureTimestamp = timestamp;
+			this.pictureKeyframe = false;
+		}
+		if (this.pendingParamNals.length > 0) {
+			for (const paramNal of this.pendingParamNals) this.pictureNals.push(paramNal);
+			this.pendingParamNals = [];
+			this.pictureKeyframe = true;
+		}
+		this.pictureNals.push(annexB);
+		if (keyframe) this.pictureKeyframe = true;
+		if (marker) this.flush();
+	}
+	/**
+	* Emit the picture in progress, if any. Called on the marker bit, on a
+	* timestamp change, and by the broker when the stream stops or redials so
+	* the last picture of a marker-less stream is not lost.
+	*/
+	flush() {
+		if (this.pictureNals.length === 0) return;
+		const nals = this.pictureNals;
+		const timestamp = this.pictureTimestamp;
+		const keyframe = this.pictureKeyframe;
+		this.pictureNals = [];
+		this.pictureKeyframe = false;
+		const annexB = nals.length === 1 ? nals[0] : Buffer.concat(nals);
+		this.onAccessUnit({
+			annexB,
+			timestamp,
+			keyframe
+		});
+	}
+	/** Drop everything held — a redial re-bases the clock, nothing carries over. */
+	reset() {
+		this.pendingParamNals = [];
+		this.pictureNals = [];
+		this.pictureTimestamp = 0;
+		this.pictureKeyframe = false;
+	}
+};
+//#endregion
 //#region src/stream-broker/rtsp/rtsp-client.ts
 var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
 var DEFAULT_KEEPALIVE_INTERVAL_MS = 3e4;
@@ -11295,6 +11518,49 @@ 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.
@@ -11305,6 +11571,12 @@ var AudioCodecSession = class {
 *
 * The buffer always starts from the most recent keyframe to ensure
 * consumers can decode the returned data.
+*
+* Every entry OWNS its backing store (`owned-buffer.ts`): a sub-stream NAL
+* arrives as a view of a shared 8 KiB pool slab, and a ring that kept it for
+* 60 s pinned the slab and every short-lived packet beside it — the clip
+* rings of ~70 brokers were the largest holder of the hub broker's
+* 550–980 MB of ArrayBuffers. The byte budget charges what an entry pins.
 */
 var EncodedRingBuffer = class {
 	packets = [];
@@ -11336,13 +11608,25 @@ var EncodedRingBuffer = class {
 	getDuration() {
 		return this.maxDurationMs / 1e3;
 	}
-	/** Push a new packet into the buffer and evict expired ones. */
+	/**
+	* Push a new packet into the buffer and evict expired ones.
+	*
+	* A pooled payload is copied into its own allocation on the way in; one
+	* that already owns its ArrayBuffer is stored as-is. The consumers fanned
+	* out from the same packet keep the original, so the copy is the ring's
+	* alone and is freed with it.
+	*/
 	push(packet) {
-		this.packets.push(packet);
-		this.bytes += packet.data.length;
+		const data = detachFromPool(packet.data);
+		const stored = data === packet.data ? packet : {
+			...packet,
+			data
+		};
+		this.packets.push(stored);
+		this.bytes += backingStoreBytes(data);
 		this.evict();
 	}
-	/** What the retained window currently costs, in bytes. */
+	/** What the retained window currently costs, in bytes of backing store. */
 	getBufferedBytes() {
 		return this.bytes;
 	}
@@ -11420,14 +11704,14 @@ var EncodedRingBuffer = class {
 		let removeCount = 0;
 		while (removeCount < this.packets.length && (this.packets[removeCount].pts < cutoff || this.packets[removeCount].pts > newest)) removeCount++;
 		if (removeCount > 0) {
-			for (let i = 0; i < removeCount; i++) this.bytes -= this.packets[i].data.length;
+			for (let i = 0; i < removeCount; i++) this.bytes -= backingStoreBytes(this.packets[i].data);
 			this.packets.splice(0, removeCount);
 		}
 		if (this.maxBytes > 0 && this.bytes > this.maxBytes) {
 			this.clampedByBytes = true;
 			let dropped = 0;
 			while (dropped < this.packets.length && this.bytes > this.maxBytes) {
-				this.bytes -= this.packets[dropped].data.length;
+				this.bytes -= backingStoreBytes(this.packets[dropped].data);
 				dropped++;
 			}
 			if (dropped > 0) this.packets.splice(0, dropped);
@@ -13091,7 +13375,7 @@ var StreamBroker = class StreamBroker {
 		this.rtspRestreamer.destroy();
 		this.preBuffer.clear();
 		this.clipBuffer?.clear();
-		this.pendingParamNals = [];
+		this.annexBAssembler.reset();
 		this.encodedCallbacks.clear();
 		this.audioChunkPlane.dispose();
 	}
@@ -13554,7 +13838,7 @@ var StreamBroker = class StreamBroker {
 		this.reconcilePrestreamWindow();
 		this.preBuffer.clear();
 		this.clipBuffer?.clear();
-		this.pendingParamNals = [];
+		this.annexBAssembler.reset();
 		this.rtspRestreamer.resetStreamState();
 		this.totalBytes = 0;
 		this.bytesInWindow = 0;
@@ -13863,8 +14147,9 @@ var StreamBroker = class StreamBroker {
 	captureRtpForPreBuffer(rtpData) {
 		const marker = rtpData.length > 1 && (rtpData[1] & 128) !== 0;
 		if (this.rtpRingPrevMarker || this.rtpRing.length === 0) this.rtpRingCurAuStart = this.rtpRing.length;
-		this.rtpRing.push(rtpData);
-		this.rtpRingBytes += rtpData.length;
+		const owned = detachFromPool(rtpData);
+		this.rtpRing.push(owned);
+		this.rtpRingBytes += backingStoreBytes(owned);
 		if (this._lastNalParamSet || this._lastNalKeyframe) {
 			const auStart = this.rtpRingCurAuStart;
 			const lastMark = this.rtpRingKeyframeMarks[this.rtpRingKeyframeMarks.length - 1];
@@ -14042,18 +14327,18 @@ var StreamBroker = class StreamBroker {
 			this.reportPreRollClamp(budget, retentionMs);
 			const historyEnd = this.rtpRingKeyframeMarks[this.rtpRingKeyframeMarks.length - 1].index;
 			let retained = 0;
-			for (let i = cut; i < historyEnd; i++) retained += this.rtpRing[i].length;
+			for (let i = cut; i < historyEnd; i++) retained += backingStoreBytes(this.rtpRing[i]);
 			let markIdx = this.rtpRingKeyframeMarks.findIndex((m) => m.index === cut);
 			while (retained > budget.bytes && markIdx >= 0 && markIdx < this.rtpRingKeyframeMarks.length - 1) {
 				const nextCut = this.rtpRingKeyframeMarks[markIdx + 1].index;
-				for (let i = cut; i < nextCut; i++) retained -= this.rtpRing[i].length;
+				for (let i = cut; i < nextCut; i++) retained -= backingStoreBytes(this.rtpRing[i]);
 				cut = nextCut;
 				markIdx++;
 			}
 		}
 		if (cut <= 0) return;
 		const dropped = this.rtpRing.splice(0, cut);
-		for (const b of dropped) this.rtpRingBytes -= b.length;
+		for (const b of dropped) this.rtpRingBytes -= backingStoreBytes(b);
 		this.rtpRingKeyframeMarks = this.rtpRingKeyframeMarks.filter((mark) => mark.index >= cut).map((mark) => ({
 			index: mark.index - cut,
 			ts: mark.ts
@@ -14393,11 +14678,15 @@ var StreamBroker = class StreamBroker {
 		if (clamped === this.clipRetentionSec) return;
 		const previous = this.clipRetentionSec;
 		this.clipRetentionSec = clamped;
-		this.logger?.info(clamped === 0 ? "Clip retention off" : "Clip retention set", { meta: {
-			seconds: clamped,
-			requested: seconds,
-			previousSeconds: previous
-		} });
+		this.logger?.info(clamped === 0 ? "Clip retention off" : "Clip retention set", {
+			tags: { deviceId: this.numericDeviceId },
+			meta: {
+				seconds: clamped,
+				requested: seconds,
+				previousSeconds: previous,
+				capBytes: StreamBroker.CLIP_RING_MAX_BYTES
+			}
+		});
 		if (clamped === 0) {
 			this.clipBuffer = null;
 			return;
@@ -14630,8 +14919,9 @@ var StreamBroker = class StreamBroker {
 				} });
 				this._lastNalKeyframe = false;
 				this._lastNalParamSet = false;
-				this.rtpDepacketizer?.processPacket(rtpData);
-				this.rtspRestreamer.pushRtpPassthrough(rtpData, this._lastNalKeyframe, this._lastNalParamSet);
+				const carried = this.rtpDepacketizer?.processPacket(rtpData) ?? null;
+				const auFlags = carried ? this.rtpAuTracker.classify(carried) : null;
+				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 {
 					cb(rtpData);
@@ -14827,51 +15117,44 @@ var StreamBroker = class StreamBroker {
 	* RTSP restreamer's pushRtpPassthrough.
 	*/
 	/**
-	* Pending parameter-set NALs (SPS/PPS for H.264, VPS/SPS/PPS for H.265).
-	* Cameras emit these as separate RTP packets before the IDR/IRAP frame.
-	* We buffer them here and prepend to the next VCL NAL so downstream
-	* consumers (WebRTC, prebuffer, restream) receive complete access units
-	* with a single `EncodedPacket` that contains SPS+PPS+IDR together.
+	* Groups the depacketizer's NALs into access units — ONE `EncodedPacket`
+	* per picture, parameter sets welded onto the keyframe picture they
+	* precede. See `access-unit-assembler.ts` for the boundary rule and the
+	* per-NAL emit it replaced.
 	*/
-	pendingParamNals = [];
+	annexBAssembler = new AccessUnitAssembler((accessUnit) => this.emitAccessUnit(accessUnit));
+	/** Access-unit membership of the source RTP packets, for the restreamer's flags. */
+	rtpAuTracker = new RtpAccessUnitTracker();
 	/**
 	* handleDepacketizedNal receives individual NALs from the RTP depacketizer
-	* and emits them as EncodedPackets.
-	*
-	* Parameter-set NALs (SPS/PPS type 7/8 for H.264, VPS/SPS/PPS type 32/33/34
-	* for H.265) are buffered and prepended to the next VCL NAL (slice/IDR).
-	* This guarantees every keyframe EncodedPacket is a self-contained access
-	* unit that a decoder can initialise from — critical for WebRTC (Chrome
-	* can't decode an IDR without preceding SPS/PPS).
+	* and hands them to the access-unit assembler, which emits one
+	* `EncodedPacket` per PICTURE (`emitAccessUnit`) — never per NAL. A
+	* multi-slice IDR, its parameter sets and its prefix SEI are one keyframe
+	* packet; three P slices are one P packet.
 	*
-	* The RTSP restreamer handles its own RTP passthrough separately and is
-	* not affected by this merging.
+	* The RTSP restreamer forwards source RTP separately (`onVideoRtp`) and is
+	* not fed from here.
 	*/
 	handleDepacketizedNal(depacketized) {
-		const { nal, keyframe, parameterSet, timestamp } = depacketized;
+		if (depacketized.keyframe) this._lastNalKeyframe = true;
+		if (depacketized.parameterSet) this._lastNalParamSet = true;
+		this.annexBAssembler.push(depacketized);
+	}
+	/**
+	* 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
+	* initialises from and what a clip or a pre-roll window may start at.
+	*/
+	emitAccessUnit(accessUnit) {
 		const codec = this.detectedCodec ?? "h264";
-		if (keyframe) this._lastNalKeyframe = true;
-		if (parameterSet) this._lastNalParamSet = true;
-		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) {
-			this.pendingParamNals.push(depacketized.annexB);
-			return;
-		}
-		const hadParamSets = this.pendingParamNals.length > 0;
-		let annexBData;
-		if (hadParamSets) {
-			this.pendingParamNals.push(depacketized.annexB);
-			annexBData = Buffer.concat(this.pendingParamNals);
-			this.pendingParamNals = [];
-		} else annexBData = depacketized.annexB;
-		const pts = Math.floor(timestamp / 90);
+		const pts = Math.floor(accessUnit.timestamp / 90);
 		const packet = {
 			type: "video",
-			data: annexBData,
+			data: accessUnit.annexB,
 			pts,
 			dts: pts,
-			keyframe: keyframe || hadParamSets,
+			keyframe: accessUnit.keyframe,
 			codec
 		};
 		this.pushEncodedPacket(packet);
@@ -15275,6 +15558,9 @@ var StreamBroker = class StreamBroker {
 			this.rtpDepacketizer.reset();
 			this.rtpDepacketizer = null;
 		}
+		this.annexBAssembler.flush();
+		this.annexBAssembler.reset();
+		this.rtpAuTracker.reset();
 		if (this.pushRtpFlagDepacketizer) {
 			this.pushRtpFlagDepacketizer.reset();
 			this.pushRtpFlagDepacketizer = null;