@camstack/addon-pipeline 1.2.128 → 1.2.130

package/dist/stream-broker/index.js

@@ -2,11 +2,11 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BZUXb5S5.js");
+const require_dist = require("../dist-DOw-izoI.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");
-const require_segment_demux_js = require("../segment-demux-js-DRutggd6.js");
+const require_segment_demux_js = require("../segment-demux-js-C2jBBqGW.js");
 let node_crypto = require("node:crypto");
 node_crypto = require_dist.__toESM(node_crypto, 1);
 let node_child_process = require("node:child_process");
@@ -390,6 +390,83 @@ var STREAM_BROKER_RETIRED_ROOT_KEYS = [
 	}
 ];
 //#endregion
+//#region src/stream-broker/stream-broker/ffmpeg-args-common.ts
+/** The `-hide_banner -loglevel <level>` preamble every broker ffmpeg site opens with. */
+function logBannerArgs(level) {
+	return [
+		"-hide_banner",
+		"-loglevel",
+		level
+	];
+}
+//#endregion
+//#region src/shared/ffmpeg-decode-args.ts
+/**
+* Canonical decode-hwaccel preference order for the ffmpeg-subprocess decoder.
+*
+* `vaapi` is ranked ABOVE `qsv` deliberately: on the Intel hub the `qsv` decode
+* child exits early (`code=171`, no frames) while the `vaapi` path decodes 8MP
+* h264 cleanly at ~50fps. The kernel probe (`resolveHwAccel`) tends to surface
+* `qsv` first on Intel, so we re-rank its result through this table before
+* building the attempt chain. `videotoolbox` leads for macOS; `cuda` / `nvdec`
+* trail for NVIDIA. A method not listed here keeps its incoming relative order,
+* placed AFTER every ranked one.
+*/
+var DECODE_HWACCEL_RANK = [
+	"videotoolbox",
+	"vaapi",
+	"qsv",
+	"cuda",
+	"nvdec",
+	"d3d11va",
+	"dxva2",
+	"amf",
+	"vdpau",
+	"drm"
+];
+/** Rank index for {@link DECODE_HWACCEL_RANK} — unranked methods sort last. */
+function decodeHwAccelRankIndex(method) {
+	const idx = DECODE_HWACCEL_RANK.indexOf(method.toLowerCase());
+	return idx < 0 ? DECODE_HWACCEL_RANK.length : idx;
+}
+/**
+* Build the ORDERED list of hardware `-hwaccel` methods to attempt for an
+* `'auto'` decode session, best-first. The session walks this chain on an
+* early-exit-with-no-frames and only falls to software once it is exhausted.
+*
+* Strategy:
+* - Seed candidates from the kernel-preferred order UNION the canonical rank
+*   UNION the build's supported list, so a method the kernel omitted but the
+*   build supports (the Intel `vaapi` case — kernel surfaces only `qsv`) is
+*   still attempted.
+* - When the build's supported-method list is known (non-empty), keep only
+*   methods it actually offers; on a probe miss (empty) keep just the kernel
+*   preferences (avoid blindly spawning every backend).
+* - Re-rank the survivors by {@link DECODE_HWACCEL_RANK} so `vaapi` precedes
+*   `qsv`. A supported method not in the rank table keeps its position AFTER
+*   every ranked one (stable sort). Returns lowercased method names; empty ⇒
+*   pure software.
+*/
+function rankDecodeHwAccels(preferred, supportedMethods) {
+	const supported = new Set(supportedMethods.map((m) => m.toLowerCase()));
+	const hasSupportList = supported.size > 0;
+	const pool = hasSupportList ? [
+		...preferred,
+		...DECODE_HWACCEL_RANK,
+		...supportedMethods
+	] : [...preferred];
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
+	for (const raw of pool) {
+		const method = raw.toLowerCase();
+		if (seen.has(method)) continue;
+		seen.add(method);
+		if (hasSupportList && !supported.has(method)) continue;
+		candidates.push(method);
+	}
+	return candidates.sort((a, b) => decodeHwAccelRankIndex(a) - decodeHwAccelRankIndex(b));
+}
+//#endregion
 //#region src/stream-broker/battery-wake-on-play.ts
 /**
 * Wake-on-play — pressing play on a sleeping battery camera wakes it, and the
@@ -592,83 +669,6 @@ async function wakeBatteryDeviceForPlay(deviceId, deps) {
 	throw new BatteryStreamUnavailableError(deviceId, outcome, wake.awoke ? "it acknowledged the wake but no stream had appeared yet — try again in a few seconds" : "it did not answer the wake in time — try again");
 }
 //#endregion
-//#region src/stream-broker/stream-broker/ffmpeg-args-common.ts
-/** The `-hide_banner -loglevel <level>` preamble every broker ffmpeg site opens with. */
-function logBannerArgs(level) {
-	return [
-		"-hide_banner",
-		"-loglevel",
-		level
-	];
-}
-//#endregion
-//#region src/shared/ffmpeg-decode-args.ts
-/**
-* Canonical decode-hwaccel preference order for the ffmpeg-subprocess decoder.
-*
-* `vaapi` is ranked ABOVE `qsv` deliberately: on the Intel hub the `qsv` decode
-* child exits early (`code=171`, no frames) while the `vaapi` path decodes 8MP
-* h264 cleanly at ~50fps. The kernel probe (`resolveHwAccel`) tends to surface
-* `qsv` first on Intel, so we re-rank its result through this table before
-* building the attempt chain. `videotoolbox` leads for macOS; `cuda` / `nvdec`
-* trail for NVIDIA. A method not listed here keeps its incoming relative order,
-* placed AFTER every ranked one.
-*/
-var DECODE_HWACCEL_RANK = [
-	"videotoolbox",
-	"vaapi",
-	"qsv",
-	"cuda",
-	"nvdec",
-	"d3d11va",
-	"dxva2",
-	"amf",
-	"vdpau",
-	"drm"
-];
-/** Rank index for {@link DECODE_HWACCEL_RANK} — unranked methods sort last. */
-function decodeHwAccelRankIndex(method) {
-	const idx = DECODE_HWACCEL_RANK.indexOf(method.toLowerCase());
-	return idx < 0 ? DECODE_HWACCEL_RANK.length : idx;
-}
-/**
-* Build the ORDERED list of hardware `-hwaccel` methods to attempt for an
-* `'auto'` decode session, best-first. The session walks this chain on an
-* early-exit-with-no-frames and only falls to software once it is exhausted.
-*
-* Strategy:
-* - Seed candidates from the kernel-preferred order UNION the canonical rank
-*   UNION the build's supported list, so a method the kernel omitted but the
-*   build supports (the Intel `vaapi` case — kernel surfaces only `qsv`) is
-*   still attempted.
-* - When the build's supported-method list is known (non-empty), keep only
-*   methods it actually offers; on a probe miss (empty) keep just the kernel
-*   preferences (avoid blindly spawning every backend).
-* - Re-rank the survivors by {@link DECODE_HWACCEL_RANK} so `vaapi` precedes
-*   `qsv`. A supported method not in the rank table keeps its position AFTER
-*   every ranked one (stable sort). Returns lowercased method names; empty ⇒
-*   pure software.
-*/
-function rankDecodeHwAccels(preferred, supportedMethods) {
-	const supported = new Set(supportedMethods.map((m) => m.toLowerCase()));
-	const hasSupportList = supported.size > 0;
-	const pool = hasSupportList ? [
-		...preferred,
-		...DECODE_HWACCEL_RANK,
-		...supportedMethods
-	] : [...preferred];
-	const seen = /* @__PURE__ */ new Set();
-	const candidates = [];
-	for (const raw of pool) {
-		const method = raw.toLowerCase();
-		if (seen.has(method)) continue;
-		seen.add(method);
-		if (hasSupportList && !supported.has(method)) continue;
-		candidates.push(method);
-	}
-	return candidates.sort((a, b) => decodeHwAccelRankIndex(a) - decodeHwAccelRankIndex(b));
-}
-//#endregion
 //#region src/stream-broker/derived/cycle-check.ts
 /**
 * Would assigning `derivedCamStreamId` to `targetProfile` create a cycle?
@@ -16279,7 +16279,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		}
 		let devices;
 		try {
-			devices = await api.deviceManager.listAll.query({});
+			devices = await api.deviceManager.listAll.query({ projection: "slim" });
 		} catch (err) {
 			this.logger.warn("profile-map prune skipped — deviceManager.listAll failed", { meta: {
 				persistedCount,
@@ -16604,7 +16604,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		if (!this.api) return;
 		let devices;
 		try {
-			devices = await this.api.deviceManager.listAll.query({});
+			devices = await this.api.deviceManager.listAll.query({ projection: "slim" });
 		} catch (err) {
 			this.logger.debug("reconcileAllCatalogs: deviceManager.listAll failed — will retry", { meta: { error: require_dist.errMsg(err) } });
 			return;
@@ -16744,7 +16744,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		if (!this.api) return false;
 		let devices;
 		try {
-			devices = await this.api.deviceManager.listAll.query({});
+			devices = await this.api.deviceManager.listAll.query({ projection: "slim" });
 		} catch {
 			return false;
 		}
@@ -23479,9 +23479,13 @@ var ControlMessageSchema = require_dist.discriminatedUnion("t", [
 	}),
 	require_dist.object({
 		t: require_dist.literal("scrubCommit"),
-		epoch: require_dist.number()
+		epoch: require_dist.number(),
+		dragId: require_dist.string().optional()
+	}),
+	require_dist.object({
+		t: require_dist.literal("scrubStart"),
+		dragId: require_dist.string().optional()
 	}),
-	require_dist.object({ t: require_dist.literal("scrubStart") }),
 	require_dist.object({
 		t: require_dist.literal("scrubTo"),
 		epoch: require_dist.number(),
@@ -23633,104 +23637,6 @@ var MonotonicClock = class {
 		this.rate = rate;
 	}
 };
-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) {
-	let total = 0;
-	for (const au of frag.aus) total += au.data.length;
-	return total;
-}
-var ScrubFragmentCache = class {
-	maxBytes;
-	otherMaxBytes;
-	map = /* @__PURE__ */ new Map();
-	/**
-	* Bytes held PER PROFILE. Budgets are per profile and so is eviction: a
-	* `high` entry must never be able to evict the `low` segments the drag is
-	* running on, and the reverse would be just as wrong.
-	*/
-	bytesByProfile = /* @__PURE__ */ new Map();
-	constructor(maxBytes = SCRUB_FRAGMENT_CACHE_MAX_BYTES, otherMaxBytes = SCRUB_FRAGMENT_CACHE_OTHER_MAX_BYTES) {
-		this.maxBytes = maxBytes;
-		this.otherMaxBytes = otherMaxBytes;
-	}
-	/** The byte budget for a profile — the scrub profile gets the real one. */
-	budgetFor(profile) {
-		return profile === "low" ? this.maxBytes : this.otherMaxBytes;
-	}
-	key(profile, startMs) {
-		return `${profile}|${startMs}`;
-	}
-	/** Exact-start lookup with LRU touch (re-insertion marks most recent). */
-	get(profile, startMs) {
-		const k = this.key(profile, startMs);
-		const frag = this.map.get(k);
-		if (!frag) return null;
-		this.map.delete(k);
-		this.map.set(k, frag);
-		return frag;
-	}
-	/**
-	* The cached fragment COVERING an instant, if any — the lookup that lets a
-	* warm drag tick skip `locate` entirely (an RPC measured at 1–8 s on a
-	* saturated hub). Coverage is proof of footage: recorded fragments are
-	* immutable, so a hit needs no re-validation. LRU-touches the hit.
-	*/
-	covering(profile, epochMs) {
-		for (const [k, frag] of this.map) {
-			if (!k.startsWith(`${profile}|`)) continue;
-			if (epochMs >= frag.startMs && epochMs < frag.startMs + frag.durMs) {
-				this.map.delete(k);
-				this.map.set(k, frag);
-				return frag;
-			}
-		}
-		return null;
-	}
-	/** Insert (or refresh) a fragment, evicting that PROFILE's oldest past its bound. */
-	put(profile, frag) {
-		const k = this.key(profile, frag.startMs);
-		const held = this.map.get(k);
-		let bytes = this.bytesByProfile.get(profile) ?? 0;
-		if (held) bytes -= fragmentBytes(held);
-		this.map.delete(k);
-		this.map.set(k, frag);
-		bytes += fragmentBytes(frag);
-		this.bytesByProfile.set(profile, bytes);
-		const budget = this.budgetFor(profile);
-		const prefix = `${profile}|`;
-		while ((this.bytesByProfile.get(profile) ?? 0) > budget && this.entriesFor(profile) > 4) {
-			const oldest = this.oldestKeyWithPrefix(prefix);
-			if (oldest === void 0) break;
-			const evicted = this.map.get(oldest);
-			this.map.delete(oldest);
-			if (evicted) this.bytesByProfile.set(profile, (this.bytesByProfile.get(profile) ?? 0) - fragmentBytes(evicted));
-		}
-	}
-	oldestKeyWithPrefix(prefix) {
-		for (const k of this.map.keys()) if (k.startsWith(prefix)) return k;
-	}
-	entriesFor(profile) {
-		const prefix = `${profile}|`;
-		let n = 0;
-		for (const k of this.map.keys()) if (k.startsWith(prefix)) n += 1;
-		return n;
-	}
-	/** Demuxed bytes currently held across every profile. */
-	get byteSize() {
-		let total = 0;
-		for (const bytes of this.bytesByProfile.values()) total += bytes;
-		return total;
-	}
-	/** Demuxed bytes held for one profile — the number its MB bound governs. */
-	byteSizeFor(profile) {
-		return this.bytesByProfile.get(profile) ?? 0;
-	}
-	get size() {
-		return this.map.size;
-	}
-};
 /**
 * A bounded numeric series. Exact count/sum/min/max forever; the median comes
 * from the first {@link SCRUB_PHASE_SAMPLE_CAP} samples.
@@ -23796,7 +23702,13 @@ var ScrubDragStats = class {
 	prefetchBytes = 0;
 	prefetchHits = 0;
 	prefetchSuppressed = 0;
+	warmReads = 0;
+	warmBytes = 0;
+	warmHits = 0;
 	ackTimeouts = 0;
+	deadlineMisses = 0;
+	retargets = 0;
+	resolveJoins = 0;
 	failures = 0;
 	firstPushMs = null;
 	creditEndedAt = null;
@@ -23806,6 +23718,9 @@ var ScrubDragStats = class {
 	demuxMs = new PhaseSamples();
 	tickMs = new PhaseSamples();
 	ackMs = new PhaseSamples();
+	leadMs = new PhaseSamples();
+	oversizeSegments = 0;
+	degradedProfile = null;
 	constructor(startedAtMs) {
 		this.startedAtMs = startedAtMs;
 	}
@@ -23856,10 +23771,43 @@ var ScrubDragStats = class {
 	recordPrefetchHit() {
 		this.prefetchHits += 1;
 	}
+	/** One window-warm read taken while the drag was live, and what it cost. */
+	recordWarmRead(bytes) {
+		this.warmReads += 1;
+		this.warmBytes += bytes;
+	}
+	/** A tick served by a fragment the window warm had already landed. */
+	recordWarmHit() {
+		this.warmHits += 1;
+	}
 	/** Pushes written off after the ack timeout — dropped work, never silent. */
 	recordAckTimeout(pushes) {
 		this.ackTimeouts += pushes;
 	}
