@camstack/addon-pipeline 1.2.11 → 1.2.13

package/dist/stream-broker/index.mjs

@@ -1,7 +1,7 @@
-import { l as __require, n as createFileDataPlaneHandler } from "../model-download-service-Cp9f4dk6-WO-foD7W.mjs";
-import { B as webrtcSessionCapability, G as DeviceType, H as BaseAddon, J as isEvent, K as createEvent, O as maskUrlCredentials, Q as parseProfileBrokerId, R as streamBrokerCapability, U as CAM_PROFILE_ORDER, V as errMsg, W as DeviceFeature, X as makeSourceBrokerId, Y as makeProfileBrokerId, ct as object, dt as union, ft as EventCategory, g as addonWidgetsSourceCapability, it as discriminatedUnion, j as nodePin, l as EncodeProfileSchema, lt as record, m as RingBuffer, nt as array, ot as literal, rt as boolean, st as number, tt as _enum, ut as string, y as cameraStreamsCapability } from "../dist-owmpaeIY.mjs";
+import { l as __require, n as createFileDataPlaneHandler, u as __toESM } from "../model-download-service-Cp9f4dk6-WO-foD7W.mjs";
+import { B as webrtcSessionCapability, G as DeviceType, H as BaseAddon, J as isEvent, K as createEvent, O as maskUrlCredentials, Q as parseProfileBrokerId, R as streamBrokerCapability, U as CAM_PROFILE_ORDER, V as errMsg, W as DeviceFeature, X as makeSourceBrokerId, Y as makeProfileBrokerId, ct as object, dt as union, ft as EventCategory, g as addonWidgetsSourceCapability, it as discriminatedUnion, j as nodePin, l as EncodeProfileSchema, lt as record, m as RingBuffer, nt as array, ot as literal, rt as boolean, st as number, tt as _enum, ut as string, y as cameraStreamsCapability } from "../dist-DuI0Ypuu.mjs";
 import { n as profileForStreamId } from "../remote-restream-BeHi78PZ.mjs";
-import { t as extractKeyframes } from "../fmp4-keyframes-qOgJBjMO.mjs";
+import { n as extractSamples, r as require_mp4box_all, t as extractKeyframes } from "../fmp4-keyframes-CV0X1mGy.mjs";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { pathToFileURL } from "node:url";
@@ -2429,6 +2429,30 @@ function logBannerArgs(level) {
 		level
 	];
 }
+/** PCMU: 8 kHz µ-law, 160 samples (20 ms), static PT 0. */
+var AUDIO_CLOCK_PCMU = {
+	codec: "pcmu",
+	rateHz: 8e3,
+	frameSamples: 160,
+	payloadType: 0
+};
+/** Opus: 48 kHz, 960 samples (20 ms), dynamic PT 111. */
+var AUDIO_CLOCK_OPUS = {
+	codec: "opus",
+	rateHz: 48e3,
+	frameSamples: 960,
+	payloadType: 111
+};
+/**
+* Select the audio clock for a negotiated sender mime type
+* (`audio/opus`, `audio/PCMU`, …). Anything not recognised as Opus falls back
+* to PCMU — the always-offered baseline codec — so an unexpected/absent mime
+* can never silently pick the wrong (48 kHz) clock for an 8 kHz track.
+*/
+function selectAudioClock(mimeType) {
+	if (mimeType && /opus/i.test(mimeType)) return AUDIO_CLOCK_OPUS;
+	return AUDIO_CLOCK_PCMU;
+}
 //#endregion
 //#region src/stream-broker/webrtc/session.ts
 var _werift;
