@camstack/addon-pipeline 1.2.372 → 1.2.373

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-DmuX7IFJ.js");
-const require_node = require("../node-DqA6nD1z.js");
+const require_dist = require("../dist-QBVFmPYQ.js");
+const require_node = require("../node-B6ev-Hqa.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-BkGK1rhu.js");
+const require_segment_demux_js = require("../segment-demux-js-Dp0OI-2n.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");
@@ -3089,6 +3089,223 @@ var RtpPacketizer = class {
 		};
 	}
 };
+function isTransferable(buf) {
+	return typeof Reflect.get(buf, "transfer") === "function";
+}
+var Slab = class {
+	now;
+	buffer;
+	offset = 0;
+	holds = 0;
+	state = "active";
+	releasedAt = 0;
+	constructor(buffer, now) {
+		this.now = now;
+		this.buffer = buffer;
+	}
+};
+/** ArrayBuffer -> slab, for every slab ArrayBuffer currently in service. */
+var slabOf = /* @__PURE__ */ new WeakMap();
+var slabsLive = 0;
+var slabsFree = 0;
+var slabAllocs = 0;
+var slabRecycles = 0;
+function readSlabTotals() {
+	return {
+		live: slabsLive,
+		free: slabsFree,
+		allocs: slabAllocs,
+		recycles: slabRecycles
+	};
+}
+/** True when `buf` is a view of a pool slab. */
+function isSlabView(buf) {
+	return slabOf.has(buf.buffer);
+}
+/** A retaining structure keeps `buf`: its slab cannot be recycled until released. */
+function holdPacket(buf) {
+	const slab = slabOf.get(buf.buffer);
+	if (slab === void 0) return;
+	slab.holds += 1;
+	if (slab.state === "quarantined") slab.state = "held";
+}
+/** The matching drop. Safe on a non-slab buffer and on a stale (recycled) view. */
+function releasePacket(buf) {
+	const slab = slabOf.get(buf.buffer);
+	if (slab === void 0 || slab.holds === 0) return;
+	slab.holds -= 1;
+	if (slab.holds === 0 && slab.state === "held") {
+		slab.state = "quarantined";
+		slab.releasedAt = slab.now();
+	}
+}
+function releasePackets(bufs) {
+	for (const b of bufs) releasePacket(b);
+}
+/**
+* A consumer's own hold on the last `limit` packets it forwarded.
+*
+* werift keeps the last RTP_HISTORY_SIZE (4096) packets of each sender for NACK
+* retransmission, and those packets' payloads are views of the broker's slabs.
+* The session mirrors that window here: each forwarded packet is held, and
+* the one falling out of the window is released, so a retransmit asked for
+* within the history is served from bytes nobody has recycled.
+*/
+var HeldPacketWindow = class {
+	limit;
+	slots;
+	next = 0;
+	constructor(limit) {
+		this.limit = limit;
+		this.slots = new Array(limit).fill(void 0);
+	}
+	hold(buf) {
+		holdPacket(buf);
+		const evicted = this.slots[this.next];
+		if (evicted !== void 0) releasePacket(evicted);
+		this.slots[this.next] = buf;
+		this.next = (this.next + 1) % this.limit;
+	}
+	releaseAll() {
+		for (let i = 0; i < this.slots.length; i++) {
+			const held = this.slots[i];
+			if (held !== void 0) releasePacket(held);
+			this.slots[i] = void 0;
+		}
+		this.next = 0;
+	}
+};
+var PacketSlabPool = class {
+	slabBytes;
+	maxPacket;
+	quarantineMs;
+	maxFree;
+	now;
+	active = null;
+	/** Sealed slabs, oldest first; entries may have been re-held since. */
+	sealed = [];
+	free = [];
+	allocs = 0;
+	recycles = 0;
+	ownBuffers = 0;
+	constructor(options = {}) {
+		this.slabBytes = options.slabBytes ?? 65536;
+		this.maxPacket = this.slabBytes >> 2;
+		this.quarantineMs = options.quarantineMs ?? 2e3;
+		this.maxFree = options.maxFree ?? 2;
+		this.now = options.now ?? Date.now;
+	}
+	/**
+	* A copy of `src[start, end)` in this pool's active slab. An oversized
+	* packet gets its own buffer (it owns its ArrayBuffer, like the old
+	* `copyOwned`).
+	*/
+	copy(src, start, end) {
+		const length = end - start;
+		recordCopyOwned(length);
+		if (length > this.maxPacket) {
+			this.ownBuffers += 1;
+			const own = Buffer.allocUnsafeSlow(length);
+			src.copy(own, 0, start, end);
+			return own;
+		}
+		let slab = this.active;
+		if (slab === null || slab.offset + length > this.slabBytes) slab = this.rotate();
+		const view = Buffer.from(slab.buffer, slab.offset, length);
+		src.copy(view, 0, start, end);
+		slab.offset += length;
+		return view;
+	}
+	/**
+	* `buf` itself when it is already owned (a slab view or a whole-ArrayBuffer
+	* buffer), else a copy in the active slab. Used for packets that arrive from
+	* paths that do not cut through {@link copy} (push-rtp).
+	*/
+	adopt(buf) {
+		if (isSlabView(buf)) return buf;
+		if (buf.byteOffset === 0 && buf.buffer.byteLength === buf.length) return buf;
+		return this.copy(buf, 0, buf.length);
+	}
+	stats() {
+		return {
+			live: this.sealed.length + (this.active === null ? 0 : 1),
+			free: this.free.length,
+			allocs: this.allocs,
+			recycles: this.recycles,
+			ownBuffers: this.ownBuffers
+		};
+	}
+	/** Drop every slab of this pool from the process counters (stream torn down). */
+	dispose() {
+		const live = this.sealed.length + (this.active === null ? 0 : 1);
+		slabsLive -= live;
+		slabsFree -= this.free.length;
+		this.sealed = [];
+		this.free = [];
+		this.active = null;
+	}
+	rotate() {
+		const previous = this.active;
+		if (previous !== null) {
+			this.sealed.push(previous);
+			if (previous.holds === 0) {
+				previous.state = "quarantined";
+				previous.releasedAt = this.now();
+			} else previous.state = "held";
+		}
+		this.reclaim();
+		const next = this.free.pop() ?? this.allocate();
+		if (next.state === "free") {
+			slabsFree -= 1;
+			slabsLive += 1;
+		}
+		next.state = "active";
+		next.offset = 0;
+		next.holds = 0;
+		this.active = next;
+		return next;
+	}
+	allocate() {
+		this.allocs += 1;
+		slabAllocs += 1;
+		slabsLive += 1;
+		const slab = new Slab(new ArrayBuffer(this.slabBytes), this.now);
+		slabOf.set(slab.buffer, slab);
+		return slab;
+	}
+	/** Move quarantined slabs whose time is up to the free list. */
+	reclaim() {
+		if (this.sealed.length === 0) return;
+		const cutoff = this.now() - this.quarantineMs;
+		const keep = [];
+		for (const slab of this.sealed) if (slab.state === "quarantined" && slab.releasedAt <= cutoff) this.recycle(slab);
+		else keep.push(slab);
+		this.sealed = keep;
+	}
+	recycle(slab) {
+		slabsLive -= 1;
+		if (this.free.length >= this.maxFree) {
+			slabOf.delete(slab.buffer);
+			slab.state = "free";
+			return;
+		}
+		const old = slab.buffer;
+		slabOf.delete(old);
+		slab.buffer = isTransferable(old) ? old.transfer() : new ArrayBuffer(this.slabBytes);
+		if (!isTransferable(old)) {
+			this.allocs += 1;
+			slabAllocs += 1;
+		}
+		slabOf.set(slab.buffer, slab);
+		slab.state = "free";
+		slab.offset = 0;
+		slab.holds = 0;
+		this.free.push(slab);
+		slabsFree += 1;
+		this.recycles += 1;
+		slabRecycles += 1;
+	}
+};
 //#endregion
 //#region src/stream-broker/stream-broker/owned-buffer.ts
 /**
@@ -3115,10 +3332,20 @@ function ownsBackingStore(buf) {
 }
 /**
 * What retaining `buf` really costs: its own length when it owns its
-* ArrayBuffer, the whole shared slab when it is a view of one.
+* ArrayBuffer (a packet slab is densely packed, so a slab view counts as its
+* own length too), the whole shared slab when it is a view of a pooled one.
+* The diagnostic `BackingTally` still sums the distinct ArrayBuffers.
 */
 function backingStoreBytes(buf) {
-	return ownsBackingStore(buf) ? buf.length : buf.buffer.byteLength;
+	return ownsBackingStore(buf) || isSlabView(buf) ? buf.length : buf.buffer.byteLength;
+}
+/**
+* What `buf` PINS: its own length when it is the whole of its ArrayBuffer, the
+* whole ArrayBuffer otherwise — a packet slab view included. This is the
+* diagnostic figure (`BackingTally`); caps charge {@link backingStoreBytes}.
+*/
+function pinnedBackingBytes(buf) {
+	return buf.byteOffset === 0 && buf.buffer.byteLength === buf.length ? buf.length : buf.buffer.byteLength;
 }
 /**
 * `buf` itself when it already owns its ArrayBuffer (decided by inspecting the
@@ -3167,7 +3394,7 @@ var BackingTally = class {
 		}
 		this.entries += 1;
 		this.payload += buf.length;
-		const backing = backingStoreBytes(buf);
+		const backing = pinnedBackingBytes(buf);
 		this.naive += backing;
 		if (!this.seen.has(buf.buffer)) {
 			this.seen.add(buf.buffer);
@@ -3460,6 +3687,7 @@ function formatBrokerMem(input) {
 	const w = input.worker;
 	if (w !== void 0 && w !== null) parts.push(`workers=${w.workers}`, `workerHeapMb=${mb(w.heapBytes)}`, `workerPhysicalMb=${mb(w.physicalBytes)}`, `workerUsedMb=${mb(w.usedBytes)}`, `workerAgeS=${Math.round(w.maxAgeMs / 1e3)}`, `workerIdleExit=${w.idleTerminates ? "yes" : "never"}`);
 	parts.push(`brokers=${samples.length}`, `ingesting=${ingesting}`, `annexBPlanes=${planes}`, `rtsp=${rtsp}`, `webrtc=${input.webrtcSessions}`, `encoded=${kindList(consumers)}`, `audioSubs=${audio}`, `pipeClients=${pipe}`, `egress=${input.egressTranscodes}`, `children=${input.childProcesses}`, `opened=${churn.opened}`, `closed=${churn.closed}`, `openedKinds=${kindList(churn.openedByKind)}`, `closedKinds=${kindList(churn.closedByKind)}`, `preBufferMb=${mb(pre)}`, `clipMb=${mb(clip)}`, `rtpRingMb=${mb(rtp)}`, `keyframeMb=${mb(kf)}`, `writeQueueSumMb=${mb(qSum)}`, `writeQueueMaxMb=${mb(qMax)}`, `copiedPackets=${copied.packets}`, `copiedMb=${mb(copied.bytes)}`, `topRingMb=${top === "" ? "none" : top}`);
+	if (input.slabs !== void 0) parts.push(`slabs=${input.slabs.live}/${input.slabs.free}`, `slabAllocs=${input.slabs.allocsDelta}`);
 	const sessions = input.sessions;
 	if (sessions !== void 0) parts.push(...formatSessionMem(sessions, input));
 	return parts.join(" ");
@@ -3849,8 +4077,7 @@ var RtspRestreamer = class {
 		this.mutedSdp = null;
 		this.deframer = null;
 		this.detectedCodec = null;
-		this.lastKeyframeRtpPackets = [];
-		this.lastKeyframeRtpBytes = 0;
+		this.dropKeyframeRtpCache();
 		this._rtpPassthroughMode = false;
 		this.collectingKeyframeRtp = false;
 		this.egressAudioBlock = null;
@@ -4203,21 +4430,21 @@ var RtspRestreamer = class {
 		if (isKeyframe || isParameterSet) {
 			if (!this.collectingKeyframeRtp) {
 				this.collectingKeyframeRtp = true;
-				this.lastKeyframeRtpPackets = [];
-				this.lastKeyframeRtpBytes = 0;
+				this.dropKeyframeRtpCache();
 			}
 		}
 		if (this.collectingKeyframeRtp && !isKeyframe && !isParameterSet) this.collectingKeyframeRtp = false;
 		if (this.collectingKeyframeRtp) {
+			const cached = isSlabView(rtpData) ? rtpData : detachFromPool(rtpData);
+			holdPacket(cached);
 			this.lastKeyframeRtpPackets.push({
-				data: detachFromPool(rtpData),
+				data: cached,
 				marker: rtpPacket.marker
 			});
 			this.lastKeyframeRtpBytes += rtpData.length;
 			if (this.lastKeyframeRtpBytes > MAX_KEYFRAME_CACHE_BYTES) {
 				this.warnCacheCapExceeded("rtp", this.lastKeyframeRtpBytes, this.lastKeyframeRtpPackets.length);
-				this.lastKeyframeRtpPackets = [];
-				this.lastKeyframeRtpBytes = 0;
+				this.dropKeyframeRtpCache();
 				this.collectingKeyframeRtp = false;
 			}
 		}
@@ -4655,6 +4882,7 @@ var RtspRestreamer = class {
 	}
 	destroy() {
 		this._onSessionCountChanged = null;
+		this.dropKeyframeRtpCache();
 		this.sentryAudioSilence?.release("restreamer destroyed");
 		this.abortAllReplays();
 		this.deframer?.flush();
@@ -4663,6 +4891,12 @@ var RtspRestreamer = class {
 		this.packetizer = null;
 		this.deframer = null;
 	}
+	/** Empty the keyframe RTP cache and let go of the slabs it pinned. */
+	dropKeyframeRtpCache() {
+		for (const cached of this.lastKeyframeRtpPackets) releasePacket(cached.data);
+		this.lastKeyframeRtpPackets = [];
+		this.lastKeyframeRtpBytes = 0;
+	}
 	/** Called by deframer for each complete NAL unit. */
 	handleNal(nal, isKeyframe) {
 		if (!this.codecParams) this.tryInitCodec(nal);
@@ -4792,6 +5026,13 @@ function resolveJoinBurstBound(input) {
 	};
 }
 //#endregion
