@camstack/addon-pipeline 1.2.129 → 1.2.131

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-D9x2_csL.js");
+const require_dist = require("../dist-CqoMNE1e.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-DiLDoV9_.js");
+const require_segment_demux_js = require("../segment-demux-js-Cu0oDMUL.js");
 let node_crypto = require("node:crypto");
 node_crypto = require_dist.__toESM(node_crypto, 1);
 let node_child_process = require("node:child_process");
@@ -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,6 +23702,9 @@ var ScrubDragStats = class {
 	prefetchBytes = 0;
 	prefetchHits = 0;
 	prefetchSuppressed = 0;
+	warmReads = 0;
+	warmBytes = 0;
+	warmHits = 0;
 	ackTimeouts = 0;
 	deadlineMisses = 0;
 	retargets = 0;
@@ -23862,6 +23771,15 @@ 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;
@@ -23944,6 +23862,9 @@ 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,
@@ -23963,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
@@ -24065,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
@@ -24124,14 +24171,30 @@ var SCRUB_WHOLE_SEGMENT_PROFILE = "low";
 * (`scrub-feeder:oversize-segment`, `oversizeSegments` on the drag census)
 * instead of being inferred from a falling hit rate.
 *
-* The real fix, 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" — which needs a provider method we do not have
-* (`readGopBytes` reads exactly one GOP). Until then this is an absolute cap
-* on a single read and the log is the guard.
+* 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.
 *
@@ -24166,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
@@ -24249,37 +24301,6 @@ var SCRUB_RIDE_WINDOW_MS = 1e4;
 * moved on to. At the cap, a tick rides the newest in-flight read instead.
 */
 var SCRUB_RESOLVE_MAX_INFLIGHT = 2;
-/**
-* 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 SCRUB_LEAD_MIN_READ_SAMPLES = 1;
 /**
 * Smoothing for the media-velocity estimate (ms of timeline per ms of wall
@@ -24512,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
@@ -24580,6 +24582,18 @@ var RecordedFeeder = class {
 	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);
@@ -24597,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
@@ -24609,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();
@@ -24620,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;
@@ -24630,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);
@@ -24642,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();
@@ -24666,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
 				});
@@ -24692,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();
@@ -24711,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";
@@ -24720,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,
@@ -24731,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;
@@ -24746,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,
@@ -24773,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 = {
@@ -24795,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,
@@ -24815,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,
@@ -24852,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;
@@ -24877,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),
@@ -24911,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;
@@ -24933,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;
@@ -24944,7 +25055,6 @@ 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;
@@ -25027,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
 		});
@@ -25052,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,
@@ -25088,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);
@@ -25127,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) {
@@ -25146,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);
@@ -25266,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,
@@ -25297,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
 				});
@@ -25329,7 +25460,7 @@ 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) {
@@ -25359,6 +25490,7 @@ var RecordedFeeder = class {
 					if (!this.scrubDeadlineLogged) {
 						this.scrubDeadlineLogged = true;
 						this.deps.onLog?.("scrub-feeder:deadline-miss", {
+							dragId: this.scrubDragId,
 							epochMs: target,
 							deadlineMs,
 							first: !this.scrubPushedThisDrag,
@@ -25482,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,
@@ -25499,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)
 			});
@@ -25548,11 +25682,15 @@ var RecordedFeeder = class {
 					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", { epochMs: target });
+						else this.deps.onLog?.("scrub-feeder:no-footage", {
+							dragId: this.scrubDragId,
+							epochMs: target
+						});
 					}
 					return null;
 				}
@@ -25568,11 +25706,15 @@ var RecordedFeeder = class {
 				if (snapped.kind !== "segment") {
 					if (!this.scrubNoFootageLogged) {
 						this.scrubNoFootageLogged = true;
-						this.deps.onLog?.("scrub-feeder:no-footage", { epochMs: target });
+						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
 				});
@@ -25705,11 +25847,12 @@ var RecordedFeeder = class {
 	*/
 	readsWholeSegment(loc) {
 		if (this.deps.profile !== SCRUB_WHOLE_SEGMENT_PROFILE) return false;
-		if (loc.bytes === void 0 || loc.bytes <= SCRUB_WHOLE_SEGMENT_MAX_BYTES) return true;
+		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,
@@ -25745,6 +25888,7 @@ var RecordedFeeder = class {
 		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
 		});
@@ -25760,17 +25904,6 @@ var RecordedFeeder = class {
 		return sorted[Math.floor(sorted.length / 2)] ?? null;
 	}
 	/**
-	* Is the disk the problem right now? The recent-read median 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.
-	*/
-	scrubReadsAreSlow() {
-		const median = this.scrubReadMedianMs();
-		if (median === null) return false;
-		return median >= (this.deps.slowReadMs ?? SCRUB_SLOW_READ_MS);
-	}
-	/**
 	* 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.
 	*/
@@ -25806,7 +25939,7 @@ var RecordedFeeder = class {
 		if (Math.sign(velocity) !== Math.sign(this.scrubVelRun)) return 0;
 		const readMs = this.scrubReadMedianMs();
 		if (readMs === null) return 0;
-		return Math.round(velocity * readMs);
+		return scrubLeadDecision(velocity, readMs).leadMs;
 	}
 	/**
 	* A single slow `locate` gets its own line, throttled per drag. Reserved for
@@ -25822,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
@@ -25838,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;
@@ -25870,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,
@@ -25964,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
@@ -26220,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);
 			}
 		});
 	}
@@ -26237,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 {
@@ -26514,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() {
@@ -26527,7 +26627,6 @@ var RecordedFeeder = class {
 		this.scrubToken++;
 		this.scrubSegment = null;
 		this.scrubPrevTarget = null;
-		this.scrubDirRun = 0;
 		this.scrubCursor = null;
 		this.scrubNoFootageLogged = false;
 		this.scrubParkLogged = false;
@@ -26619,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 ? {
@@ -26876,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
@@ -28313,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, {