@@ -2867,6 +2891,8 @@ var AdaptiveSession = class AdaptiveSession {
 	*/
 	recordedAudioRebasePending = false;
 	recordedAudioTsOffset = 0;
+	negotiatedAudioClock = null;
+	opusSilenceFrame = null;
 	/** Client-created control data channel (recorded-playback protocol). */
 	controlChannel = null;
 	onControlMessageCb = null;
@@ -3225,6 +3251,12 @@ var AdaptiveSession = class AdaptiveSession {
 			codecs: {
 				video: this.sourceCodec === "H265" ? [h265Codec, h264Codec] : [h264Codec],
 				audio: [new werift.RTCRtpCodecParameters({
+					mimeType: "audio/opus",
+					clockRate: 48e3,
+					payloadType: 111,
+					channels: 2,
+					parameters: "minptime=10;useinbandfec=1"
+				}), new werift.RTCRtpCodecParameters({
 					mimeType: "audio/PCMU",
 					clockRate: 8e3,
 					payloadType: 0,
@@ -4202,7 +4234,7 @@ var AdaptiveSession = class AdaptiveSession {
 					} else if (mediaFrame.type === "audio") {
 						const frame = mediaFrame.frame;
 						if (!this.audioSender) continue;
-						const rtpTs = Math.floor(frame.timestampMicros * AdaptiveSession.PCMU_RTP_CLOCK_HZ / 1e6) >>> 0;
+						const rtpTs = Math.floor(frame.timestampMicros * this.audioClock().rateHz / 1e6) >>> 0;
 						this.recordAudioSourceLatency(frame.timestampMicros);
 						this.writeAudio(frame.data, rtpTs, frame.codec);
 					}
@@ -4321,7 +4353,7 @@ var AdaptiveSession = class AdaptiveSession {
 					if (signal.aborted || this.closed) break;
 					if (mediaFrame.type === "audio") {
 						const frame = mediaFrame.frame;
-						const rtpTs = Math.floor(frame.timestampMicros * AdaptiveSession.PCMU_RTP_CLOCK_HZ / 1e6) >>> 0;
+						const rtpTs = Math.floor(frame.timestampMicros * this.audioClock().rateHz / 1e6) >>> 0;
 						this.recordAudioSourceLatency(frame.timestampMicros);
 						this.writeAudio(frame.data, rtpTs, frame.codec);
 					}
@@ -4477,6 +4509,41 @@ var AdaptiveSession = class AdaptiveSession {
 		}
 	}
 	/**
+	* Send one recorded Opus (48 kHz) audio frame on the shared audio sender.
+	* The Opus sibling of `writeRecordedAudio` — active ONLY while the live feed
+	* is gated and the session negotiated Opus. Stored Opus AUs (post-A1 fMP4
+	* fragments) are forwarded with NO transcode. Timestamp is software-rebased
+	* to continue monotonically from the last sent audio packet across the
+	* live→recorded switch, at the 48 kHz Opus clock (one 20 ms frame = 960
+	* samples).
+	*/
+	writeRecordedAudioOpus(opus, rtpTs48k) {
+		if (!this.audioSender || !_werift) return;
+		if (!this.liveFeedGated) return;
+		const werift = _werift;
+		if (this.recordedAudioRebasePending) {
+			this.recordedAudioRebasePending = false;
+			this.recordedAudioTsOffset = (this.lastAudioRtpTs ?? 0) + AUDIO_CLOCK_OPUS.frameSamples - rtpTs48k | 0;
+		}
+		const outTs = rtpTs48k + this.recordedAudioTsOffset >>> 0;
+		const pt = this.audioSender.codec?.payloadType ?? AUDIO_CLOCK_OPUS.payloadType;
+		try {
+			const header = new werift.RtpHeader();
+			header.payloadType = pt;
+			header.timestamp = outTs;
+			header.marker = true;
+			header.sequenceNumber = this.audioSeqNum = this.audioSeqNum + 1 & 65535;
+			this.audioSender.sendRtp(new werift.RtpPacket(header, opus));
+			this.lastAudioRtpTs = outTs;
+		} catch (err) {
+			this.logger.debug("recorded opus audio write error", { meta: {
+				phase: "session",
+				sessionId: this.sessionId,
+				error: errMsg(err)
+			} });
+		}
+	}
+	/**
 	* On a source switch, remap werift's sender offsets so the new source's first
 	* packet (seq/ts) continues seamlessly from the last sent packet. One-shot per
 	* switch (cleared after firing). No-op until a packet has actually been sent
@@ -4688,6 +4755,32 @@ var AdaptiveSession = class AdaptiveSession {
 			}
 		}
 	}
+	/**
+	* The negotiated audio RTP clock (PCMU 8 kHz or Opus 48 kHz), resolved once
+	* from the werift sender's bound codec and cached. Returns the PCMU baseline
+	* (uncached) until the sender codec is bound, so an early call can't lock in
+	* the wrong clock.
+	*/
+	audioClock() {
+		if (this.negotiatedAudioClock) return this.negotiatedAudioClock;
+		const mime = this.audioSender?.codec?.mimeType;
+		if (!mime) return AUDIO_CLOCK_PCMU;
+		const clock = selectAudioClock(mime);
+		this.negotiatedAudioClock = clock;
+		return clock;
+	}
+	/** True once the session has negotiated the Opus audio codec. */
+	get isOpusAudio() {
+		return this.audioClock().codec === "opus";
+	}
+	/**
+	* Inject the canonical 20 ms Opus silence packet used for prestream A/V-sync
+	* padding. Broker-provided (encoded via the audio-codec cap) because Opus has
+	* no fixed silence byte the way PCMU does (0xFF).
+	*/
+	setOpusSilenceFrame(frame) {
+		this.opusSilenceFrame = frame;
+	}
 	writeAudio(data, rtpTs, codec) {
 		if (!this.audioSender || !_werift) return;
 		if (this.liveFeedGated) return;
@@ -4740,17 +4833,19 @@ var AdaptiveSession = class AdaptiveSession {
 		if (!this.audioSender || !_werift) return;
 		const werift = _werift;
 		const nowMs = Date.now();
+		const clock = this.audioClock();
+		const silencePayload = clock.codec === "opus" ? this.opusSilenceFrame : Buffer.alloc(AdaptiveSession.PCMU_FRAME_SAMPLES, AdaptiveSession.PCMU_SILENCE_BYTE);
+		if (!silencePayload) return;
 		const plan = planAudioSilencePadPackets({
 			nowMs,
 			firstVideoSendWallMs: this.firstVideoSendWallMs,
-			framesizeSamples: AdaptiveSession.PCMU_FRAME_SAMPLES,
-			rateHz: AdaptiveSession.PCMU_RTP_CLOCK_HZ,
+			framesizeSamples: clock.frameSamples,
+			rateHz: clock.rateHz,
 			maxPadMs: AdaptiveSession.AUDIO_SILENCE_MAX_PAD_MS,
 			realRtpTs,
 			audioSeqNum: this.audioSeqNum
 		});
 		if (plan.packets.length === 0) return;
-		const silencePayload = Buffer.alloc(AdaptiveSession.PCMU_FRAME_SAMPLES, AdaptiveSession.PCMU_SILENCE_BYTE);
 		for (let i = 0; i < plan.packets.length; i++) {
 			const planned = plan.packets[i];
 			try {
@@ -4785,7 +4880,7 @@ var AdaptiveSession = class AdaptiveSession {
 			gapMs: this.firstVideoSendWallMs === null ? null : nowMs - this.firstVideoSendWallMs,
 			firstSilenceRtpTs: plan.packets[0]?.rtpTs ?? null,
 			realRtpTs,
-			frameSize: AdaptiveSession.PCMU_FRAME_SAMPLES
+			frameSize: clock.frameSamples
 		} });
 	}
 	startStatsCollection() {
@@ -4832,10 +4927,9 @@ var AdaptiveSession = class AdaptiveSession {
 		});
 		this.emitAvSyncDiag();
 	}
-	/** Negotiated audio RTP clock rate in Hz (PCMU is always 8 kHz here; falls
-	*  back to the sender's clockRate if werift reports one). Video is 90 kHz. */
+	/** Video RTP clock rate in Hz (audio rate now comes from `audioClock()`,
+	*  which follows the negotiated codec — PCMU 8 kHz / Opus 48 kHz). */
 	static VIDEO_RTP_CLOCK_HZ = 9e4;
-	static PCMU_RTP_CLOCK_HZ = 8e3;
 	/**
 	* Emit the periodic "av-sync diag" log (debug only, ~every 3s) to gather the
 	* evidence for the steady "audio plays ~0.5s behind video" lag — WITHOUT
@@ -4851,7 +4945,7 @@ var AdaptiveSession = class AdaptiveSession {
 	emitAvSyncDiag() {
 		if (!this.debug) return;
 		const elapsedMs = Date.now() - this.createdAt;
-		const audioRate = AdaptiveSession.PCMU_RTP_CLOCK_HZ;
+		const audioRate = this.audioClock().rateHz;
 		const skew = computeAvSyncSkew({
 			video: this.lastVideoRtpTs === null || this.firstVideoRtpTs === null ? null : {
 				rtpTs: this.lastVideoRtpTs - this.firstVideoRtpTs >>> 0,
@@ -5819,6 +5913,21 @@ function appendAudioMediaBlock(videoSdp, audioBlock) {
 */
 var LIVE_EDGE_MAX_SPAN_MS = 500;
 /**
+* Defensive hard bound on the per-keyframe RTP/NAL cache (both the passthrough
+* `lastKeyframeRtpPackets` and the Annex-B `lastKeyframeNals`). A single
+* keyframe GOP is at most a few large NALs — well under a megabyte or two even
+* for 4K/8MP IDRs. Anything past this cap means the collection latch never
+* closed (an all-intra stream, or a stall right after an IDR before the first
+* P-frame), so the cache would otherwise grow without bound. That is the exact
+* structure that reached ~1.5 GB and OOM-killed the hub stream-broker runner
+* (heap snapshot: 1567 MB retained by `RtspRestreamer.lastKeyframeRtpPackets`).
+* On overflow we drop the partial cache and stop collecting until the next
+* clean GOP boundary; the live edge is unaffected — only the late-joiner
+* keyframe burst is skipped meanwhile.
+*/
+var MAX_KEYFRAME_CACHE_BYTES = 16 * 1024 * 1024;
+var CACHE_CAP_WARN_INTERVAL_MS = 3e4;
+/**
 * Per-broker RTSP restreamer.
 *
 * Operates in two modes:
@@ -5851,6 +5960,7 @@ var RtspRestreamer = class {
 	egressAudioBlock = null;
 	/** Cached last keyframe NALs (SPS/PPS + IDR) for late-joining clients. */
 	lastKeyframeNals = [];
+	lastKeyframeNalBytes = 0;
 	lastKeyframeTimestamp = 0;
 	/** True if we're currently accumulating a keyframe's NALs. */
 	collectingKeyframe = false;
@@ -5858,6 +5968,9 @@ var RtspRestreamer = class {
 	currentTimestamp = 0;
 	/** RTP passthrough: cached last keyframe RTP packets for late-joining clients. */
 	lastKeyframeRtpPackets = [];
+	lastKeyframeRtpBytes = 0;
+	/** Throttle for the defensive keyframe-cache overflow warning. */
+	cacheCapWarnMs = 0;
 	/** True when in RTP passthrough mode (setCameraSdp was called). */
 	_rtpPassthroughMode = false;
 	/** Accumulating keyframe RTP packets in passthrough mode. */
@@ -5898,6 +6011,7 @@ var RtspRestreamer = class {
 	*/
 	resetStreamState() {
 		this.lastKeyframeNals = [];
+		this.lastKeyframeNalBytes = 0;
 		this.lastKeyframeTimestamp = 0;
 		this.collectingKeyframe = false;
 		this.currentTimestamp = 0;
@@ -5908,11 +6022,29 @@ var RtspRestreamer = class {
 		this.deframer = null;
 		this.detectedCodec = null;
 		this.lastKeyframeRtpPackets = [];
+		this.lastKeyframeRtpBytes = 0;
 		this._rtpPassthroughMode = false;
 		this.collectingKeyframeRtp = false;
 		this.egressAudioBlock = null;
 	}
 	/**
+	* Enforce the defensive per-keyframe cache byte cap. Returns true when the
+	* cap was exceeded (caller must have already reset the cache + collecting
+	* flag). Warns at most once per {@link CACHE_CAP_WARN_INTERVAL_MS}.
+	*/
+	warnCacheCapExceeded(kind, bytes, packets) {
+		const now = Date.now();
+		if (now - this.cacheCapWarnMs < CACHE_CAP_WARN_INTERVAL_MS) return;
+		this.cacheCapWarnMs = now;
+		this.logger?.warn("keyframe cache exceeded defensive cap — dropping partial GOP", { meta: {
+			streamName: this.streamName,
+			kind,
+			bytes,
+			packets,
+			capBytes: MAX_KEYFRAME_CACHE_BYTES
+		} });
+	}
+	/**
 	* Graft (or clear) a transcode-egress audio track onto the push-mode SDP.
 	* Safe to call before or after the video codec params are detected — the SDP
 	* is recomposed whenever both are available.
@@ -5993,7 +6125,6 @@ var RtspRestreamer = class {
 	* @param isParameterSet True if this packet contains SPS/PPS/VPS
 	*/
 	pushRtpPassthrough(rtpData, isKeyframe, isParameterSet) {
-		if (this.sessions.size === 0 && !isKeyframe && !isParameterSet) return;
 		const rtpPacket = {
 			data: rtpData,
 			marker: (rtpData[1] & 128) !== 0
@@ -6003,6 +6134,7 @@ var RtspRestreamer = class {
 			if (!this.collectingKeyframeRtp) {
 				this.collectingKeyframeRtp = true;
 				this.lastKeyframeRtpPackets = [];
+				this.lastKeyframeRtpBytes = 0;
 			}
 		}
 		if (this.collectingKeyframeRtp) {
@@ -6010,7 +6142,14 @@ var RtspRestreamer = class {
 				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) {
+				this.warnCacheCapExceeded("rtp", this.lastKeyframeRtpBytes, this.lastKeyframeRtpPackets.length);
+				this.lastKeyframeRtpPackets = [];
+				this.lastKeyframeRtpBytes = 0;
+				this.collectingKeyframeRtp = false;
+			}
 		}
 		if (this.sessions.size === 0) return;
 		this.servePendingSessionsRtp();
@@ -6123,12 +6262,20 @@ var RtspRestreamer = class {
 			if (!this.collectingKeyframe) {
 				this.collectingKeyframe = true;
 				this.lastKeyframeNals = [];
+				this.lastKeyframeNalBytes = 0;
 				this.lastKeyframeTimestamp = this.currentTimestamp;
 			}
 		}
 		if (this.collectingKeyframe) {
 			this.lastKeyframeNals.push(Buffer.from(nal));
+			this.lastKeyframeNalBytes += nal.length;
 			if (!isKeyframe && !this.isParameterSetNal(nal)) this.collectingKeyframe = false;
+			else if (this.lastKeyframeNalBytes > MAX_KEYFRAME_CACHE_BYTES) {
+				this.warnCacheCapExceeded("nal", this.lastKeyframeNalBytes, this.lastKeyframeNals.length);
+				this.lastKeyframeNals = [];
+				this.lastKeyframeNalBytes = 0;
+				this.collectingKeyframe = false;
+			}
 		}
 		if (this.sessions.size === 0) return;
 		if (!this.packetizer) return;
@@ -8887,13 +9034,13 @@ var AudioChunkPlane = class {
 };
 //#endregion
 //#region src/stream-broker/stream-broker/audio-codec-session.ts
-var POLL_INTERVAL_MS = 40;
+var POLL_INTERVAL_MS$1 = 40;
 var MAX_PCM_PER_POLL = 16;
 var RTP_HEADER_LENGTH = 12;
-var WARN_THROTTLE_MS = 5e3;
-var SESSION_NOT_FOUND_RE = /decode session\b.*\bnot found\b/;
-function isSessionGone(err) {
-	return SESSION_NOT_FOUND_RE.test(errMsg(err));
+var WARN_THROTTLE_MS$1 = 5e3;
+var SESSION_NOT_FOUND_RE$1 = /decode session\b.*\bnot found\b/;
+function isSessionGone$1(err) {
+	return SESSION_NOT_FOUND_RE$1.test(errMsg(err));
 }
 var AudioCodecSession = class {
 	api;
@@ -9072,7 +9219,7 @@ var AudioCodecSession = class {
 		if (this.pollTimer || this.closed) return;
 		this.pollTimer = setInterval(() => {
 			this.pollOnce();
-		}, POLL_INTERVAL_MS);
+		}, POLL_INTERVAL_MS$1);
 		if (typeof this.pollTimer.unref === "function") this.pollTimer.unref();
 	}
 	async pollOnce() {
@@ -9087,7 +9234,7 @@ var AudioCodecSession = class {
 			});
 			for (const pcm of pcms) this.appendPcm(pcm);
 		} catch (err) {
-			if (isSessionGone(err)) {
+			if (isSessionGone$1(err)) {
 				this.handleSessionGone(sid);
 				return;
 			}
@@ -9133,7 +9280,7 @@ var AudioCodecSession = class {
 		this.warnThrottled("audio-codec: session reaped upstream — will re-create on next packet", `staleSessionId=${staleSid}`);
 	}
 	handlePushError(label, sid, err) {
-		if (isSessionGone(err)) {
+		if (isSessionGone$1(err)) {
 			this.handleSessionGone(sid);
 			return;
 		}
@@ -9149,7 +9296,7 @@ var AudioCodecSession = class {
 		const key = `${label}|${detail}`;
 		const now = Date.now();
 		const prev = this.warnState.get(key);
-		if (prev && now - prev.lastLoggedAt < WARN_THROTTLE_MS) {
+		if (prev && now - prev.lastLoggedAt < WARN_THROTTLE_MS$1) {
 			prev.suppressed++;
 			return;
 		}
@@ -10139,6 +10286,41 @@ function pcmToMulaw(pcm) {
 	for (let i = 0; i < pcm.length; i++) result[i] = linearToMulaw(pcm[i]);
 	return result;
 }
+/** Decode a single µ-law byte back to a 16-bit signed PCM sample (ITU-T G.711). */
+function mulawToLinear(uVal) {
+	const u = ~uVal & 255;
+	let t = ((u & 15) << 3) + MULAW_BIAS;
+	t <<= (u & 112) >> 4;
+	return (u & 128) !== 0 ? MULAW_BIAS - t : t - MULAW_BIAS;
+}
+/**
+* Decode µ-law bytes to 16-bit signed PCM. The inverse of {@link pcmToMulaw};
+* used by the WebRTC Opus egress to turn the broker's native/companded G.711
+* audio back into PCM for the Opus encoder (source→PCM→Opus).
+*/
+function mulawToPcm(ulaw) {
+	const out = new Int16Array(ulaw.length);
+	for (let i = 0; i < ulaw.length; i++) out[i] = mulawToLinear(ulaw[i]);
+	return out;
+}
+function alawToLinear(aVal) {
+	let a = aVal ^ 85;
+	let t = (a & 15) << 4;
+	const seg = (a & 112) >> 4;
+	if (seg === 0) t += 8;
+	else if (seg === 1) t += 264;
+	else {
+		t += 264;
+		t <<= seg - 1;
+	}
+	return (a & 128) !== 0 ? t : -t;
+}
+/** Decode A-law (PCMA) bytes to 16-bit signed PCM. */
+function alawToPcm(alaw) {
+	const out = new Int16Array(alaw.length);
+	for (let i = 0; i < alaw.length; i++) out[i] = alawToLinear(alaw[i]);
+	return out;
+}
 /**
 * Downsample µ-law by picking every Nth sample. Used when source
 * sample rate exceeds 8kHz (e.g. AAC at 16kHz → G.711 at 8kHz).
@@ -10151,138 +10333,429 @@ function downsampleUlaw(data, ratio) {
 	return result;
 }
 //#endregion
-//#region src/stream-broker/stream-broker/placeholder-frames.ts
-var FRAME_B64 = {
-	h264: {
-		reconnecting: "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",
-		sleeping: "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",
-		offline: "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",
-		disabled: "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",
-		waking: "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"
-	},
-	h265: {
-		reconnecting: "AAAAAUABDAH//wQIAAADAJ+oAAADAABdugJAAAAAAUIBAQQIAAADAJ+oAAADAABdoAKAgC0WW6SkwvAWgIAAAAMAgAAAAwCEAAAAAUQBwHGDEgAAAU4BBf///////////wQsot4JtRdH27tVpP5/wvxOeDI2NSAoYnVpbGQgMjE1KSAtIDQuMSsxLTFkMTE3YmU6W01hYyBPUyBYXVtjbGFuZyAxNi4wLjBdWzY0IGJpdF0gOGJpdCsxMGJpdCsxMmJpdCAtIEguMjY1L0hFVkMgY29kZWMgLSBDb3B5cmlnaHQgMjAxMy0yMDE4IChjKSBNdWx0aWNvcmV3YXJlLCBJbmMgLSBodHRwOi8veDI2NS5vcmcgLSBvcHRpb25zOiBjcHVpZD05OCBmcmFtZS10aHJlYWRzPTMgd3BwIG5vLXBtb2RlIG5vLXBtZSBuby1wc25yIG5vLXNzaW0gbG9nLWxldmVsPTIgYml0ZGVwdGg9OCBpbnB1dC1jc3A9MSBmcHM9MS8xIGlucHV0LXJlcz0xMjgweDcyMCBpbnRlcmxhY2U9MCB0b3RhbC1mcmFtZXM9MCBsZXZlbC1pZGM9MCBoaWdoLXRpZXI9MSB1aGQtYmQ9MCByZWY9MSBuby1hbGxvdy1ub24tY29uZm9ybWFuY2UgcmVwZWF0LWhlYWRlcnMgYW5uZXhiIG5vLWF1ZCBuby1lb2Igbm8tZW9zIG5vLWhyZCBpbmZvIGhhc2g9MCB0ZW1wb3JhbC1sYXllcnM9MCBuby1vcGVuLWdvcCBtaW4ta2V5aW50PTEga2V5aW50PTEgZ29wLWxvb2thaGVhZD0wIGJmcmFtZXM9MCBiLWFkYXB0PTAgbm8tYi1weXJhbWlkIGJmcmFtZS1iaWFzPTAgcmMtbG9va2FoZWFkPTAgbG9va2FoZWFkLXNsaWNlcz00IHNjZW5lY3V0PTAgbm8taGlzdC1zY2VuZWN1dCByYWRsPTAgbm8tc3BsaWNlIG5vLWludHJhLXJlZnJlc2ggY3R1PTMyIG1pbi1jdS1zaXplPTE2IG5vLXJlY3Qgbm8tYW1wIG1heC10dS1zaXplPTMyIHR1LWludGVyLWRlcHRoPTEgdHUtaW50cmEtZGVwdGg9MSBsaW1pdC10dT0wIHJkb3EtbGV2ZWw9MCBkeW5hbWljLXJkPTAuMDAgbm8tc3NpbS1yZCBuby1zaWduaGlkZSBuby10c2tpcCBuci1pbnRyYT0wIG5yLWludGVyPTAgbm8tY29uc3RyYWluZWQtaW50cmEgc3Ryb25nLWludHJhLXNtb290aGluZyBtYXgtbWVyZ2U9MiBsaW1pdC1yZWZzPTAgbm8tbGltaXQtbW9kZXMgbWU9MCBzdWJtZT0wIG1lcmFuZ2U9NTcgdGVtcG9yYWwtbXZwIG5vLWZyYW1lLWR1cCBuby1obWUgbm8td2VpZ2h0cCBuby13ZWlnaHRiIG5vLWFuYWx5emUtc3JjLXBpY3MgZGVibG9jaz0wOjAgbm8tc2FvIG5vLXNhby1ub24tZGVibG9jayByZD0yIHNlbGVjdGl2ZS1zYW89MCBlYXJseS1za2lwIHJza2lwIGZhc3QtaW50cmEgbm8tdHNraXAtZmFzdCBuby1jdS1sb3NzbGVzcyBuby1iLWludHJhIG5vLXNwbGl0cmQtc2tpcCByZHBlbmFsdHk9MCBwc3ktcmQ9Mi4wMCBwc3ktcmRvcT0wLjAwIG5vLXJkLXJlZmluZSBuby1sb3NzbGVzcyBjYnFwb2Zmcz0wIGNycXBvZmZzPTAgcmM9Y3JmIGNyZj0yOC4wIHFjb21wPTAuNjAgcXBzdGVwPTQgc3RhdHMtd3JpdGU9MCBzdGF0cy1yZWFkPTAgaXByYXRpbz0xLjQwIGFxLW1vZGU9MCBhcS1zdHJlbmd0aD0wLjAwIG5vLWN1dHJlZSB6b25lLWNvdW50PTAgbm8tc3RyaWN0LWNiciBxZy1zaXplPTMyIG5vLXJjLWdyYWluIHFwbWF4PTY5IHFwbWluPTAgbm8tY29uc3QtdmJ2IHNhcj0xIG92ZXJzY2FuPTAgdmlkZW9mb3JtYXQ9NSByYW5nZT0wIGNvbG9ycHJpbT0yIHRyYW5zZmVyPTIgY29sb3JtYXRyaXg9MiBjaHJvbWFsb2M9MCBkaXNwbGF5LXdpbmRvdz0wIGNsbD0wLDAgbWluLWx1bWE9MCBtYXgtbHVtYT0yNTUgbG9nMi1tYXgtcG9jLWxzYj04IHZ1aS10aW1pbmctaW5mbyB2dWktaHJkLWluZm8gc2xpY2VzPTEgbm8tb3B0LXFwLXBwcyBuby1vcHQtcmVmLWxpc3QtbGVuZ3RoLXBwcyBuby1tdWx0aS1wYXNzLW9wdC1ycHMgc2NlbmVjdXQtYmlhcz0wLjA1IG5vLW9wdC1jdS1kZWx0YS1xcCBuby1hcS1tb3Rpb24gbm8taGRyMTAgbm8taGRyMTAtb3B0IG5vLWRoZHIxMC1vcHQgbm8taWRyLXJlY292ZXJ5LXNlaSBhbmFseXNpcy1yZXVzZS1sZXZlbD0wIGFuYWx5c2lzLXNhdmUtcmV1c2UtbGV2ZWw9MCBhbmFseXNpcy1sb2FkLXJldXNlLWxldmVsPTAgc2NhbGUtZmFjdG9yPTAgcmVmaW5lLWludHJhPTAgcmVmaW5lLWludGVyPTAgcmVmaW5lLW12PTEgcmVmaW5lLWN0dS1kaXN0b3J0aW9uPTAgbm8tbGltaXQtc2FvIGN0dS1pbmZvPTAgbm8tbG93cGFzcy1kY3QgcmVmaW5lLWFuYWx5c2lzLXR5cGU9MCBjb3B5LXBpYz0xIG1heC1hdXNpemUtZmFjdG9yPTEuMCBuby1keW5hbWljLXJlZmluZSBuby1zaW5nbGUtc2VpIG5vLWhldmMtYXEgbm8tc3Z0IG5vLWZpZWxkIHFwLWFkYXB0YXRpb24tcmFuZ2U9MS4wMCBzY2VuZWN1dC1hd2FyZS1xcD0wY29uZm9ybWFuY2Utd2luZG93LW9mZnNldHMgcmlnaHQ9MCBib3R0b209MCBkZWNvZGVyLW1heC1yYXRlPTAgbm8tdmJ2LWxpdmUtbXVsdGktcGFzcyBuby1tY3N0ZiBuby1zYnJjIG5vLWZyYW1lLXJjgAAAASgBrcLjAFwEgEQEADwDgDgDgDQDJdd4QDwCwCwCgCgCQCQCQCQCYNEX/8/CcyLuuu2nGKAAAAMAAAMAAAMCEgdwaCTacYoAAAMAAAMAAAMABEQI1dtOMUAAAAMAAAMAAAMAElAMJyWgAAADAAADAAADAAAqYA5IgAAAAwAAAwAAAwAAGTARgAAAAwAAAwAAAwAAB9QAAAMAAAMAAAMAAAMAAQsAAAMAAAMAAAMAAAMAGBAAAAMAAAMAAAMAAAMBkQAAAwAAAwAAAwAADTgAAAMAV0oBlPeTVLjjiybt/79hr8egLGkfgRr4BMQkiA4Kvw8jeWLF+WRCVyWx9qYu5G9T5CK0jQtgcXtpIjS8fOF3Fs7TooZzWpZ8ReTWIvMHVoz1Khj/MspUENldBCyT8am2SvF0ODUrVIDRf6nQo2S7JadxlbCTlotNQq+hoKRRpfUfWMJmvuh1JQQ53qCMdtbzzujg03ARtryGryC21x+/3HlsDdJjIo2bsBqcJDGhtutOY09UKR2fB4qo0gcO4YaWz8+LdoSQytzg8i7YAgrr++G2P+ciO8uBIRmUDS3dtHY2qm5ES/5WKQRfGoCYlXSFktimmNXaNVi6B/F8WTM6qww3C8/HRnP19lFBhwjM+so5wYr/a/dEoNHlt3zo+DYqXCzrM89XtWZ+VEiEGHThWZz4ueu9hRf4kAsDnSm/K+EKgxVzC/x5RkkoP8gg1uFv4OZXv6v6KgwUUFg/coPxInxbWw9F/Em349gUCz1BftvEUsr1DSslq5wmBHSQnaZ4NEC5uQ7E+IJkO5r5l6deZqifhgY72K8BvaeifJXZz9C7VWOQC49uyADmfqmA4QOBnjvlaVjMljLHauN0OBCnR/ehSff3ux90YSUWX2rBSERUDJ+yZhj0SgEfXbjmW4YuMYX4/97H46RZnNCBX9OYbLbrBFzgnHD6njGyfAdcBZh2f7mjH0QJBJ8VmQS0B0bAfj6avyTuVGltkpP5Dzzs+gjJ0md5RwCvg1V8rV+2K2YdUNNdVjwHGk5KYz7o8mnWuj1D96sE5UIELAcjJ5b9vqIkAsXM3Vnx08ySHbPcRPvHypZc7irWXbQZFIGvaSJaFPgPfzut47l2K7f9PNWh5RQzvRryfmocEduA73fOehHOSh6GDB93aZZIC6QlT54zV5fxdeulJJhr76lPm6TPWqydI1W/qztOgkF8uUTfVwt+vT6TlPdWxK1rXl4RbzjtzV7SMAALHytwvzDfSm+958O8Cr5eqkkCllpWRgAqvNbAK54kh1ApOCBDkGEFsTLVRQAgUdw58gie9hHM8u36TEEKqpQVAorSyValMe8g85gYdkOY+0wB+0iHrxgYruhqpzWE/1uOkRFUFP2u6pE3uudGUR0IH1V9O5pKVT21Typx2BQJR4YlZaCIEWe1050WXbGNg9/iw+rICd036Z8OuiwWGbinPZLfr+rIAhXldbFQYq2G94iPJLh9j2SHCV4F1Aiii9jfSgYXo0PBsJ7lJkmr0LrHeZS94G0bI7OfVGGKTAFOqUdABWQAaqoyZKJHE3vb3N/jVzQxnO968s6FOcEljAwlHET9NwSytW2ltw/KkBMSefHyKhLX/0NgBvoBNpannebIPuQuDyVugvZzGrgdUEoDQKyjiQsSxinE/HfAqdLE9U2PgXxXD44oIoidTBs0pHMtZEUgQeJmulJz4zufU3tla2hHg5afwGT1778P8mURVtY9WYYsA0ov+06wmR7ZyAA94Ane5bG1e+HcdkJfwjDB5ECH3BiF0Luicv7PLXi6Ci4ozoX7d5fn0zYMXFVF3N2rnh/WmSzDD7Q/Yx0ttU/siyEirAQqrQnEav6JK+uaQwUdK77oi4laVukHGWP2V2X1yuHVV8AlW0z1wpmPtUnu1MmeHIavzUFAZgWXD5++r6Ot/hOgJp0ZxPZZUCgbmvknx5guU/EmHwrKCjOjqIsvFYuC2yd0FpCAz1B6OI6V7WfG1P56Ln5aI06Mf46GEEjh8gK4KRznRdB/xXyJUnbQh3VRu022hXqpI439/25/8EyU+o6TjhSMpV2XnR83rGflzCfxYBa0eqm/oCDk5lpViQusu+1v7g6+/B8A3JkM78sO064c9DJHwBKcssLoncxh1rOZHqYmH7dyJcKvKl56c4yjMAPGoTu/dQ7DqUl+/1ZTfXnScfhvxLshgyc0P9fbDvKJngtx+FL7pEI3N0am5b7qNTDhVZT3KgbCynYRYKvL/yEzW67K2BJ5ZFl9CGtKA/Wuue66P7sZTogpNLy5bCzs0EBpxAz15JdP6o8IKrx8g4YPCirXwWayjOcdVY5Yzoh3EIABoL7JyIPJ+cOqOQRVbaNRSK3uqK0cDclgP7JNT6itDaY+eNuGZnsLka93Ojqnx0/OvvcM/VMOV3XNoBzjMCwBK62jL3BJ6Sjkzv9zgFSVmuyQ1AhGowTYPI7lEOqJeg9acM47dS50fO57M1ipbHahZzkNA7cArH+mpK6pofOUpxsEuAjwx0/oJZX7WPb+2nYRSd8bSa6KvwWZKrxcxDGUDRuPXs1qUL0bx5/nt4Rpdh+r541w9HBywK/EqnlL5DYgjOp4GzorITU/9i2NsPaK/Z6yc4RvPkpFu+lTXX15KedvWxUH8IMgm4DaPS9pdw0J6iZtJSap+C6kyRPgZtqZ9JVAU0V5i8gQY+L0jFX3PnWHcMOAzHQwFGZWBOtMq8pkyJ93N3kgst1DWGj6egLEMVuSRONH/3vN8qXpifVRo9g/NcuIYc8l/zYlWqIIB/WlttCvqZ/NE9cN6m6xU2WDfO+5QIHQBMGSHWZCN16hw86A0bJeS6SRsmWbN0LJO0V/YXTr2EiAtBYVawrglXrSVtdH8nEGXJVznoRPgYu5p4Llm0e3e6GvZnJYWJ97lrbWXcLvpXP54XUDyIEPuXlZTRmMUWoHFTl8OIgUPhTIKMoG/Ib89C5uyCXO415fSc6Ppq8MEiTT76ZAqXjfG7Dl5ACmBTbvX450/CB1Vi9xB8IIFFT7xD+OAmwewOGLaXBBO4pkl5r7Upopbpeoi/FAHZ0bMCdmOQgDTKnioiPzQYcq0KWVAoG5r5J8jULlPxJh8Kyxozo6iLLxWLfvItk+Dk1uOEUQG0sxnSpTCtftlKRmLEP1+zyJErrDz9yres+EgsDhno7sW7bOYXOuph4PB+Ra87C7UpcF7QoQ4Rq7+QtOobzeYS5V2OR5dJxNkiYFzyiARK0HojeNvZPsDPukDb/rr8DQ14H4kMoXqBt5PD6qjJfl4JKPpPL4SRx2PfF7oETuqmVkkm6si4m2Yxa551yCAs2KFO04guWSpDFtgl80mCDMLqMoSphaJF3HEX71YqU7ZLyY8Zdk8ruJMIrvZvlE8/RxyFAjlGSVYrv6wO2FPVx0houMsMwB5IpBY4ki9hC5edchcPQZNwM878Wt/o+bYxR+wIqJgK1nMqybFzcZEapW0k0SBbKXlHosilK/N6AAACngAAADAbwcg0sfHQt65f6mnxtP2r+08fGJCSWncC9bRMWkwVBgpQR9hbHN4iZZRH0Z8rW+xzoBFYLNKy3xIereHgLNTMOv62N2JOpDqN++sH7wAcc3e9Fo2nP31QA4zC527jTsgdwKgJaisVqq83vKsLGD+mX0effufZ3T8Mg5/QoFOcWvVE4u51cXJYr+7QsOOiBhz1wGGb7n5Riy+uIE70aDf4chPltnlwTlOPeaZba/RfYvXb3LTvBBXvXF2/vt/uNbdw73//djuXVcc2u778jWxY8yXBlDP1Lh7gFkKU9LsFJc+gnHXU7W3jI8fFwuxeJKAfRlWNwTZmYANsBtJlzM4qbyhxXYGOOzWlDyICJTKcnkQssORsQVM5bsaHBXPm4piT9sxg19wlCBp6K5MigVX+HFnevX/Y55tonjRrEoHmGCV9kKRV6ZUIESRziBozfic6j2ftv4oLu5bI/fQtkvAnj3rtJ1XWbfdQsBxRBf6dZjWewdrMtZy7s2Wqf9d6W9GrHRKH44rS+gtFLk8h0FJLn6zQLoVdsrtdTnOdG+3OB2nJ8Ll1ZrqsyrSK0KBWtBthMS90/8GbrLJyds6h7ctDw791GN2aqDJ4h42RhTazZhiZ2XJjw6PtucSfsCR0iPYPlOm9W7uSVsQwgcfzevIWBhU/4K4IxYJohDWirZbT7QciZuXwTC574DOGso6Ddu3iRhYFYzPOcWvgxxKvDr8UBw//4Jnc4JfKbvTGbc3k50ML5IZCuQJxyj+K22xRf2fBinLjfiXt1ncXjhKC7lzlgYXWi7dNZL917wYytylf0nvn0ABCs9XijfD8jvNVUhzn7FyKsLJbgHr24rz1hCw/YBipkxDP39vYAiBmNX2uG5IuVVnJZ5fGHEdy09nClEnyPYgLxuQs9UBSwoUcd1awDoeG0l/+NyE4HnszKMX3+4VyQwKWqek0dspBqT2meYK0sbomqG3nRKxUANy0l4iqNX/xwPjuCyd/7Xdxz93mT5yVFNbci5YUea9g6jhB/KT8HdwnvDe/DMilt1HPZpgB0wgXCNAaIqLjVB+8kxgLrHmYXtvo2wbzl5+7FVN78Rm8uMHl/AobG9C2ph/tMv6LoCfkq6pRm4x5IMB0kModAdXa3qjA92hYeX2AAkTYfvAGU0jYpUtcE6IUmjyt8t79IA3do96y3l/Yrpo5p67dN3Xmp+3lkuj8pcIfCqZBUyQlrrXNgaj3zli2u4StYzLJgLhQ3OKrP/sQZ14caam0hWYDNJkEgN3Ydj6InQ1Ymx0Aedt/SUXSbw1w5oiZahKrkub8bHe3MAMed981rnNunKdC18+ckf3z1FaLECw0A5R3vJEfVyRPkyBxckOY59j+suEa5MpVNZalf+UxyzmlqUbgmkaXgHe9PbtWLkdHWXn5HRQeWABU0ky7jrKktuGVmiHhjtyjzPBq4ZEZxfciWLnJRfLzzue4v+azInxca0i8DzyTb2eWXtl9yVEz2yxJ1mX7tdQej9o0nYsHpN4EBE5SHK5o32tCjxpYdr2cufCrq9sl0bHxRDKZceNwgKGCTSPXYIwC04S5qBjOrxDVexlbFVvOpSrh6KxSamB9ZGgkKGqP2RKVci7zuI9wEMNLjkO7elLpXa4KU8NIwAHNp7SJoIpMYxBaD/iK4ZDq2AP3G0kIWJRKvZl2whIMguF9R7pDDFNn9WoFJ021BWo8DMFyrxvNQCoZlopDA7/sgJ16VBsGKOXDltXigk5APGWqSjaeezweoevWhT+M8th4+2yF862EsNo36UF0xB16BSZOaMSB8vTsH0u3+Lc6Czm0A7UiUvNlkwJ5z0lLwIxmI/+LSWEmzHIsjeXWQHde30gUHvTvOMIhWqHvjiSvLjw17T6tijkO47h8RI9bWzmG9DNEn9a8bmlJrHh/tGMgAwGu4DUUotoHfaHegkYIrWzkfVH13yHTTGrcY82KdmS6lT5E8uXIcyGoQ6LJYmDZu3WX2GS66RN8oehSzHcH58HgYoTpYKIDweSZcEiWYz/tZAWMYZgWXnWQZPfaABFbbCns0twaNs0Sn41f8gkjAc3lm4pqFMTAj9xaMBcmLefXcrkWTHw691m21Xnc9pQdMbWmlorU8Boq5AbDnckloxu0Z74DJi9j6A0n9LVh6dlzvodocp71Er/hGdNJRi+Vcl+kHo1ic3iIOHsS2Yqhs0RNFjo/fjbxeaOBgWRLxNRkx/AIkiJVHNV0XAv98N3FxA1oWE28krbjksU0KMrB6rkKwUfNcfbACNDAtzuKkSRpw07CcY+Zpnp00QTqET6boRpUMsnfaZdk21i1g0aIOiDRr2dpZ5PoUh+x3t9oWEgAsb4tJ+WL2NgGdhlL9ArpbJCkoYxz1XC143XWlkVey9DkztysoGKuHxs1kS/741nQt+prrl/yhEsVDmZ/Z5MMAj9O3hJyAkT44zRhjJLh3tWJoeFlbIzQq1uS5d0BE3kG6Qr6QNycPBhMCmaPgehdmJY+pOPHDi7GKK5rgDhTTxTtxWHyLLtfZ0uvhCyP2f/vgdf//AW22MA3F7+0FcPd/9PQKUGX/d4OreG7Oo6JiAmP2IarCYG1AQh9D8GlhytEMDqFqrMb+m0c0dcyEfdriIIgDPTFNJ50aGVMu1lYMBAeTw5jwhtYMuiogKIPkiwBbuxxmY24CzXbT4fPEXiuSTi3xI+QpK6pQKD303zumZnAWYRe3RoU+5hh2mqFB4XpO7X67q4pTDvY2iIBJgNeVaNgkLRA5AgiUAq9OnZZ6DW/qsT3aLY1XqDqoX0OQqltPj2HGVs3TjfcD74AvF6ESnvX9RzOG9LDlya+1j7GxfQB8dY96fBq7EdJtwBRND9wTMC7kswFAClGZNPZ5FhthY9JGLV3GPjO2Pa1kZwp9IvZZMROq0ELt2ZAfv+Ue5IoQO7pEUCsjOnNStt3pWwP6Vpi5XsQVkGI+NARaVSl7Nudb0UnrG5gbENDRtcZIXAxGdIgwOt6e8vysvL+b5Yi8IRqaaQ89puymmtR6vrVec2CcaYWm5nZdP6HLbqgFDHujcz0NOqV71H1GCiaNrWy/t35pRVfq640VGg52Hqg8tTaaqsXG2uuThvW3MRANtcHJMvdaV8I9d+Vb28UNf47VvosuDkJxZYexaYsVvpxtvlHsbGPbfsUm+ucN6qbHw/4nWSJgPd9K2t+LpU6dW01zs7bZUA0ZWBh8KbVP8neck5aIq4IsoFGxGdJRugUY2kc1o6QKsSFpzqsUO8DxRZ9uWp/d88Uhl33NB99BZD64HBGT5R6s3X/NwvIehHtrdWJ1CQexCTVFv3Eb0CuuWaglxVhyrp+p3xVxoVlxqBIRw1ct155Gf4rLGzRWhi/lD/h6eJ6I6Gh3DZ/waZwb/4jhIjHRYemhw12YoNzyTqV340QHjgBALKzT6EYu0BCp3k05aopnwZDqqCC6uc4H2//2hUxaKOv36N7VdYluXSj1nq4fr5Xn+mvFRheiMKxalcBxAPkgiRIO3V2M8WZp05C0d7dovQabSceQ7zzX5Kis3fOr4IQvGA1dsmQYeHClVm749yGxVPhITPaIxhFGdKsnqp/N5oBrOs08kkmO4KsIQ4YVjQp3SDyekaMbdh42ZKxmzF7CDszcChDbzxKi/47kzTL+XxnDI6npJCUA/lvh6P/3ooqWRAZ+ohyjnqz/83aeJjC0d2toQFL4EIajAiRul9hQypMhS0XnmHZ15XbBiLRGpbDdZQ6bWbe/6+fbakKDMUP5Ewz8DK0PijXVkvCQYaBrVQqwKhquutLM69iT5h9cVApJCw+Nllb0UHOiobf4oGg8lIC3H/FN62IA/vHZcetduokSAeNxWOKvrPx6q4aEXZEqEJU/5RxL2EPUidxh1T7aRM3MGJM8f3SkvCq+bq1EmJthptURTAgWP/WpjVjvdcYz2L9qxOe83/8Gw8//0js8i4pOvGOcmCVLlb4Im0GZJQfCQD3bdwBFnTf0blZtn+4pOOyWKF5kvPUqsNLRIYwRaZxrtVx11WJI938QDTMzbi1RAh3yZRRfc5+zf1Gr2LTnThAaUv17gs5KGGbGfd0Uuc/Ky7Cdjbnj6KmLHSCCrFDBzQAMHtbNdI/mGg9ut9ZcCsKZngnEFCvoQaLf66strIWjhDB7bqnxq8cqq4mATh7t98ES8NnEOWXT9z0zhDfRMZ8e7CQOk3nc3+p5zyNXA0TXCtjAP6sE0ShNfMQ/tTguB5Zj1E+zUb7sOjZANfmHFtjJlzY34YLRBGUg5o5sR+nCG+kaOtdxHUSq8C3YtzqQT+e5sxuLeme3xCkLSaC9OUO8cmIzNmtFnYk353mnh8Wgg4UdK5SI1oF2vRRsjcGL571LepYc8lwkS/WmcdAhR379sIjgQT14ysZ8k9eLssO9UjB/7q2tG1AL0KYlwjlCuqjR6pAdrjmOpq2kVVY045O/7L+Jhpn7PqvQDgFhsWOrMEOm1EoTFMgRuPtoWHTeizXe9lcCYVsCt/5rG6LxIPBz4ZVFBF0Cj8Or6q2yftONDIY/UXBy0KnWmbHRu4he3qt7vWLVh7/3NxyGNNxn9X1b9D50txYJA15Itn3rsHOBNYb94xeX3niF0VIWMbgv+9wCqYqRlwoGtH0CFyNFo4+2qOJpXAoXM937ry/eSK+Z8c40wn9AIPg8C1T5qscDGAvYolWSVJqa0imWz+UnlYPGjnQCMII4mY9IWqUOKRC2N8NKHvw/EwFYAAAMCqTu4+23fGyAAABLQAAADAAADAAADACtgAAADAAADAAADAH+AAAADAAADAAADAWMAAAMAAAMAAAMDsgAAAwAAAwAABuQAAAMAAAMAAA4YAAADAAADAAAY0AAAAwAAAwAAKSAAAAMAAAMAADzghwAAAwAAAwAAAwAAAwAAAwAAAwFp",
-		sleeping: "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",
-		offline: "AAAAAUABDAH//wQIAAADAJ+oAAADAABdugJAAAAAAUIBAQQIAAADAJ+oAAADAABdoAKAgC0WW6SkwvAWgIAAAAMAgAAAAwCEAAAAAUQBwHGDEgAAAU4BBf///////////wQsot4JtRdH27tVpP5/wvxOeDI2NSAoYnVpbGQgMjE1KSAtIDQuMSsxLTFkMTE3YmU6W01hYyBPUyBYXVtjbGFuZyAxNi4wLjBdWzY0IGJpdF0gOGJpdCsxMGJpdCsxMmJpdCAtIEguMjY1L0hFVkMgY29kZWMgLSBDb3B5cmlnaHQgMjAxMy0yMDE4IChjKSBNdWx0aWNvcmV3YXJlLCBJbmMgLSBodHRwOi8veDI2NS5vcmcgLSBvcHRpb25zOiBjcHVpZD05OCBmcmFtZS10aHJlYWRzPTMgd3BwIG5vLXBtb2RlIG5vLXBtZSBuby1wc25yIG5vLXNzaW0gbG9nLWxldmVsPTIgYml0ZGVwdGg9OCBpbnB1dC1jc3A9MSBmcHM9MS8xIGlucHV0LXJlcz0xMjgweDcyMCBpbnRlcmxhY2U9MCB0b3RhbC1mcmFtZXM9MCBsZXZlbC1pZGM9MCBoaWdoLXRpZXI9MSB1aGQtYmQ9MCByZWY9MSBuby1hbGxvdy1ub24tY29uZm9ybWFuY2UgcmVwZWF0LWhlYWRlcnMgYW5uZXhiIG5vLWF1ZCBuby1lb2Igbm8tZW9zIG5vLWhyZCBpbmZvIGhhc2g9MCB0ZW1wb3JhbC1sYXllcnM9MCBuby1vcGVuLWdvcCBtaW4ta2V5aW50PTEga2V5aW50PTEgZ29wLWxvb2thaGVhZD0wIGJmcmFtZXM9MCBiLWFkYXB0PTAgbm8tYi1weXJhbWlkIGJmcmFtZS1iaWFzPTAgcmMtbG9va2FoZWFkPTAgbG9va2FoZWFkLXNsaWNlcz00IHNjZW5lY3V0PTAgbm8taGlzdC1zY2VuZWN1dCByYWRsPTAgbm8tc3BsaWNlIG5vLWludHJhLXJlZnJlc2ggY3R1PTMyIG1pbi1jdS1zaXplPTE2IG5vLXJlY3Qgbm8tYW1wIG1heC10dS1zaXplPTMyIHR1LWludGVyLWRlcHRoPTEgdHUtaW50cmEtZGVwdGg9MSBsaW1pdC10dT0wIHJkb3EtbGV2ZWw9MCBkeW5hbWljLXJkPTAuMDAgbm8tc3NpbS1yZCBuby1zaWduaGlkZSBuby10c2tpcCBuci1pbnRyYT0wIG5yLWludGVyPTAgbm8tY29uc3RyYWluZWQtaW50cmEgc3Ryb25nLWludHJhLXNtb290aGluZyBtYXgtbWVyZ2U9MiBsaW1pdC1yZWZzPTAgbm8tbGltaXQtbW9kZXMgbWU9MCBzdWJtZT0wIG1lcmFuZ2U9NTcgdGVtcG9yYWwtbXZwIG5vLWZyYW1lLWR1cCBuby1obWUgbm8td2VpZ2h0cCBuby13ZWlnaHRiIG5vLWFuYWx5emUtc3JjLXBpY3MgZGVibG9jaz0wOjAgbm8tc2FvIG5vLXNhby1ub24tZGVibG9jayByZD0yIHNlbGVjdGl2ZS1zYW89MCBlYXJseS1za2lwIHJza2lwIGZhc3QtaW50cmEgbm8tdHNraXAtZmFzdCBuby1jdS1sb3NzbGVzcyBuby1iLWludHJhIG5vLXNwbGl0cmQtc2tpcCByZHBlbmFsdHk9MCBwc3ktcmQ9Mi4wMCBwc3ktcmRvcT0wLjAwIG5vLXJkLXJlZmluZSBuby1sb3NzbGVzcyBjYnFwb2Zmcz0wIGNycXBvZmZzPTAgcmM9Y3JmIGNyZj0yOC4wIHFjb21wPTAuNjAgcXBzdGVwPTQgc3RhdHMtd3JpdGU9MCBzdGF0cy1yZWFkPTAgaXByYXRpbz0xLjQwIGFxLW1vZGU9MCBhcS1zdHJlbmd0aD0wLjAwIG5vLWN1dHJlZSB6b25lLWNvdW50PTAgbm8tc3RyaWN0LWNiciBxZy1zaXplPTMyIG5vLXJjLWdyYWluIHFwbWF4PTY5IHFwbWluPTAgbm8tY29uc3QtdmJ2IHNhcj0xIG92ZXJzY2FuPTAgdmlkZW9mb3JtYXQ9NSByYW5nZT0wIGNvbG9ycHJpbT0yIHRyYW5zZmVyPTIgY29sb3JtYXRyaXg9MiBjaHJvbWFsb2M9MCBkaXNwbGF5LXdpbmRvdz0wIGNsbD0wLDAgbWluLWx1bWE9MCBtYXgtbHVtYT0yNTUgbG9nMi1tYXgtcG9jLWxzYj04IHZ1aS10aW1pbmctaW5mbyB2dWktaHJkLWluZm8gc2xpY2VzPTEgbm8tb3B0LXFwLXBwcyBuby1vcHQtcmVmLWxpc3QtbGVuZ3RoLXBwcyBuby1tdWx0aS1wYXNzLW9wdC1ycHMgc2NlbmVjdXQtYmlhcz0wLjA1IG5vLW9wdC1jdS1kZWx0YS1xcCBuby1hcS1tb3Rpb24gbm8taGRyMTAgbm8taGRyMTAtb3B0IG5vLWRoZHIxMC1vcHQgbm8taWRyLXJlY292ZXJ5LXNlaSBhbmFseXNpcy1yZXVzZS1sZXZlbD0wIGFuYWx5c2lzLXNhdmUtcmV1c2UtbGV2ZWw9MCBhbmFseXNpcy1sb2FkLXJldXNlLWxldmVsPTAgc2NhbGUtZmFjdG9yPTAgcmVmaW5lLWludHJhPTAgcmVmaW5lLWludGVyPTAgcmVmaW5lLW12PTEgcmVmaW5lLWN0dS1kaXN0b3J0aW9uPTAgbm8tbGltaXQtc2FvIGN0dS1pbmZvPTAgbm8tbG93cGFzcy1kY3QgcmVmaW5lLWFuYWx5c2lzLXR5cGU9MCBjb3B5LXBpYz0xIG1heC1hdXNpemUtZmFjdG9yPTEuMCBuby1keW5hbWljLXJlZmluZSBuby1zaW5nbGUtc2VpIG5vLWhldmMtYXEgbm8tc3Z0IG5vLWZpZWxkIHFwLWFkYXB0YXRpb24tcmFuZ2U9MS4wMCBzY2VuZWN1dC1hd2FyZS1xcD0wY29uZm9ybWFuY2Utd2luZG93LW9mZnNldHMgcmlnaHQ9MCBib3R0b209MCBkZWNvZGVyLW1heC1yYXRlPTAgbm8tdmJ2LWxpdmUtbXVsdGktcGFzcyBuby1tY3N0ZiBuby1zYnJjIG5vLWZyYW1lLXJjgAAAASgBrcLiwLgSAiBAB4DgHAOAaAyPGfQGALAWAoBQCQEgJASAmNEX/8/CcyLuuu2nGKAAAAMAAAMAAAMCEgdwaCTacYoAAAMAAAMAAAMABEQI1dtOMUAAAAMAAAMAAAMAElAMJyWgAAADAAADAAADAAAqYA5IgAAAAwAAAwAAAwAAGTARgAAAAwAAAwAAAwAAB9QAAAMAAAMAAAMAAAMAAQsAAAMAAAMAAAMAAAMAGBAAAAMAAAMAAAMAAAMBkQAAAwAAAwAAAwAADTgAAAMAAnIRJY7mt6jxDg1ZAEbP7/LhpeVRCRSHYPE9hJm0I9bQrAjX0yu6L7lrKwJuj+U+EieuvMXkRVod2huH5MMqkgjezPIXhMMMbzPxp9/3NjL4R6GTuXhhGpNVRUatKyGtGQprE67mXeVeyt8q8XH55OXhBv4tDkapTnVztyP476G0CbTtwCKWm1coovmbCwsGoeuxe1KH1XPfGSpVvJgH0eKir9DUKGvaq38A+K4vCdrPnW9h2AIgZQrFMG5esP5M5Vj+RViJ4rcaYrxWVJKxyOBSOjLp6asU5sEWJAjP0CgnmWFIIYk5t2zZ2KhVPRpZS2kZwJK+3NeZ9kVSFWLkmyzQtyHQl8Ucj2Qow+3sBQdhZKdqVYVJVVwTt/s/IObzDjXLhsl9qkhIpu1hikB7vq9GZzw/NJumDCpYEInYS9ZjrHx2jmMk0QXSKkQwL2RsB9I2l7bz6z5L1NT98KZZF4sTRSGmMlivbyZ6QH2AARLMbZsL9jTxFXmaSSc5pg1FlgnRRlrEqSt3S44/VRE6LcU54L45c/EJERdNI0lAT5iAga8pllYNnCugL/iwnq0lrXn+6HpHCRx2ajLvmql6dkwKGaZn1HSeHAUhn8rCMlgMxBIR5a4Qgehe/I8rWdm8cuZE+WzQHumkeUjfvLw5E31mquqpttU5jt1ADcJI3p//dEp0KJHGJ2wDkMeCzn9I+pOF8+hZI/LRnP8YiGf6oZuABjwZnG6hnjWnoq1wIB+/tQ7c5K6JESHleEBruHbZrCsW876YwkveQTUPVpWe/XuzgiZaJWDrWd6edJ/6Z4mcIVSTeqAV0gPOeeFlgEYI6cAB78bESFgmNZTukgcfdEw5rxFwECmrf98AabHx28Daoh6o1eP/iU0MEx+0lfwtn62vvLrkJr6LdqppJ/V4uthU+zSDDntLN3wOfBbSIBAXheiqHz9TB0PLj0IMQAcJFKvsGo1WIw9QO7tp/Fd6bENcv9tPTqJI08/spfWrW/0TE/MjfEN5FI7WN6jTWU7YiDaEJfBKSBQw2yQobgCB9hA2Hl+qG88UZhAg5oq1DfkvQyqGvDUjKT4RZim5X96qCV7rA+cHQbHM/dXNaWbv7Lncbm0+4wJ9E/VuB161yenwEq6JVlJpXEpZ4/D+cqmG9jf3ZPBBXvpzjoJR/As59Ju+izJ7rHmT2Gzwj6RsgBtYN6ljCTSxeTv6+RkWH8gjUq1BZPKbZQuSwrMpiVzy869A4FtxbTHDYig1FRfZtufurQyp7EVkIv1YRrQt9CQvdQnehenXY84QdXD3VA0X3P08Wj0oMK450ODnAIaGKgHM3z7zFBzJmZ4D+XC1owLRQ0Zj4AjPztk0HGezZczdyHnkQto7mkLcoGTDK3CATzvt8GNXOptD4/nV4M9E+jbvwWpOFViuWr+AqRwZZ8uC+1or4+3EZ2Vrvwg4AKB5PWsR+0lkUFWiLnkMyagxv8aU2+b/Cti0KlOUys0h1KactAoSxwN/JX0D7HnwTV96KAAAAwCmgAAAAwAD/BQmkkSAIeH2QL4F/A6HctVCKGX8yMdMaxWTbi3QOpN4Alk9HT68HOZZgaitJoPjH+HZc6411cnVrqfm9Iaio91UDA0UGzBk66tFpYSgBjNxkHN4cYfiwGvdz7XviLZ8O/doO+VIfXSRLBzypg46GnIJ/iGll8gtiV6ax3vU1yktNzcqMKzD9V8I1N+2yedgAM5M5BmZLSdVI9Tqn1CtDLReN6032lEHUdP0bWOOFwsuqiuBKESunznZIwiFJtuajlou+N4mSpHy0SlnJRRZTmHPdlJO3laXfzLuSiqAU4OZiJbOFPhg2DwnP+vKIHwIPGZSWW9NqqH3ZdEAaMjYbIa1vEJ0DJV+NuCr5xAmV3tILbuFFEwUCcJdbiRRAMtR1JxQ2JUlEN9L/RuBBx5bQZdd7QJhiYKNw/ssyKrDPAkyoSfGy7YR6ki6Nj3FCVNeyL3FDjvZ52487UGX5U8gP4uBp5E2r/hZyh0++PQtzgL2XbaUEw65Ztry7AQmeZo43NHtNX0juv0qLk90iAkKLgebAQS0RTWb4epVN47jXXMGWoDvTnQchHQsgXD67fj85ol2cvZm9dIv5cuX8nG3+3eRV4otZUTNr0JdaQO8+KCLlO5RM8hSavTSZ39LvLj8WdK96/B1D9RU7zaEDEamMceo9pgX44L+dwwjprLTVbTae5zSe8d3ielSzh77uhuzkqm42ZcPAOOVAPR5xjN6Ha4PPr4u5me1ioZS5iIw+uFOBFUKbex+iI/AK1q3vQFSIZ0g0HIQWXLFqInWc6bqE3lzCw4Cddnri6Znt8AdZScPqX7e/F2mUhMnCtJaOWgITt1f9bkUFnkiW+E1ZAAc+0wCmDP7I6+6nmgPjZXHOJq+Gfo5yHyOBFMoNjXJN0fZ7p4tQYIR3UgocweENGz1gLn1Pk4HodRvgNXy5YdxRIRyhqa5OL+BTCoML8oDXy9wed42esjF56MDhO2Kf0wpYoT4bNpbFoYsY7qxtF+omIMhXqS8I+PSsMh0Woo13avSa7OCo3WkTrspLvnuH7rhbVDgXS6nQPJodXz/7GA0xr9Ub1NZkJSNxKQQMi/e+Bj6XuDVH2lXa9h9TtRAlh9srl3rVItUnP227ZOHq6trhyUlLnTFlnroyDEZWYJd95sGQQAsD0kmHlfqXPR7PvtKoH1iuHKaSTLMmBE26TsrmB5ZBhc10GEH8at9RuaYxB1F//vNyhZQL5BHENtNa5akA9Wz6MxFAOs1Ab5suoLUxAvxIkXEmrrNEKlsg+jIfWLqFQM6PBMRyvmhH0vvkOtxlV9WlaqPvMhzJoXQY9K2xSxsYXkDbsugNXg8Ll7zDPW31e2gQUZimo4tFsJHa1MocIt5q1COaYN5wz9pKsE4aMBy0JsqLvr7/C/8JRPwhnh2YsatfbQkhW0XYrG6XdUN5+cARZeE3htgV7M4ZZvHH9Uq7JYrJmdJmspKxEBWAjtHg0HgME5a0nult4pUYId35Huitxo/JektWcz63gJzSu1h7opGDVUwhm0fp8nFoFgprwp1OKjTBzo/j2+Rr8dWKQNovcrNLJ8f+nkM/UTpejJwirJckIyOKzhtmhhug1wU2G/2mNaF30ZdTBp/H9p1+d8hASZfNeto3JmNZSrsoPFFZlfYNN9+KHxNSyNMlDxABkFzl7wN1rDrnt9n+A+raSJqVZT/xeFpief4TbTJr42q/5X/SpHcZrf5YQs0jR0Mvua8BvheJzjTdDQuuwJzuySbnJ8cyafEJNf9xKvhgoAzohE7DxXlC4vlUFsVOvYqh0aBwJXHAQSQHDTMA/4LIle0cJ59iYwGPbR7c+oi3T58YJ1VyBpwJ2gekbLGFnUHA8cVAUB8I4wcDHV/jdjErT/aSrIefqCKMJmEqazX5Z0PecB+sM0C7gBzsN86VU0IyILMTSEJuWgQFQuIfrCIdzApSF5hGM511/bNlNYlyiXAyBJDB+P2ogCucX2SfBR8moHx0EB5YumzDw54TwjUMvgSX+LyK0HWETf5Wrl1y7QS3WakcKshxUBsTx5KP//iLpWgj2tdTTZFgDDGahR/I1lCA8JqSzWmObHQlm3mSm2dDtXvzXo6rA8wCW6w7UiMx20nx/bxXbKoRu+ecHCQ+T4chv2Ko+Se4QCceUigLhDty8jdZsD8Z8u31mSP6wjLjwdIeymOSqmjk9QrkiybypmIrm7bMUA/oAAAAwAvnIinFF4ABwwAAAMAAAMAAAMAK2AAAAMAAAMAAAMAf4AAAAMAAAMAAAMBYwAAAwAAAwAAAwOyAAADAAADAAAG5AAAAwAAAwAADhgAAAMAAAMAABjQAAADAAADAAApIAAAAwAAAwAAPOCHAAADAAADAAADAAADAAADAAADAWk=",
-		disabled: "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",
-		waking: "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"
-	}
-};
-var cache = {};
-/**
-* Get the pre-encoded placeholder frame for `(kind, codec)`. Buffer
-* is created once on first use per (codec, kind) pair and cached
-* permanently — safe to call from hot paths (~5-9KB per pair, ~60KB
-* worst-case across both codecs and all five states).
-*/
-function getPlaceholderFrame(kind, codec) {
-	const codecCache = cache[codec] ?? (cache[codec] = {});
-	const cached = codecCache[kind];
-	if (cached) return cached;
-	const buf = Buffer.from(FRAME_B64[codec][kind], "base64");
-	codecCache[kind] = buf;
-	return buf;
+//#region src/stream-broker/stream-broker/opus-encode-session.ts
+var POLL_INTERVAL_MS = 40;
+var MAX_ENCODED_PER_POLL = 16;
+var WARN_THROTTLE_MS = 5e3;
+var OPUS_CODEC = "opus";
+var SESSION_NOT_FOUND_RE = /encode session\b.*\bnot found\b/;
+function isSessionGone(err) {
+	return SESSION_NOT_FOUND_RE.test(errMsg(err));
 }
-//#endregion
-//#region src/stream-broker/stream-broker/stream-pipe-server.ts
-/**
-* A lightweight TCP server that broadcasts raw encoded video bytes
-* (H.264/H.265 Annex-B) to all connected clients.
-*
-* Each StreamBroker owns one StreamPipeServer. Restreamers (e.g. go2rtc)
-* connect via `tcp://127.0.0.1:{port}` and receive the same byte stream
-* that the broker reads from the camera, eliminating duplicate RTSP
-* connections.
-*/
-/** Max bytes queued in a client's write buffer before we consider it too slow */
-var MAX_WRITE_BUFFER_BYTES = 2 * 1024 * 1024;
-var StreamPipeServer = class {
-	server;
-	clients = /* @__PURE__ */ new Set();
-	port = 0;
-	started = false;
+var OpusEncodeSession = class {
+	api;
+	cfg;
+	emit;
 	logger;
-	_onClientCountChanged = null;
-	/** Register a callback invoked when pipe client count changes. */
-	onClientCountChanged(cb) {
-		this._onClientCountChanged = cb;
-	}
-	constructor(logger) {
+	sessionId = null;
+	sessionNodeId = null;
+	creating = null;
+	pollTimer = null;
+	closed = false;
+	chunksIn = 0;
+	chunksDropped = 0;
+	warnState = /* @__PURE__ */ new Map();
+	constructor(api, cfg, emit, logger) {
+		this.api = api;
+		this.cfg = cfg;
+		this.emit = emit;
 		this.logger = logger;
-		this.server = net.createServer((socket) => {
-			this.handleConnection(socket);
-		});
-		this.server.on("error", (err) => {
-			this.logger?.error("StreamPipeServer error", { meta: { error: err.message } });
-		});
 	}
-	async start() {
-		if (this.started) return;
-		await new Promise((resolve, reject) => {
-			this.server.once("error", reject);
-			this.server.listen(0, "127.0.0.1", () => {
-				this.server.removeListener("error", reject);
-				const address = this.server.address();
-				this.port = address.port;
-				this.started = true;
-				this.logger?.debug("StreamPipeServer listening", { meta: { port: this.port } });
-				resolve();
+	/**
+	* Push one decoded PCM chunk. The session is created lazily on the first
+	* push; the poll loop then drains Opus frames back out via `emit`.
+	* `pts` is source-relative ms (falls back to the chunk timestamp).
+	*/
+	pushPcm(chunk) {
+		if (this.closed) return;
+		if (chunk.data.byteLength === 0) return;
+		this.chunksIn++;
+		const data = Uint8Array.from(chunk.data);
+		const pts = chunk.timestamp;
+		this.ensureSession().then((sid) => {
+			if (!sid || this.closed) return;
+			const nodeId = this.sessionNodeId ?? void 0;
+			this.api.pushPcm({
+				sessionId: sid,
+				...nodeId ? { nodeId } : {},
+				data,
+				pts
+			}).catch((err) => {
+				this.chunksDropped++;
+				this.handlePushError("opus-encode: pushPcm failed", sid, err);
 			});
 		});
 	}
+	getStats() {
+		return {
+			chunksIn: this.chunksIn,
+			chunksDropped: this.chunksDropped,
+			sessionId: this.sessionId
+		};
+	}
 	/**
-	* Broadcast raw encoded bytes to all connected clients.
-	* Silently drops data for clients that are slow or disconnected.
+	* Release the upstream encode session + poll loop WITHOUT closing the handle
+	* (demand-gate: no Opus consumer ⇒ the encoder is pure waste). Reusable — the
+	* next `pushPcm` re-creates the session. Mirrors the decode client's `idle`.
 	*/
-	broadcast(data) {
-		for (const client of this.clients) {
-			if (client.destroyed) {
-				this.clients.delete(client);
-				continue;
-			}
-			if (client.writableLength > MAX_WRITE_BUFFER_BYTES) {
-				this.logger?.warn("StreamPipeServer client buffer overflow — dropping client", { meta: { bufferMB: Number((client.writableLength / 1024 / 1024).toFixed(1)) } });
-				this.removeClient(client);
-				continue;
-			}
-			client.write(data, (err) => {
-				if (err) {
-					this.logger?.debug("StreamPipeServer write error, removing client", { meta: { error: err.message } });
-					this.removeClient(client);
-				}
+	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("opus-encode: idle closeSession failed", { meta: { error: errMsg(err) } });
 		}
+		this.logger?.info("opus-encode: encode session idled (no opus consumer)", { meta: { sessionId: sid } });
 	}
-	getPort() {
-		return this.port;
-	}
-	getUrl() {
-		return `tcp://127.0.0.1:${this.port}`;
-	}
-	getClientCount() {
-		return this.clients.size;
-	}
-	isStarted() {
-		return this.started;
-	}
-	async stop() {
-		if (!this.started) return;
-		this.started = false;
-		this._onClientCountChanged = null;
-		for (const client of this.clients) client.destroy();
-		this.clients.clear();
-		await new Promise((resolve) => {
-			this.server.close(() => {
-				this.logger?.debug("StreamPipeServer stopped");
-				resolve();
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		if (this.pollTimer) {
+			clearInterval(this.pollTimer);
+			this.pollTimer = null;
+		}
+		if (!this.sessionId) return;
+		const sid = this.sessionId;
+		const nodeId = this.sessionNodeId ?? void 0;
+		try {
+			const tail = await this.api.flushEncode({
+				sessionId: sid,
+				...nodeId ? { nodeId } : {}
 			});
-		});
+			for (const enc of tail) this.emitEncoded(enc);
+		} catch (err) {
+			if (!isSessionGone(err)) this.warnThrottled("opus-encode: flushEncode failed", errMsg(err));
+		}
+		try {
+			await this.api.closeSession({
+				sessionId: sid,
+				...nodeId ? { nodeId } : {}
+			});
+		} catch (err) {
+			this.logger?.warn("opus-encode: closeSession failed", { meta: { error: errMsg(err) } });
+		}
+		this.sessionId = null;
+		this.sessionNodeId = null;
 	}
-	handleConnection(socket) {
-		this.clients.add(socket);
-		this.logger?.debug("StreamPipeServer client connected", { meta: { total: this.clients.size } });
-		this._onClientCountChanged?.();
-		socket.on("close", () => {
+	async ensureSession() {
+		if (this.sessionId) return this.sessionId;
+		if (this.creating) return this.creating;
+		this.creating = (async () => {
+			try {
+				const res = await this.api.createEncodeSession({
+					codec: OPUS_CODEC,
+					sourceSampleRate: this.cfg.sourceSampleRate,
+					sourceChannels: this.cfg.sourceChannels,
+					...this.cfg.sourceFormat ? { sourceFormat: this.cfg.sourceFormat } : {},
+					targetSampleRate: this.cfg.targetSampleRate,
+					targetChannels: this.cfg.targetChannels,
+					...this.cfg.bitrateKbps ? { bitrateKbps: this.cfg.bitrateKbps } : {},
+					...this.cfg.tag ? { tag: this.cfg.tag } : {}
+				});
+				if (this.closed) {
+					try {
+						await this.api.closeSession({
+							sessionId: res.sessionId,
+							...res.nodeId ? { nodeId: res.nodeId } : {}
+						});
+					} catch (err) {
+						this.logger?.warn("opus-encode: closeSession (closed mid-create) failed", { meta: { error: errMsg(err) } });
+					}
+					return null;
+				}
+				this.sessionId = res.sessionId;
+				this.sessionNodeId = res.nodeId;
+				this.startPollLoop();
+				this.logger?.info("opus-encode: encode session ready", { meta: {
+					sessionId: res.sessionId,
+					nodeId: res.nodeId,
+					source: `${this.cfg.sourceSampleRate}Hz×${this.cfg.sourceChannels}`,
+					target: `${this.cfg.targetSampleRate}Hz×${this.cfg.targetChannels} opus`
+				} });
+				return res.sessionId;
+			} catch (err) {
+				this.logger?.error("opus-encode: createEncodeSession failed", { meta: { error: errMsg(err) } });
+				return null;
+			} finally {
+				this.creating = null;
+			}
+		})();
+		return this.creating;
+	}
+	startPollLoop() {
+		if (this.pollTimer || this.closed) return;
+		this.pollTimer = setInterval(() => {
+			this.pollOnce();
+		}, POLL_INTERVAL_MS);
+		if (typeof this.pollTimer.unref === "function") this.pollTimer.unref();
+	}
+	async pollOnce() {
+		const sid = this.sessionId;
+		if (!sid || this.closed) return;
+		const nodeId = this.sessionNodeId ?? void 0;
+		try {
+			const encoded = await this.api.pullEncoded({
+				sessionId: sid,
+				...nodeId ? { nodeId } : {},
+				maxCount: MAX_ENCODED_PER_POLL
+			});
+			for (const enc of encoded) this.emitEncoded(enc);
+		} catch (err) {
+			if (isSessionGone(err)) {
+				this.handleSessionGone(sid);
+				return;
+			}
+			this.warnThrottled("opus-encode: pullEncoded failed", errMsg(err));
+		}
+	}
+	emitEncoded(enc) {
+		if (enc.data.byteLength === 0) return;
+		this.emit({
+			data: Buffer.from(enc.data),
+			ptsMs: enc.pts
+		});
+	}
+	handleSessionGone(staleSid) {
+		if (this.sessionId !== staleSid) return;
+		this.sessionId = null;
+		this.sessionNodeId = null;
+		if (this.pollTimer) {
+			clearInterval(this.pollTimer);
+			this.pollTimer = null;
+		}
+		this.warnThrottled("opus-encode: session reaped upstream — will re-create on next chunk", `staleSessionId=${staleSid}`);
+	}
+	handlePushError(label, sid, err) {
+		if (isSessionGone(err)) {
+			this.handleSessionGone(sid);
+			return;
+		}
+		this.warnThrottled(label, errMsg(err));
+	}
+	warnThrottled(label, detail) {
+		const key = `${label}|${detail}`;
+		const now = Date.now();
+		const prev = this.warnState.get(key);
+		if (prev && now - prev.lastLoggedAt < WARN_THROTTLE_MS) {
+			prev.suppressed++;
+			return;
+		}
+		const suppressed = prev?.suppressed ?? 0;
+		this.warnState.set(key, {
+			lastLoggedAt: now,
+			suppressed: 0
+		});
+		this.logger?.warn(label, { meta: {
+			error: detail,
+			...suppressed > 0 ? { suppressedSinceLastLog: suppressed } : {}
+		} });
+	}
+};
+var OPUS_SILENCE_RATE_HZ = 48e3;
+var OPUS_SILENCE_FRAME_SAMPLES = 960;
+var OPUS_SILENCE_PRIME_FRAMES = 6;
+/**
+* Produce ONE canonical 20 ms Opus silence packet by encoding PCM zeros through
+* the audio-codec cap, for the WebRTC session's prestream A/V-sync padding
+* (Opus has no fixed "silence byte" like PCMU's 0xFF — silence must be encoded).
+* A short-lived encode session is created, primed with a few zero frames, and
+* flushed; the LAST steady-state frame is returned. Returns `null` when the cap
+* is unavailable or yields nothing so the caller can skip prestream padding.
+*/
+async function encodeOpusSilenceFrame(api, cfg) {
+	let sessionId = null;
+	let nodeId;
+	try {
+		const res = await api.createEncodeSession({
+			codec: OPUS_CODEC,
+			sourceSampleRate: OPUS_SILENCE_RATE_HZ,
+			sourceChannels: cfg.channels,
+			sourceFormat: "f32le",
+			targetSampleRate: OPUS_SILENCE_RATE_HZ,
+			targetChannels: cfg.channels,
+			...cfg.bitrateKbps ? { bitrateKbps: cfg.bitrateKbps } : {},
+			tag: "opus-silence"
+		});
+		sessionId = res.sessionId;
+		nodeId = res.nodeId;
+		const zeros = Buffer.alloc(OPUS_SILENCE_FRAME_SAMPLES * cfg.channels * 4);
+		const collected = [];
+		for (let i = 0; i < OPUS_SILENCE_PRIME_FRAMES; i++) {
+			await api.pushPcm({
+				sessionId,
+				...nodeId ? { nodeId } : {},
+				data: zeros,
+				pts: i * 20
+			});
+			const out = await api.pullEncoded({
+				sessionId,
+				...nodeId ? { nodeId } : {},
+				maxCount: 8
+			});
+			for (const e of out) if (e.data.byteLength > 0) collected.push(Buffer.from(e.data));
+		}
+		const tail = await api.flushEncode({
+			sessionId,
+			...nodeId ? { nodeId } : {}
+		});
+		for (const e of tail) if (e.data.byteLength > 0) collected.push(Buffer.from(e.data));
+		return collected.length > 0 ? collected[collected.length - 1] : null;
+	} catch {
+		return null;
+	} finally {
+		if (sessionId) await api.closeSession({
+			sessionId,
+			...nodeId ? { nodeId } : {}
+		}).catch(() => {});
+	}
+}
+//#endregion
+//#region src/stream-broker/stream-broker/placeholder-frames.ts
+var FRAME_B64 = {
+	h264: {
+		reconnecting: "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",
+		sleeping: "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",
+		offline: "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",
+		disabled: "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",
+		waking: "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"
+	},
+	h265: {
+		reconnecting: "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",
+		sleeping: "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",
+		offline: "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",
+		disabled: "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",
+		waking: "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"
+	}
+};
+var cache = {};
+/**
+* Get the pre-encoded placeholder frame for `(kind, codec)`. Buffer
+* is created once on first use per (codec, kind) pair and cached
+* permanently — safe to call from hot paths (~5-9KB per pair, ~60KB
+* worst-case across both codecs and all five states).
+*/
+function getPlaceholderFrame(kind, codec) {
+	const codecCache = cache[codec] ?? (cache[codec] = {});
+	const cached = codecCache[kind];
+	if (cached) return cached;
+	const buf = Buffer.from(FRAME_B64[codec][kind], "base64");
+	codecCache[kind] = buf;
+	return buf;
+}
+//#endregion
+//#region src/stream-broker/stream-broker/stream-pipe-server.ts
+/**
+* A lightweight TCP server that broadcasts raw encoded video bytes
+* (H.264/H.265 Annex-B) to all connected clients.
+*
+* Each StreamBroker owns one StreamPipeServer. Restreamers (e.g. go2rtc)
+* connect via `tcp://127.0.0.1:{port}` and receive the same byte stream
+* that the broker reads from the camera, eliminating duplicate RTSP
+* connections.
+*/
+/** Max bytes queued in a client's write buffer before we consider it too slow */
+var MAX_WRITE_BUFFER_BYTES = 2 * 1024 * 1024;
+var StreamPipeServer = class {
+	server;
+	clients = /* @__PURE__ */ new Set();
+	port = 0;
+	started = false;
+	logger;
+	_onClientCountChanged = null;
+	/** Register a callback invoked when pipe client count changes. */
+	onClientCountChanged(cb) {
+		this._onClientCountChanged = cb;
+	}
+	constructor(logger) {
+		this.logger = logger;
+		this.server = net.createServer((socket) => {
+			this.handleConnection(socket);
+		});
+		this.server.on("error", (err) => {
+			this.logger?.error("StreamPipeServer error", { meta: { error: err.message } });
+		});
+	}
+	async start() {
+		if (this.started) return;
+		await new Promise((resolve, reject) => {
+			this.server.once("error", reject);
+			this.server.listen(0, "127.0.0.1", () => {
+				this.server.removeListener("error", reject);
+				const address = this.server.address();
+				this.port = address.port;
+				this.started = true;
+				this.logger?.debug("StreamPipeServer listening", { meta: { port: this.port } });
+				resolve();
+			});
+		});
+	}
+	/**
+	* Broadcast raw encoded bytes to all connected clients.
+	* Silently drops data for clients that are slow or disconnected.
+	*/
+	broadcast(data) {
+		for (const client of this.clients) {
+			if (client.destroyed) {
+				this.clients.delete(client);
+				continue;
+			}
+			if (client.writableLength > MAX_WRITE_BUFFER_BYTES) {
+				this.logger?.warn("StreamPipeServer client buffer overflow — dropping client", { meta: { bufferMB: Number((client.writableLength / 1024 / 1024).toFixed(1)) } });
+				this.removeClient(client);
+				continue;
+			}
+			client.write(data, (err) => {
+				if (err) {
+					this.logger?.debug("StreamPipeServer write error, removing client", { meta: { error: err.message } });
+					this.removeClient(client);
+				}
+			});
+		}
+	}
+	getPort() {
+		return this.port;
+	}
+	getUrl() {
+		return `tcp://127.0.0.1:${this.port}`;
+	}
+	getClientCount() {
+		return this.clients.size;
+	}
+	isStarted() {
+		return this.started;
+	}
+	async stop() {
+		if (!this.started) return;
+		this.started = false;
+		this._onClientCountChanged = null;
+		for (const client of this.clients) client.destroy();
+		this.clients.clear();
+		await new Promise((resolve) => {
+			this.server.close(() => {
+				this.logger?.debug("StreamPipeServer stopped");
+				resolve();
+			});
+		});
+	}
+	handleConnection(socket) {
+		this.clients.add(socket);
+		this.logger?.debug("StreamPipeServer client connected", { meta: { total: this.clients.size } });
+		this._onClientCountChanged?.();
+		socket.on("close", () => {
 			this.removeClient(socket);
 		});
 		socket.on("error", () => {
@@ -10388,6 +10861,18 @@ var StreamBroker = class StreamBroker {
 	audioRtpDecoder = null;
 	audioCodecSession = null;
 	/**
+	* Live Opus egress encoder — lazily created when a WebRTC session negotiates
+	* Opus (`opusConsumerCount > 0`). Encodes the SAME decoded PCM that feeds the
+	* PCMU path into 48 kHz Opus access units, emitted as `codec:'opus'`
+	* EncodedPackets ALONGSIDE the untouched PCMU packets (strictly additive — the
+	* PCMU fan-out stays byte-identical for fallback sessions). Idled when the
+	* last Opus consumer detaches. In-process (audio-codec cap / node-av), no
+	* ffmpeg. See {@link feedOpusEncoder}.
+	*/
+	opusEncodeSession = null;
+	/** Number of attached WebRTC sessions that negotiated Opus (demand gate). */
+	opusConsumerCount = 0;
+	/**
 	* 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}.
@@ -10888,6 +11373,73 @@ var StreamBroker = class StreamBroker {
 		return this.encodedCallbacks.size > 0 || this.audioChunkPlane.subscriberCount > 0;
 	}
 	/**
+	* Register a WebRTC session that negotiated Opus. Turns on the live Opus
+	* egress encoder (lazily, on the first decoded PCM chunk). Additive — the
+	* PCMU fan-out is untouched, so PCMU-fallback sessions are unaffected.
+	*/
+	acquireOpusEgress() {
+		this.opusConsumerCount++;
+	}
+	/**
+	* Deregister an Opus session. Idles (but keeps) the encoder when the last
+	* Opus consumer detaches — the next {@link acquireOpusEgress} + PCM push
+	* re-creates the upstream encode session, exactly like the decode client.
+	*/
+	releaseOpusEgress() {
+		if (this.opusConsumerCount > 0) this.opusConsumerCount--;
+		if (this.opusConsumerCount === 0 && this.opusEncodeSession) this.opusEncodeSession.idle().catch((err) => {
+			this.logger?.warn("opus-egress: idle failed", { meta: { error: errMsg(err) } });
+		});
+	}
+	/**
+	* Encode ONE canonical 20 ms Opus silence packet for a session's prestream
+	* A/V-sync padding (Opus has no fixed silence byte). Returns `null` when the
+	* audio-codec cap is unavailable. See {@link encodeOpusSilenceFrame}.
+	*/
+	async makeOpusSilenceFrame(channels) {
+		if (!this.audioCodecApi) return null;
+		return encodeOpusSilenceFrame(this.audioCodecApi, { channels });
+	}
+	/**
+	* Feed one decoded PCM chunk (f32le, the decode contract) into the live Opus
+	* egress encoder when an Opus consumer is attached. Lazily creates the encode
+	* session sized to the chunk. No-op without Opus demand or the cap.
+	*/
+	feedOpusEncoder(chunk) {
+		if (this.opusConsumerCount === 0) return;
+		const api = this.audioCodecApi;
+		if (!api) return;
+		if (!this.opusEncodeSession) {
+			const targetChannels = Math.min(2, Math.max(1, chunk.channels));
+			this.opusEncodeSession = new OpusEncodeSession(api, {
+				sourceSampleRate: chunk.sampleRate,
+				sourceChannels: chunk.channels,
+				sourceFormat: "f32le",
+				targetSampleRate: 48e3,
+				targetChannels,
+				bitrateKbps: targetChannels >= 2 ? 64 : 48,
+				tag: `broker:${this.deviceId}:opus-egress`
+			}, (frame) => this.emitOpusEncoded(frame), this.logger ?? void 0);
+		}
+		this.opusEncodeSession.pushPcm(chunk);
+	}
+	/** Fan out one encoded Opus access unit as a `codec:'opus'` EncodedPacket. */
+	emitOpusEncoded(frame) {
+		if (this.encodedCallbacks.size === 0) return;
+		const packet = {
+			type: "audio",
+			data: frame.data,
+			pts: frame.ptsMs,
+			dts: frame.ptsMs,
+			keyframe: false,
+			codec: "opus"
+		};
+		for (const [cb, entry] of this.encodedCallbacks) {
+			cb(packet);
+			entry.packetsDelivered += 1;
+		}
+	}
+	/**
 	* 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
@@ -11988,6 +12540,17 @@ var StreamBroker = class StreamBroker {
 							cb(packet);
 							entry.packetsDelivered += 1;
 						}
+						if (this.opusConsumerCount > 0 && this.audioCodecApi) {
+							const pcm16 = this.audioCodec === "PCMA" ? alawToPcm(payload) : mulawToPcm(payload);
+							const f32 = new Float32Array(pcm16.length);
+							for (let i = 0; i < pcm16.length; i++) f32[i] = pcm16[i] / 32768;
+							this.feedOpusEncoder({
+								data: Buffer.from(f32.buffer, f32.byteOffset, f32.byteLength),
+								sampleRate: 8e3,
+								channels: 1,
+								timestamp: pts
+							});
+						}
 					}
 				}
 				this.rtspRestreamer.pushAudioRtpPassthrough(rtpData);
@@ -12461,6 +13024,13 @@ var StreamBroker = class StreamBroker {
 				this.logger?.warn("audio-codec: session close failed", { meta: { error: errMsg(err) } });
 			});
 		}
+		if (this.opusEncodeSession) {
+			const opus = this.opusEncodeSession;
+			this.opusEncodeSession = null;
+			opus.close().catch((err) => {
+				this.logger?.warn("opus-egress: session close failed", { meta: { error: errMsg(err) } });
+			});
+		}
 	}
 	/**
 	* Map an SDP audio track to an `AudioCodecSession` config the
@@ -12509,6 +13079,7 @@ var StreamBroker = class StreamBroker {
 					offsetBytes = end;
 					chunkOffsetMs += 20;
 				}
+				this.feedOpusEncoder(chunk);
 			}
 		};
 	}
@@ -17122,8 +17693,8 @@ var SCRUB_PREFETCH_DIR_THRESHOLD = 2;
 var RecordedFeeder = class {
 	deps;
 	clock = new MonotonicClock();
-	/** Separate 8 kHz clock for PCMU audio; re-anchored together with video. */
-	audioClock = new MonotonicClock(8e3);
+	/** Audio clock (PCMU 8 kHz / Opus 48 kHz); re-anchored together with video. */
+	audioClock;
 	clockHasAdvanced = false;
 	/** Playback rate: 0 (paused) or a continuous factor in [0.25, 4]. */
 	rate = 1;
@@ -17206,6 +17777,18 @@ var RecordedFeeder = class {
 	scrubPrefetchInFlight = false;
 	constructor(deps) {
 		this.deps = deps;
+		this.audioClock = new MonotonicClock(deps.audioClockRateHz ?? 8e3);
+	}
+	/**
+	* The negotiated audio sink push fn (Opus preferred, else PCMU), or undefined
+	* for a video-only sink. A feeder is wired with exactly ONE of the two.
+	*/
+	resolveAudioPush() {
+		const sink = this.deps.sink;
+		const opus = sink.pushAudioOpus;
+		if (typeof opus === "function") return (data, rtpTs) => opus.call(sink, data, rtpTs);
+		const pcmu = sink.pushAudioPcmu;
+		if (typeof pcmu === "function") return (data, rtpTs) => pcmu.call(sink, data, rtpTs);
 	}
 	/**
 	* Seek to an epoch and (if rate > 0) begin forward playback. Resolves after
@@ -17725,7 +18308,8 @@ var RecordedFeeder = class {
 	*/
 	async paceSegment(prepared, gen, resumeAfterPtsMs = null) {
 		const rate = this.rate;
-		const hasAudioSink = typeof this.deps.sink.pushAudioPcmu === "function" && rate === 1;
+		const audioPush = this.resolveAudioPush();
+		const hasAudioSink = audioPush !== void 0 && rate === 1;
 		const schedule = [];
 		for (const au of prepared.aus) if (resumeAfterPtsMs === null || au.ptsMs > resumeAfterPtsMs) schedule.push({
 			ptsMs: au.ptsMs,
@@ -17769,8 +18353,7 @@ var RecordedFeeder = class {
 				this.lastFedVideoIdx = videoIdx++;
 				this.cursorMs = prepared.startMs + (item.video.ptsMs - firstVideoPtsMs);
 			} else if (item.audio) {
-				const pushAudio = this.deps.sink.pushAudioPcmu;
-				if (pushAudio) pushAudio.call(this.deps.sink, item.audio.data, this.audioClock.stamp(item.audio.ptsMs));
+				if (audioPush) audioPush(item.audio.data, this.audioClock.stamp(item.audio.ptsMs));
 			}
 		}
 		if (pushedVideo) this.clockHasAdvanced = true;
@@ -17852,7 +18435,7 @@ var RecordedFeeder = class {
 		const video = await this.withTimeout(demux(bytes));
 		if (this.disposed || token !== this.seekToken) return null;
 		let audio = [];
-		if (wantAudio && this.deps.demuxAudio && this.deps.sink.pushAudioPcmu) {
+		if (wantAudio && this.deps.demuxAudio && this.resolveAudioPush() !== void 0) {
 			try {
 				audio = await this.withTimeout(this.deps.demuxAudio(bytes));
 			} catch {
@@ -17997,7 +18580,154 @@ var TimelineSession = class {
 		this.feeder?.dispose();
 		this.feeder = null;
 	}
-};
+};
+//#endregion
+//#region src/stream-broker/recorded/avcc-annexb.ts
+/**
+* avcc-annexb — pure byte helpers to turn an ISO-BMFF (mp4) length-prefixed
+* video sample plus its `avcC`/`hvcC` decoder config into an Annex-B access
+* unit with the parameter sets prepended (SPS/PPS for H.264, VPS/SPS/PPS for
+* H.265).
+*
+* mp4 stores VCL NALs length-prefixed (AVCC/HVCC: a 1–4 byte big-endian length
+* field, `lengthSizeMinusOne+1`, before each NAL) and keeps the parameter sets
+* OUT of the samples, inside the `avcC`/`hvcC` box. A raw decoder / RTP
+* packetizer needs Annex-B start codes (`00 00 00 01`) AND the parameter sets
+* fused onto every IDR. These helpers do exactly that in JS — no ffmpeg, no
+* decode, byte copies only — so the feeder-scrub keyframe path can skip the
+* per-fragment ffmpeg spawn.
+*
+* All functions are pure and total for well-formed input; malformed config /
+* sample bytes throw a `RangeError` (the caller treats a throw as "fall back to
+* ffmpeg"). The `description` bytes are the box payload WITH the 8-byte box
+* header already stripped (i.e. starting at `configurationVersion`), matching
+* `mp4box`'s `avcC`/`hvcC` DataStream output minus header — see
+* `recorder/scrub/fmp4-keyframes.ts` `extractDescription`.
+*/
+/** Annex-B 4-byte start code prepended before every emitted NAL. */
+var START_CODE = Uint8Array.of(0, 0, 0, 1);
+/** Big-endian unsigned read of `size` (1..4) bytes at `off`. */
+function readUint(bytes, off, size) {
+	if (off + size > bytes.length) throw new RangeError(`readUint out of range: off=${off} size=${size} len=${bytes.length}`);
+	let v = 0;
+	for (let i = 0; i < size; i++) v = v * 256 + bytes[off + i];
+	return v;
+}
+/**
+* NAL length-prefix size in bytes (`lengthSizeMinusOne + 1`, 1..4) read from the
+* decoder config. `avcC` carries it at byte 4 (low 2 bits); `hvcC` at byte 21
+* (low 2 bits).
+*/
+function parseNalLengthSize(description, isHevc) {
+	const idx = isHevc ? 21 : 4;
+	if (description.length <= idx) throw new RangeError(`config too short for lengthSizeMinusOne (len=${description.length})`);
+	return (description[idx] & 3) + 1;
+}
+/** Concatenate byte chunks into one Uint8Array. */
+function concat$1(chunks) {
+	let total = 0;
+	for (const c of chunks) total += c.length;
+	const out = new Uint8Array(total);
+	let off = 0;
+	for (const c of chunks) {
+		out.set(c, off);
+		off += c.length;
+	}
+	return out;
+}
+/** Push one Annex-B NAL (start code + payload) onto `chunks`. */
+function pushNal(chunks, payload) {
+	chunks.push(START_CODE, payload);
+}
+/**
+* Parse the `avcC` parameter sets (SPS then PPS), emitting each as an Annex-B
+* NAL. Layout after the 4-byte profile/level prefix: byte 4 low-2 = length
+* size; byte 5 low-5 = numSPS; then `[u16 len][SPS]…`; then `[u8 numPPS]`; then
+* `[u16 len][PPS]…`.
+*/
+function extractAvcParameterSets(desc) {
+	const chunks = [];
+	const numSps = desc[5] & 31;
+	let p = 6;
+	for (let i = 0; i < numSps; i++) {
+		const len = readUint(desc, p, 2);
+		p += 2;
+		if (p + len > desc.length) throw new RangeError("avcC SPS length overruns config");
+		pushNal(chunks, desc.subarray(p, p + len));
+		p += len;
+	}
+	const numPps = readUint(desc, p, 1);
+	p += 1;
+	for (let i = 0; i < numPps; i++) {
+		const len = readUint(desc, p, 2);
+		p += 2;
+		if (p + len > desc.length) throw new RangeError("avcC PPS length overruns config");
+		pushNal(chunks, desc.subarray(p, p + len));
+		p += len;
+	}
+	return chunks;
+}
+/**
+* Parse the `hvcC` parameter-set arrays (typically VPS, SPS, PPS in order),
+* emitting each contained NAL as Annex-B. Layout: byte 22 = numOfArrays; then
+* per array `[u8 flags+NALtype][u16 numNalus]` followed by `numNalus` ×
+* `[u16 len][NAL]`.
+*/
+function extractHevcParameterSets(desc) {
+	const chunks = [];
+	const numArrays = readUint(desc, 22, 1);
+	let p = 23;
+	for (let a = 0; a < numArrays; a++) {
+		p += 1;
+		const numNalus = readUint(desc, p, 2);
+		p += 2;
+		for (let n = 0; n < numNalus; n++) {
+			const len = readUint(desc, p, 2);
+			p += 2;
+			if (p + len > desc.length) throw new RangeError("hvcC NAL length overruns config");
+			pushNal(chunks, desc.subarray(p, p + len));
+			p += len;
+		}
+	}
+	return chunks;
+}
+/**
+* Parameter sets from the decoder config as one Annex-B blob (each NAL led by a
+* `00 00 00 01` start code): SPS+PPS for H.264, VPS+SPS+PPS (+ any hvcC arrays)
+* for H.265. Throws on a malformed config.
+*/
+function extractParameterSetsAnnexB(description, isHevc) {
+	return concat$1(isHevc ? extractHevcParameterSets(description) : extractAvcParameterSets(description));
+}
+/**
+* Convert one length-prefixed (AVCC/HVCC) sample into Annex-B: walk each
+* `nalLengthSize`-byte length field, replacing it with a `00 00 00 01` start
+* code. Handles multi-NAL samples (multiple slices / SEI + VCL). Throws if a
+* length field overruns the sample.
+*/
+function avccSampleToAnnexB(sample, nalLengthSize) {
+	const chunks = [];
+	let p = 0;
+	while (p + nalLengthSize <= sample.length) {
+		const len = readUint(sample, p, nalLengthSize);
+		p += nalLengthSize;
+		if (len === 0) continue;
+		if (p + len > sample.length) throw new RangeError("AVCC NAL length overruns sample");
+		pushNal(chunks, sample.subarray(p, p + len));
+		p += len;
+	}
+	if (chunks.length === 0) throw new RangeError("AVCC sample yielded no NALs");
+	return concat$1(chunks);
+}
+/**
+* Build a standalone-decodable Annex-B keyframe access unit: the config's
+* parameter sets, then the sample's NALs, all Annex-B framed. Throws on
+* malformed input (caller falls back to the ffmpeg demux).
+*/
+function buildKeyframeAnnexB(sample, description, isHevc) {
+	const nalLengthSize = parseNalLengthSize(description, isHevc);
+	return concat$1([extractParameterSetsAnnexB(description, isHevc), avccSampleToAnnexB(sample, nalLengthSize)]);
+}
 //#endregion
 //#region src/stream-broker/recorded/ffmpeg-run-once.ts
 /**
@@ -18266,7 +18996,7 @@ function demuxMpegTsToAnnexB(ts) {
 	let current = null;
 	const finalize = () => {
 		if (current === null) return;
-		const pes = current.length === 1 ? current[0] : concat$1(current);
+		const pes = current.length === 1 ? current[0] : concat(current);
 		current = null;
 		const split = splitPes(pes);
 		if (split === null || split.es.length === 0) return;
@@ -18297,7 +19027,7 @@ function demuxMpegTsToAnnexB(ts) {
 	};
 }
 /** Concatenate TS payload fragments into one contiguous PES buffer. */
-function concat$1(parts) {
+function concat(parts) {
 	let total = 0;
 	for (const p of parts) total += p.length;
 	const out = new Uint8Array(total);
@@ -18443,156 +19173,15 @@ async function demuxSegmentKeyframesToAnnexB(bytes, ffmpegPath = "ffmpeg") {
 	return keyframes.length > 0 ? keyframes : mapped.slice(0, 1);
 }
 //#endregion
-//#region src/stream-broker/recorded/avcc-annexb.ts
-/**
-* avcc-annexb — pure byte helpers to turn an ISO-BMFF (mp4) length-prefixed
-* video sample plus its `avcC`/`hvcC` decoder config into an Annex-B access
-* unit with the parameter sets prepended (SPS/PPS for H.264, VPS/SPS/PPS for
-* H.265).
-*
-* mp4 stores VCL NALs length-prefixed (AVCC/HVCC: a 1–4 byte big-endian length
-* field, `lengthSizeMinusOne+1`, before each NAL) and keeps the parameter sets
-* OUT of the samples, inside the `avcC`/`hvcC` box. A raw decoder / RTP
-* packetizer needs Annex-B start codes (`00 00 00 01`) AND the parameter sets
-* fused onto every IDR. These helpers do exactly that in JS — no ffmpeg, no
-* decode, byte copies only — so the feeder-scrub keyframe path can skip the
-* per-fragment ffmpeg spawn.
-*
-* All functions are pure and total for well-formed input; malformed config /
-* sample bytes throw a `RangeError` (the caller treats a throw as "fall back to
-* ffmpeg"). The `description` bytes are the box payload WITH the 8-byte box
-* header already stripped (i.e. starting at `configurationVersion`), matching
-* `mp4box`'s `avcC`/`hvcC` DataStream output minus header — see
-* `recorder/scrub/fmp4-keyframes.ts` `extractDescription`.
-*/
-/** Annex-B 4-byte start code prepended before every emitted NAL. */
-var START_CODE = Uint8Array.of(0, 0, 0, 1);
-/** Big-endian unsigned read of `size` (1..4) bytes at `off`. */
-function readUint(bytes, off, size) {
-	if (off + size > bytes.length) throw new RangeError(`readUint out of range: off=${off} size=${size} len=${bytes.length}`);
-	let v = 0;
-	for (let i = 0; i < size; i++) v = v * 256 + bytes[off + i];
-	return v;
-}
-/**
-* NAL length-prefix size in bytes (`lengthSizeMinusOne + 1`, 1..4) read from the
-* decoder config. `avcC` carries it at byte 4 (low 2 bits); `hvcC` at byte 21
-* (low 2 bits).
-*/
-function parseNalLengthSize(description, isHevc) {
-	const idx = isHevc ? 21 : 4;
-	if (description.length <= idx) throw new RangeError(`config too short for lengthSizeMinusOne (len=${description.length})`);
-	return (description[idx] & 3) + 1;
-}
-/** Concatenate byte chunks into one Uint8Array. */
-function concat(chunks) {
-	let total = 0;
-	for (const c of chunks) total += c.length;
-	const out = new Uint8Array(total);
-	let off = 0;
-	for (const c of chunks) {
-		out.set(c, off);
-		off += c.length;
-	}
-	return out;
-}
-/** Push one Annex-B NAL (start code + payload) onto `chunks`. */
-function pushNal(chunks, payload) {
-	chunks.push(START_CODE, payload);
-}
-/**
-* Parse the `avcC` parameter sets (SPS then PPS), emitting each as an Annex-B
-* NAL. Layout after the 4-byte profile/level prefix: byte 4 low-2 = length
-* size; byte 5 low-5 = numSPS; then `[u16 len][SPS]…`; then `[u8 numPPS]`; then
-* `[u16 len][PPS]…`.
-*/
-function extractAvcParameterSets(desc) {
-	const chunks = [];
-	const numSps = desc[5] & 31;
-	let p = 6;
-	for (let i = 0; i < numSps; i++) {
-		const len = readUint(desc, p, 2);
-		p += 2;
-		if (p + len > desc.length) throw new RangeError("avcC SPS length overruns config");
-		pushNal(chunks, desc.subarray(p, p + len));
-		p += len;
-	}
-	const numPps = readUint(desc, p, 1);
-	p += 1;
-	for (let i = 0; i < numPps; i++) {
-		const len = readUint(desc, p, 2);
-		p += 2;
-		if (p + len > desc.length) throw new RangeError("avcC PPS length overruns config");
-		pushNal(chunks, desc.subarray(p, p + len));
-		p += len;
-	}
-	return chunks;
-}
-/**
-* Parse the `hvcC` parameter-set arrays (typically VPS, SPS, PPS in order),
-* emitting each contained NAL as Annex-B. Layout: byte 22 = numOfArrays; then
-* per array `[u8 flags+NALtype][u16 numNalus]` followed by `numNalus` ×
-* `[u16 len][NAL]`.
-*/
-function extractHevcParameterSets(desc) {
-	const chunks = [];
-	const numArrays = readUint(desc, 22, 1);
-	let p = 23;
-	for (let a = 0; a < numArrays; a++) {
-		p += 1;
-		const numNalus = readUint(desc, p, 2);
-		p += 2;
-		for (let n = 0; n < numNalus; n++) {
-			const len = readUint(desc, p, 2);
-			p += 2;
-			if (p + len > desc.length) throw new RangeError("hvcC NAL length overruns config");
-			pushNal(chunks, desc.subarray(p, p + len));
-			p += len;
-		}
-	}
-	return chunks;
-}
-/**
-* Parameter sets from the decoder config as one Annex-B blob (each NAL led by a
-* `00 00 00 01` start code): SPS+PPS for H.264, VPS+SPS+PPS (+ any hvcC arrays)
-* for H.265. Throws on a malformed config.
-*/
-function extractParameterSetsAnnexB(description, isHevc) {
-	return concat(isHevc ? extractHevcParameterSets(description) : extractAvcParameterSets(description));
-}
-/**
-* Convert one length-prefixed (AVCC/HVCC) sample into Annex-B: walk each
-* `nalLengthSize`-byte length field, replacing it with a `00 00 00 01` start
-* code. Handles multi-NAL samples (multiple slices / SEI + VCL). Throws if a
-* length field overruns the sample.
-*/
-function avccSampleToAnnexB(sample, nalLengthSize) {
-	const chunks = [];
-	let p = 0;
-	while (p + nalLengthSize <= sample.length) {
-		const len = readUint(sample, p, nalLengthSize);
-		p += nalLengthSize;
-		if (len === 0) continue;
-		if (p + len > sample.length) throw new RangeError("AVCC NAL length overruns sample");
-		pushNal(chunks, sample.subarray(p, p + len));
-		p += len;
-	}
-	if (chunks.length === 0) throw new RangeError("AVCC sample yielded no NALs");
-	return concat(chunks);
-}
-/**
-* Build a standalone-decodable Annex-B keyframe access unit: the config's
-* parameter sets, then the sample's NALs, all Annex-B framed. Throws on
-* malformed input (caller falls back to the ffmpeg demux).
-*/
-function buildKeyframeAnnexB(sample, description, isHevc) {
-	const nalLengthSize = parseNalLengthSize(description, isHevc);
-	return concat([extractParameterSetsAnnexB(description, isHevc), avccSampleToAnnexB(sample, nalLengthSize)]);
-}
-//#endregion
 //#region src/stream-broker/recorded/segment-demux-js.ts
 /**
-* segment-demux-js — PURE-JS keyframe demux for the feeder-scrub sub-mode.
+* segment-demux-js — PURE-JS in-process demux for recorded playback.
+*
+* Two flavours, both replacing a per-fragment ffmpeg spawn with an mp4box parse:
+*   - {@link demuxSegmentKeyframesJs} / {@link demuxSegmentKeyframesPreferJs} —
+*     KEYFRAME-only, for the feeder-scrub sub-mode.
+*   - {@link demuxSegmentFullJs} / {@link demuxSegmentPreferJs} — FULL playback
+*     (every access unit, sync + delta), the drop-in for `RecordedFeederDeps.demux`.
 *
 * Replaces the per-fragment ffmpeg spawn ({@link demuxSegmentKeyframesToAnnexB},
 * a ~140 ms subprocess floor) with an in-process mp4box parse. A recorded `.m4s`
@@ -18653,6 +19242,52 @@ async function demuxSegmentKeyframesPreferJs(bytes, opts = {}) {
 	}
 	return demuxSegmentKeyframesToAnnexB(bytes, opts.ffmpegPath);
 }
+/**
+* Pure-JS FULL-playback demux of one self-contained `.m4s` fragment: return
+* EVERY access unit (sync + delta) as params-fused Annex-B with segment-relative
+* `ptsMs`, matching the {@link AccessUnit} contract of {@link demuxSegmentToAnnexB}
+* (the ffmpeg mpegts path). Returns `null` if mp4box found no video / no
+* decodable sample (caller falls back to ffmpeg).
+*
+* Each sync sample is emitted through {@link buildKeyframeAnnexB} (parameter sets
+* fused ahead of the IDR — SPS/PPS for H.264, VPS/SPS/PPS for H.265); each delta
+* sample is emitted through {@link avccSampleToAnnexB} (its VCL NALs converted
+* from length-prefixed AVCC/HVCC to Annex-B, no parameter sets). `ptsMs` is the
+* sample composition time anchored to 0 at the first sample — the same
+* segment-relative timeline the ffmpeg PES-PTS path produces.
+*
+* Throws only on a genuinely malformed decoder config / sample; the wrapper
+* ({@link demuxSegmentPreferJs}) turns that into an ffmpeg fallback.
+*/
+async function demuxSegmentFullJs(bytes) {
+	const extracted = await extractSamples(bytes, 0);
+	if (!extracted || extracted.samples.length === 0) return null;
+	const isHevc = isHevcCodec(extracted.codec);
+	const codec = isHevc ? "H265" : "H264";
+	const nalLengthSize = parseNalLengthSize(extracted.description, isHevc);
+	return extracted.samples.map((s) => ({
+		data: s.isSync ? buildKeyframeAnnexB(s.data, extracted.description, isHevc) : avccSampleToAnnexB(s.data, nalLengthSize),
+		ptsMs: s.ts,
+		keyframe: s.isSync,
+		codec
+	}));
+}
+/**
+* Feeder FULL-playback demux: try the pure-JS extractor first, fall back to the
+* ffmpeg spawn ({@link demuxSegmentToAnnexB}) if the JS parse yields no access
+* unit or throws on malformed bytes. Preserves the exact {@link AccessUnit}
+* contract either way, so it is a drop-in for `RecordedFeederDeps.demux`.
+*/
+async function demuxSegmentPreferJs(bytes, opts = {}) {
+	try {
+		const js = await demuxSegmentFullJs(bytes);
+		if (js && js.length > 0) return js;
+		opts.onJsFallback?.("mp4box parse found no access units");
+	} catch (err) {
+		opts.onJsFallback?.(`mp4box parse threw: ${String(err)}`);
+	}
+	return demuxSegmentToAnnexB(bytes, opts.ffmpegPath);
+}
 //#endregion
 //#region src/stream-broker/recorded/segment-audio.ts
 /**
@@ -18737,6 +19372,147 @@ async function demuxSegmentToPcmu(bytes, ffmpegPath = "ffmpeg") {
 	return sliceMuLawToPcmuFrames(mulaw);
 }
 //#endregion
+//#region src/stream-broker/recorded/segment-audio-js.ts
+var import_mp4box_all = /* @__PURE__ */ __toESM(require_mp4box_all());
+/** True for an mp4box audio codec string that is Opus (`Opus`/`opus`). */
+function isOpusCodec(codec) {
+	return /^opus$/i.test(codec);
+}
+/**
+* Phase 1: append the whole segment, flush, resolve the FIRST audio track when
+* `onReady` fires. Resolves null on any failure (no audio track, error, or
+* garbage bytes that never trigger a callback — a short timer settles those).
+* Mirrors `fmp4-keyframes.ts` `readTrack` but for the audio track.
+*/
+function readAudioTrack(file, segment) {
+	return new Promise((resolve) => {
+		let settled = false;
+		const done = (v) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			resolve(v);
+		};
+		const timer = setTimeout(() => done(null), 250);
+		file.onError = () => done(null);
+		file.onReady = (info) => {
+			const audio = info.audioTracks?.[0];
+			if (!audio) return done(null);
+			done({ audio });
+		};
+		const copy = segment.buffer.slice(segment.byteOffset, segment.byteOffset + segment.byteLength);
+		copy.fileStart = 0;
+		try {
+			file.appendBuffer(copy);
+			file.flush();
+		} catch {
+			done(null);
+		}
+	});
+}
+/**
+* Demux a recorded `.m4s` fragment's audio track and return its codec + all
+* access units, or null if the fragment carries no audio / no decodable sample.
+* Codec-agnostic: the caller decides what to do with a non-Opus codec.
+* No decode, no ffmpeg — byte copies only.
+*/
+async function extractAudioSamples(bytes) {
+	const file = import_mp4box_all.createFile();
+	const ready = await readAudioTrack(file, bytes);
+	if (!ready) return null;
+	const { audio } = ready;
+	const collected = [];
+	let firstCts = null;
+	file.onSamples = (_id, _user, samples) => {
+		for (const s of samples) {
+			if (firstCts === null) firstCts = s.cts;
+			const ptsMs = Math.round((s.cts - firstCts) / s.timescale * 1e3);
+			collected.push({
+				data: new Uint8Array(s.data),
+				ptsMs
+			});
+		}
+	};
+	file.setExtractionOptions(audio.id, null, { nbSamples: 1e5 });
+	try {
+		file.start();
+	} catch {
+		return null;
+	}
+	if (collected.length === 0) return null;
+	return {
+		codec: audio.codec,
+		sampleRate: audio.audio?.sample_rate ?? 0,
+		channels: audio.audio?.channel_count ?? 0,
+		accessUnits: collected
+	};
+}
+/**
+* Pure-JS Opus audio demux of one fragment: return the fragment's Opus access
+* units, or `null` when the audio track is absent or NOT Opus (a legacy AAC
+* fragment → caller falls back to the ffmpeg AAC→Opus path). Throws only on a
+* genuinely malformed parse; the wrapper turns that into a fallback.
+*/
+async function demuxSegmentAudioOpusJs(bytes) {
+	const extracted = await extractAudioSamples(bytes);
+	if (!extracted || !isOpusCodec(extracted.codec)) return null;
+	return extracted.accessUnits;
+}
+/**
+* ffmpeg args to transcode a fragment's audio (stdin) into a self-contained
+* fragmented-mp4 with an Opus track on stdout — the SAME container the recorder
+* writes (`ffmpeg-args.ts`), so {@link demuxSegmentAudioOpusJs} reads the result
+* back with no extra code. Used ONLY as the legacy-AAC fallback for Opus
+* sessions. `-vn` drops video; `-map 0:a:0` picks the audio track.
+*/
+var SEGMENT_AUDIO_OPUS_FFMPEG_ARGS = [
+	"-hide_banner",
+	"-loglevel",
+	"error",
+	"-i",
+	"pipe:0",
+	"-vn",
+	"-map",
+	"0:a:0",
+	"-c:a",
+	"libopus",
+	"-b:a",
+	"48k",
+	"-f",
+	"mp4",
+	"-movflags",
+	"+frag_keyframe+empty_moov+default_base_moof",
+	"pipe:1"
+];
+/**
+* Opus-preferred recorded audio demux for Opus-negotiated sessions:
+*   1. Try the in-process Opus extraction (post-A1 fragments — NO ffmpeg).
+*   2. On a miss (legacy pre-A1 AAC fragment), transcode the fragment's audio
+*      to an Opus fragmented-mp4 via ffmpeg and read THAT back in-process.
+* Returns `[]` (never throws) when there is no usable audio — recorded audio is
+* best-effort and must never block recorded video. Mirrors the video-side
+* `demuxSegmentPreferJs`.
+*/
+async function demuxSegmentAudioOpusPreferJs(bytes, opts = {}) {
+	try {
+		const direct = await demuxSegmentAudioOpusJs(bytes);
+		if (direct) return direct;
+	} catch {}
+	opts.onFfmpegFallback?.("audio track is not Opus (legacy fragment)");
+	try {
+		const opusFmp4 = await runFfmpegOnce({
+			ffmpegPath: opts.ffmpegPath ?? "ffmpeg",
+			args: SEGMENT_AUDIO_OPUS_FFMPEG_ARGS,
+			input: bytes,
+			tolerateNonZeroExit: true
+		});
+		if (opusFmp4.length === 0) return [];
+		return await demuxSegmentAudioOpusJs(opusFmp4) ?? [];
+	} catch {
+		return [];
+	}
+}
+//#endregion
 //#region src/stream-broker/webrtc/broker-webrtc-server.ts
 /**
 * Broker-integrated WebRTC server.
@@ -18760,6 +19536,14 @@ var ADAPTIVE_CONFIG = {
 	minTimeBetweenChangesMs: 6e4
 };
 /**
+* True when `broker` is an in-process StreamBroker exposing the Opus egress
+* controls. Uses `in` narrowing + `typeof` checks (no cast) so the returned
+* type predicate is sound.
+*/
+function supportsOpusEgress(broker) {
+	return "acquireOpusEgress" in broker && typeof broker.acquireOpusEgress === "function" && "releaseOpusEgress" in broker && typeof broker.releaseOpusEgress === "function" && "makeOpusSilenceFrame" in broker && typeof broker.makeOpusSilenceFrame === "function";
+}
+/**
 * Whether a WebRTC session for this broker must re-encode the source to
 * Constrained Baseline H.264 so iOS (WebKit) can decode it. True only for
 * an H.264 source whose profile-level-id is known AND non-Baseline
@@ -19346,16 +20130,34 @@ var BrokerWebrtcServer = class {
 						timestampMicros: packet.pts * 1e3
 					}
 				});
-			} else if (packet.type === "audio") pushFrame({
-				type: "audio",
-				frame: {
-					data: packet.data,
-					codec: packet.codec?.toLowerCase() === "pcma" ? "Pcma" : "Pcmu",
-					sampleRate: 8e3,
-					channels: 1,
-					timestampMicros: packet.pts * 1e3
+			} else if (packet.type === "audio") {
+				const pktCodec = packet.codec?.toLowerCase();
+				if (session?.isOpusAudio === true) {
+					if (pktCodec !== "opus") return;
+					pushFrame({
+						type: "audio",
+						frame: {
+							data: packet.data,
+							codec: "Opus",
+							sampleRate: 48e3,
+							channels: 2,
+							timestampMicros: packet.pts * 1e3
+						}
+					});
+				} else {
+					if (pktCodec === "opus") return;
+					pushFrame({
+						type: "audio",
+						frame: {
+							data: packet.data,
+							codec: pktCodec === "pcma" ? "Pcma" : "Pcmu",
+							sampleRate: 8e3,
+							channels: 1,
+							timestampMicros: packet.pts * 1e3
+						}
+					});
 				}
-			});
+			}
 		}, annexbAttribution);
 		warmUpUnsubscribe?.();
 		const preBuffer = broker.getPreBuffer();
@@ -19528,46 +20330,84 @@ var BrokerWebrtcServer = class {
 		const readRecorded = this.readRecordedSegmentBytes;
 		const resolveFfmpeg = this.resolveFfmpegPath;
 		let scrubJsFallbackLogged = false;
+		let fullJsFallbackLogged = false;
+		let audioOpusFallbackLogged = false;
 		if (locateRecorded && readRecorded) {
 			let timeline;
 			timeline = new TimelineSession({
 				session,
 				deviceId,
-				makeFeeder: (profile) => new RecordedFeeder({
-					deviceId,
-					profile,
-					locate: locateRecorded,
-					readBytes: readRecorded,
-					demux: (b) => demuxSegmentToAnnexB(b, resolveFfmpeg?.()),
-					demuxScrub: (b) => demuxSegmentKeyframesPreferJs(b, {
-						ffmpegPath: resolveFfmpeg?.(),
-						onFfmpegFallback: (reason) => {
-							if (scrubJsFallbackLogged) return;
-							scrubJsFallbackLogged = true;
-							sessionLogger.warn("recorded scrub: JS keyframe demux failed — ffmpeg fallback (once/session)", { meta: {
+				makeFeeder: (profile) => {
+					const opusSession = session.isOpusAudio;
+					return new RecordedFeeder({
+						deviceId,
+						profile,
+						locate: locateRecorded,
+						readBytes: readRecorded,
+						demux: (b) => demuxSegmentPreferJs(b, {
+							ffmpegPath: resolveFfmpeg?.(),
+							onJsFallback: (reason) => {
+								if (fullJsFallbackLogged) return;
+								fullJsFallbackLogged = true;
+								sessionLogger.warn("recorded playback: JS full demux failed — ffmpeg fallback (once/session)", { meta: {
+									sessionId,
+									deviceId,
+									profile,
+									reason
+								} });
+							}
+						}),
+						demuxScrub: (b) => demuxSegmentKeyframesPreferJs(b, {
+							ffmpegPath: resolveFfmpeg?.(),
+							onFfmpegFallback: (reason) => {
+								if (scrubJsFallbackLogged) return;
+								scrubJsFallbackLogged = true;
+								sessionLogger.warn("recorded scrub: JS keyframe demux failed — ffmpeg fallback (once/session)", { meta: {
+									sessionId,
+									deviceId,
+									profile,
+									reason
+								} });
+							}
+						}),
+						demuxAudio: opusSession ? async (b) => {
+							return (await demuxSegmentAudioOpusPreferJs(b, {
+								ffmpegPath: resolveFfmpeg?.(),
+								onFfmpegFallback: (reason) => {
+									if (audioOpusFallbackLogged) return;
+									audioOpusFallbackLogged = true;
+									sessionLogger.warn("recorded audio: JS Opus demux missed — ffmpeg AAC→Opus fallback (once/session)", { meta: {
+										sessionId,
+										deviceId,
+										profile,
+										reason
+									} });
+								}
+							})).map((au) => ({
+								data: au.data,
+								ptsMs: au.ptsMs
+							}));
+						} : (b) => demuxSegmentToPcmu(b, resolveFfmpeg?.()),
+						audioClockRateHz: opusSession ? 48e3 : 8e3,
+						sink: opusSession ? {
+							pushAccessUnit: (data, ts, codec) => session.pushRecordedAccessUnit(data, ts, codec),
+							pushAudioOpus: (opus, ts) => session.writeRecordedAudioOpus(Buffer.from(opus), ts)
+						} : {
+							pushAccessUnit: (data, ts, codec) => session.pushRecordedAccessUnit(data, ts, codec),
+							pushAudioPcmu: (pcmu, ts) => session.writeRecordedAudio(Buffer.from(pcmu), ts)
+						},
+						onState: (s) => {
+							sessionLogger.info("recorded: feeder state", { meta: {
 								sessionId,
 								deviceId,
 								profile,
-								reason
+								state: s
 							} });
-						}
-					}),
-					demuxAudio: (b) => demuxSegmentToPcmu(b, resolveFfmpeg?.()),
-					sink: {
-						pushAccessUnit: (data, ts, codec) => session.pushRecordedAccessUnit(data, ts, codec),
-						pushAudioPcmu: (pcmu, ts) => session.writeRecordedAudio(Buffer.from(pcmu), ts)
-					},
-					onState: (s) => {
-						sessionLogger.info("recorded: feeder state", { meta: {
-							sessionId,
-							deviceId,
-							profile,
-							state: s
-						} });
-						timeline._emitState(s);
-					},
-					onPosition: (epochMs) => timeline._emitPosition(epochMs)
-				})
+							timeline._emitState(s);
+						},
+						onPosition: (epochMs) => timeline._emitPosition(epochMs)
+					});
+				}
 			});
 			sessionLogger.info("recorded: TimelineSession wired (control accessors present)", { meta: {
 				sessionId,
@@ -19591,6 +20431,13 @@ var BrokerWebrtcServer = class {
 			};
 		}
 		session.onConnected = () => {
+			if (!entry.releaseOpusEgress && session.isOpusAudio && supportsOpusEgress(broker)) {
+				broker.acquireOpusEgress();
+				entry.releaseOpusEgress = () => broker.releaseOpusEgress();
+				broker.makeOpusSilenceFrame(2).then((frame) => {
+					if (frame) session.setOpusSilenceFrame(frame);
+				}).catch(() => {});
+			}
 			if (entry.attributionTagged) return;
 			let attempt = 0;
 			const tag = () => {
@@ -19789,6 +20636,8 @@ var BrokerWebrtcServer = class {
 		entry.unsubBroker();
 		entry.unsubRtp?.();
 		entry.unsubSdpParams?.();
+		entry.releaseOpusEgress?.();
+		entry.releaseOpusEgress = void 0;
 		entry.closeSource();
 	}
 	resolveBrokerId(streamId, hints = {}) {