+//#region src/stream-broker/stream-broker/held-write.ts
+/** Write `payload`, holding its slab until the write completes (or fails). */
+function writeHeld(sink, payload) {
+	holdPacket(payload);
+	return sink.write(payload, () => releasePacket(payload));
+}
+//#endregion
 //#region src/stream-broker/rtsp/rtsp-session.ts
 /**
 * Handles one RTSP client connection.
@@ -5107,15 +5348,17 @@ 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 —
-	* `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 payload is a view of the broker's packet slab (`slab-pool.ts`, D868),
+	* never 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. A slab is RECYCLED once the
+	* broker's rings let go of it, and a queued socket write outlives that: Node
+	* keeps the chunk behind a full kernel buffer for as long as the peer takes to
+	* drain (seconds, for a recorder or a LAN decoder), and libuv reads the bytes
+	* only when it writes. So the payload goes out through `writeHeld`, which
+	* holds its slab until Node's write callback (success, error or destroy). A
+	* write that skipped the hold would send a header promising N bytes followed
+	* by zeros.
 	*
 	* The rule to keep: **`socket.write` forbids MUTATION before the write
 	* completes, not retention.** So the header, which IS built per call, must
@@ -5152,7 +5395,7 @@ var RtspSession = class {
 			process.nextTick(this.uncorkAccessUnit);
 		}
 		this.socket.write(header);
-		this.socket.write(payload);
+		writeHeld(this.socket, payload);
 		if (endOfAccessUnit) this.uncorkAccessUnit();
 		this.lastRtpAt = Date.now();
 		this.bytesSent += 4 + payload.length;
@@ -10515,6 +10758,7 @@ var Rfc4571Reader = class {
 	options;
 	callbacks;
 	logger;
+	allocatePacket;
 	host;
 	port;
 	authLine;
@@ -10528,6 +10772,7 @@ var Rfc4571Reader = class {
 	constructor(options, callbacks) {
 		this.options = options;
 		this.callbacks = callbacks;
+		this.allocatePacket = options.packetAllocator ?? copyOwned;
 		this.logger = options.logger;
 		const parsed = new URL(options.url);
 		this.host = parsed.hostname;
@@ -10592,7 +10837,7 @@ var Rfc4571Reader = class {
 		while (this.readBuffer.length >= 2) {
 			const length = this.readBuffer.readUInt16BE(0);
 			if (this.readBuffer.length < 2 + length) return;
-			const rtpPacket = copyOwned(this.readBuffer, 2, 2 + length);
+			const rtpPacket = this.allocatePacket(this.readBuffer, 2, 2 + length);
 			this.readBuffer = this.readBuffer.subarray(2 + length);
 			this.dispatchRtp(rtpPacket);
 		}
@@ -11113,6 +11358,7 @@ var NativeRtspClient = class {
 	keepaliveIntervalMs;
 	logger;
 	callbacks;
+	allocatePacket;
 	/** Parsed SDP from DESCRIBE response. */
 	parsedSdp = null;
 	rawSdpText = null;