+	/** A frame abandoned on its deadline — dropped work, counted every time. */
+	recordDeadlineMiss() {
+		this.deadlineMisses += 1;
+	}
+	/** A landing re-aimed at the newer finger position it also covered. */
+	recordRetarget() {
+		this.retargets += 1;
+	}
+	/** A whole-segment read that had to degrade to a GOP range on size. */
+	recordOversizeSegment() {
+		this.oversizeSegments += 1;
+	}
+	/** This drag is not running on the scrub profile — every gate is off. */
+	recordProfileDegraded(profile) {
+		this.degradedProfile = profile;
+	}
+	/** One read aimed ahead of the finger, and by how much. */
+	recordLead(leadMs) {
+		this.leadMs.add(Math.abs(leadMs));
+	}
+	/** A tick served by the read another tick already had in flight. */
+	recordResolveJoin() {
+		this.resolveJoins += 1;
+	}
 	/** A swallowed `scrubTick` throw — the branch where a dark failure hides. */
 	recordFailure() {
 		this.failures += 1;
@@ -23875,6 +23823,7 @@ var ScrubDragStats = class {
 		const dmx = this.demuxMs.summary();
 		const tick = this.tickMs.summary();
 		const ack = this.ackMs.summary();
+		const lead = this.leadMs.summary();
 		return {
 			ticks: this.ticks,
 			dragMs: Math.round(dragMs),
@@ -23913,7 +23862,17 @@ var ScrubDragStats = class {
 			prefetchBytes: this.prefetchBytes,
 			prefetchHits: this.prefetchHits,
 			prefetchSuppressed: this.prefetchSuppressed,
+			warmReads: this.warmReads,
+			warmBytes: this.warmBytes,
+			warmHits: this.warmHits,
 			ackTimeouts: this.ackTimeouts,
+			deadlineMisses: this.deadlineMisses,
+			retargets: this.retargets,
+			resolveJoins: this.resolveJoins,
+			leadMsP50: lead.p50Ms,
+			leadMsMax: lead.maxMs,
+			oversizeSegments: this.oversizeSegments,
+			degradedProfile: this.degradedProfile,
 			failures: this.failures,
 			creditEndedAt: this.creditEndedAt,
 			acks: ack.n,
@@ -23925,8 +23884,158 @@ var ScrubDragStats = class {
 		};
 	}
 };
+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) {
+	let total = 0;
+	for (const au of frag.aus) total += au.data.length;
+	return total;
+}
+var ScrubFragmentCache = class {
+	maxBytes;
+	otherMaxBytes;
+	map = /* @__PURE__ */ new Map();
+	/**
+	* Bytes held PER PROFILE. Budgets are per profile and so is eviction: a
+	* `high` entry must never be able to evict the `low` segments the drag is
+	* running on, and the reverse would be just as wrong.
+	*/
+	bytesByProfile = /* @__PURE__ */ new Map();
+	constructor(maxBytes = SCRUB_FRAGMENT_CACHE_MAX_BYTES, otherMaxBytes = SCRUB_FRAGMENT_CACHE_OTHER_MAX_BYTES) {
+		this.maxBytes = maxBytes;
+		this.otherMaxBytes = otherMaxBytes;
+	}
+	/** The byte budget for a profile — the scrub profile gets the real one. */
+	budgetFor(profile) {
+		return profile === "low" ? this.maxBytes : this.otherMaxBytes;
+	}
+	key(profile, startMs) {
+		return `${profile}|${startMs}`;
+	}
+	/** Exact-start lookup with LRU touch (re-insertion marks most recent). */
+	get(profile, startMs) {
+		const k = this.key(profile, startMs);
+		const frag = this.map.get(k);
+		if (!frag) return null;
+		this.map.delete(k);
+		this.map.set(k, frag);
+		return frag;
+	}
+	/**
+	* The cached fragment COVERING an instant, if any — the lookup that lets a
+	* warm drag tick skip `locate` entirely (an RPC measured at 1–8 s on a
+	* saturated hub). Coverage is proof of footage: recorded fragments are
+	* immutable, so a hit needs no re-validation. LRU-touches the hit.
+	*/
+	covering(profile, epochMs) {
+		for (const [k, frag] of this.map) {
+			if (!k.startsWith(`${profile}|`)) continue;
+			if (epochMs >= frag.startMs && epochMs < frag.startMs + frag.durMs) {
+				this.map.delete(k);
+				this.map.set(k, frag);
+				return frag;
+			}
+		}
+		return null;
+	}
+	/** Insert (or refresh) a fragment, evicting that PROFILE's oldest past its bound. */
+	put(profile, frag) {
+		const k = this.key(profile, frag.startMs);
+		const held = this.map.get(k);
+		let bytes = this.bytesByProfile.get(profile) ?? 0;
+		if (held) bytes -= fragmentBytes(held);
+		this.map.delete(k);
+		this.map.set(k, frag);
+		bytes += fragmentBytes(frag);
+		this.bytesByProfile.set(profile, bytes);
+		const budget = this.budgetFor(profile);
+		const prefix = `${profile}|`;
+		while ((this.bytesByProfile.get(profile) ?? 0) > budget && this.entriesFor(profile) > 4) {
+			const oldest = this.oldestKeyWithPrefix(prefix);
+			if (oldest === void 0) break;
+			const evicted = this.map.get(oldest);
+			this.map.delete(oldest);
+			if (evicted) this.bytesByProfile.set(profile, (this.bytesByProfile.get(profile) ?? 0) - fragmentBytes(evicted));
+		}
+	}
+	oldestKeyWithPrefix(prefix) {
+		for (const k of this.map.keys()) if (k.startsWith(prefix)) return k;
+	}
+	entriesFor(profile) {
+		const prefix = `${profile}|`;
+		let n = 0;
+		for (const k of this.map.keys()) if (k.startsWith(prefix)) n += 1;
+		return n;
+	}
+	/** Demuxed bytes currently held across every profile. */
+	get byteSize() {
+		let total = 0;
+		for (const bytes of this.bytesByProfile.values()) total += bytes;
+		return total;
+	}
+	/** Demuxed bytes held for one profile — the number its MB bound governs. */
+	byteSizeFor(profile) {
+		return this.bytesByProfile.get(profile) ?? 0;
+	}
+	get size() {
+		return this.map.size;
+	}
+};
+/**
+* `velocity` is ms of timeline per ms of wall clock, signed. `readMs` is what a
+* read costs on this disk right now. Either being null means "not enough is
+* known to aim" — which is NOT saturation: an unknown velocity must not switch
+* speculation off, or the first ticks of every drag would lose it.
+*/
+function scrubLeadDecision(velocity, readMs) {
+	if (velocity === null || readMs === null) return {
+		leadMs: 0,
+		saturated: false
+	};
+	const raw = Math.round(velocity * readMs);
+	if (Math.abs(raw) > 3e4) return {
+		leadMs: 0,
+		saturated: true
+	};
+	return {
+		leadMs: raw,
+		saturated: false
+	};
+}
 //#endregion
 //#region src/stream-broker/recorded/recorded-feeder.ts
+/**
+* READ-AHEAD LEAD — the fix for "the picture chases the finger".
+*
+* A scrub frame is always the frame a read STARTED for, one read time ago.
+* On this disk that is 531 ms of wall clock (p50, census 2026-08-25), and on
+* a wide window 531 ms of gesture is TWENTY MINUTES of timeline: measured in
+* the drag bench, the median painted frame on a 2 h fling was 1 220 000 ms
+* behind the finger. Nothing about that is I/O — it is aiming at where the
+* finger WAS.
+*
+* So a steady drag reads where the finger WILL BE: `mediaVelocity ×
+* medianRecentReadMs`. It costs nothing (the same one read, at a different
+* offset), and it is bounded by the two things that make it a prediction
+* rather than a guess:
+*
+*  - a direction RUN of at least {@link SCRUB_LEAD_MIN_DIR_RUN} POINTER
+*    samples, so a jittery or reversing drag never leads. Pointer samples and
+*    not pushes: on this disk a 3 s drag produces ~75 pointer samples and only
+*    ~4 pushes, so a gate counted in pushes has no runway inside the gesture
+*    it is supposed to help — measured in the drag bench, it engaged once, at
+*    the very end;
+*  - at least {@link SCRUB_LEAD_MIN_READ_SAMPLES} measured read, so the lead
+*    is derived from this disk right now and not from a constant. ONE is
+*    enough: against a read cost that is unknown, a one-sample estimate is not
+*    a good prediction — it is simply a far better one than assuming zero.
+*
+* Overshoot is self-correcting: the retarget below serves the newest target
+* the landed fragment covers, so a lead that is slightly long lands on the
+* finger exactly, and one that is wrong costs the same single read it would
+* have cost anyway.
+*/
 var SEGMENT_TIMEOUT_MS = 8e3;
 /**
 * Deadline for the recorded-AUDIO demux on the `reusedWhole` seek path, and
@@ -24027,30 +24136,6 @@ var SEEK_ANIMATION_MIN_DISTANCE_MS = 8e3;
 */
 var SCRUB_JUMP_TRAVEL_MAX_STILLS = 3;
 /**
-* Consecutive same-direction `scrubTo` deltas required before a direction-aware
-* prefetch commits its (single) background slot. Two deltas ⇒ the drag shows a
-* sustained direction, so a jittery/reversing drag never wastes the slot.
-*/
-var SCRUB_PREFETCH_DIR_THRESHOLD = 2;
-/**
-* How many speculative GOP reads may be in flight at once, i.e. how many drag
-* steps ahead the feeder reads.
-*
-* The scrub tick IS the read: measured on salone 590 over `low`,
-* `tickMsP50 = 270` of which `readMsP50 = 263` — a cold ~135 KB fragment off
-* the HDD array through shfs/FUSE, `demuxMsP50 = 1`. One read at a time is a
-* hard ~3.8 push/s ceiling no cache can lift, because a drag whose steps are
-* tens of seconds apart revisits nothing. Reading N steps ahead is the only
-* thing that converts wall-clock the drag is ALREADY spending into pushes.
-*
-* 2 and not more: these reads land on the same spindles the recorder is writing
-* every camera to, and past a small number concurrent random reads stop
-* overlapping and start thrashing. Raise it only against a measured
-* `prefetchHits` / `readMsP50` pair — it is the knob, and the census carries
-* both halves of the evidence.
-*/
-var SCRUB_PREFETCH_MAX_INFLIGHT = 2;
-/**
 * The profile whose scrub read unit is the WHOLE SEGMENT.
 *
 * Every drag is pinned to `low` by the client, and a `low` segment is ~230 KB
@@ -24068,14 +24153,48 @@ var SCRUB_PREFETCH_MAX_INFLIGHT = 2;
 */
 var SCRUB_WHOLE_SEGMENT_PROFILE = "low";
 /**
-* Safety ceiling on the whole-segment read. `low` is ~230 KB per 10 s, so this
-* is ~6× headroom for a camera whose substream is unusually fat — but a
-* segment past it (a mis-pinned `high` at ~5 MB) falls back to the GOP range,
-* because reading 5 MB to push one keyframe is the trade this change exists to
-* avoid, in the other direction.
+* Safety ceiling on ONE scrub read, in bytes.
+*
+* `low` is ~230 KB per 10 s, so this is ~6× headroom for a camera whose
+* substream is unusually fat — but a segment past it (a mis-pinned `high` at
+* ~5 MB) falls back to the GOP range, because reading 5 MB to push one
+* keyframe is the trade this change exists to avoid, in the other direction.
+*
+* ⚠️ THIS NUMBER IS TIED TO THE SEGMENT DURATION AND THE TIE IS NOT ENFORCED.
+* It was tuned against a 10-second `low` segment. At the 60-second segments
+* the 2026-08-25 teardown proposes, a NATIVE `low` is ~1.4 MB (just inside,
+* and the whole-segment read gets six times better — one seek leaves a minute
+* of access units behind) while a DERIVED `low` is ~4.8 MB (outside, and every
+* scrub read silently degrades to a 3-seek GOP range that leaves nothing
+* behind). Same constant, opposite outcomes, no signal either way — which is
+* why the degradation is now COUNTED and LOGGED
+* (`scrub-feeder:oversize-segment`, `oversizeSegments` on the drag census)
+* instead of being inferred from a falling hit rate.
+*
+* The real fix, for when 60 s segments land, is a read unit that is a BYTE
+* BUDGET over the fragment's own keyframe table — "as many consecutive GOPs
+* as fit in N bytes" — computed from `tfra` offsets alone, no payload read
+* (`fragmentsWithinBudget`, `recorder/mfra-index.ts`). `readGopBytes` now uses
+* exactly this budget on the fallback path below: it no longer reads exactly
+* one GOP, it reads as many CONSECUTIVE fragments as fit this same ceiling, in
+* one range read (`gop-range-read.ts`'s `maxBytes`). The recorder-side handler
+* (`recording-provider.ts`) declares its OWN copy of this number
+* (`SCRUB_GOP_BUDGET_MAX_BYTES` in `gop-range-read.ts`) rather than importing
+* this module — the client feeder is a different addon-internal concern, and
+* pulling its whole dependency graph in for one number is the wrong
+* direction. Exported here so a future caller in THIS process can reuse it;
+* if D163's number moves, move both.
 */
 var SCRUB_WHOLE_SEGMENT_MAX_BYTES = 15e5;
 /**
+* How still the finger must be before the window warm may take the disk back.
+*
+* Long enough that it does not thrash on the gap between two ticks of a slow
+* drag (tickMsP50 was 120-129 ms on the measured drags), short enough that a
+* pause the operator would call "stopped" is warm again before they move.
+*/
+var SCRUB_WARM_QUIET_MS = 300;
+/**
 * How far the entry warm-up reaches, backward and forward from the playhead the
 * drag starts on.
 *
@@ -24110,17 +24229,6 @@ var SCRUB_WARM_MAX_SEGMENTS = Math.max(1, Math.floor(SCRUB_FRAGMENT_CACHE_MAX_BY
 */
 var IDLE_WARM_READ_GAP_MS = 250;
 /**
-* Median recent read time at or above which the feeder STOPS speculating.
-*
-* Speculation is a bet that spare I/O exists. When reads are this slow there is
-* no spare I/O — the array is saturated — and a prefetch is not free work, it
-* is another random seek queued ahead of the read the operator is waiting on.
-* The field regime that forced this: 54 prefetch reads for 9 hits with the disk
-* at 98% busy. Suppression is counted (`prefetchSuppressed`) so the decision is
-* visible, and it lifts by itself as soon as reads come back.
-*/
-var SCRUB_SLOW_READ_MS = 600;
-/**
 * Max forward TARGET delta (ms of timeline, between consecutive drag targets)
 * that SWEEPS predicted frames instead of jumping. A steady forward drag is
 * playback with a moving target: once a keyframe decoded, the predicted frames
@@ -24133,6 +24241,84 @@ var SCRUB_SLOW_READ_MS = 600;
 */
 var SCRUB_SWEEP_WINDOW_MS = 4e3;
 /**
+* THE DEADLINE ON ONE SCRUB FRAME — and the reason it is not
+* {@link SEGMENT_TIMEOUT_MS}.
+*
+* A scrub tick used to be bounded only by the 8 s per-RPC timeout, against a
+* cold read measured at p50 531 ms, p95 1.4–2 s and a 9.2 s max (census
+* 2026-08-25). So the feeder WAITED. The frame it eventually pushed was for a
+* finger position from seconds earlier, and the gesture spent its whole
+* duration on a handful of stale frames — the operator's "quasi 0 frame, e
+* l'immagine insegue il dito".
+*
+* The reference design (Scrypted NVR, teardown 2026-08-25) spends at most
+* ~1000 ms on the WHOLE scrub animation and gives every single frame the
+* REMAINING window as its deadline: a frame that cannot be produced in time is
+* dropped, never awaited. This is the same contract on our constraints.
+*
+* 700 ms and not 1000: the deadline must be shorter than the gesture's own
+* animation window or it can never fire twice inside one, and it must be above
+* the cold-read p50 (531 ms) or the median frame would be dropped — a deadline
+* that drops the median makes the picture WORSE, not fresher. 700 ms sits
+* between: it serves the p50–p60 of cold reads and cuts the p90 tail that used
+* to eat the gesture.
+*
+* Dropping is never silent: `deadlineMisses` on the drag aggregate plus one
+* `scrub-feeder:deadline-miss` line per drag.
+*/
+var SCRUB_TICK_DEADLINE_MS = 700;
+/**
+* The FIRST frame of a drag gets a longer deadline, because nothing is painted
+* yet.
+*
+* Every later frame has a predecessor on screen, so dropping it costs
+* freshness. The first one has none: dropping it costs the whole picture, and
+* the operator reads a blank recorded view as "playback parte dopo una vita".
+* The reference design has the same asymmetry for the same reason — its
+* animation frames are deadline-dropped while the LANDING seek is unbounded.
+*
+* 2500 ms covers the cold-read p95 (1.4–2 s) and still cuts the 9.2 s tail.
+*/
+var SCRUB_FIRST_TICK_DEADLINE_MS = 2500;
+/**
+* How far a new target may be from an in-flight read's target and still RIDE
+* it instead of starting a second one.
+*
+* A `low` segment is ~10 s of timeline and the read unit is the whole segment
+* ({@link SCRUB_WHOLE_SEGMENT_PROFILE}), so a target within one segment of the
+* one being read is very likely already inside the bytes on their way. Riding
+* costs nothing and saves a random seek on the spindle that is the bottleneck;
+* being wrong costs one wasted deadline, which is now cheap by construction.
+*/
+var SCRUB_RIDE_WINDOW_MS = 1e4;
+/**
+* Hard bound on concurrent fragment resolutions for one drag.
+*
+* A deadline that drops frames is only safe if dropping does not multiply the
+* work: without this bound a drag over slow footage would abandon a read every
+* {@link SCRUB_TICK_DEADLINE_MS} and start another, turning one saturated
+* spindle into N. Two: the one that is landing, and the one the finger has
+* moved on to. At the cap, a tick rides the newest in-flight read instead.
+*/
+var SCRUB_RESOLVE_MAX_INFLIGHT = 2;
+var SCRUB_LEAD_MIN_READ_SAMPLES = 1;
+/**
+* Smoothing for the media-velocity estimate (ms of timeline per ms of wall
+* clock), folded on every pointer sample. Half-and-half: fast enough to track
+* a fling that starts mid-gesture, slow enough that one jittery sample cannot
+* aim a read an hour away.
+*/
+var SCRUB_VELOCITY_EMA = .5;
+/** Same-direction POINTER samples required before a read may aim ahead. */
+var SCRUB_LEAD_MIN_DIR_RUN = 2;
+/**
+* Pointer-sample gaps outside this range do not update the velocity estimate:
+* below it the delta is dominated by timer jitter, above it the finger has
+* effectively paused and the "velocity" is an artefact of the pause.
+*/
+var SCRUB_VELOCITY_MIN_GAP_MS = 10;
+var SCRUB_VELOCITY_MAX_GAP_MS = 500;
+/**
 * Receiver-credit cap for scrub pushes: at most this many PUSHES may be
 * OUTSTANDING (on the track, not yet acknowledged by the viewer via
 * `scrubAck`). The coalescing window above shapes the INPUT; on a thin pipe it
@@ -24347,25 +24533,6 @@ var RecordedFeeder = class {
 	scrubLastPushLogAtMs = 0;
 	scrubLastSlowLocateLogAtMs = 0;
 	/**
-	* Signed run-length of consecutive same-direction `scrubTo` deltas (+ forward,
-	* − backward). A prefetch commits only once `|run| ≥ SCRUB_PREFETCH_DIR_THRESHOLD`;
-	* a reversal or an in-fragment no-move resets it.
-	*/
-	scrubDirRun = 0;
-	/**
-	* Prefetch reads in flight. Bounded by {@link SCRUB_PREFETCH_MAX_INFLIGHT}:
-	* these are the SPECULATIVE concurrency slots, and they only fill
-	* `scrubCache` — they never push, never touch the pending/timer/latest-wins
-	* state, and never block the live coalesced tick.
-	*
-	* More than one because the read IS the tick (263 of 270 ms measured): with a
-	* single slot the drag can never go faster than one cold read, however well
-	* the speculation guesses.
-	*/
-	scrubPrefetchInFlight = 0;
-	/** Probe instants currently being read, so two horizons never duplicate one. */
-	scrubPrefetchProbes = /* @__PURE__ */ new Set();
-	/**
 	* Fragment starts this drag put in the cache SPECULATIVELY. A later tick that
 	* hits one of them is what makes speculation provably worth its I/O
 	* (`prefetchHits`) — without this the feeder could double the load on the disk
@@ -24389,10 +24556,44 @@ var RecordedFeeder = class {
 	scrubWarmGen = 0;
 	/** Tick demand-read in flight: the fill waits so the finger wins the spindle. */
 	scrubTickReadInFlight = false;
+	/**
+	* The newest fragment resolution in flight for this drag — what a later tick
+	* rides instead of issuing its own read. Cleared by the resolution itself.
+	*/
+	scrubResolve = null;
+	/** Concurrent resolutions, bounded by {@link SCRUB_RESOLVE_MAX_INFLIGHT}. */
+	scrubResolvesInFlight = 0;
+	/** One `deadline-miss` line per drag; the count lives on the aggregate. */
+	scrubDeadlineLogged = false;
+	/** One `oversize-segment` line per drag; the count lives on the aggregate. */
+	scrubOversizeLogged = false;
+	/** One `profile-degraded` line per drag — the `low` pin is lost. */
+	scrubProfileLogged = false;
+	/** Has this drag put a frame on the wire? Gates the first-frame deadline. */
+	scrubPushedThisDrag = false;
+	/** Smoothed media-ms per wall-ms of the drag, signed. Null until measurable. */
+	scrubVelocity = null;
+	/** Previous pointer sample, for the velocity estimate above. */
+	scrubLastSampleMs = null;
+	scrubLastSampleAtMs = 0;
+	/** Signed run of consecutive same-direction POINTER samples. */
+	scrubVelRun = 0;
 	/** 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;
+	/**
+	* The client-supplied id of the CURRENT (or most recently active) scrub
+	* gesture, set by `beginScrub(dragId)`. Printed on every `scrub-feeder:*`
+	* line — ticks, warm fill, park/deadline/ack pathologies, and the drag-end
+	* aggregate — so a drag can be isolated in the logs without depending on
+	* wall-clock proximity. `undefined` outside a drag (and for a feeder whose
+	* caller never sends one — additive, optional, see D1 in the plan).
+	*/
+	scrubDragId;
+	/** This feeder's own last-announced state — the `from` half of every
+	*  {@link FeederStateTransition}. `null` before the first transition. */
+	lastAnnouncedState = null;
 	constructor(deps) {
 		this.deps = deps;
 		this.audioClock = new MonotonicClock(deps.audioClockRateHz ?? 8e3);
@@ -24410,6 +24611,50 @@ var RecordedFeeder = class {
 		if (typeof pcmu === "function") return (data, rtpTs) => pcmu.call(sink, data, rtpTs);
 	}
 	/**
+	* Emit one state transition through `onState` — see
+	* {@link FeederStateTransition} for why `from`/`reason`/`seekToken` exist.
+	* The ONLY place `this.lastAnnouncedState` is written, so every announced
+	* state (wherever it is announced from) is captured as the next
+	* transition's `from`.
+	*/
+	emitState(to, reason, seekToken, dragId) {
+		const from = this.lastAnnouncedState;
+		this.lastAnnouncedState = to;
+		this.deps.onState({
+			from,
+			to,
+			reason,
+			seekToken,
+			dragId
+		});
+	}
+	/**
+	* ONE line per `seek()` call, unconditionally — the C3 rendiconto. Before
+	* this, a commit's outcome was told by WHICHEVER of several lines happened
+	* to fire: `recorded:seek-ready` only on success, `recorded:seek-abandoned`
+	* only when a later token/dispose superseded this one, `recorded:seek-no-footage`
+	* / `recorded:snap-too-far` only on a gap — and a raw thrown error (or an
+	* error on an ALREADY-abandoned commit) logged NOTHING at all. That silent
+	* shape is exactly the 2026-08-26 stall: two commits reached
+	* `playback:intent` and never `playback:ready`, with nothing in the feeder's
+	* own logs saying why. Every return path in `seek()` now calls this before
+	* it exits, so a commit that never lands still leaves one line naming what
+	* happened to it.
+	*/
+	logSeekOutcome(token, seekStartedAt, epochMs, dragId, outcome, state) {
+		this.deps.onLog?.("recorded:seek-outcome", {
+			dragId,
+			epochMs,
+			outcome,
+			state,
+			disposed: this.disposed,
+			superseded: token !== this.seekToken,
+			tokenAtStart: token,
+			tokenNow: this.seekToken,
+			totalMs: Math.round(performance.now() - seekStartedAt)
+		});
+	}
+	/**
 	* Seek to an epoch and (if rate > 0) begin forward playback. Resolves after
 	* the FIRST located segment is fed; the forward `advance` loop is started
 	* fire-and-forget so seek never blocks on its pacing. Latest-wins: a newer
@@ -24422,6 +24667,7 @@ var RecordedFeeder = class {
 		let loadMs = 0;
 		let firstFrameMs = 0;
 		const token = ++this.seekToken;
+		const dragId = opts?.dragId;
 		const wasScrubbing = this.scrubbing;
 		if (this.scrubbing) {
 			this.emitDragEnd();
@@ -24433,7 +24679,6 @@ var RecordedFeeder = class {
 			this.clearScrubAckTimeout();
 			this.scrubPendingHint = null;
 			this.scrubPrevTarget = null;
-			this.scrubDirRun = 0;
 			if (this.scrubTimer) {
 				clearTimeout(this.scrubTimer);
 				this.scrubTimer = null;
@@ -24443,7 +24688,7 @@ var RecordedFeeder = class {
 		this.inFlightSeekEpochMs = epochMs;
 		let snapInfo = null;
 		try {
-			this.deps.onState("loading");
+			this.emitState("loading", "seek-start", token, dragId);
 			if (this.clockHasAdvanced) {
 				this.clock.markDiscontinuity(SEEK_DISCONTINUITY_MS);
 				this.audioClock.markDiscontinuity(SEEK_DISCONTINUITY_MS);
@@ -24455,21 +24700,29 @@ var RecordedFeeder = class {
 				epochMs
 			}));
 			locateMs += performance.now() - locateStartedAt;
-			if (this.disposed || token !== this.seekToken) return;
+			if (this.disposed || token !== this.seekToken) {
+				this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "abandoned", null);
+				return;
+			}
 			let landMs = epochMs;
 			if (loc.kind === "gap") {
 				const decision = resolveSnapTarget(loc, epochMs);
 				if (decision.kind !== "snap") {
 					if (decision.kind === "too-far") this.deps.onLog?.("recorded:snap-too-far", {
+						dragId,
 						requestedMs: epochMs,
 						nearestMs: decision.snapMs,
 						distanceMs: decision.distanceMs
 					});
-					else this.deps.onLog?.("recorded:seek-no-footage", { requestedMs: epochMs });
+					else this.deps.onLog?.("recorded:seek-no-footage", {
+						dragId,
+						requestedMs: epochMs
+					});
 					this.currentSegment = null;
 					this.lastFedVideoIdx = -1;
 					this.stopPositionReports();
-					this.deps.onState("gap");
+					this.emitState("gap", decision.kind === "too-far" ? "seek-snap-too-far" : "seek-no-footage", token, dragId);
+					this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "gap", "gap");
 					return;
 				}
 				const snapLocateStartedAt = performance.now();
@@ -24479,19 +24732,25 @@ var RecordedFeeder = class {
 					epochMs: decision.snapMs
 				}));
 				locateMs += performance.now() - snapLocateStartedAt;
-				if (this.disposed || token !== this.seekToken) return;
+				if (this.disposed || token !== this.seekToken) {
+					this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "abandoned", null);
+					return;
+				}
 				if (snapped.kind !== "segment") {
 					this.deps.onLog?.("recorded:seek-no-footage", {
+						dragId,
 						requestedMs: epochMs,
 						snappedMs: decision.snapMs
 					});
 					this.currentSegment = null;
 					this.lastFedVideoIdx = -1;
 					this.stopPositionReports();
-					this.deps.onState("gap");
+					this.emitState("gap", "seek-snap-target-no-footage", token, dragId);
+					this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "gap", "gap");
 					return;
 				}
 				this.deps.onLog?.("recorded:seek-snapped", {
+					dragId,
 					requestedMs: epochMs,
 					snappedMs: decision.snapMs
 				});
@@ -24505,9 +24764,12 @@ var RecordedFeeder = class {
 			const travelFromMs = opts?.travelFromMs ?? (this.clockHasAdvanced ? this.cursorMs : null);
 			if (!wasScrubbing && travelFromMs !== null) {
 				const travelStartedAt = performance.now();
-				await this.animateSeekTravel(travelFromMs, landMs, token);
+				await this.animateSeekTravel(travelFromMs, landMs, token, dragId);
 				travelMs = performance.now() - travelStartedAt;
-				if (this.disposed || token !== this.seekToken) return;
+				if (this.disposed || token !== this.seekToken) {
+					this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "abandoned", null);
+					return;
+				}
 			}
 			this.cursorMs = loc.startMs;
 			const loadStartedAt = performance.now();
@@ -24524,7 +24786,10 @@ var RecordedFeeder = class {
 					prefixSource = "cache";
 				} else {
 					const fragmentLoad = await this.loadScrubFragment(loc, landMs);
-					if (fragmentLoad === null) return;
+					if (fragmentLoad === null) {
+						this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "abandoned", null);
+						return;
+					}
 					fragment = fragmentLoad.seg;
 					this.scrubCache.put(this.deps.profile, fragment);
 					prefixSource = fragmentLoad.wholeSegmentRead ? "whole" : "gop";
@@ -24533,7 +24798,10 @@ var RecordedFeeder = class {
 						bytes: fragmentLoad.rawBytes
 					};
 				}
-				if (this.disposed || token !== this.seekToken) return;
+				if (this.disposed || token !== this.seekToken) {
+					this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "abandoned", null);
+					return;
+				}
 				const fragmentLoc = {
 					kind: "segment",
 					startMs: fragment.startMs,
@@ -24544,7 +24812,7 @@ var RecordedFeeder = class {
 				prefixFed = true;
 				gopFirst = true;
 				firstFrameMs = performance.now() - seekStartedAt;
-				this.deps.onState(this.rate === 0 ? "paused" : "playing");
+				this.emitState(this.rate === 0 ? "paused" : "playing", "seek-gop-prefix-landed", token, dragId);
 				this.deps.onPosition(this.cursorMs);
 				this.startPositionReports();
 				stateAnnounced = true;
@@ -24559,6 +24827,7 @@ var RecordedFeeder = class {
 						audio = [...await this.withTimeout(this.deps.demuxAudio(reusedWhole.bytes), AUDIO_DEMUX_TIMEOUT_MS)];
 					} catch (err) {
 						this.deps.onLog?.("recorded:seek-audio-dropped", {
+							dragId,
 							waitedMs: Date.now() - audioStartedAt,
 							budgetMs: AUDIO_DEMUX_TIMEOUT_MS,
 							bytes: reusedWhole.bytes.byteLength,
@@ -24586,7 +24855,21 @@ var RecordedFeeder = class {
 				loadAusMs = performance.now() - loadAusStartedAt;
 			}
 			loadMs = performance.now() - loadStartedAt;
-			if (this.disposed || token !== this.seekToken || loaded === null) return;
+			if (this.disposed || token !== this.seekToken || loaded === null) {
+				this.deps.onLog?.("recorded:seek-abandoned", {
+					dragId,
+					requestedMs: epochMs,
+					disposed: this.disposed,
+					superseded: token !== this.seekToken,
+					tokenAtStart: token,
+					tokenNow: this.seekToken,
+					loadedNull: loaded === null,
+					announcedLoading: true,
+					loadMs: Math.round(loadMs)
+				});
+				this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "abandoned", null);
+				return;
+			}
 			if (!prefixFed) this.feedPrefix(loc, loaded.video, landMs);
 			if (gopFirst) {
 				this.currentSegment = {
@@ -24608,11 +24891,12 @@ var RecordedFeeder = class {
 			}
 			if (this.rate === 0) {
 				if (!stateAnnounced) {
-					this.deps.onState("paused");
+					this.emitState("paused", "seek-landed-paused", token, dragId);
 					this.deps.onPosition(this.cursorMs);
 					this.startPositionReports();
 				}
 				this.logSeekReady({
+					dragId,
 					epochMs,
 					startedAt: seekStartedAt,
 					locateMs,
@@ -24628,14 +24912,16 @@ var RecordedFeeder = class {
 					loadAusMs: Math.round(loadAusMs)
 				});
 				this.startIdleWarm(this.cursorMs);
+				this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "served", "paused");
 				return;
 			}
 			if (!stateAnnounced) {
-				this.deps.onState("playing");
+				this.emitState("playing", "seek-landed-playing", token, dragId);
 				this.deps.onPosition(this.cursorMs);
 				this.startPositionReports();
 			}
 			this.logSeekReady({
+				dragId,
 				epochMs,
 				startedAt: seekStartedAt,
 				locateMs,
@@ -24665,22 +24951,26 @@ var RecordedFeeder = class {
 				resumeAfterPtsMs
 			});
 			this.startIdleWarm(this.cursorMs);
+			this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "served", "playing");
 		} catch (err) {
 			if (!this.disposed && token === this.seekToken) {
 				this.stopPositionReports();
 				if (snapInfo !== null) {
 					this.deps.onLog?.("recorded:seek-snap-load-failed", {
+						dragId,
 						requestedMs: snapInfo.requestedMs,
 						snappedMs: snapInfo.snappedMs,
 						error: require_dist.errMsg(err)
 					});
 					this.currentSegment = null;
 					this.lastFedVideoIdx = -1;
-					this.deps.onState("gap");
+					this.emitState("gap", "seek-snap-load-failed", token, dragId);
+					this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "gap", "gap");
 					return;
 				}
-				this.deps.onState("error");
-			}
+				this.emitState("error", "seek-error", token, dragId);
+				this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "error", "error");
+			} else this.logSeekOutcome(token, seekStartedAt, epochMs, dragId, "abandoned", null);
 		} finally {
 			if (token === this.seekToken) {
 				this.inFlightSeekEpochMs = null;
@@ -24690,6 +24980,7 @@ var RecordedFeeder = class {
 	}
 	logSeekReady(fields) {
 		this.deps.onLog?.("recorded:seek-ready", {
+			dragId: fields.dragId,
 			epochMs: fields.epochMs,
 			state: fields.state,
 			totalMs: Math.round(performance.now() - fields.startedAt),
@@ -24724,7 +25015,7 @@ var RecordedFeeder = class {
 		if (next === 0) {
 			this.advanceToken++;
 			this.stopPositionReports();
-			this.deps.onState("paused");
+			this.emitState("paused", "rate-zero", this.seekToken, this.scrubDragId);
 			return;
 		}
 		this.pendingStepDirs.length = 0;
@@ -24746,9 +25037,16 @@ var RecordedFeeder = class {
 	* (which flips `scrubbing` false and clears the session cache) or `dispose()`;
 	* a genuinely NEW drag is therefore always preceded by that exit, so its
 	* `beginScrub` runs the full reset below. (D-scrub-ux)
+	*
+	* `dragId` is the client's id for this gesture (optional — the viewer's main
+	* session generates it; a caller that omits it gets identical behaviour,
+	* just no id on the logs). Stored for the whole drag, including its commit:
+	* every `scrub-feeder:*` line printed until the next `beginScrub` carries it
+	* (C1).
 	*/
-	beginScrub() {
+	beginScrub(dragId) {
 		if (this.disposed || this.scrubbing) return;
+		this.scrubDragId = dragId;
 		this.seekToken++;
 		this.advanceToken++;
 		this.scrubbing = true;
@@ -24757,17 +25055,25 @@ var RecordedFeeder = class {
 		this.scrubSegment = null;
 		this.scrubCredit = SCRUB_CREDIT_CAP;
 		this.scrubPrevTarget = null;
-		this.scrubDirRun = 0;
 		this.scrubPrefetched = /* @__PURE__ */ new Set();
 		this.scrubCursor = null;
 		this.scrubNoFootageLogged = false;
 		this.scrubParkLogged = false;
+		this.scrubDeadlineLogged = false;
+		this.scrubOversizeLogged = false;
+		this.scrubProfileLogged = false;
+		this.scrubPushedThisDrag = false;
+		this.scrubResolve = null;
+		this.scrubVelocity = null;
+		this.scrubLastSampleMs = null;
+		this.scrubVelRun = 0;
 		this.scrubOutstanding = [];
 		this.clearScrubAckTimeout();
 		this.scrubAckTimeoutLogged = false;
 		this.scrubPendingHint = null;
 		this.scrubStartedAtMs = performance.now();
 		this.scrubStats = new ScrubDragStats(this.scrubStartedAtMs);
+		this.reportProfileDegradation();
 		this.scrubDemuxMark = this.deps.demuxTally?.counts() ?? null;
 		this.scrubLastPushLogAtMs = 0;
 		this.scrubLastSlowLocateLogAtMs = 0;
@@ -24831,6 +25137,7 @@ var RecordedFeeder = class {
 		this.scrubWarmBackMs = opts?.backMs ?? SCRUB_WARM_BACK_MS;
 		this.scrubWarmFwdMs = opts?.fwdMs ?? SCRUB_WARM_FWD_MS;
 		this.deps.onLog?.("scrub-feeder:warm-start", {
+			dragId: this.scrubDragId,
 			centreMs,
 			fillGen: this.scrubWarmGen
 		});
@@ -24856,6 +25163,7 @@ var RecordedFeeder = class {
 				lastWorked = gen;
 				if (gen === this.scrubWarmGen) {
 					this.deps.onLog?.("scrub-feeder:warm-done", {
+						dragId: this.scrubDragId,
 						fillGen: gen,
 						idle: this.idleWarm && !this.scrubbing,
 						fetched,
@@ -24892,6 +25200,19 @@ var RecordedFeeder = class {
 		if (Math.abs(targetMs - centre) <= SCRUB_RECENTER_MS) return;
 		this.recenterScrubWarm(targetMs);
 	}
+	/**
+	* Is the operator's finger actually moving right now?
+	*
+	* `scrubbing` alone is not the question — a drag stays open while the finger
+	* rests, and those pauses are exactly when the warm should work. The signal
+	* is the pointer sample clock, which `noteScrubSample` stamps on every
+	* `scrubTo` before any velocity gating, so it is true even for a drag too
+	* slow or too jittery for the velocity estimator.
+	*/
+	fingerIsMoving() {
+		if (!this.scrubbing) return false;
+		return performance.now() - this.scrubLastSampleAtMs < SCRUB_WARM_QUIET_MS;
+	}
 	async warmScrubWindow(centreMs, dragGen, fillGen, backMs, fwdMs) {
 		const spent = await this.warmScrubDirection(centreMs, -1, backMs, 0, dragGen, fillGen);
 		return this.warmScrubDirection(centreMs, 1, fwdMs, spent, dragGen, fillGen);
@@ -24931,6 +25252,10 @@ var RecordedFeeder = class {
 				durMs: warm.durMs,
 				fetched: false
 			};
+			while (this.fingerIsMoving()) {
+				if (!this.warmLoopAlive(dragGen) || fillGen !== this.scrubWarmGen) return null;
+				await new Promise((r) => setTimeout(r, SCRUB_WARM_QUIET_MS));
+			}
 			if (this.idleWarm && !this.scrubbing) {
 				await new Promise((r) => setTimeout(r, this.deps.idleWarmGapMs ?? IDLE_WARM_READ_GAP_MS));
 				while (this.inFlightSeekEpochMs !== null) {
@@ -24950,7 +25275,7 @@ var RecordedFeeder = class {
 			if (loc.kind !== "segment") return null;
 			if (!await this.waitForTickReadIdle(fillGen)) return null;
 			const load = await this.loadScrubFragment(loc, probeMs);
-			if (load !== null && this.scrubbing) this.scrubStats?.recordPrefetchRead(load.readBytes);
+			if (load !== null && this.scrubbing) this.scrubStats?.recordWarmRead(load.readBytes);
 			if (!this.warmLoopAlive(dragGen) || load === null) return null;
 			if (fillGen !== this.scrubWarmGen) return null;
 			this.scrubCache.put(this.deps.profile, load.seg);
@@ -24982,6 +25307,7 @@ var RecordedFeeder = class {
 	*/
 	scrubTo(epochMs, hint) {
 		if (this.disposed || !this.scrubbing) return;
+		this.noteScrubSample(epochMs);
 		this.scrubPendingEpochMs = epochMs;
 		this.scrubPendingHint = hint ?? null;
 		if (this.scrubTimer === null) this.scrubTimer = setTimeout(() => void this.scrubTick(), 0);
@@ -25069,6 +25395,7 @@ var RecordedFeeder = class {
 			if (!this.scrubAckTimeoutLogged) {
 				this.scrubAckTimeoutLogged = true;
 				this.deps.onLog?.("scrub-feeder:ack-timeout", {
+					dragId: this.scrubDragId,
 					pushes: expired,
 					frames,
 					timeoutMs: SCRUB_ACK_TIMEOUT_MS,
@@ -25100,6 +25427,7 @@ var RecordedFeeder = class {
 			if (!this.scrubParkLogged) {
 				this.scrubParkLogged = true;
 				this.deps.onLog?.("scrub-feeder:parked", {
+					dragId: this.scrubDragId,
 					pendingEpochMs: this.scrubPendingEpochMs,
 					outstanding: this.scrubOutstanding.length
 				});
@@ -25107,7 +25435,7 @@ var RecordedFeeder = class {
 			return;
 		}
 		const target = this.scrubPendingEpochMs;
-		const hint = this.scrubPendingHint;
+		let hint = this.scrubPendingHint;
 		this.scrubPendingEpochMs = null;
 		this.scrubPendingHint = null;
 		if (target === null) {
@@ -25132,74 +25460,62 @@ var RecordedFeeder = class {
 				seg = this.scrubCache.covering(this.deps.profile, target);
 				if (seg) {
 					coverage = "cache";
-					if (this.scrubPrefetched.has(seg.startMs)) this.scrubStats?.recordPrefetchHit();
+					if (this.scrubPrefetched.has(seg.startMs)) this.scrubStats?.recordWarmHit();
 				}
 			}
 			if (!seg) {
-				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: 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({
-							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
+				const cfg = this.deps.scrubDeadline;
+				const rideWindowMs = cfg?.rideWindowMs ?? SCRUB_RIDE_WINDOW_MS;
+				const inFlight = this.scrubResolve;
+				let entry;
+				if (inFlight !== null && (Math.abs(target - inFlight.target) <= rideWindowMs || this.scrubResolvesInFlight >= SCRUB_RESOLVE_MAX_INFLIGHT)) {
+					entry = inFlight;
+					this.scrubStats?.recordResolveJoin();
+				} else {
+					const leadMs = this.scrubLeadMs();
+					if (leadMs !== 0) this.scrubStats?.recordLead(leadMs);
+					const readTarget = target + leadMs;
+					entry = {
+						target: readTarget,
+						promise: this.startScrubResolve(readTarget, gen)
+					};
+					this.scrubResolve = entry;
+				}
+				const deadlineMs = this.scrubPushedThisDrag ? cfg?.tickMs ?? SCRUB_TICK_DEADLINE_MS : cfg?.firstTickMs ?? SCRUB_FIRST_TICK_DEADLINE_MS;
+				const res = await this.raceDeadline(entry.promise, performance.now() + deadlineMs);
+				if (this.disposed || !this.scrubbing || gen !== this.scrubToken) return;
+				if (res === "deadline") {
+					this.scrubStats?.recordDeadlineMiss();
+					if (this.scrubPendingEpochMs === null) this.scrubPendingEpochMs = target;
+					if (!this.scrubDeadlineLogged) {
+						this.scrubDeadlineLogged = true;
+						this.deps.onLog?.("scrub-feeder:deadline-miss", {
+							dragId: this.scrubDragId,
+							epochMs: target,
+							deadlineMs,
+							first: !this.scrubPushedThisDrag,
+							inFlight: this.scrubResolvesInFlight
 						});
-						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);
 					}
-				} finally {
-					this.scrubTickReadInFlight = false;
+					return;
 				}
+				if (res === null) return;
+				seg = res.seg;
+				const newest = this.scrubPendingEpochMs;
+				if (res.effTarget !== res.requested) effTarget = res.effTarget;
+				else if (newest !== null && fragmentCovers(seg, newest)) {
+					effTarget = newest;
+					hint = this.scrubPendingHint;
+					this.scrubPendingEpochMs = null;
+					this.scrubPendingHint = null;
+				} else effTarget = newest ?? target;
+				if (effTarget !== res.effTarget) this.scrubStats?.recordRetarget();
+				locateCalls = res.locateCalls;
+				locateMs = res.locateMs;
+				readMs = res.readMs;
+				readBytes = res.readBytes;
+				demuxMs = res.demuxMs;
+				wholeSegmentRead = res.wholeSegmentRead;
 			}
 			this.scrubSegment = seg;
 			const prevTarget = this.scrubPrevTarget;
@@ -25266,6 +25582,7 @@ var RecordedFeeder = class {
 				pushedAtMs
 			}];
 			this.scrubCredit -= 1;
+			this.scrubPushedThisDrag = true;
 			this.armScrubAckTimeout();
 			this.clockHasAdvanced = true;
 			let runBytes = 0;
@@ -25297,6 +25614,7 @@ var RecordedFeeder = class {
 			if (this.scrubLastPushLogAtMs === 0 || pushedAtMs - this.scrubLastPushLogAtMs >= 1e3) {
 				this.scrubLastPushLogAtMs = pushedAtMs;
 				this.deps.onLog?.("scrub-feeder:pushed", {
+					dragId: this.scrubDragId,
 					epochMs: effTarget,
 					mode,
 					dir,
@@ -25314,10 +25632,11 @@ var RecordedFeeder = class {
 				});
 			}
 			this.deps.onPosition(this.clampIntoSegment(seg, effTarget), pushSeq);
-			this.maybeScrubPrefetch(seg, effTarget, gen);
+			this.scrubPrevTarget = effTarget;
 		} catch (err) {
 			this.scrubStats?.recordFailure();
 			this.deps.onLog?.("scrub-feeder:tick-failed", {
+				dragId: this.scrubDragId,
 				epochMs: target,
 				error: err instanceof Error ? err.message : String(err)
 			});
@@ -25327,6 +25646,115 @@ var RecordedFeeder = class {
 		}
 	}
 	/**
+	* ONE fragment resolution for the drag: locate (with gap snapping), read,
+	* demux, cache. Deliberately NOT bound to the tick that started it.
+	*
+	* The tick races this with the frame's deadline and may walk away; this
+	* promise then finishes on its own and puts the fragment in the session
+	* cache, because the read is already on the wire and abandoning its RESULT
+	* as well would turn a dropped frame into wasted disk. That is what makes
+	* the deadline cheap: the tick after a miss is usually a cache hit.
+	*
+	* Null ⇒ nothing to serve (dead zone, superseded generation, or a load the
+	* seek token invalidated). Throws propagate to the tick's `tick-failed`.
+	*/
+	async startScrubResolve(target, gen) {
+		this.scrubResolvesInFlight += 1;
+		this.scrubTickReadInFlight = true;
+		let locateCalls = 0;
+		let locateMs = null;
+		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: target
+			}));
+			locateCalls += 1;
+			locateMs = performance.now() - locateStartMs;
+			this.maybeLogSlowLocate(target, locateMs);
+			if (this.disposed || gen !== this.scrubToken) return null;
+			let effTarget = 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", {
+							dragId: this.scrubDragId,
+							epochMs: target,
+							nearestMs: decision.snapMs,
+							distanceMs: decision.distanceMs
+						});
+						else this.deps.onLog?.("scrub-feeder:no-footage", {
+							dragId: this.scrubDragId,
+							epochMs: target
+						});
+					}
+					return null;
+				}
+				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 || gen !== this.scrubToken) return null;
+				if (snapped.kind !== "segment") {
+					if (!this.scrubNoFootageLogged) {
+						this.scrubNoFootageLogged = true;
+						this.deps.onLog?.("scrub-feeder:no-footage", {
+							dragId: this.scrubDragId,
+							epochMs: target
+						});
+					}
+					return null;
+				}
+				this.deps.onLog?.("scrub-feeder:snapped", {
+					dragId: this.scrubDragId,
+					requestedMs: target,
+					snappedMs: decision.snapMs
+				});
+				loc = snapped;
+				effTarget = decision.snapMs;
+			}
+			const warm = this.scrubCache.covering(this.deps.profile, effTarget);
+			if (warm) return {
+				seg: warm,
+				requested: target,
+				effTarget,
+				locateCalls,
+				locateMs,
+				readMs: null,
+				readBytes: null,
+				demuxMs: null,
+				wholeSegmentRead: false
+			};
+			const load = await this.loadScrubFragment(loc, effTarget);
+			if (this.disposed || load === null) return null;
+			this.scrubCache.put(this.deps.profile, load.seg);
+			if (gen !== this.scrubToken) return null;
+			return {
+				seg: load.seg,
+				requested: target,
+				effTarget,
+				locateCalls,
+				locateMs,
+				readMs: load.readMs,
+				readBytes: load.readBytes,
+				demuxMs: load.demuxMs,
+				wholeSegmentRead: load.wholeSegmentRead
+			};
+		} finally {
+			this.scrubResolvesInFlight -= 1;
+			if (this.scrubResolvesInFlight === 0) this.scrubTickReadInFlight = false;
+			if (this.scrubResolve?.target === target) this.scrubResolve = null;
+		}
+	}
+	/**
 	* Index of the nearest AU at-or-before the drag target within `seg`
 	* (default 0 — the fragment's params-fused IDR, which the demux contract
 	* guarantees). `keyframesOnly` restricts the pick to sync frames — the JUMP
@@ -25419,7 +25847,21 @@ var RecordedFeeder = class {
 	*/
 	readsWholeSegment(loc) {
 		if (this.deps.profile !== SCRUB_WHOLE_SEGMENT_PROFILE) return false;
-		return loc.bytes === void 0 || loc.bytes <= SCRUB_WHOLE_SEGMENT_MAX_BYTES;
+		if (loc.bytes === void 0 || loc.bytes <= 15e5) return true;
+		this.scrubStats?.recordOversizeSegment();
+		if (!this.scrubOversizeLogged) {
+			this.scrubOversizeLogged = true;
+			this.deps.onLog?.("scrub-feeder:oversize-segment", {
+				dragId: this.scrubDragId,
+				profile: this.deps.profile,
+				startMs: loc.startMs,
+				durMs: loc.durMs,
+				bytes: loc.bytes,
+				maxBytes: SCRUB_WHOLE_SEGMENT_MAX_BYTES,
+				bytesPerSecond: loc.durMs > 0 ? Math.round(loc.bytes / (loc.durMs / 1e3)) : null
+			});
+		}
+		return false;
 	}
 	/**
 	* Fold one read into the recent-read window that governs speculation. The
@@ -25430,15 +25872,74 @@ var RecordedFeeder = class {
 		this.scrubReadMsWindow = [...this.scrubReadMsWindow, readMs].slice(-5);
 	}
 	/**
-	* Is the disk the problem right now? Median of the recent reads against
-	* {@link SCRUB_SLOW_READ_MS}. Median and not mean because one slow read is
-	* noise and the decision must not swing on it; and never before a few
-	* samples, or a cold first read would suppress the whole drag.
+	* A drag that is NOT on the scrub profile runs with every scrub optimisation
+	* off: the whole-segment read unit, the 48 MB fragment-cache budget and the
+	* entry warm are all gated on the exact string `low`
+	* ({@link SCRUB_WHOLE_SEGMENT_PROFILE}). A momentary hole in `low` therefore
+	* turns a drag into 3-seek GOP reads over ~5 MB `high` segments — measured at
+	* 2 642 ms cold — and the client cannot repair it.
+	*
+	* It used to be indistinguishable from a slow disk. Now it says so, once per
+	* drag, and the census carries the flag beside the numbers it explains.
+	*/
+	reportProfileDegradation() {
+		if (this.deps.profile === SCRUB_WHOLE_SEGMENT_PROFILE) return;
+		this.scrubStats?.recordProfileDegraded(this.deps.profile);
+		if (this.scrubProfileLogged) return;
+		this.scrubProfileLogged = true;
+		this.deps.onLog?.("scrub-feeder:profile-degraded", {
+			dragId: this.scrubDragId,
+			profile: this.deps.profile,
+			scrubProfile: SCRUB_WHOLE_SEGMENT_PROFILE
+		});
+	}
+	/**
+	* Median of the recent reads — what a read costs on this disk RIGHT NOW.
+	* Null until there are enough samples to call it anything: a single cold
+	* first read is not a median, and acting on it would aim a whole gesture.
 	*/
-	scrubReadsAreSlow() {
-		if (this.scrubReadMsWindow.length < 3) return false;
+	scrubReadMedianMs() {
+		if (this.scrubReadMsWindow.length < SCRUB_LEAD_MIN_READ_SAMPLES) return null;
 		const sorted = this.scrubReadMsWindow.toSorted((a, b) => a - b);
-		return (sorted[Math.floor(sorted.length / 2)] ?? 0) >= (this.deps.slowReadMs ?? SCRUB_SLOW_READ_MS);
+		return sorted[Math.floor(sorted.length / 2)] ?? null;
+	}
+	/**
+	* Fold one pointer sample into the drag's media velocity (ms of timeline per
+	* ms of wall clock, signed). Cheap on purpose: this runs at pointer rate.
+	*/
+	noteScrubSample(epochMs) {
+		const now = performance.now();
+		const prev = this.scrubLastSampleMs;
+		const prevAt = this.scrubLastSampleAtMs;
+		this.scrubLastSampleMs = epochMs;
+		this.scrubLastSampleAtMs = now;
+		if (prev === null) return;
+		const gapMs = now - prevAt;
+		if (gapMs < SCRUB_VELOCITY_MIN_GAP_MS || gapMs > SCRUB_VELOCITY_MAX_GAP_MS) return;
+		const deltaMs = epochMs - prev;
+		const dir = Math.sign(deltaMs);
+		if (dir === 0) {
+			this.scrubVelRun = 0;
+			return;
+		}
+		this.scrubVelRun = Math.sign(this.scrubVelRun) === dir ? this.scrubVelRun + dir : dir;
+		const v = deltaMs / gapMs;
+		this.scrubVelocity = this.scrubVelocity === null ? v : this.scrubVelocity * (1 - SCRUB_VELOCITY_EMA) + v * SCRUB_VELOCITY_EMA;
+	}
+	/**
+	* How far AHEAD of the finger this read should aim — see the
+	* {@link SCRUB_LEAD_MIN_READ_SAMPLES} docblock for why this exists and what
+	* bounds it. Zero whenever the prediction is not earned: no measured reads,
+	* no sustained direction, or a velocity whose sign disagrees with the run.
+	*/
+	scrubLeadMs() {
+		const velocity = this.scrubVelocity;
+		if (velocity === null) return 0;
+		if (Math.abs(this.scrubVelRun) < SCRUB_LEAD_MIN_DIR_RUN) return 0;
+		if (Math.sign(velocity) !== Math.sign(this.scrubVelRun)) return 0;
+		const readMs = this.scrubReadMedianMs();
+		if (readMs === null) return 0;
+		return scrubLeadDecision(velocity, readMs).leadMs;
 	}
 	/**
 	* A single slow `locate` gets its own line, throttled per drag. Reserved for
@@ -25454,6 +25955,7 @@ var RecordedFeeder = class {
 		if (this.scrubLastSlowLocateLogAtMs !== 0 && now - this.scrubLastSlowLocateLogAtMs < SCRUB_PATHOLOGY_LOG_INTERVAL_MS) return;
 		this.scrubLastSlowLocateLogAtMs = now;
 		this.deps.onLog?.("scrub-feeder:slow-locate", {
+			dragId: this.scrubDragId,
 			epochMs,
 			locateMs: Math.round(locateMs),
 			thresholdMs: threshold
@@ -25470,7 +25972,7 @@ var RecordedFeeder = class {
 	* interval comes out warm for the next drag. Aborts (without landing — the
 	* caller owns that) the moment a newer seek bumps the token.
 	*/
-	async animateSeekTravel(fromMs, toMs, token) {
+	async animateSeekTravel(fromMs, toMs, token, dragId) {
 		const cfg = this.deps.seekAnimation;
 		const budgetMs = cfg?.budgetMs ?? SEEK_ANIMATION_BUDGET_MS;
 		const tickMs = cfg?.tickMs ?? SEEK_ANIMATION_TICK_MS;
@@ -25502,6 +26004,7 @@ var RecordedFeeder = class {
 			if (this.disposed || token !== this.seekToken) return;
 		}
 		if (stills > 0) this.deps.onLog?.("recorded:seek-travel", {
+			dragId,
 			fromMs,
 			toMs,
 			stills,
@@ -25596,79 +26099,41 @@ var RecordedFeeder = class {
 		return stills;
 	}
 	/**
-	* Update the drag-direction run from the just-served target and, once the drag
-	* shows a sustained direction, kick off a single background prefetch of the
-	* NEXT fragment in that direction. Prefetch fills the cache only — it never
-	* pushes, so crossing into the neighbour later is an instant cache hit.
-	*/
-	maybeScrubPrefetch(seg, target, gen) {
-		const prev = this.scrubPrevTarget;
-		this.scrubPrevTarget = target;
-		if (prev === null) {
-			this.scrubDirRun = 0;
-			return;
-		}
-		const stepMs = target - prev;
-		const dir = stepMs > 0 ? 1 : stepMs < 0 ? -1 : 0;
-		if (dir === 0) {
-			this.scrubDirRun = 0;
-			return;
-		}
-		this.scrubDirRun = Math.sign(this.scrubDirRun) === dir ? this.scrubDirRun + dir : dir;
-		if (Math.abs(this.scrubDirRun) < SCRUB_PREFETCH_DIR_THRESHOLD) return;
-		if (this.scrubReadsAreSlow()) {
-			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++) {
-			if (this.scrubPrefetchInFlight >= SCRUB_PREFETCH_MAX_INFLIGHT) return;
-			const probeMs = target + dir * aheadMs * horizon;
-			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);
-		}
-	}
-	/**
-	* Speculative read: locate + read + demux the fragment covering `probeMs` into
-	* `scrubCache`. Bounded by {@link SCRUB_PREFETCH_MAX_INFLIGHT}; aborts at any
-	* teardown (`disposed` / left scrub / a bumped `scrubToken`); a failure is
-	* swallowed (the fragment just demuxes on demand). Never pushes and never
-	* mutates latest-wins state.
+	* The directional prefetch is GONE (2026-08-26), not disabled.
 	*
-	* Every read it issues is COUNTED (`prefetchReads` / `prefetchBytes`), and the
-	* fragment it lands is remembered so a later tick hitting it counts as a
-	* `prefetchHit`. Speculation that cannot be shown to pay for itself is just
-	* load on the disk the drag is already waiting for.
-	*/
-	async scrubPrefetch(probeMs, gen) {
-		if (this.scrubPrefetchInFlight >= SCRUB_PREFETCH_MAX_INFLIGHT) return;
-		this.scrubPrefetchInFlight += 1;
-		this.scrubPrefetchProbes.add(probeMs);
-		try {
-			if (this.disposed || !this.scrubbing || gen !== this.scrubToken) return;
-			if (this.scrubCache.covering(this.deps.profile, probeMs)) return;
-			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;
-			if (loc.kind !== "segment") return;
-			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;
-			this.scrubCache.put(this.deps.profile, load.seg);
-			this.scrubPrefetched.add(load.seg.startMs);
-		} catch {} finally {
-			this.scrubPrefetchInFlight -= 1;
-			this.scrubPrefetchProbes.delete(probeMs);
-		}
-	}
+	* It guessed where the next tick would land from the drag's recent
+	* direction. Measured on the operator's own drags the day it was removed:
+	* **25 speculative reads bought 3 hits** — 88% waste, and roughly 60% of all
+	* disk work during a gesture, queued as random seeks ahead of the read the
+	* finger was actually blocked on, on a 5400 rpm SMR disk.
+	*
+	* The regression tests it passed drove a drag at CONSTANT step size, which is
+	* the one regime where direction predicts position. A real backward scrub is
+	* exploratory — 26 of 29 jumps backward, step size set by where the operator
+	* decided to look next — so the premise never held in the field.
+	*
+	* Scrypted has no predictive prefetch either: their read-ahead is a stream
+	* `highWaterMark`, and a short forward move is a fast-forward on an open fd
+	* rather than a seek. They deleted the problem instead of solving it.
+	*
+	* What REMAINS and must not be confused with this: the WINDOW warm
+	* (`runScrubFillLoop`) — a sequential walk of the window around the playhead.
+	*
+	* It was described here, wrongly, as running "when no drag is live, so it
+	* competes with nothing". It does not: its survival condition is
+	* `this.scrubbing || this.idleWarm`, and within hours of this deletion it had
+	* inherited the deleted predictor's role — 1.9 MB and 2.4 MB of reads on two
+	* measured drags, 38-45% of the gesture's I/O, zero cache hits. Deleting one
+	* speculator without looking at the other left the contention exactly where
+	* it was. It now waits out a moving finger (`fingerIsMoving`), which is what
+	* the sentence above claimed all along.
+	*
+	* Cost of the removal, bounded and accepted: a careful short-step drag no
+	* longer warms the fragment across the edge, so the first tick past a
+	* boundary may pay one cold read. Its own regression test shows that case is
+	* served by the MEMO (`coverMemo ≥ 5`) with the neighbour warm worth ≤2
+	* reads.
+	*/
 	/**
 	* Feed exactly one frame forward (+1) or backward (-1). Only meaningful while
 	* paused over a segment (rate 0, recorded mode) — ignored otherwise. Forward
@@ -25852,7 +26317,7 @@ var RecordedFeeder = class {
 		this.advanceLoop(gen, initial).catch(() => {
 			if (!this.disposed && gen === this.advanceToken) {
 				this.stopPositionReports();
-				this.deps.onState("error");
+				this.emitState("error", "advance-loop-failed", this.seekToken, this.scrubDragId);
 			}
 		});
 	}
@@ -25869,7 +26334,7 @@ var RecordedFeeder = class {
 			if (prepared === null) return;
 			if (prepared === "ended") {
 				this.stopPositionReports();
-				this.deps.onState("ended");
+				this.emitState("ended", "advance-ended", this.seekToken, this.scrubDragId);
 				return;
 			}
 			if (isResumedSegment) {} else {
@@ -26146,7 +26611,10 @@ var RecordedFeeder = class {
 		const mark = this.scrubDemuxMark;
 		const demux = mark && this.deps.demuxTally ? this.deps.demuxTally.deltaSince(mark) : void 0;
 		this.scrubDemuxMark = null;
-		this.deps.onLog?.("scrub-feeder:drag-end", stats.toLogFields(performance.now() - this.scrubStartedAtMs, demux));
+		this.deps.onLog?.("scrub-feeder:drag-end", {
+			dragId: this.scrubDragId,
+			...stats.toLogFields(performance.now() - this.scrubStartedAtMs, demux)
+		});
 	}
 	/** Stop everything: invalidate in-flight work and tear down the position timer. */
 	dispose() {
@@ -26159,10 +26627,17 @@ var RecordedFeeder = class {
 		this.scrubToken++;
 		this.scrubSegment = null;
 		this.scrubPrevTarget = null;
-		this.scrubDirRun = 0;
 		this.scrubCursor = null;
 		this.scrubNoFootageLogged = false;
 		this.scrubParkLogged = false;
+		this.scrubDeadlineLogged = false;
+		this.scrubOversizeLogged = false;
+		this.scrubProfileLogged = false;
+		this.scrubPushedThisDrag = false;
+		this.scrubResolve = null;
+		this.scrubVelocity = null;
+		this.scrubLastSampleMs = null;
+		this.scrubVelRun = 0;
 		this.scrubOutstanding = [];
 		this.clearScrubAckTimeout();
 		this.scrubPendingHint = null;
@@ -26243,10 +26718,11 @@ var TimelineSession = class {
 				await this.playAt(msg.epoch, this.profile, { travelFromMs: this.lastPositionMs });
 				break;
 			case "scrubCommit":
-				await this.playAt(msg.epoch, this.profile);
+				if (msg.dragId !== void 0) await this.playAt(msg.epoch, this.profile, { dragId: msg.dragId });
+				else await this.playAt(msg.epoch, this.profile);
 				break;
 			case "scrubStart":
-				(this.mode === "recorded" && this.feeder ? this.feeder : this.enterRecorded()).beginScrub();
+				(this.mode === "recorded" && this.feeder ? this.feeder : this.enterRecorded()).beginScrub(msg.dragId);
 				break;
 			case "scrubTo": {
 				const hint = msg.m !== void 0 && msg.v !== void 0 ? {
@@ -26500,7 +26976,7 @@ function createOffThreadJsParse(deps) {
 		if (!w) return deps.parseInProcess(bytes);
 		const id = nextId;
 		nextId += 1;
-		const copy = bytes.slice();
+		const copy = new Uint8Array(bytes);
 		const request = {
 			id,
 			bytes: copy
@@ -27937,14 +28413,21 @@ var BrokerWebrtcServer = class {
 							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);
+						onState: (t) => {
+							sessionLogger.info("recorded: feeder state", {
+								tags: { deviceId },
+								meta: {
+									sessionId,
+									deviceId,
+									profile,
+									from: t.from,
+									to: t.to,
+									reason: t.reason,
+									seekToken: t.seekToken,
+									dragId: t.dragId
+								}
+							});
+							timeline._emitState(t.to);
 						},
 						onPosition: (epochMs, pushSeq) => timeline._emitPosition(epochMs, pushSeq),
 						onLog: (msg, data) => sessionLogger.info(msg, {