@camstack/addon-pipeline 1.2.253 → 1.2.255

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-G5Uib9Bn.js");
-const require_node = require("../node-ByNljnzV.js");
-const require_restream_intent = require("../restream-intent-C4adO0P8.js");
+const require_dist = require("../dist-CqqhxcYH.js");
+const require_node = require("../node-bdHZWpo1.js");
+const require_restream_intent = require("../restream-intent-VVJiUAkh.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-CtQrIvn7.js");
+const require_segment_demux_js = require("../segment-demux-js-CaDmuf08.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");
@@ -654,8 +654,8 @@ function healthEventIsOperatorFacing(camStreamId) {
 	return !PRIVATE_STREAM_PREFIXES.some((prefix) => camStreamId.startsWith(prefix));
 }
 //#endregion
-//#region src/stream-broker/stream-broker/prestream-eligibility.ts
-function prestreamEligible(input) {
+//#region src/stream-broker/stream-broker/sentry-eligibility.ts
+function sentryEligible(input) {
 	if (input.batteryOperated === null || input.declaresSignals === null) return {
 		eligible: false,
 		reason: "unknown"
@@ -671,7 +671,7 @@ function prestreamEligible(input) {
 	return { eligible: true };
 }
 //#endregion
-//#region src/stream-broker/stream-broker/prestream-signal-selection.ts
+//#region src/stream-broker/stream-broker/sentry-signal-selection.ts
 function nextEnabledSignals(input) {
 	const base = input.stored ?? input.declared;
 	const set = new Set(base);
@@ -689,7 +689,7 @@ function nextEnabledSignals(input) {
 * A stream a consumer merely watches is not a reason to wake a battery camera —
 * a Frigate-style puller holds a session open for ever, and treating that as
 * demand keeps the camera awake for ever, which is the whole point of the
-* battery (D173). So a prestream consumer is FED without being INTENT, and the
+* battery (D173). So a sentry consumer is FED without being INTENT, and the
 * only thing that dials is a signal the camera reported about itself.
 *
 * This module is the timing half of that, and it is pure so the arithmetic can
@@ -3130,11 +3130,11 @@ var RtspRestreamer = class {
 		return this.sessions.size;
 	}
 	/**
-	* Sessions that count as LIVE INTENT — everything except a prestream dial.
+	* Sessions that count as LIVE INTENT — everything except a sentry dial.
 	*
 	* The split exists so a Frigate-style puller can hold a session open for ever
 	* against a battery camera without keeping it awake (D173). For a broker with
-	* no prestream session this equals {@link getSessionCount} exactly, which is
+	* no sentry session this equals {@link getSessionCount} exactly, which is
 	* why nothing else changed behaviour.
 	*/
 	getLiveIntentSessionCount() {
@@ -3142,7 +3142,7 @@ var RtspRestreamer = class {
 		for (const session of this.sessions.values()) if (!session.isPrestreamIntent()) n += 1;
 		return n;
 	}
-	/** Sessions asking only for the picture. Drives the prestream pump, nothing
+	/** Sessions asking only for the picture. Drives the sentry pump, nothing
 	*  else — it must never reach a dial decision. */
 	getPrestreamSessionCount() {
 		let n = 0;
@@ -3903,12 +3903,12 @@ var RtspSession = class {
 	/**
 	* Whether this dial asked for the STREAM without asking for the CAMERA.
 	*
-	* The one question the demand split turns on: a prestream session is FED but
+	* The one question the demand split turns on: a sentry session is FED but
 	* is not INTENT, so it never dials a sleeping camera. See
-	* `PRESTREAM_PATH_SUFFIX`.
+	* `SENTRY_PATH_SUFFIX`.
 	*/
 	isPrestreamIntent() {
-		return this.declaration.intent === "prestream";
+		return this.declaration.intent === "sentry";
 	}
 	/**
 	* Ms of retained history this session ASKED for on its dial. `0` = none.
@@ -4207,7 +4207,7 @@ var RtspListenServer = class RtspListenServer {
 	brokerEnabled = /* @__PURE__ */ new Map();
 	/** brokerId → warm-up closure registered alongside the restreamer */
 	brokerWarmUps = /* @__PURE__ */ new Map();
-	/** brokerId → prestream picture-window opener */
+	/** brokerId → sentry picture-window opener */
 	brokerPrestreamOpeners = /* @__PURE__ */ new Map();
 	/** Generate a random token for a stream path */
 	static generateToken() {
@@ -4219,7 +4219,7 @@ var RtspListenServer = class RtspListenServer {
 	* If not, generate a new one.
 	* Returns the token used.
 	*/
-	registerRestreamer(brokerId, restreamer, warmUp, existingToken, prestreamOpener) {
+	registerRestreamer(brokerId, restreamer, warmUp, existingToken, sentryOpener) {
 		const oldToken = this.brokerTokens.get(brokerId);
 		if (oldToken) {
 			this.restreamers.delete(oldToken);
@@ -4230,7 +4230,7 @@ var RtspListenServer = class RtspListenServer {
 		this.brokerTokens.set(brokerId, token);
 		this.tokenBrokers.set(token, brokerId);
 		if (warmUp) this.brokerWarmUps.set(brokerId, warmUp);
-		if (prestreamOpener) this.brokerPrestreamOpeners.set(brokerId, prestreamOpener);
+		if (sentryOpener) this.brokerPrestreamOpeners.set(brokerId, sentryOpener);
 		return token;
 	}
 	unregisterRestreamer(brokerId) {
@@ -4342,9 +4342,9 @@ var RtspListenServer = class RtspListenServer {
 			socket.destroy();
 			return;
 		}
-		const prestreamDial = declaration.intent === "prestream";
-		const warmUp = brokerId && !prestreamDial ? this.brokerWarmUps.get(brokerId) : void 0;
-		const opener = brokerId && prestreamDial ? this.brokerPrestreamOpeners.get(brokerId) : void 0;
+		const sentryDial = declaration.intent === "sentry";
+		const warmUp = brokerId && !sentryDial ? this.brokerWarmUps.get(brokerId) : void 0;
+		const opener = brokerId && sentryDial ? this.brokerPrestreamOpeners.get(brokerId) : void 0;
 		const releaseWarmUp = warmUp ? warmUp() : opener?.() ?? null;
 		let released = false;
 		const releaseOnce = () => {
@@ -7648,16 +7648,16 @@ function runGif(input, args) {
 	});
 }
 //#endregion
-//#region src/stream-broker/stream-broker/prestream-encode.ts
+//#region src/stream-broker/stream-broker/sentry-encode.ts
 /**
-* ONE short-lived ffmpeg turns the prestream's picture into ONE Annex-B IDR.
+* ONE short-lived ffmpeg turns the sentry's picture into ONE Annex-B IDR.
 *
 * ── Why one encode and not a continuous child ─────────────────────────────
 * The obvious shape is `-loop 1 -framerate 1` and let ffmpeg emit the picture
 * for as long as the camera is waking. That is a resident child per sleeping
 * camera, for the whole wake, to redraw a picture that changes at most hourly.
 * So the child encodes exactly ONE frame (`-frames:v 1`) and exits, the caller
-* caches the bytes, and {@link PrestreamPump} re-emits them. A new encode
+* caches the bytes, and {@link SentryPump} re-emits them. A new encode
 * happens only when the picture changes.
 *
 * ── Why every frame carries its own parameter sets ────────────────────────
@@ -7682,10 +7682,10 @@ function runGif(input, args) {
 */
 /**
 * Bound on the encode. A single 4 MP still on `ultrafast` is milliseconds; a
-* child that has not answered in this long is hung, and the prestream would
+* child that has not answered in this long is hung, and the sentry would
 * otherwise hold a promise open for the rest of the process's life.
 */
-var PRESTREAM_ENCODE_TIMEOUT_MS = 1e4;
+var SENTRY_ENCODE_TIMEOUT_MS = 1e4;
 /** Grace before escalating SIGTERM → SIGKILL on a child that will not go. */
 var KILL_GRACE_MS = 500;
 /** x264/x265 params shared by both codecs: one-frame GOP, headers on it. */
@@ -7740,7 +7740,7 @@ function buildPrestreamEncodeArgs(plan) {
 }
 /**
 * Run the encode. Resolves with the Annex-B bytes, rejects with a named reason
-* — the caller turns a rejection into a refusal log and no prestream, which is
+* — the caller turns a rejection into a refusal log and no sentry, which is
 * the same outcome as a black screen and never worse than one.
 */
 function encodePrestreamIdr(options) {
@@ -7752,7 +7752,7 @@ function encodePrestreamIdr(options) {
 		try {
 			child = spawnFn(options.ffmpegPath, args);
 		} catch (err) {
-			reject(/* @__PURE__ */ new Error(`prestream encode could not spawn ffmpeg: ${require_dist.errMsg(err)}`));
+			reject(/* @__PURE__ */ new Error(`sentry encode could not spawn ffmpeg: ${require_dist.errMsg(err)}`));
 			return;
 		}
 		const chunks = [];
@@ -7767,8 +7767,8 @@ function encodePrestreamIdr(options) {
 		};
 		const timer = setTimeout(() => {
 			killChild(child);
-			finish({ error: /* @__PURE__ */ new Error(`prestream encode timed out after ${String(PRESTREAM_ENCODE_TIMEOUT_MS)} ms`) });
-		}, PRESTREAM_ENCODE_TIMEOUT_MS);
+			finish({ error: /* @__PURE__ */ new Error(`sentry encode timed out after ${String(SENTRY_ENCODE_TIMEOUT_MS)} ms`) });
+		}, SENTRY_ENCODE_TIMEOUT_MS);
 		timer.unref?.();
 		child.stdout?.on("data", (chunk) => chunks.push(chunk));
 		child.stderr?.on("data", (chunk) => {
@@ -7776,19 +7776,19 @@ function encodePrestreamIdr(options) {
 		});
 		child.stdin?.on("error", () => {});
 		child.on("error", (err) => {
-			finish({ error: /* @__PURE__ */ new Error(`prestream encode failed: ${err.message}`) });
+			finish({ error: /* @__PURE__ */ new Error(`sentry encode failed: ${err.message}`) });
 		});
 		child.on("exit", (code, signal) => {
 			if (code !== 0) {
-				finish({ error: /* @__PURE__ */ new Error(`prestream encode exited ${String(code ?? signal)}: ${stderrTail.trim() || "no stderr"}`) });
+				finish({ error: /* @__PURE__ */ new Error(`sentry encode exited ${String(code ?? signal)}: ${stderrTail.trim() || "no stderr"}`) });
 				return;
 			}
 			const bytes = Buffer.concat(chunks);
 			if (bytes.length === 0) {
-				finish({ error: /* @__PURE__ */ new Error("prestream encode produced no bytes") });
+				finish({ error: /* @__PURE__ */ new Error("sentry encode produced no bytes") });
 				return;
 			}
-			options.logger?.debug("prestream: picture encoded", {
+			options.logger?.debug("sentry: picture encoded", {
 				...tags,
 				meta: {
 					codec: options.plan.codec,
@@ -7810,9 +7810,9 @@ function killChild(child) {
 	}, KILL_GRACE_MS).unref?.();
 }
 //#endregion
-//#region src/stream-broker/stream-broker/prestream-picture.ts
+//#region src/stream-broker/stream-broker/sentry-picture.ts
 /**
-* The PICTURE the prestream shows: the camera's own last frame under a "Waking"
+* The PICTURE the sentry shows: the camera's own last frame under a "Waking"
 * treatment, or — when there is none — a generated card carrying its name.
 *
 * ── Why a fallback exists at all ──────────────────────────────────────────
@@ -7843,16 +7843,18 @@ function killChild(child) {
 */
 async function composePrestreamPicture(input) {
 	const tags = input.deviceId === void 0 ? {} : { tags: { deviceId: input.deviceId } };
+	const reason = "sleeping";
 	if (input.cachedJpeg !== null && input.cachedJpeg.length > 0) try {
 		return {
 			jpeg: await (0, _camstack_system_addon_utils.renderCourtesyOverlayJpeg)(input.cachedJpeg, {
 				deviceName: input.deviceName,
-				reason: "waking"
+				reason
 			}),
-			source: "cached-snapshot"
+			source: "cached-snapshot",
+			reason
 		};
 	} catch (err) {
-		input.logger?.warn("prestream: cached frame could not be treated — using the card", {
+		input.logger?.warn("sentry: cached frame could not be treated — using the card", {
 			...tags,
 			meta: { error: require_dist.errMsg(err) }
 		});
@@ -7860,11 +7862,12 @@ async function composePrestreamPicture(input) {
 	return {
 		jpeg: await (0, _camstack_system_addon_utils.renderCourtesyJpeg)({
 			deviceName: input.deviceName,
-			reason: "waking",
+			reason,
 			width: input.width,
 			height: input.height
 		}),
-		source: "generated-card"
+		source: "generated-card",
+		reason
 	};
 }
 function planPrestream(input) {
@@ -7879,7 +7882,7 @@ function planPrestream(input) {
 	} };
 }
 /**
-* `null` for a codec nobody has read. NOT a default of h264: a prestream in the
+* `null` for a codec nobody has read. NOT a default of h264: a sentry in the
 * wrong codec is a stream the consumer cannot decode at all, which is worse
 * than the black screen it replaces.
 */
@@ -11981,11 +11984,11 @@ 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
+* the audio-codec cap, for the WebRTC session's sentry 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.
+* is unavailable or yields nothing so the caller can skip sentry padding.
 */
 async function encodeOpusSilenceFrame(api, cfg) {
 	let sessionId = null;
@@ -12068,9 +12071,9 @@ function getPlaceholderFrame(kind, codec) {
 	return buf;
 }
 //#endregion
-//#region src/stream-broker/stream-broker/prestream-pump.ts
+//#region src/stream-broker/stream-broker/sentry-pump.ts
 /**
-* The prestream pump: ONE encode, then a 1 fps re-emit until real media lands.
+* The sentry pump: ONE encode, then a 1 fps re-emit until real media lands.
 *
 * ── What it is for ────────────────────────────────────────────────────────
 * A lazy source is BUILT on demand, and on this hub that build costs 2.2 to
@@ -12092,12 +12095,12 @@ function getPlaceholderFrame(kind, codec) {
 *  3. **It never dials.** The pump has no source, no socket and no demand. It
 *     is started alongside the publisher request, never instead of it.
 *
-* Emission is the caller's: {@link PrestreamPumpOptions.emit} is where the
+* Emission is the caller's: {@link SentryPumpOptions.emit} is where the
 * `isPlaceholder: true` packet is built, because that flag belongs to the
 * broker's packet contract and the containment that reads it lives there.
 */
-var DEFAULT_PRESTREAM_INTERVAL_MS = 1e3;
-var PrestreamPump = class {
+var DEFAULT_SENTRY_INTERVAL_MS = 1e3;
+var SentryPump = class {
 	options;
 	intervalMs;
 	tags;
@@ -12109,7 +12112,7 @@ var PrestreamPump = class {
 	emitted = 0;
 	constructor(options) {
 		this.options = options;
-		this.intervalMs = options.intervalMs ?? DEFAULT_PRESTREAM_INTERVAL_MS;
+		this.intervalMs = options.intervalMs ?? DEFAULT_SENTRY_INTERVAL_MS;
 		this.tags = options.deviceId === void 0 ? {} : { tags: { deviceId: options.deviceId } };
 	}
 	/** Whether the window is currently being filled (or about to be). */
@@ -12128,16 +12131,16 @@ var PrestreamPump = class {
 		this.emitted = 0;
 		this.options.prepare({ sourceUrl }).then((frame) => {
 			if (!this.active) {
-				this.options.logger?.debug("prestream: preparation landed after the window closed", { ...this.tags });
+				this.options.logger?.debug("sentry: preparation landed after the window closed", { ...this.tags });
 				return;
 			}
 			if (frame === null) {
-				this.options.logger?.info("prestream: refused — the window goes unfilled", { ...this.tags });
+				this.options.logger?.info("sentry: refused — the window goes unfilled", { ...this.tags });
 				this.active = false;
 				return;
 			}
 			this.frame = frame;
-			this.options.logger?.info("prestream: filling the wake window", {
+			this.options.logger?.info("sentry: filling the wake window", {
 				...this.tags,
 				meta: {
 					codec: frame.codec,
@@ -12149,7 +12152,7 @@ var PrestreamPump = class {
 			this.tick();
 			this.timer = setInterval(() => this.tick(), this.intervalMs);
 		}).catch((err) => {
-			this.options.logger?.warn("prestream: preparation failed — the window goes unfilled", {
+			this.options.logger?.warn("sentry: preparation failed — the window goes unfilled", {
 				...this.tags,
 				meta: { error: require_dist.errMsg(err) }
 			});
@@ -12158,7 +12161,7 @@ var PrestreamPump = class {
 	}
 	/**
 	* Close the window. Called on the first NON-placeholder packet — the one edge
-	* the prestream is defined by — and on the broker's own teardown paths so a
+	* the sentry is defined by — and on the broker's own teardown paths so a
 	* stopped broker leaves no timer behind.
 	*/
 	stop(reason) {
@@ -12168,7 +12171,7 @@ var PrestreamPump = class {
 			clearInterval(this.timer);
 			this.timer = void 0;
 		}
-		this.options.logger?.info("prestream: window closed", {
+		this.options.logger?.info("sentry: window closed", {
 			...this.tags,
 			meta: {
 				reason,
@@ -12479,12 +12482,12 @@ var StreamBroker = class StreamBroker {
 	reconnectTimer;
 	placeholderTimer;
 	/**
-	* The prestream pump, armed by the manager via `setPrestreamProvider`.
-	* `undefined` on a broker whose manager supplied none — the pre-prestream
+	* The sentry pump, armed by the manager via `setPrestreamProvider`.
+	* `undefined` on a broker whose manager supplied none — the pre-sentry
 	* behaviour, unchanged.
 	*/
-	prestreamPump;
-	/** The manager's hook for "real media started" — see `PrestreamProvider`. */
+	sentryPump;
+	/** The manager's hook for "real media started" — see `SentryProvider`. */
 	onRealMediaStarted;
 	/**
 	* Latched once real media has been seen on this session.
@@ -12494,9 +12497,9 @@ var StreamBroker = class StreamBroker {
 	* window that real bytes have already closed, and the consumer would get a
 	* still picture painted over live video every second. Reset exactly where
 	* `firstKeyframeReceived` is — broker stop and suspend — so a battery camera
-	* that goes back to sleep gets its prestream again on the next wake.
+	* that goes back to sleep gets its sentry again on the next wake.
 	*/
-	prestreamWindowClosed = false;
+	sentryWindowClosed = false;
 	reconnectDelayMs = INITIAL_RECONNECT_DELAY_MS;
 	/**
 	* Dial rate-limiter (2026-07-23 storm fix): the earliest wall-clock at
@@ -12772,7 +12775,7 @@ var StreamBroker = class StreamBroker {
 	* that socket down. In that window `resolveCurrentSource()` truthfully
 	* answers with a socket nobody can dial.
 	*
-	* That cost device 640 its prestream on 2026-09-16: the window re-opened
+	* That cost device 640 its sentry on 2026-09-16: the window re-opened
 	* (which `suspend()` does deliberately, for a consumer that never left) with
 	* the real url, `planPrestream` refused it `not-lazy`, and the refusal is
 	* terminal — the operator's client sat dark for ten seconds and gave up six
@@ -12781,8 +12784,8 @@ var StreamBroker = class StreamBroker {
 	* NOT cleared when `start()` is later called with a materialized url: that
 	* happens on every wake, and clearing it there is the bug again. A broker
 	* genuinely reconfigured onto a permanent mains source keeps a stale value,
-	* which costs nothing — `prestreamEligible` (battery + declared signals) is
-	* the authority on whether a camera gets a prestream at all, and it is asked
+	* which costs nothing — `sentryEligible` (battery + declared signals) is
+	* the authority on whether a camera gets a sentry at all, and it is asked
 	* first, in the manager.
 	*/
 	lazySourceUrl;
@@ -13045,7 +13048,7 @@ var StreamBroker = class StreamBroker {
 		this.requestSourceRefresh = notify;
 	}
 	/**
-	* Arm the PRESTREAM — the fill for the window between "someone asked for this
+	* Arm the SENTRY — the fill for the window between "someone asked for this
 	* camera" and "the camera is awake".
 	*
 	* Manager-owned, because everything the fill needs is the manager's: the
@@ -13053,13 +13056,13 @@ var StreamBroker = class StreamBroker {
 	* snapshot, its name, and the ffmpeg binary. The broker contributes the one
 	* thing it owns — WHEN the window is open — and nothing else.
 	*
-	* A broker with no provider behaves exactly as it did before the prestream
+	* A broker with no provider behaves exactly as it did before the sentry
 	* existed: the lazy branch asks the publisher to materialize and the consumer
 	* sees black, which is the outcome every refusal falls back to.
 	*/
 	setPrestreamProvider(provider) {
 		this.onRealMediaStarted = provider.onRealMediaStarted;
-		this.prestreamPump = new PrestreamPump({
+		this.sentryPump = new SentryPump({
 			prepare: provider.prepare,
 			emit: (frame) => {
 				const now = Date.now();
@@ -13179,7 +13182,7 @@ var StreamBroker = class StreamBroker {
 	*
 	* Here and not only in `start()` because a broker that has never dialled is a
 	* real and common state: a battery camera nobody has asked for yet, with a
-	* prestream consumer attached, has a recipe and no socket. Learning it from
+	* sentry consumer attached, has a recipe and no socket. Learning it from
 	* the dial alone would leave exactly that broker unable to describe itself.
 	*/
 	noteLazyUrl(url) {
@@ -13256,8 +13259,8 @@ var StreamBroker = class StreamBroker {
 			clearInterval(this.placeholderTimer);
 			this.placeholderTimer = void 0;
 		}
-		this.prestreamPump?.stop("broker stopped");
-		this.prestreamWindowClosed = false;
+		this.sentryPump?.stop("broker stopped");
+		this.sentryWindowClosed = false;
 		if (this.reconnectTimer) {
 			clearTimeout(this.reconnectTimer);
 			this.reconnectTimer = void 0;
@@ -13427,7 +13430,7 @@ var StreamBroker = class StreamBroker {
 	*
 	*  - the caller has already checked the signal is ENABLED for this camera
 	*    (the broker manager owns that setting), and
-	*  - somebody is actually waiting on the prestream. Waking a camera nobody is
+	*  - somebody is actually waiting on the sentry. Waking a camera nobody is
 	*    watching is the one thing a battery camera must never do, and a signal
 	*    arriving with no consumer is exactly that.
 	*
@@ -13470,7 +13473,7 @@ var StreamBroker = class StreamBroker {
 		if (delay <= 0) return;
 		this.wakeHoldTimer = setTimeout(() => {
 			this.wakeHoldTimer = void 0;
-			this.logger?.info("wake hold lapsed — back to the prestream picture", {
+			this.logger?.info("wake hold lapsed — back to the sentry picture", {
 				tags: { deviceId: this.numericDeviceId },
 				meta: {
 					brokerId: this.deviceId,
@@ -13483,20 +13486,20 @@ var StreamBroker = class StreamBroker {
 		this.wakeHoldTimer.unref?.();
 	}
 	/**
-	* Anything that must be FED, prestream sessions included.
+	* Anything that must be FED, sentry sessions included.
 	*
-	* The only consumer of this is the prestream pump: it says "somebody is
+	* The only consumer of this is the sentry pump: it says "somebody is
 	* watching, keep the picture going", and says nothing about whether the
 	* camera may be dialled. {@link hasLiveIntent} answers that, and it is the
 	* one every dial path asks.
 	*/
 	hasAnyConsumer() {
 		if (this.hasLiveIntent()) return true;
-		if (this.prestreamHolds > 0) return true;
+		if (this.sentryHolds > 0) return true;
 		return this.rtspRestreamer.getPrestreamSessionCount() > 0;
 	}
 	/**
-	* Somebody is DESCRIBING a prestream and has no session yet.
+	* Somebody is DESCRIBING a sentry and has no session yet.
 	*
 	* The RTSP dispatch reads the SDP before `addSession` runs, so a window that
 	* waits for the session is too late: the consumer is handed an empty SDP and
@@ -13504,28 +13507,28 @@ var StreamBroker = class StreamBroker {
 	* on the attach and closed 42 ms later having emitted zero frames, because
 	* ffmpeg had already given up.
 	*
-	* This is the prestream counterpart of `BrokerWarmUp` and its exact opposite
+	* This is the sentry counterpart of `BrokerWarmUp` and its exact opposite
 	* in effect: the warm-up subscribes demand, which DIALS; this opens the
 	* picture, which never does. A battery camera is not touched.
 	*/
 	openPrestreamWindow() {
-		this.prestreamHolds += 1;
+		this.sentryHolds += 1;
 		this.checkDemand();
 		let released = false;
 		return () => {
 			if (released) return;
 			released = true;
-			this.prestreamHolds = Math.max(0, this.prestreamHolds - 1);
+			this.sentryHolds = Math.max(0, this.sentryHolds - 1);
 			this.checkDemand();
 		};
 	}
-	/** DESCRIBE-window prestream holds: sessions that do not exist yet. */
-	prestreamHolds = 0;
+	/** DESCRIBE-window sentry holds: sessions that do not exist yet. */
+	sentryHolds = 0;
 	/**
 	* Consumers that may DIAL. Every term of the former `hasDemand`, with the
-	* RTSP session count filtered to exclude prestream dials, plus the wake hold.
+	* RTSP session count filtered to exclude sentry dials, plus the wake hold.
 	*
-	* For a broker with no prestream session attached this is term-for-term what
+	* For a broker with no sentry session attached this is term-for-term what
 	* `hasDemand` was, which is why every existing camera, consumer and test
 	* behaves identically.
 	*/
@@ -13570,7 +13573,7 @@ var StreamBroker = class StreamBroker {
 		});
 	}
 	/**
-	* Encode ONE canonical 20 ms Opus silence packet for a session's prestream
+	* Encode ONE canonical 20 ms Opus silence packet for a session's sentry
 	* A/V-sync padding (Opus has no fixed silence byte). Returns `null` when the
 	* audio-codec cap is unavailable. See {@link encodeOpusSilenceFrame}.
 	*/
@@ -13680,16 +13683,16 @@ var StreamBroker = class StreamBroker {
 				if (!this.hasLiveIntent() && !this.manualStop && !this.stopping) this.suspend();
 			}, SUSPEND_GRACE_MS);
 		}
-		this.prestreamWanted = this.hasAnyConsumer() && !this.hasLiveIntent();
+		this.sentryWanted = this.hasAnyConsumer() && !this.hasLiveIntent();
 		this.reconcilePrestreamWindow();
 	}
 	/**
-	* Open or close the prestream window to match {@link prestreamWanted}.
+	* Open or close the sentry window to match {@link sentryWanted}.
 	*
-	* This is the half that was missing. `prestreamWanted` has been computed
+	* This is the half that was missing. `sentryWanted` has been computed
 	* correctly since the feature shipped, but the only thing that ever STARTED
 	* the pump was the lazy branch of `start()` — a DIAL, which needs live
-	* intent, which a prestream session does not have by construction. So the
+	* intent, which a sentry session does not have by construction. So the
 	* window opened only when something else had already woken the camera, and
 	* `suspend()` closed it for good.
 	*
@@ -13699,22 +13702,22 @@ var StreamBroker = class StreamBroker {
 	* demand check costs one encode per window and no more.
 	*/
 	reconcilePrestreamWindow() {
-		if (!this.prestreamPump) return;
-		if (this.prestreamWanted && !this.prestreamWindowClosed) {
+		if (!this.sentryPump) return;
+		if (this.sentryWanted && !this.sentryWindowClosed) {
 			const url = this.lazySourceUrl ?? this.resolveCurrentSource()?.url ?? this.source?.url;
-			if (url !== void 0) this.prestreamPump.start(url);
+			if (url !== void 0) this.sentryPump.start(url);
 			return;
 		}
-		if (!this.prestreamWanted) this.prestreamPump.stop("no prestream consumer");
+		if (!this.sentryWanted) this.sentryPump.stop("no sentry consumer");
 	}
 	/**
-	* Whether a prestream picture should be flowing right now: somebody is
+	* Whether a sentry picture should be flowing right now: somebody is
 	* watching and the camera is not up. Read by the pump.
 	*/
-	prestreamWanted = false;
+	sentryWanted = false;
 	/** Whether the picture should be flowing — the pump's one question. */
 	wantsPrestream() {
-		return this.prestreamWanted;
+		return this.sentryWanted;
 	}
 	/** Suspend the stream: kill ffmpeg/native client, clear buffers, go idle. Source is preserved for resume. */
 	suspend() {
@@ -13739,8 +13742,8 @@ var StreamBroker = class StreamBroker {
 			clearInterval(this.placeholderTimer);
 			this.placeholderTimer = void 0;
 		}
-		this.prestreamPump?.stop("broker suspended");
-		this.prestreamWindowClosed = false;
+		this.sentryPump?.stop("broker suspended");
+		this.sentryWindowClosed = false;
 		this.reconcilePrestreamWindow();
 		this.preBuffer.clear();
 		this.decoderSeedBuffer.clear();
@@ -13825,13 +13828,13 @@ var StreamBroker = class StreamBroker {
 	}
 	pushEncodedPacket(packet) {
 		if (this.stopping) return;
-		if (packet.isPlaceholder !== true && !this.prestreamWindowClosed) {
-			this.prestreamWindowClosed = true;
-			this.prestreamPump?.stop("first real packet");
+		if (packet.isPlaceholder !== true && !this.sentryWindowClosed) {
+			this.sentryWindowClosed = true;
+			this.sentryPump?.stop("first real packet");
 			try {
 				this.onRealMediaStarted?.();
 			} catch (err) {
-				this.logger?.debug("prestream: real-media hook threw", {
+				this.logger?.debug("sentry: real-media hook threw", {
 					tags: { deviceId: this.numericDeviceId ?? 0 },
 					meta: { error: String(err) }
 				});
@@ -15580,7 +15583,7 @@ var StreamBroker = class StreamBroker {
 			});
 			this._status = "error";
 			this.notifySourceRefresh();
-			if (!this.prestreamWindowClosed) this.prestreamPump?.start(source.url);
+			if (!this.sentryWindowClosed) this.sentryPump?.start(source.url);
 			this.scheduleReconnect();
 			return;
 		}
@@ -16312,16 +16315,16 @@ var DeviceOverrideSchema = require_dist.object({
 	sourceParser: require_dist.record(require_dist.string(), SourceParserSettingSchema).optional(),
 	sourceParserArgs: require_dist.record(require_dist.string(), SourceParserArgsEntrySchema).optional(),
 	/**
-	* The on-demand PRESTREAM, per camera.
+	* The on-demand SENTRY, per camera.
 	*
 	* Absent means the operator has never touched it, which is NOT the same as
 	* off: `enabledSignals` absent means "every signal this camera recommends",
-	* so a Reolink works the moment a prestream URL is dialled without an
+	* so a Reolink works the moment a sentry URL is dialled without an
 	* operator hunting for a checkbox. An empty ARRAY is a deliberate "none" and
 	* is honoured — the two are different answers and the shape keeps them
 	* apart.
 	*/
-	prestream: require_dist.object({
+	sentry: require_dist.object({
 		/** Signal codes allowed to wake this camera. Absent ⇒ the recommended set. */
 		enabledSignals: require_dist.array(require_dist.string()).optional(),
 		/** How long the camera stays up after the LAST signal. Absent ⇒ default. */
@@ -16515,13 +16518,13 @@ var StreamBrokerManager = class StreamBrokerManager {
 	/** Per-device published cam-stream registry. */
 	cameraStreams = /* @__PURE__ */ new Map();
 	/**
-	* The encoded prestream frame per broker, with the digest of the picture it
+	* The encoded sentry frame per broker, with the digest of the picture it
 	* was made from. One entry is one still image — kilobytes — and it is
 	* dropped with the broker in `releaseBroker`.
 	*/
-	/** Brokers with a background prestream re-encode in flight (single-flight). */
-	prestreamRefreshing = /* @__PURE__ */ new Set();
-	prestreamFrames = /* @__PURE__ */ new Map();
+	/** Brokers with a background sentry re-encode in flight (single-flight). */
+	sentryRefreshing = /* @__PURE__ */ new Set();
+	sentryFrames = /* @__PURE__ */ new Map();
 	/** Monotonic insertion counter per device — feeds `CameraStreamInternal.order`. */
 	streamOrderSeq = /* @__PURE__ */ new Map();
 	/** Persisted operator intent: which cam stream serves which profile. */
@@ -17413,7 +17416,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 	* client-side and we get a typed payload.
 	*/
 	/**
-	* Build the per-broker PRESTREAM provider — the fill for the window between
+	* Build the per-broker SENTRY provider — the fill for the window between
 	* "someone asked for this camera" and "the camera is awake".
 	*
 	* On this hub that window is 2.2-12.4 s for a lazy source, and it is not
@@ -17426,19 +17429,19 @@ var StreamBrokerManager = class StreamBrokerManager {
 	* cached snapshot, its name, and the ffmpeg binary path.
 	*
 	* `null` is a REFUSAL, named in the log. Refusing is cheap — the consumer
-	* gets the black screen it got before the prestream existed — and the
+	* gets the black screen it got before the sentry existed — and the
 	* alternative for an unknown geometry is the decoder freeze the whole
 	* synthetic-frame path is shaped around.
 	*/
 	buildPrestreamProvider(deviceId, camStreamId, brokerId, logger) {
 		return {
 			prepare: async ({ sourceUrl }) => {
-				const gate = prestreamEligible({
+				const gate = sentryEligible({
 					batteryOperated: await this.isBatteryOperated(deviceId),
 					declaresSignals: (await this.declaredSignalCodes(deviceId)).length > 0
 				});
 				if (!gate.eligible) {
-					logger.info("prestream: not offered for this camera", {
+					logger.info("sentry: not offered for this camera", {
 						tags: { deviceId },
 						meta: {
 							brokerId,
@@ -17456,7 +17459,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 					codec
 				});
 				if ("refusal" in planned) {
-					logger.info("prestream: no fill for this camera", {
+					logger.info("sentry: no fill for this camera", {
 						tags: { deviceId },
 						meta: {
 							refusal: planned.refusal,
@@ -17476,7 +17479,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 			* The window shows the camera's last snapshot, and nothing was
 			* refreshing it: a battery camera refuses a capture while it believes
 			* itself asleep, and that belief lags the wake by seconds — so the only
-			* attempts ever made were the prestream's own, while composing, which is
+			* attempts ever made were the sentry's own, while composing, which is
 			* BEFORE any media exists. Measured on device 640 (2026-09-16): four
 			* wakes in forty minutes, the encoded picture `bytes=23912` every time,
 			* and between first packet and suspend not one capture was even
@@ -17499,12 +17502,12 @@ var StreamBrokerManager = class StreamBrokerManager {
 				const api = this.api;
 				if (!api) return;
 				api.snapshot.getSnapshot.query({ deviceId }).then(() => {
-					logger.debug("prestream: picture refreshed from the live window", {
+					logger.debug("sentry: picture refreshed from the live window", {
 						tags: { deviceId },
 						meta: { brokerId }
 					});
 				}).catch((err) => {
-					logger.debug("prestream: live-window refresh failed — keeping the older picture", {
+					logger.debug("sentry: live-window refresh failed — keeping the older picture", {
 						tags: { deviceId },
 						meta: {
 							brokerId,
@@ -17525,7 +17528,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 	*/
 	async preparePrestreamFrame(deviceId, brokerId, plan, logger) {
 		if (!this.api) {
-			logger.info("prestream: no api access — the window goes unfilled", { tags: { deviceId } });
+			logger.info("sentry: no api access — the window goes unfilled", { tags: { deviceId } });
 			return null;
 		}
 		const api = this.api;
@@ -17534,7 +17537,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 			const image = await api.snapshot.getSnapshot.query({ deviceId });
 			if (image) cachedJpeg = Buffer.from(image.base64, "base64");
 		} catch (err) {
-			logger.debug("prestream: cached snapshot read failed — falling back to the card", {
+			logger.debug("sentry: cached snapshot read failed — falling back to the card", {
 				tags: { deviceId },
 				meta: { error: require_dist.errMsg(err) }
 			});
@@ -17544,15 +17547,15 @@ var StreamBrokerManager = class StreamBrokerManager {
 			const device = await api.deviceManager.getDevice.query({ deviceId });
 			if (device?.name) deviceName = device.name;
 		} catch (err) {
-			logger.debug("prestream: device name read failed — using the numeric id", {
+			logger.debug("sentry: device name read failed — using the numeric id", {
 				tags: { deviceId },
 				meta: { error: require_dist.errMsg(err) }
 			});
 		}
 		const key = `${(0, node_crypto.createHash)("sha1").update(cachedJpeg ?? Buffer.alloc(0)).update(deviceName).digest("hex")}:${String(plan.width)}x${String(plan.height)}:${plan.codec}`;
-		const cached = this.prestreamFrames.get(brokerId);
+		const cached = this.sentryFrames.get(brokerId);
 		if (cached && cached.key === key) {
-			logger.debug("prestream: re-using the encoded frame", {
+			logger.debug("sentry: re-using the encoded frame", {
 				tags: { deviceId },
 				meta: { bytes: cached.frame.annexB.length }
 			});
@@ -17561,7 +17564,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		const cachedGeometry = cached ? cached.key.slice(cached.key.indexOf(":")) : null;
 		const wantedGeometry = key.slice(key.indexOf(":"));
 		if (cached && cachedGeometry === wantedGeometry) {
-			logger.info("prestream: serving the previous picture while the new one encodes", {
+			logger.info("sentry: serving the previous picture while the new one encodes", {
 				tags: { deviceId },
 				meta: { bytes: cached.frame.annexB.length }
 			});
@@ -17586,10 +17589,11 @@ var StreamBrokerManager = class StreamBrokerManager {
 			logger,
 			deviceId
 		});
-		logger.info("prestream: picture composed", {
+		logger.info("sentry: picture composed", {
 			tags: { deviceId },
 			meta: {
 				source: picture.source,
+				reason: picture.reason,
 				width: plan.width,
 				height: plan.height,
 				codec: plan.codec
@@ -17605,7 +17609,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 				deviceId
 			});
 		} catch (err) {
-			logger.warn("prestream: encode failed — the window goes unfilled", {
+			logger.warn("sentry: encode failed — the window goes unfilled", {
 				tags: { deviceId },
 				meta: { error: require_dist.errMsg(err) }
 			});
@@ -17615,7 +17619,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 			annexB,
 			codec: plan.codec
 		};
-		this.prestreamFrames.set(brokerId, {
+		this.sentryFrames.set(brokerId, {
 			key,
 			frame
 		});
@@ -17629,10 +17633,10 @@ var StreamBrokerManager = class StreamBrokerManager {
 	* operator is actually waiting for.
 	*/
 	encodePrestreamInBackground(deviceId, brokerId, plan, key, cachedJpeg, deviceName, logger) {
-		if (this.prestreamRefreshing.has(brokerId)) return;
-		this.prestreamRefreshing.add(brokerId);
+		if (this.sentryRefreshing.has(brokerId)) return;
+		this.sentryRefreshing.add(brokerId);
 		this.composeAndEncodePrestream(deviceId, brokerId, plan, key, cachedJpeg, deviceName, logger).catch(() => {}).finally(() => {
-			this.prestreamRefreshing.delete(brokerId);
+			this.sentryRefreshing.delete(brokerId);
 		});
 	}
 	subscribePlaceholderStateSources(bus) {
@@ -19639,7 +19643,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 				reason: "unknown-code"
 			};
 		}
-		const settings = this.deviceOverrides.get(input.deviceId)?.prestream;
+		const settings = this.deviceOverrides.get(input.deviceId)?.sentry;
 		if (!(settings?.enabledSignals ?? declared).includes(input.code)) return {
 			accepted: false,
 			reason: "not-enabled"
@@ -19821,11 +19825,11 @@ var StreamBrokerManager = class StreamBrokerManager {
 			label: hwAccelOptionLabel(setting)
 		}));
 		const declaredSignals = await this.declaredSignalList(deviceId);
-		const prestreamGate = prestreamEligible({
+		const sentryGate = sentryEligible({
 			batteryOperated: await this.isBatteryOperated(deviceId),
 			declaresSignals: declaredSignals.length > 0
 		});
-		const prestreamOffered = prestreamGate.eligible;
+		const sentryOffered = sentryGate.eligible;
 		const streamTabs = streams.filter((s) => !s.camStreamId.startsWith("derived:")).map((stream) => {
 			const camStreamId = stream.camStreamId;
 			const brokerId = brokerIdFor(deviceId, camStreamId);
@@ -19925,18 +19929,18 @@ var StreamBrokerManager = class StreamBrokerManager {
 						tooltip: "Copy muted URL to clipboard"
 					}]
 				},
-				...prestreamOffered ? [{
+				...sentryOffered ? [{
 					type: "text",
 					key: `rtspPrestreamUrl:${camStreamId}`,
-					label: "RTSP URL (prestream)",
+					label: "RTSP URL (sentry)",
 					description: "Video-only. Shows this camera’s last picture while it sleeps and cuts to live video when one of its wake signals fires — without a consumer on this URL ever keeping the camera awake.",
 					readonlyField: true,
 					span: 2,
-					value: rtspEntry?.url ? `${rtspEntry.url}/prestream` : "inactive",
+					value: rtspEntry?.url ? `${rtspEntry.url}/sentry` : "inactive",
 					actions: [{
 						action: "copy-value",
 						icon: "copy",
-						tooltip: "Copy prestream URL to clipboard"
+						tooltip: "Copy sentry URL to clipboard"
 					}]
 				}] : [],
 				{
@@ -20124,25 +20128,25 @@ var StreamBrokerManager = class StreamBrokerManager {
 				]
 			}]
 		};
-		const prestreamCfg = override?.prestream;
-		const prestreamSections = prestreamGate.eligible ? [{
-			id: "stream-broker-prestream",
+		const sentryCfg = override?.sentry;
+		const sentrySections = sentryGate.eligible ? [{
+			id: "stream-broker-sentry",
 			title: "Wake signals",
 			tab: "stream-broker",
 			location: "top-tab",
 			order: 50,
-			description: "A consumer can dial this camera’s prestream URL (the profile URL with /prestream) and be shown the last picture while the camera sleeps. It is fed without keeping the camera awake: only the signals below wake it, and it goes back to sleep once they stop.",
+			description: "A consumer can dial this camera’s sentry URL (the profile URL with /sentry) and be shown the last picture while the camera sleeps. It is fed without keeping the camera awake: only the signals below wake it, and it goes back to sleep once they stop.",
 			fields: [...declaredSignals.map((signal) => ({
 				type: "boolean",
 				style: "switch",
-				key: `prestreamSignal:${signal.code}`,
+				key: `sentrySignal:${signal.code}`,
 				label: signal.label,
 				description: signal.recommended ? "Recommended by this camera’s driver." : "Offered by this camera’s driver.",
 				default: signal.recommended,
-				value: prestreamCfg?.enabledSignals === void 0 ? true : prestreamCfg.enabledSignals.includes(signal.code)
+				value: sentryCfg?.enabledSignals === void 0 ? true : sentryCfg.enabledSignals.includes(signal.code)
 			})), {
 				type: "number",
-				key: "prestreamHoldMs",
+				key: "sentryHoldMs",
 				label: "Stay awake after the last signal",
 				description: "How long the camera keeps streaming once its signals stop. Extended by each new signal, never stacked — continuous motion keeps it up and it sleeps this long after the last one. One run is capped at five minutes whatever this says, and a camera whose sensor never stops is left alone for ten minutes after that.",
 				min: 1e3,
@@ -20150,7 +20154,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 				step: 1e3,
 				unit: "ms",
 				default: DEFAULT_WAKE_HOLD_MS,
-				value: prestreamCfg?.holdMs ?? 15e3
+				value: sentryCfg?.holdMs ?? 15e3
 			}]
 		}] : [];
 		const diagnosticsSection = {
@@ -20179,7 +20183,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		};
 		return { sections: [
 			streamBrokerSection,
-			...prestreamSections,
+			...sentrySections,
 			diagnosticsSection
 		] };
 	}
@@ -20293,27 +20297,27 @@ var StreamBrokerManager = class StreamBrokerManager {
 				nextOverride.sourceParserArgs = spa;
 				continue;
 			}
-			if (fieldKey.startsWith("prestreamSignal:")) {
+			if (fieldKey.startsWith("sentrySignal:")) {
 				overrideDirty = true;
 				const next = nextEnabledSignals({
 					declared: await this.declaredSignalCodes(deviceId),
-					stored: nextOverride.prestream?.enabledSignals,
-					code: fieldKey.slice(16),
+					stored: nextOverride.sentry?.enabledSignals,
+					code: fieldKey.slice(13),
 					enabled: value === null || value === void 0 ? true : Boolean(value)
 				});
-				nextOverride.prestream = {
-					...nextOverride.prestream,
+				nextOverride.sentry = {
+					...nextOverride.sentry,
 					enabledSignals: [...next]
 				};
 				continue;
 			}
-			if (fieldKey === "prestreamHoldMs") {
+			if (fieldKey === "sentryHoldMs") {
 				overrideDirty = true;
 				const raw = typeof value === "number" ? value : Number(value);
 				if (!Number.isFinite(raw)) continue;
 				const clamped = Math.min(3e5, Math.max(1e3, Math.round(raw)));
-				nextOverride.prestream = {
-					...nextOverride.prestream,
+				nextOverride.sentry = {
+					...nextOverride.sentry,
 					holdMs: clamped
 				};
 				continue;
@@ -21156,7 +21160,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		this.streamOfflineReasonByBroker.delete(brokerId);
 		await broker.stop();
 		this.brokers.delete(brokerId);
-		this.prestreamFrames.delete(brokerId);
+		this.sentryFrames.delete(brokerId);
 		this.sweepFrameSubscriptions(brokerId);
 		this.rtspProvider.persistTokens();
 		this.syncProfileRestreamers(deviceId);
@@ -24724,7 +24728,7 @@ var AdaptiveSession = class AdaptiveSession {
 	* silence packets (0xFF bytes, 160 samples each = 20 ms) so the audio
 	* sender's first wall-clock instant aligns with the video sender's first
 	* wall-clock instant, then the real packet continues seamlessly. See
-	* `prestreamAudioSilenceIfNeeded` + `computeAudioSilencePadPackets`.
+	* `sentryAudioSilenceIfNeeded` + `computeAudioSilencePadPackets`.
 	*/
 	firstAudioFramePadded = false;
 	/** PCMU frame size in samples per packet — 160 = 20 ms at 8 kHz. */
@@ -25120,7 +25124,7 @@ var AdaptiveSession = class AdaptiveSession {
 		return this.audioClock().codec === "opus";
 	}
 	/**
-	* Inject the canonical 20 ms Opus silence packet used for prestream A/V-sync
+	* Inject the canonical 20 ms Opus silence packet used for sentry A/V-sync
 	* padding. Broker-provided (encoded via the audio-codec cap) because Opus has
 	* no fixed silence byte the way PCMU does (0xFF).
 	*/
@@ -25134,7 +25138,7 @@ var AdaptiveSession = class AdaptiveSession {
 		const senderCodec = this.audioSender.codec;
 		const fallbackPt = codec === "Pcmu" || codec === "Pcma" ? 0 : 111;
 		const pt = senderCodec?.payloadType ?? fallbackPt;
-		this.prestreamAudioSilenceIfNeeded(rtpTs >>> 0, pt);
+		this.sentryAudioSilenceIfNeeded(rtpTs >>> 0, pt);
 		try {
 			const header = new werift.RtpHeader();
 			header.payloadType = pt;
@@ -25173,7 +25177,7 @@ var AdaptiveSession = class AdaptiveSession {
 	* diag reads ~0). Any failure on a single `sendRtp` is logged and the loop
 	* continues — partial alignment is better than aborting.
 	*/
-	prestreamAudioSilenceIfNeeded(realRtpTs, payloadType) {
+	sentryAudioSilenceIfNeeded(realRtpTs, payloadType) {
 		if (this.firstAudioFramePadded) return;
 		this.firstAudioFramePadded = true;
 		if (!this.audioSender || !_werift) return;