@@ -11139,6 +11385,7 @@ var NativeRtspClient = class {
 	tornDown = false;
 	constructor(options, callbacks) {
 		this.callbacks = callbacks;
+		this.allocatePacket = options.packetAllocator ?? copyOwned;
 		this.logger = options.logger;
 		this.connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
 		this.keepaliveIntervalMs = options.keepaliveIntervalMs ?? DEFAULT_KEEPALIVE_INTERVAL_MS;
@@ -11311,7 +11558,7 @@ var NativeRtspClient = class {
 			const channel = this.readBuffer[1];
 			const length = this.readBuffer.readUInt16BE(2);
 			if (this.readBuffer.length < 4 + length) return;
-			const payload = copyOwned(this.readBuffer, 4, 4 + length);
+			const payload = this.allocatePacket(this.readBuffer, 4, 4 + length);
 			this.readBuffer = this.readBuffer.subarray(4 + length);
 			this.handleInterleavedPacket(channel, payload);
 		} else {
@@ -11766,7 +12013,7 @@ var AudioCodecSession = class {
 	processPacket(rtpData) {
 		if (this.closed) return;
 		if (rtpData.length <= RTP_HEADER_LENGTH) return;
-		const payload = rtpData.subarray(RTP_HEADER_LENGTH);
+		const payload = Buffer.from(rtpData.subarray(RTP_HEADER_LENGTH));
 		this.packetsIn++;
 		this.ensureSession().then((sid) => {
 			if (!sid || this.closed) return;
@@ -13384,6 +13631,13 @@ var StreamBroker = class StreamBroker {
 	* Only populated for RTP sources (`isRtpSource()`).
 	*/
 	rtpRing = [];
+	/**
+	* Where this stream's source packets are cut (`slab-pool.ts`, D868): the
+	* readers copy into the pool's slabs, the ring and the restreamer's keyframe
+	* cache hold/release them, and a slab no ring holds is recycled.
+	*/
+	packetPool = new PacketSlabPool();
+	packetAllocator = (src, start, end) => this.packetPool.copy(src, start, end);
 	rtpRingCurAuStart = 0;
 	rtpRingPrevMarker = true;
 	rtpRingHasKeyframe = false;
@@ -13904,6 +14158,8 @@ var StreamBroker = class StreamBroker {
 		this.annexBAssembler.reset();
 		this.encodedCallbacks.clear();
 		this.audioChunkPlane.dispose();
+		this.resetRtpPreBuffer();
+		this.packetPool.dispose();
 	}
 	/** Whether the broker is currently suspended (idle, no RTSP connection). */
 	get suspended() {
@@ -14658,7 +14914,8 @@ 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;
-		const owned = detachFromPool(rtpData);
+		const owned = this.packetPool.adopt(rtpData);
+		holdPacket(owned);
 		this.rtpRing.push(owned);
 		this.rtpRingBytes += backingStoreBytes(owned);
 		if (this._lastNalParamSet || this._lastNalKeyframe) {
@@ -14754,6 +15011,7 @@ var StreamBroker = class StreamBroker {
 	* non-decodable slice instead of waiting for the new dial's first keyframe.
 	*/
 	resetRtpPreBuffer() {
+		releasePackets(this.rtpRing);
 		this.rtpRing = [];
 		this.rtpRingBytes = 0;
 		this.rtpRingCurAuStart = 0;
@@ -14850,6 +15108,7 @@ var StreamBroker = class StreamBroker {
 		if (cut <= 0) return;
 		const dropped = this.rtpRing.splice(0, cut);
 		for (const b of dropped) this.rtpRingBytes -= backingStoreBytes(b);
+		releasePackets(dropped);
 		this.rtpRingKeyframeMarks = this.rtpRingKeyframeMarks.filter((mark) => mark.index >= cut).map((mark) => ({
 			index: mark.index - cut,
 			ts: mark.ts
@@ -15530,7 +15789,7 @@ var StreamBroker = class StreamBroker {
 				this.audioRtpDecoder?.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);
+					const payload = Buffer.from(rtpData.subarray(12));
 					if (payload.length > 0) {
 						const rtpTimestamp = rtpData.readUInt32BE(4);
 						const pts = Math.floor(rtpTimestamp / 8);
@@ -15593,7 +15852,8 @@ var StreamBroker = class StreamBroker {
 		this.logger?.info("starting native RTSP reader");
 		const client = new NativeRtspClient({
 			url: source.url,
-			logger: this.logger?.child("rtsp-native")
+			logger: this.logger?.child("rtsp-native"),
+			packetAllocator: this.packetAllocator
 		}, this.buildRtpStreamCallbacks("native RTSP", () => this.destroyNativeClient(), () => this.nativeClient !== client));
 		this.nativeClient = client;
 		client.connect().catch((err) => {
@@ -16100,7 +16360,8 @@ var StreamBroker = class StreamBroker {
 		const reader = new Rfc4571Reader({
 			url: source.url,
 			sdp,
-			...this.logger ? { logger: this.logger.child("rfc4571") } : {}
+			...this.logger ? { logger: this.logger.child("rfc4571") } : {},
+			packetAllocator: this.packetAllocator
 		}, this.buildRtpStreamCallbacks("rfc4571", () => this.destroyRfc4571Reader(), () => this.rfc4571Reader !== reader));
 		this.rfc4571Reader = reader;
 		reader.connect().catch((err) => {
@@ -22690,19 +22951,19 @@ var H265Repacketizer = class {
 		return this.codecInfo;
 	}
 	updateVps(vps) {
-		this.ensureCodecInfo().vps = vps;
+		this.ensureCodecInfo().vps = Buffer.from(vps);
 	}
 	updateSps(sps) {
-		this.ensureCodecInfo().sps = sps;
+		this.ensureCodecInfo().sps = Buffer.from(sps);
 	}
 	updatePps(pps) {
-		this.ensureCodecInfo().pps = pps;
+		this.ensureCodecInfo().pps = Buffer.from(pps);
 	}
 	updateSeiPrefix(sei) {
-		this.ensureCodecInfo().seiPrefix = sei;
+		this.ensureCodecInfo().seiPrefix = Buffer.from(sei);
 	}
 	updateSeiSuffix(sei) {
-		this.ensureCodecInfo().seiSuffix = sei;
+		this.ensureCodecInfo().seiSuffix = Buffer.from(sei);
 	}
 	shouldFilter(_nalType) {
 		return false;
@@ -23013,6 +23274,48 @@ var H265Repacketizer = class {
 		}
 	}
 };
+//#endregion
+//#region src/stream-broker/webrtc/output-arena.ts
+/**
+* A bump allocator for the buffers the WebRTC send path builds per packet
+* (repacketizer outputs, STAP-A aggregates).
+*
+* `Buffer.from([...])` and `Buffer.concat` below 4 KiB are served from Node's
+* shared 8 KiB pool: one ~1.2 KB fragment per pool slab share, interleaved
+* with every other short-lived pooled buffer in the process. werift keeps the
+* last RTP_HISTORY_SIZE (4096) outputs of a sender for NACK, so each pinned
+* the shared slab it came from and everything beside it. Here every output is
+* a dense view of an arena that holds nothing else.
+*
+* Nothing is ever reused: an arena is left to the GC once full, and lives as
+* long as the last view of it (a NACK slot, a datagram still in flight). That
+* is why there is no hold/release protocol here, unlike `slab-pool.ts`.
+*/
+/** Bytes per arena: ~50 packets of ~1.2 KB per allocation instead of one per 6. */
+var OUTPUT_ARENA_BYTES = 64 * 1024;
+/** A request larger than a quarter of an arena gets its own buffer. */
+var OUTPUT_ARENA_MAX_REQUEST = 16384;
+var OutputArena = class {
+	chunk = Buffer.allocUnsafeSlow(0);
+	offset = 0;
+	chunks = 0;
+	/** `size` writable bytes (contents unspecified: the caller fills all of them). */
+	take(size) {
+		if (size > OUTPUT_ARENA_MAX_REQUEST) return Buffer.allocUnsafeSlow(size);
+		if (this.offset + size > this.chunk.length) {
+			this.chunk = Buffer.allocUnsafeSlow(OUTPUT_ARENA_BYTES);
+			this.chunks += 1;
+			this.offset = 0;
+		}
+		const out = this.chunk.subarray(this.offset, this.offset + size);
+		this.offset += size;
+		return out;
+	}
+	/** ArrayBuffers allocated by this arena so far. */
+	get allocations() {
+		return this.chunks;
+	}
+};
 var NAL_HEADER_SIZE = 1;
 var FU_A_HEADER_SIZE = 2;
 var LENGTH_FIELD_SIZE = 2;
@@ -23057,6 +23360,8 @@ var H264Repacketizer = class {
 	pendingFuA;
 	stapa;
 	fuaMin;
+	/** Dense home for every buffer this repacketizer builds (`output-arena.ts`). */
+	arena = new OutputArena();
 	constructor(console, maxPacketSize, codecInfo, jitterBuffer = new JitterBuffer(console, 4)) {
 		this.console = console;
 		this.maxPacketSize = maxPacketSize;
@@ -23074,70 +23379,78 @@ var H264Repacketizer = class {
 		return this.codecInfo;
 	}
 	updateSps(sps) {
-		this.ensureCodecInfo().sps = sps;
+		this.ensureCodecInfo().sps = Buffer.from(sps);
 	}
 	updatePps(pps) {
-		this.ensureCodecInfo().pps = pps;
+		this.ensureCodecInfo().pps = Buffer.from(pps);
 	}
 	updateSei(sei) {
-		this.ensureCodecInfo().sei = sei;
+		this.ensureCodecInfo().sei = Buffer.from(sei);
 	}
 	shouldFilter(_nalType) {
 		return false;
 	}
 	packetizeFuA(data, noStart, noEnd) {
+		let nalHeader;
+		let bodyStart;
 		if ((data[0] & 31) === 28) {
-			const fnri = data[0] & 224;
-			const originalNalType = data[1] & 31;
 			const isFuStart = !!(data[1] & 128);
 			const isFuEnd = !!(data[1] & 64);
-			const isFuMiddle = !isFuStart && !isFuEnd;
-			const originalNalHeader = Buffer.from([fnri | originalNalType]);
-			data = Buffer.concat([originalNalHeader, data.subarray(FU_A_HEADER_SIZE)]);
+			nalHeader = data[0] & 224 | data[1] & 31;
+			bodyStart = FU_A_HEADER_SIZE;
 			if (isFuStart) noEnd = true;
 			else if (isFuEnd) noStart = true;
-			else if (isFuMiddle) {
+			else {
 				noStart = true;
 				noEnd = true;
 			}
+		} else {
+			nalHeader = data[0];
+			bodyStart = NAL_HEADER_SIZE;
 		}
-		const fnri = data[0] & 224;
-		const nalType = data[0] & 31;
-		const fuIndicator = fnri | 28;
-		const fuHeaderMiddle = Buffer.from([fuIndicator, nalType]);
-		const fuHeaderStart = noStart ? fuHeaderMiddle : Buffer.from([fuIndicator, nalType | 128]);
-		const fuHeaderEnd = noEnd ? fuHeaderMiddle : Buffer.from([fuIndicator, nalType | 64]);
-		let fuHeader = fuHeaderStart;
+		const nalType = nalHeader & 31;
+		const fuIndicator = nalHeader & 224 | 28;
+		const startHeader = noStart ? nalType : nalType | 128;
+		const endHeader = noEnd ? nalType : nalType | 64;
 		const packages = [];
-		let offset = NAL_HEADER_SIZE;
+		let offset = bodyStart;
+		let first = true;
 		while (offset < data.length) {
 			const packageSize = Math.min(this.fuaMax, data.length - offset);
-			const payload = data.subarray(offset, offset + packageSize);
+			const last = offset + packageSize === data.length;
+			const out = this.arena.take(FU_A_HEADER_SIZE + packageSize);
+			out[0] = fuIndicator;
+			out[1] = last ? endHeader : first ? startHeader : nalType;
+			data.copy(out, FU_A_HEADER_SIZE, offset, offset + packageSize);
+			packages.push(out);
 			offset += packageSize;
-			if (offset === data.length) fuHeader = fuHeaderEnd;
-			packages.push(Buffer.concat([fuHeader, payload]));
-			fuHeader = fuHeaderMiddle;
+			first = false;
 		}
 		return packages;
 	}
 	packetizeOneStapA(datas) {
-		const payload = [];
 		if (!datas.length) throw new Error("packetizeOneStapA requires at least one NAL");
-		let counter = 0;
+		const taken = [];
 		let availableSize = this.maxPacketSize - STAP_A_HEADER_SIZE;
 		const stapHeader = 24;
-		while (datas.length && datas[0].length + LENGTH_FIELD_SIZE <= availableSize && counter < 9) {
+		while (datas.length && datas[0].length + LENGTH_FIELD_SIZE <= availableSize && taken.length < 9) {
 			const nalu = datas.shift();
 			availableSize -= LENGTH_FIELD_SIZE + nalu.length;
-			counter += 1;
-			const packed = Buffer.alloc(2);
-			packed.writeUInt16BE(nalu.length, 0);
-			payload.push(packed, nalu);
+			taken.push(nalu);
+		}
+		if (taken.length === 0) return datas.shift();
+		if (taken.length === 1) return taken[0];
+		let total = 1;
+		for (const nalu of taken) total += LENGTH_FIELD_SIZE + nalu.length;
+		const out = this.arena.take(total);
+		out[0] = stapHeader;
+		let offset = 1;
+		for (const nalu of taken) {
+			out.writeUInt16BE(nalu.length, offset);
+			nalu.copy(out, offset + LENGTH_FIELD_SIZE);
+			offset += LENGTH_FIELD_SIZE + nalu.length;
 		}
-		if (counter === 0) return datas.shift();
-		if (counter === 1) return payload[1];
-		payload.unshift(Buffer.from([stapHeader]));
-		return Buffer.concat(payload);
+		return out;
 	}
 	packetizeStapA(datas) {
 		const ret = [];
@@ -23169,12 +23482,15 @@ var H264Repacketizer = class {
 		const originalNalType = first.payload[1] & 31;
 		const hasFuStart = !!(first.payload[1] & 128);
 		const hasFuEnd = !!(last.payload[1] & 64);
-		const fnri = first.payload[0] & 224;
-		const originalNalHeader = Buffer.from([fnri | originalNalType]);
+		const originalNalHeader = first.payload[0] & 224 | originalNalType;
 		const getDefragmentedPendingFua = () => {
-			const originalFragments = pending.map((packet) => packet.payload.subarray(FU_A_HEADER_SIZE));
-			originalFragments.unshift(originalNalHeader);
-			return Buffer.concat(originalFragments);
+			let total = NAL_HEADER_SIZE;
+			for (const packet of pending) total += packet.payload.length - FU_A_HEADER_SIZE;
+			const out = this.arena.take(total);
+			out[0] = originalNalHeader;
+			let offset = NAL_HEADER_SIZE;
+			for (const packet of pending) offset += packet.payload.copy(out, offset, FU_A_HEADER_SIZE);
+			return out;
 		};
 		if (originalNalType === 7) {
 			const splits = splitH264NaluStartCode(getDefragmentedPendingFua());
@@ -23699,6 +24015,8 @@ function selectAudioClock(mimeType) {
 */
 /** A REMB unchanged this long is no estimate (`RembWatch`). */
 var REMB_STALE_MS = 3e4;
+/** werift's NACK history depth (patched RTP_HISTORY_SIZE, `patches/werift+0.22.9.patch`). */
+var SOURCE_RTP_HOLD_PACKETS = 4096;
 var _werift;
 async function loadWerift() {
 	if (_werift) return _werift;
@@ -24246,6 +24564,8 @@ var AdaptiveSession = class AdaptiveSession {
 	*  recovery). While active, live source-RTP packets are enqueued behind
 	*  the replay tail to preserve packet order. Aborted on close/rebind. */
 	activeRtpReplay = null;
+	/** The source packets werift's NACK history may still read (`slab-pool.ts`). */
+	sourceRtpHold = new HeldPacketWindow(SOURCE_RTP_HOLD_PACKETS);
 	/**
 	* Trickle ICE: the server's locally-gathered candidates, buffered as werift
 	* surfaces them via `onIceCandidate`. The client polls `getIceCandidates`
@@ -25124,6 +25444,7 @@ var AdaptiveSession = class AdaptiveSession {
 			this.activeRtpReplay.abort();
 			this.activeRtpReplay = null;
 		}
+		this.sourceRtpHold.releaseAll();
 		await this.releaseTranscodeEgress();
 		try {
 			await this.source.return(void 0);
@@ -25257,6 +25578,7 @@ var AdaptiveSession = class AdaptiveSession {
 			} });
 			return false;
 		}
+		this.sourceRtpHold.hold(rtpData);
 		if (this.sourceVideoSsrc === null) this.sourceVideoSsrc = srcPkt.header.ssrc;
 		const pt = this.videoSender.codec?.payloadType ?? (codec === "H265" ? 97 : 96);
 		let outPkts;
@@ -37862,6 +38184,16 @@ function dialAnswerFromError(err) {
 }
 //#endregion
 //#region src/stream-broker/broker-mem-report.ts
+function readSlabReading() {
+	const totals = readSlabTotals();
+	const allocsDelta = totals.allocs - lastSlabAllocs;
+	lastSlabAllocs = totals.allocs;
+	return {
+		live: totals.live,
+		free: totals.free,
+		allocsDelta
+	};
+}
 /** Linux only: elsewhere (or on a read error) the native view is simply absent. */
 async function readProc() {
 	if (process.platform !== "linux") return {
@@ -37874,6 +38206,8 @@ async function readProc() {
 		maps
 	};
 }
+/** `slabAllocs` is a delta: the totals the previous line saw. */
+var lastSlabAllocs = readSlabTotals().allocs;
 async function emitOnce(deps) {
 	const now = Date.now();
 	const [proc, worker] = await Promise.all([readProc(), readDemuxWorkerHeaps(now)]);
@@ -37886,6 +38220,7 @@ async function emitOnce(deps) {
 		proc,
 		churn: consumerChurn.drain(),
 		copied: readCopyOwnedTotals(),
+		slabs: readSlabReading(),
 		v8: readV8Heap(),
 		worker,
 		sessions: deps.sessionMem(),