@camstack/addon-pipeline 1.2.107 → 1.2.115

package/dist/stream-broker/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-L-1LMGQs.js");
+const require_dist = require("../dist-BqIbYW1A.js");
 const require_restream_intent = require("../restream-intent-Cv9x3jmu.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 const require_retire_root_keys = require("../retire-root-keys-KE6D6Xh_.js");
@@ -23631,7 +23631,7 @@ var MonotonicClock = class {
 		this.rate = rate;
 	}
 };
-var SCRUB_FRAGMENT_CACHE_MAX_BYTES = 24 * 1024 * 1024;
+var SCRUB_FRAGMENT_CACHE_MAX_BYTES = 48 * 1024 * 1024;
 var SCRUB_FRAGMENT_CACHE_OTHER_MAX_BYTES = 2 * 1024 * 1024;
 /** Demuxed bytes an entry holds — what the byte bound actually counts. */
 function fragmentBytes(frag) {
@@ -24053,14 +24053,22 @@ var SCRUB_WHOLE_SEGMENT_MAX_BYTES = 15e5;
 * drag starts on.
 *
 * Asymmetric because the gesture is: a drag that begins at the live edge — or
-* at a notification's moment — is looking for what ALREADY happened. 90 s back
-* against 30 s forward is 12 segments ≈ 2.8 MB at `low`, read sequentially in
-* the background while the operator is still deciding where to drag.
+* at a notification's moment — is looking for what ALREADY happened. 15 min
+* back against 5 min forward fills the 48 MB window where the finger will
+* actually move, read sequentially in the background while the first ticks
+* still pay their own demand-read.
 */
-var SCRUB_WARM_BACK_MS = 9e4;
-var SCRUB_WARM_FWD_MS = 3e4;
-/** Hard bound on warm reads, whatever the spans above resolve to. */
-var SCRUB_WARM_MAX_SEGMENTS = 14;
+var SCRUB_WARM_BACK_MS = 15 * 6e4;
+var SCRUB_WARM_FWD_MS = 5 * 6e4;
+/** Symmetric span used after a jump: scrub around the landing, both ways. */
+var SCRUB_WARM_AROUND_MS = 15 * 6e4;
+/**
+* Re-centre the fill when a tick lands this far from the window we are filling.
+* A slow drag stays inside this; a jump to 8am does not.
+*/
+var SCRUB_RECENTER_MS = 12e4;
+/** Hard bound on warm reads, derived from the session RAM budget. */
+var SCRUB_WARM_MAX_SEGMENTS = Math.max(1, Math.floor(SCRUB_FRAGMENT_CACHE_MAX_BYTES / 2e5));
 /**
 * Median recent read time at or above which the feeder STOPS speculating.
 *
@@ -24314,6 +24322,16 @@ var RecordedFeeder = class {
 	scrubReadMsWindow = [];
 	/** Warm-up runs once per drag, from the playhead the finger went down on. */
 	scrubWarmStarted = false;
+	/** Centre of the fill currently in flight (or last completed). */
+	scrubWarmCentreMs = null;
+	/** Bumped to abort a fill without aborting the drag tick (`scrubToken`). */
+	scrubWarmGen = 0;
+	/** Tick demand-read in flight: the fill waits so the finger wins the spindle. */
+	scrubTickReadInFlight = false;
+	/** One fill walker per drag — a fling retargets it, it does not spawn another. */
+	scrubFillLoopActive = false;
+	scrubWarmBackMs = SCRUB_WARM_BACK_MS;
+	scrubWarmFwdMs = SCRUB_WARM_FWD_MS;
 	constructor(deps) {
 		this.deps = deps;
 		this.audioClock = new MonotonicClock(deps.audioClockRateHz ?? 8e3);
@@ -24435,6 +24453,7 @@ var RecordedFeeder = class {
 			let prefixFed = false;
 			let gopFirst = false;
 			let stateAnnounced = false;
+			let reusedWhole = null;
 			if (this.deps.readGop) {
 				const cached = this.scrubCache.covering(this.deps.profile, landMs);
 				let fragment;
@@ -24444,6 +24463,10 @@ var RecordedFeeder = class {
 					if (fragmentLoad === null) return;
 					fragment = fragmentLoad.seg;
 					this.scrubCache.put(this.deps.profile, fragment);
+					if (fragmentLoad.wholeSegmentRead && fragmentLoad.rawBytes) reusedWhole = {
+						video: fragment.aus,
+						bytes: fragmentLoad.rawBytes
+					};
 				}
 				if (this.disposed || token !== this.seekToken) return;
 				const fragmentLoc = {
@@ -24461,14 +24484,23 @@ var RecordedFeeder = class {
 				this.startPositionReports();
 				stateAnnounced = true;
 			}
-			const fullLoad = this.loadAus(loc.startMs, this.rate !== 0, this.deps.readGop ? void 0 : (video) => {
-				if (this.disposed || token !== this.seekToken) return;
-				this.feedPrefix(loc, video, landMs);
-				prefixFed = true;
-				firstFrameMs = performance.now() - seekStartedAt;
-			});
-			fullLoad.catch(() => {});
-			const loaded = await fullLoad;
+			let loaded;
+			if (reusedWhole) {
+				const audio = this.rate !== 0 && this.deps.demuxAudio && this.resolveAudioPush() !== void 0 ? await this.withTimeout(this.deps.demuxAudio(reusedWhole.bytes)).catch(() => []) : [];
+				loaded = {
+					video: reusedWhole.video,
+					audio
+				};
+			} else {
+				const fullLoad = this.loadAus(loc.startMs, this.rate !== 0, this.deps.readGop ? void 0 : (video) => {
+					if (this.disposed || token !== this.seekToken) return;
+					this.feedPrefix(loc, video, landMs);
+					prefixFed = true;
+					firstFrameMs = performance.now() - seekStartedAt;
+				});
+				fullLoad.catch(() => {});
+				loaded = await fullLoad;
+			}
 			loadMs = performance.now() - loadStartedAt;
 			if (this.disposed || token !== this.seekToken || loaded === null) return;
 			if (!prefixFed) this.feedPrefix(loc, loaded.video, landMs);
@@ -24630,38 +24662,92 @@ var RecordedFeeder = class {
 	* back and {@link SCRUB_WARM_FWD_MS} forward from the entry playhead, one
 	* segment at a time, backward first.
 	*
-	* Once per drag, always in the background, and never on the tick's path — a
-	* tick that arrives against a cold cache pays its own read exactly as before.
+	* Fire-and-forget, never on the tick's path — a tick that arrives against a
+	* cold cache pays its own read exactly as before. A later jump more than
+	* {@link SCRUB_RECENTER_MS} from this centre aborts the fill (via
+	* {@link scrubWarmGen}, not the drag token) and starts a new window.
+	*
 	* It walks segment to segment through `locate` rather than assuming a segment
 	* length, so a recorder configured with a different `segmentSeconds` warms the
 	* same SPAN rather than the same count.
 	*/
-	startScrubWarm(centreMs, gen) {
-		if (this.scrubWarmStarted) return;
+	startScrubWarm(centreMs, dragGen, opts) {
+		if (this.scrubWarmStarted && !opts?.force) return;
 		this.scrubWarmStarted = true;
-		this.warmScrubWindow(centreMs, gen);
+		this.scrubWarmGen += 1;
+		this.scrubWarmCentreMs = centreMs;
+		this.scrubWarmBackMs = opts?.backMs ?? SCRUB_WARM_BACK_MS;
+		this.scrubWarmFwdMs = opts?.fwdMs ?? SCRUB_WARM_FWD_MS;
+		this.deps.onLog?.("scrub-feeder:warm-start", {
+			centreMs,
+			fillGen: this.scrubWarmGen
+		});
+		if (this.scrubFillLoopActive) return;
+		this.scrubFillLoopActive = true;
+		this.runScrubFillLoop(dragGen);
+	}
+	/**
+	* A single sequential walk. Recentre bumps {@link scrubWarmGen} and this loop
+	* restarts around the new cursor — it must never `void` a second walker, or a
+	* coarse fling stacks one USB walk per tick and play/scrub starve (1.2.113:
+	* 16 walkers, seek `loadMs=16652`, drags with `ticks=0`).
+	*/
+	async runScrubFillLoop(dragGen) {
+		let lastWorked = -1;
+		try {
+			while (!this.disposed && this.scrubbing && dragGen === this.scrubToken) {
+				const gen = this.scrubWarmGen;
+				const centre = this.scrubWarmCentreMs;
+				if (centre === null) return;
+				await this.warmScrubWindow(centre, dragGen, gen, this.scrubWarmBackMs, this.scrubWarmFwdMs);
+				lastWorked = gen;
+				if (gen === this.scrubWarmGen) return;
+			}
+		} finally {
+			this.scrubFillLoopActive = false;
+			if (!this.disposed && this.scrubbing && dragGen === this.scrubToken && this.scrubWarmCentreMs !== null && this.scrubWarmGen !== lastWorked) {
+				this.scrubFillLoopActive = true;
+				this.runScrubFillLoop(dragGen);
+			}
+		}
+	}
+	/**
+	* Abort the current fill and start a new ±15 min window around `centreMs`.
+	* Does not bump `scrubToken` — the in-flight tick must still land.
+	*/
+	recenterScrubWarm(centreMs) {
+		if (this.deps.profile !== SCRUB_WHOLE_SEGMENT_PROFILE) return;
+		this.startScrubWarm(centreMs, this.scrubToken, {
+			force: true,
+			backMs: SCRUB_WARM_AROUND_MS,
+			fwdMs: SCRUB_WARM_AROUND_MS
+		});
+	}
+	maybeRecenterScrubWarm(targetMs) {
+		if (this.deps.profile !== SCRUB_WHOLE_SEGMENT_PROFILE) return;
+		const centre = this.scrubWarmCentreMs;
+		if (centre === null) return;
+		if (Math.abs(targetMs - centre) <= SCRUB_RECENTER_MS) return;
+		this.recenterScrubWarm(targetMs);
 	}
-	async warmScrubWindow(centreMs, gen) {
-		const spent = await this.warmScrubDirection(centreMs, -1, SCRUB_WARM_BACK_MS, 0, gen);
-		await this.warmScrubDirection(centreMs, 1, SCRUB_WARM_FWD_MS, spent, gen);
+	async warmScrubWindow(centreMs, dragGen, fillGen, backMs, fwdMs) {
+		const spent = await this.warmScrubDirection(centreMs, -1, backMs, 0, dragGen, fillGen);
+		await this.warmScrubDirection(centreMs, 1, fwdMs, spent, dragGen, fillGen);
 	}
 	/**
 	* Walk `dir` from `fromMs` until `spanMs` of timeline is warm (or the shared
 	* bound is hit), reading each segment that is not already cached. Returns the
 	* running total of segments read, so the two directions share one budget.
 	*/
-	async warmScrubDirection(fromMs, dir, spanMs, spent, gen) {
+	async warmScrubDirection(fromMs, dir, spanMs, spent, dragGen, fillGen) {
 		let read = spent;
 		let probeMs = fromMs;
 		for (let i = 0; i < SCRUB_WARM_MAX_SEGMENTS; i++) {
-			if (this.disposed || !this.scrubbing || gen !== this.scrubToken) return read;
+			if (this.disposed || !this.scrubbing || dragGen !== this.scrubToken) return read;
+			if (fillGen !== this.scrubWarmGen) return read;
 			if (read >= SCRUB_WARM_MAX_SEGMENTS) return read;
 			if (Math.abs(probeMs - fromMs) > spanMs) return read;
-			if (this.scrubReadsAreSlow()) {
-				this.scrubStats?.recordPrefetchSuppressed();
-				return read;
-			}
-			const seg = await this.warmOneScrubSegment(probeMs, gen);
+			const seg = await this.warmOneScrubSegment(probeMs, dragGen, fillGen);
 			if (seg === null) return read;
 			if (seg.fetched) read += 1;
 			probeMs = dir === -1 ? seg.startMs - 1 : seg.startMs + seg.durMs + 1;
@@ -24675,7 +24761,7 @@ var RecordedFeeder = class {
 	* so the walk can step to its neighbour, or null when the walk must stop (a
 	* gap, a failure, or teardown).
 	*/
-	async warmOneScrubSegment(probeMs, gen) {
+	async warmOneScrubSegment(probeMs, dragGen, fillGen) {
 		try {
 			const warm = this.scrubCache.covering(this.deps.profile, probeMs);
 			if (warm) return {
@@ -24683,16 +24769,20 @@ var RecordedFeeder = class {
 				durMs: warm.durMs,
 				fetched: false
 			};
+			if (!await this.waitForTickReadIdle(fillGen)) return null;
 			const loc = await this.withTimeout(this.deps.locate({
 				deviceId: this.deps.deviceId,
 				profile: this.deps.profile,
 				epochMs: probeMs
 			}));
-			if (this.disposed || !this.scrubbing || gen !== this.scrubToken) return null;
+			if (this.disposed || !this.scrubbing || dragGen !== this.scrubToken) return null;
+			if (fillGen !== this.scrubWarmGen) return null;
 			if (loc.kind !== "segment") return null;
+			if (!await this.waitForTickReadIdle(fillGen)) return null;
 			const load = await this.loadScrubFragment(loc, probeMs);
 			if (load !== null) this.scrubStats?.recordPrefetchRead(load.readBytes);
-			if (this.disposed || !this.scrubbing || gen !== this.scrubToken || load === null) return null;
+			if (this.disposed || !this.scrubbing || dragGen !== this.scrubToken || load === null) return null;
+			if (fillGen !== this.scrubWarmGen) return null;
 			this.scrubCache.put(this.deps.profile, load.seg);
 			this.scrubPrefetched.add(load.seg.startMs);
 			return {
@@ -24704,6 +24794,14 @@ var RecordedFeeder = class {
 			return null;
 		}
 	}
+	/** Yield the spindle to an in-flight finger tick. Returns false if this fill died. */
+	async waitForTickReadIdle(fillGen) {
+		while (this.scrubTickReadInFlight) {
+			await new Promise((r) => setTimeout(r, 4));
+			if (this.disposed || !this.scrubbing || fillGen !== this.scrubWarmGen) return false;
+		}
+		return true;
+	}
 	/**
 	* EXPERIMENTAL feeder-scrub: register a drag target. Records the newest target
 	* and, if no tick cycle is live, starts a leading-edge tick. A burst of moves
@@ -24867,63 +24965,69 @@ var RecordedFeeder = class {
 				}
 			}
 			if (!seg) {
-				const locateStartMs = performance.now();
-				let loc = await this.withTimeout(this.deps.locate({
-					deviceId: this.deps.deviceId,
-					profile: this.deps.profile,
-					epochMs: target
-				}));
-				locateCalls += 1;
-				locateMs = performance.now() - locateStartMs;
-				this.maybeLogSlowLocate(target, locateMs);
-				if (this.disposed || !this.scrubbing || gen !== this.scrubToken) return;
-				if (loc.kind === "gap") {
-					const decision = resolveSnapTarget(loc, target);
-					if (decision.kind !== "snap") {
-						if (!this.scrubNoFootageLogged) {
-							this.scrubNoFootageLogged = true;
-							if (decision.kind === "too-far") this.deps.onLog?.("scrub-feeder:snap-too-far", {
-								epochMs: target,
-								nearestMs: decision.snapMs,
-								distanceMs: decision.distanceMs
-							});
-							else this.deps.onLog?.("scrub-feeder:no-footage", { epochMs: target });
-						}
-						return;
-					}
-					const snapStartMs = performance.now();
-					const snapped = await this.withTimeout(this.deps.locate({
+				this.scrubTickReadInFlight = true;
+				try {
+					this.maybeRecenterScrubWarm(target);
+					const locateStartMs = performance.now();
+					let loc = await this.withTimeout(this.deps.locate({
 						deviceId: this.deps.deviceId,
 						profile: this.deps.profile,
-						epochMs: decision.snapMs
+						epochMs: target
 					}));
 					locateCalls += 1;
-					locateMs = (locateMs ?? 0) + (performance.now() - snapStartMs);
+					locateMs = performance.now() - locateStartMs;
+					this.maybeLogSlowLocate(target, locateMs);
 					if (this.disposed || !this.scrubbing || gen !== this.scrubToken) return;
-					if (snapped.kind !== "segment") {
-						if (!this.scrubNoFootageLogged) {
-							this.scrubNoFootageLogged = true;
-							this.deps.onLog?.("scrub-feeder:no-footage", { epochMs: target });
+					if (loc.kind === "gap") {
+						const decision = resolveSnapTarget(loc, target);
+						if (decision.kind !== "snap") {
+							if (!this.scrubNoFootageLogged) {
+								this.scrubNoFootageLogged = true;
+								if (decision.kind === "too-far") this.deps.onLog?.("scrub-feeder:snap-too-far", {
+									epochMs: target,
+									nearestMs: decision.snapMs,
+									distanceMs: decision.distanceMs
+								});
+								else this.deps.onLog?.("scrub-feeder:no-footage", { epochMs: target });
+							}
+							return;
 						}
-						return;
+						const snapStartMs = performance.now();
+						const snapped = await this.withTimeout(this.deps.locate({
+							deviceId: this.deps.deviceId,
+							profile: this.deps.profile,
+							epochMs: decision.snapMs
+						}));
+						locateCalls += 1;
+						locateMs = (locateMs ?? 0) + (performance.now() - snapStartMs);
+						if (this.disposed || !this.scrubbing || gen !== this.scrubToken) return;
+						if (snapped.kind !== "segment") {
+							if (!this.scrubNoFootageLogged) {
+								this.scrubNoFootageLogged = true;
+								this.deps.onLog?.("scrub-feeder:no-footage", { epochMs: target });
+							}
+							return;
+						}
+						this.deps.onLog?.("scrub-feeder:snapped", {
+							requestedMs: target,
+							snappedMs: decision.snapMs
+						});
+						loc = snapped;
+						effTarget = decision.snapMs;
 					}
-					this.deps.onLog?.("scrub-feeder:snapped", {
-						requestedMs: target,
-						snappedMs: decision.snapMs
-					});
-					loc = snapped;
-					effTarget = decision.snapMs;
-				}
-				seg = this.scrubCache.covering(this.deps.profile, effTarget);
-				if (!seg) {
-					const load = await this.loadScrubFragment(loc, effTarget);
-					if (this.disposed || !this.scrubbing || gen !== this.scrubToken || load === null) return;
-					seg = load.seg;
-					readMs = load.readMs;
-					readBytes = load.readBytes;
-					demuxMs = load.demuxMs;
-					wholeSegmentRead = load.wholeSegmentRead;
-					this.scrubCache.put(this.deps.profile, seg);
+					seg = this.scrubCache.covering(this.deps.profile, effTarget);
+					if (!seg) {
+						const load = await this.loadScrubFragment(loc, effTarget);
+						if (this.disposed || !this.scrubbing || gen !== this.scrubToken || load === null) return;
+						seg = load.seg;
+						readMs = load.readMs;
+						readBytes = load.readBytes;
+						demuxMs = load.demuxMs;
+						wholeSegmentRead = load.wholeSegmentRead;
+						this.scrubCache.put(this.deps.profile, seg);
+					}
+				} finally {
+					this.scrubTickReadInFlight = false;
 				}
 			}
 			this.scrubSegment = seg;
@@ -25132,7 +25236,8 @@ var RecordedFeeder = class {
 			readMs: readEndMs - readStartMs,
 			readBytes: bytes.length,
 			demuxMs: performance.now() - readEndMs,
-			wholeSegmentRead: true
+			wholeSegmentRead: true,
+			rawBytes: bytes
 		};
 	}
 	/**
@@ -25344,6 +25449,7 @@ var RecordedFeeder = class {
 			this.scrubStats?.recordPrefetchSuppressed();
 			return;
 		}
+		if (this.scrubFillLoopActive) return;
 		const aheadMs = Math.max(Math.abs(stepMs), seg.durMs + 1);
 		const horizons = Math.abs(stepMs) > seg.durMs ? SCRUB_PREFETCH_MAX_INFLIGHT : 1;
 		for (let horizon = 1; horizon <= horizons; horizon++) {
@@ -25352,6 +25458,7 @@ var RecordedFeeder = class {
 			if (probeMs < 0) continue;
 			if (this.scrubPrefetchProbes.has(probeMs)) continue;
 			if (this.scrubCache.covering(this.deps.profile, probeMs)) continue;
+			if (this.scrubWarmCentreMs !== null && Math.abs(probeMs - this.scrubWarmCentreMs) > SCRUB_WARM_AROUND_MS) continue;
 			this.scrubPrefetch(probeMs, gen);
 		}
 	}
@@ -25974,7 +26081,7 @@ var TimelineSession = class {
 	*
 	* 1. The scrub is pinned to `low` by the client, and every D163 pre-cache
 	*    behaviour is gated on `deps.profile === 'low'` by exact string equality
-	*    — the 90 s/30 s entry warm, the whole-segment read, and the 24 MB
+	*    — the ±15 min entry warm, the whole-segment read, and the 48 MB
 	*    fragment budget (2 MB for anything else). `profileSearchOrder` puts
 	*    `high` BEFORE `low`, so a momentary `low` gap used to hand the drag a
 	*    `high` feeder and silently turn all three off. The client cannot repair
@@ -33710,6 +33817,70 @@ function preferLiveAdaptiveCandidates(candidates) {
 	return natives.length > 0 ? natives : [...candidates];
 }
 //#endregion
+//#region src/stream-broker/webrtc/adaptive-tier.ts
+var RANK = {
+	low: 1,
+	mid: 2,
+	high: 3
+};
+var QUALITY_FIRST = [
+	"high",
+	"mid",
+	"low"
+];
+var SMALLEST_FIRST = [
+	"low",
+	"mid",
+	"high"
+];
+function isTier(value) {
+	return value === "high" || value === "mid" || value === "low";
+}
+function firstAvailable(order, available) {
+	const set = new Set(available);
+	return order.find((t) => set.has(t));
+}
+function capTo(tier, available) {
+	const max = RANK[tier];
+	return firstAvailable(QUALITY_FIRST.filter((t) => RANK[t] <= max), available);
+}
+function pickAdaptiveTier(input) {
+	const available = input.available.filter((t) => t === "high" || t === "mid" || t === "low");
+	const fallback = firstAvailable(QUALITY_FIRST, available) ?? "high";
+	if (isTier(input.prefersTier)) {
+		const exact = available.includes(input.prefersTier) ? input.prefersTier : void 0;
+		if (exact) return {
+			tier: exact,
+			reason: "prefers-tier"
+		};
+		return {
+			tier: firstAvailable(SMALLEST_FIRST, available) ?? fallback,
+			reason: "prefers-tier-fallback"
+		};
+	}
+	let tier = fallback;
+	let reason = "default-high";
+	if (input.downlinkMbps !== void 0 && Number.isFinite(input.downlinkMbps) && input.downlinkMbps >= 0) {
+		tier = capTo(input.downlinkMbps >= 8 ? "high" : input.downlinkMbps >= 2.5 ? "mid" : "low", available) ?? fallback;
+		reason = "downlink";
+	}
+	const width = input.viewportWidth;
+	const height = input.viewportHeight;
+	if (width !== void 0 && height !== void 0 && width > 0 && height > 0) {
+		if (Math.max(width, height) < 240) {
+			const tiled = capTo("low", available) ?? fallback;
+			if (RANK[tiled] < RANK[tier]) return {
+				tier: tiled,
+				reason: "viewport-ceiling"
+			};
+		}
+	}
+	return {
+		tier,
+		reason
+	};
+}
+//#endregion
 //#region src/stream-broker/webrtc/broker-webrtc-server.ts
 /**
 * Broker-integrated WebRTC server.
@@ -33825,36 +33996,12 @@ function deriveH264ProfileLevelId(sdpParameterSets, preBuffer) {
 		if (profileLevelId) return profileLevelId;
 	}
 }
-/** Fallback resolution/bitrate per label when the broker hasn't reported stats yet. */
-var LABEL_DEFAULTS = {
-	high: {
-		pixels: 1920 * 1080,
-		bitrateKbps: 4e3
-	},
-	mid: {
-		pixels: 1280 * 720,
-		bitrateKbps: 1200
-	},
-	low: {
-		pixels: 640 * 360,
-		bitrateKbps: 400
-	}
-};
-var TIER_PREFERENCE = [
-	"high",
-	"mid",
-	"low"
-];
-/** Smallest-keyframe-first tier order. Used as the fallback when an explicit
-*  `prefersTier` (e.g. the hub's `remote`-viewer bias to `low`) has no exact
-*  assigned slot: prefer the SMALLEST available tier rather than the
-*  quality-first default, so a remote-biased request never silently lands back
-*  on `high`. */
-var SMALLEST_FIRST_TIER_PREFERENCE = [
-	"low",
-	"mid",
-	"high"
-];
+function adaptivePickLogLine(reason) {
+	if (reason === "prefers-tier") return "Adaptive source selected (prefersTier exact)";
+	if (reason === "prefers-tier-fallback") return "Adaptive source selected (prefersTier fallback → smallest available)";
+	if (reason === "default-high") return "Adaptive source selected (no client hints — tier preference)";
+	return "Adaptive source selected";
+}
 /** Push-queue overflow purges are aggregated and reported at most this often. */
 var FRAME_DROP_LOG_INTERVAL_MS = 3e4;
 /**
@@ -33895,20 +34042,6 @@ function reduceProfileForTranscodeDown(base) {
 		}
 	};
 }
-function scoreBroker(tier, broker, hints) {
-	const stats = broker.getStats();
-	const fallback = tier ? LABEL_DEFAULTS[tier] : void 0;
-	const bitrateKbps = stats.bitrateKbps > 0 ? stats.bitrateKbps : fallback?.bitrateKbps ?? 2e3;
-	const srcPixels = fallback?.pixels ?? 1920 * 1080;
-	const targetPixels = (hints.viewportWidth ?? 1920) * (hints.viewportHeight ?? 1080);
-	const pixelDistance = Math.abs(srcPixels - targetPixels) / 1e6;
-	let bandwidthPenalty = 0;
-	if (hints.downlinkMbps && hints.downlinkMbps > 0 && bitrateKbps > 0) {
-		const availableKbps = hints.downlinkMbps * 1e3 * .6;
-		if (bitrateKbps > availableKbps) bandwidthPenalty = (bitrateKbps - availableKbps) / availableKbps * 100;
-	}
-	return pixelDistance + bandwidthPenalty;
-}
 var BrokerWebrtcServer = class {
 	logger;
 	getIceServersFn;
@@ -35040,78 +35173,26 @@ var BrokerWebrtcServer = class {
 		if (pool.length === 1) return pool[0].brokerId;
 		const adaptiveDeviceIdTag = Number(deviceKey.split("/")[0]);
 		const deviceIdTag = Number.isFinite(adaptiveDeviceIdTag) ? { tags: { deviceId: adaptiveDeviceIdTag } } : {};
-		if (hints.prefersTier === "high" || hints.prefersTier === "mid" || hints.prefersTier === "low") {
-			const explicit = pool.find((c) => c.tier === hints.prefersTier);
-			if (explicit) {
-				this.logger.info("Adaptive source selected (prefersTier exact)", {
-					...deviceIdTag,
-					meta: {
-						deviceKey,
-						selected: explicit.brokerId,
-						tier: explicit.tier,
-						prefersTier: hints.prefersTier
-					}
-				});
-				return explicit.brokerId;
-			}
-			for (const tier of SMALLEST_FIRST_TIER_PREFERENCE) {
-				const match = pool.find((c) => c.tier === tier);
-				if (match) {
-					this.logger.info("Adaptive source selected (prefersTier fallback → smallest available)", {
-						...deviceIdTag,
-						meta: {
-							deviceKey,
-							selected: match.brokerId,
-							tier: match.tier,
-							prefersTier: hints.prefersTier
-						}
-					});
-					return match.brokerId;
-				}
-			}
-		}
-		if (!(hints.viewportWidth !== void 0 || hints.viewportHeight !== void 0 || hints.downlinkMbps !== void 0)) {
-			for (const tier of TIER_PREFERENCE) {
-				const match = pool.find((c) => c.tier === tier);
-				if (match) {
-					this.logger.info("Adaptive source selected (no client hints — tier preference)", {
-						...deviceIdTag,
-						meta: {
-							deviceKey,
-							selected: match.brokerId,
-							tier: match.tier
-						}
-					});
-					return match.brokerId;
-				}
-			}
-			return pool[0].brokerId;
-		}
-		let bestId = pool[0].brokerId;
-		let bestTier = pool[0].tier;
-		let bestScore = Infinity;
-		for (const c of pool) {
-			const score = scoreBroker(c.tier, c.broker, hints);
-			const cRank = c.tier ? TIER_PREFERENCE.indexOf(c.tier) : TIER_PREFERENCE.length;
-			const bestRank = bestTier ? TIER_PREFERENCE.indexOf(bestTier) : TIER_PREFERENCE.length;
-			if (score < bestScore || score === bestScore && cRank < bestRank) {
-				bestId = c.brokerId;
-				bestTier = c.tier;
-				bestScore = score;
-			}
-		}
-		const adaptiveDeviceId = Number(deviceKey.split("/")[0]);
-		this.logger.debug("Adaptive source selected", {
-			...Number.isFinite(adaptiveDeviceId) ? { tags: { deviceId: adaptiveDeviceId } } : {},
+		const pick = pickAdaptiveTier({
+			available: pool.map((c) => c.tier),
+			prefersTier: hints.prefersTier,
+			downlinkMbps: hints.downlinkMbps,
+			viewportWidth: hints.viewportWidth,
+			viewportHeight: hints.viewportHeight
+		});
+		const selected = pool.find((c) => c.tier === pick.tier) ?? pool[0];
+		this.logger.info(adaptivePickLogLine(pick.reason), {
+			...deviceIdTag,
 			meta: {
 				deviceKey,
-				selected: bestId,
-				tier: bestTier,
-				score: Math.round(bestScore * 100) / 100,
+				selected: selected.brokerId,
+				tier: selected.tier,
+				reason: pick.reason,
+				prefersTier: hints.prefersTier,
 				hints
 			}
 		});
-		return bestId;
+		return selected.brokerId;
 	}
 	async resolveIceServers() {
 		if (this.getIceServersFn) try {