@camstack/addon-pipeline 1.2.54 → 1.2.58

package/dist/recorder/index.js

@@ -1118,6 +1118,10 @@ function* hourBuckets(fromMs, toMs) {
 }
 var RecordingIndex = class {
 	byDevice = /* @__PURE__ */ new Map();
+	/** Start-sorted snapshots, rebuilt only after index mutations. Interactive
+	* locate/range calls reuse them instead of filtering+sorting the complete
+	* archive on every seek and scrub miss. */
+	sortedByDevice = /* @__PURE__ */ new Map();
 	/** Hour buckets this device has been walked for; `ALL_HOURS` after a full
 	*  hydrate. Empty = nothing has been looked at, which is NOT the same as
 	*  "there is nothing" — see {@link hydrationOf}. */
@@ -1130,6 +1134,24 @@ var RecordingIndex = class {
 		}
 		return m;
 	}
+	invalidateSorted(deviceId) {
+		this.sortedByDevice.delete(deviceId);
+	}
+	sortedSegments(deviceId, profile) {
+		let deviceCache = this.sortedByDevice.get(deviceId);
+		if (!deviceCache) {
+			deviceCache = /* @__PURE__ */ new Map();
+			this.sortedByDevice.set(deviceId, deviceCache);
+		}
+		const key = profile ?? "";
+		const cached = deviceCache.get(key);
+		if (cached) return cached;
+		const m = this.byDevice.get(deviceId);
+		if (!m) return [];
+		const sorted = [...m.values()].filter((s) => profile == null || s.profile === profile).toSorted((a, b) => a.startMs - b.startMs);
+		deviceCache.set(key, sorted);
+		return sorted;
+	}
 	/**
 	* Replace a device's segments FOR ONE LOCATION from a `storage.list` result (paths relative to that
 	* location root). Rows on other locations are preserved. Non-segment paths and other devices are ignored.
@@ -1150,6 +1172,7 @@ var RecordingIndex = class {
 				locationId
 			});
 		}
+		this.invalidateSorted(deviceId);
 	}
 	/**
 	* Whether the index has WALKED `[fromMs, toMs)` for a device.
@@ -1206,25 +1229,25 @@ var RecordingIndex = class {
 				locationId
 			});
 		}
+		this.invalidateSorted(deviceId);
 		this.markHydrated(deviceId, hourStartMs, hourStartMs + HOUR_MS$1);
 	}
 	/** Insert/replace one finalized segment (idempotent by path). */
 	addSegment(s) {
 		this.mapFor(s.deviceId).set(s.path, s);
+		this.invalidateSorted(s.deviceId);
 	}
 	/** Remove segments by relative path, routing each path to the correct device map via its encoded deviceId. */
 	removeSegments(paths) {
 		for (const p of paths) {
 			const parsed = parseSegmentPath(p);
 			if (!parsed) continue;
-			this.byDevice.get(parsed.deviceId)?.delete(p);
+			if (this.byDevice.get(parsed.deviceId)?.delete(p)) this.invalidateSorted(parsed.deviceId);
 		}
 	}
 	/** Rows for a device (optionally one profile), sorted by start. */
 	segments(deviceId, profile) {
-		const m = this.byDevice.get(deviceId);
-		if (!m) return [];
-		return [...m.values()].filter((s) => profile == null || s.profile === profile).toSorted((a, b) => a.startMs - b.startMs);
+		return [...this.sortedSegments(deviceId, profile)];
 	}
 	/** Aggregate accounting for a device across ALL its locations (use `accountingForLocation` for one location). */
 	accounting(deviceId) {
@@ -1338,7 +1361,7 @@ var RecordingIndex = class {
 	}
 	/** The segment whose [startMs, startMs+durMs) window contains `epochMs`, or null if `epochMs` falls in a gap / there is no footage. */
 	segmentAt(deviceId, profile, epochMs) {
-		return this.segmentAtIn(this.segments(deviceId, profile), epochMs);
+		return this.segmentAtIn(this.sortedSegments(deviceId, profile), epochMs);
 	}
 	/**
 	* If epochMs is covered, returns it unchanged. Otherwise returns the start of the
@@ -1346,7 +1369,7 @@ var RecordingIndex = class {
 	* (epoch past all footage, or no footage at all). Only snaps forward — never backward.
 	*/
 	nearestCoveredEdge(deviceId, profile, epochMs) {
-		const segs = this.segments(deviceId, profile);
+		const segs = this.sortedSegments(deviceId, profile);
 		if (segs.length === 0) return null;
 		if (this.segmentAtIn(segs, epochMs) !== null) return epochMs;
 		const next = segs.find((s) => s.startMs >= epochMs);
@@ -1362,14 +1385,14 @@ var RecordingIndex = class {
 	*/
 	coveredEdgeBefore(deviceId, profile, epochMs) {
 		let best = null;
-		for (const s of this.segments(deviceId, profile)) {
+		for (const s of this.sortedSegments(deviceId, profile)) {
 			const end = s.startMs + s.durMs;
 			if (end <= epochMs && (best === null || end > best)) best = end;
 		}
 		return best;
 	}
 	ranges(deviceId, profile, fromMs, toMs, gapToleranceMs) {
-		return mergeRanges(this.segments(deviceId, profile).filter((s) => s.startMs + s.durMs > fromMs && s.startMs < toMs), gapToleranceMs).map((r) => ({
+		return mergeRanges(this.sortedSegments(deviceId, profile).filter((s) => s.startMs + s.durMs > fromMs && s.startMs < toMs), gapToleranceMs).map((r) => ({
 			startMs: Math.max(r.startMs, fromMs),
 			endMs: Math.min(r.endMs, toMs)
 		}));
@@ -1828,15 +1851,15 @@ async function readGopRange(file, args) {
 		bytesRead += chunk.length;
 		return chunk;
 	};
-	const parsed = await parseTail(file, read);
-	if (parsed === null) return null;
-	const { tail, index } = parsed;
+	const parsed = args.seededIndex === void 0 ? await parseTail(file, read) : null;
+	if (args.seededIndex === void 0 && parsed === null) return null;
+	const index = args.seededIndex ?? parsed.index;
 	const firstMoof = index.samples[0]?.moofOffset ?? 0;
 	if (firstMoof <= 0 || firstMoof >= file.size) return null;
 	const head = await read(0, firstMoof);
 	const init = parseInitInfo(head);
 	if (init === null) return null;
-	const videoIndex = index.trackId === init.videoTrackId ? index : reparseTail(tail, file.size, init.videoTrackId);
+	const videoIndex = index.trackId === init.videoTrackId ? index : parsed === null ? null : reparseTail(parsed.tail, file.size, init.videoTrackId);
 	if (videoIndex === null) return null;
 	const { start, end, sampleIndex } = fragmentRangeFor(videoIndex, Math.max(0, args.epochMs - args.segmentStartMs) / 1e3 * init.videoTimescale);
 	if (start <= 0 || end <= start || end > file.size) return null;
@@ -2264,6 +2287,10 @@ var DEFAULT_BANDWIDTH = 1e6;
 * multiple missing segments) splits the ranges so real discontinuities show.
 */
 var RANGE_MERGE_GAP_MS = 5e3;
+/** Include the neighboring minute so a segment that starts in the previous
+* hour but covers the requested epoch is hydrated too. Recorder segments are
+* currently much shorter; the margin keeps this boundary future-safe. */
+var LOCATE_HYDRATE_MARGIN_MS = 6e4;
 /** Empty "no playback" manifest. */
 function noPlayback(deviceId) {
 	return {
@@ -2613,6 +2640,9 @@ function buildRecordingProvider(deps) {
 		},
 		getDeviceConfig: async ({ deviceId }) => loadDeviceConfig(deps.configStore, deviceId),
 		locateSegment: async ({ deviceId, profile, epochMs }) => {
+			const hydrateFromMs = Math.max(0, epochMs - LOCATE_HYDRATE_MARGIN_MS);
+			const hydrateToMs = epochMs + LOCATE_HYDRATE_MARGIN_MS;
+			if (deps.index.hydrationOf(deviceId, hydrateFromMs, hydrateToMs) !== "hydrated") await deps.hydrateWindow?.(deviceId, hydrateFromMs, hydrateToMs);
 			const seg = deps.index.segmentAt(deviceId, profile, epochMs);
 			if (seg) return {
 				kind: "segment",
@@ -2638,7 +2668,8 @@ function buildRecordingProvider(deps) {
 				const gop = await readGopRange(file, {
 					segmentStartMs: seg.startMs,
 					segmentDurMs: seg.durMs,
-					epochMs
+					epochMs,
+					seededIndex: deps.mfraFor?.(deviceId, profile, startMs)
 				});
 				if (gop !== null) return {
 					data: gop.data,
@@ -5407,6 +5438,7 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 			capacity: (root) => this.locationCapacity(root),
 			hydrateDevice: (deviceId, locations) => hydrateDeviceFromStorage(this.ctx.api, this.index, deviceId, locations, this.ctx.logger),
 			calendar: this.calendar,
+			mfraFor: (deviceId, profile, startMs) => this.mfraTables.get(deviceId, profile, startMs),
 			hydrateWindow: (deviceId, fromMs, toMs) => hydrateWindowFromStorage(this.index, deviceId, fromMs, toMs, this.resolvedLocations, this.ctx.logger),
 			onConfigChanged: (deviceId) => this.controller?.onConfigChanged(deviceId) ?? Promise.resolve(),
 			dataDir: this.ctx.dataDir,

package/dist/recorder/index.mjs

@@ -1116,6 +1116,10 @@ function* hourBuckets(fromMs, toMs) {
 }
 var RecordingIndex = class {
 	byDevice = /* @__PURE__ */ new Map();
+	/** Start-sorted snapshots, rebuilt only after index mutations. Interactive
+	* locate/range calls reuse them instead of filtering+sorting the complete
+	* archive on every seek and scrub miss. */
+	sortedByDevice = /* @__PURE__ */ new Map();
 	/** Hour buckets this device has been walked for; `ALL_HOURS` after a full
 	*  hydrate. Empty = nothing has been looked at, which is NOT the same as
 	*  "there is nothing" — see {@link hydrationOf}. */
@@ -1128,6 +1132,24 @@ var RecordingIndex = class {
 		}
 		return m;
 	}
+	invalidateSorted(deviceId) {
+		this.sortedByDevice.delete(deviceId);
+	}
+	sortedSegments(deviceId, profile) {
+		let deviceCache = this.sortedByDevice.get(deviceId);
+		if (!deviceCache) {
+			deviceCache = /* @__PURE__ */ new Map();
+			this.sortedByDevice.set(deviceId, deviceCache);
+		}
+		const key = profile ?? "";
+		const cached = deviceCache.get(key);
+		if (cached) return cached;
+		const m = this.byDevice.get(deviceId);
+		if (!m) return [];
+		const sorted = [...m.values()].filter((s) => profile == null || s.profile === profile).toSorted((a, b) => a.startMs - b.startMs);
+		deviceCache.set(key, sorted);
+		return sorted;
+	}
 	/**
 	* Replace a device's segments FOR ONE LOCATION from a `storage.list` result (paths relative to that
 	* location root). Rows on other locations are preserved. Non-segment paths and other devices are ignored.
@@ -1148,6 +1170,7 @@ var RecordingIndex = class {
 				locationId
 			});
 		}
+		this.invalidateSorted(deviceId);
 	}
 	/**
 	* Whether the index has WALKED `[fromMs, toMs)` for a device.
@@ -1204,25 +1227,25 @@ var RecordingIndex = class {
 				locationId
 			});
 		}
+		this.invalidateSorted(deviceId);
 		this.markHydrated(deviceId, hourStartMs, hourStartMs + HOUR_MS$1);
 	}
 	/** Insert/replace one finalized segment (idempotent by path). */
 	addSegment(s) {
 		this.mapFor(s.deviceId).set(s.path, s);
+		this.invalidateSorted(s.deviceId);
 	}
 	/** Remove segments by relative path, routing each path to the correct device map via its encoded deviceId. */
 	removeSegments(paths) {
 		for (const p of paths) {
 			const parsed = parseSegmentPath(p);
 			if (!parsed) continue;
-			this.byDevice.get(parsed.deviceId)?.delete(p);
+			if (this.byDevice.get(parsed.deviceId)?.delete(p)) this.invalidateSorted(parsed.deviceId);
 		}
 	}
 	/** Rows for a device (optionally one profile), sorted by start. */
 	segments(deviceId, profile) {
-		const m = this.byDevice.get(deviceId);
-		if (!m) return [];
-		return [...m.values()].filter((s) => profile == null || s.profile === profile).toSorted((a, b) => a.startMs - b.startMs);
+		return [...this.sortedSegments(deviceId, profile)];
 	}
 	/** Aggregate accounting for a device across ALL its locations (use `accountingForLocation` for one location). */
 	accounting(deviceId) {
@@ -1336,7 +1359,7 @@ var RecordingIndex = class {
 	}
 	/** The segment whose [startMs, startMs+durMs) window contains `epochMs`, or null if `epochMs` falls in a gap / there is no footage. */
 	segmentAt(deviceId, profile, epochMs) {
-		return this.segmentAtIn(this.segments(deviceId, profile), epochMs);
+		return this.segmentAtIn(this.sortedSegments(deviceId, profile), epochMs);
 	}
 	/**
 	* If epochMs is covered, returns it unchanged. Otherwise returns the start of the
@@ -1344,7 +1367,7 @@ var RecordingIndex = class {
 	* (epoch past all footage, or no footage at all). Only snaps forward — never backward.
 	*/
 	nearestCoveredEdge(deviceId, profile, epochMs) {
-		const segs = this.segments(deviceId, profile);
+		const segs = this.sortedSegments(deviceId, profile);
 		if (segs.length === 0) return null;
 		if (this.segmentAtIn(segs, epochMs) !== null) return epochMs;
 		const next = segs.find((s) => s.startMs >= epochMs);
@@ -1360,14 +1383,14 @@ var RecordingIndex = class {
 	*/
 	coveredEdgeBefore(deviceId, profile, epochMs) {
 		let best = null;
-		for (const s of this.segments(deviceId, profile)) {
+		for (const s of this.sortedSegments(deviceId, profile)) {
 			const end = s.startMs + s.durMs;
 			if (end <= epochMs && (best === null || end > best)) best = end;
 		}
 		return best;
 	}
 	ranges(deviceId, profile, fromMs, toMs, gapToleranceMs) {
-		return mergeRanges(this.segments(deviceId, profile).filter((s) => s.startMs + s.durMs > fromMs && s.startMs < toMs), gapToleranceMs).map((r) => ({
+		return mergeRanges(this.sortedSegments(deviceId, profile).filter((s) => s.startMs + s.durMs > fromMs && s.startMs < toMs), gapToleranceMs).map((r) => ({
 			startMs: Math.max(r.startMs, fromMs),
 			endMs: Math.min(r.endMs, toMs)
 		}));
@@ -1826,15 +1849,15 @@ async function readGopRange(file, args) {
 		bytesRead += chunk.length;
 		return chunk;
 	};
-	const parsed = await parseTail(file, read);
-	if (parsed === null) return null;
-	const { tail, index } = parsed;
+	const parsed = args.seededIndex === void 0 ? await parseTail(file, read) : null;
+	if (args.seededIndex === void 0 && parsed === null) return null;
+	const index = args.seededIndex ?? parsed.index;
 	const firstMoof = index.samples[0]?.moofOffset ?? 0;
 	if (firstMoof <= 0 || firstMoof >= file.size) return null;
 	const head = await read(0, firstMoof);
 	const init = parseInitInfo(head);
 	if (init === null) return null;
-	const videoIndex = index.trackId === init.videoTrackId ? index : reparseTail(tail, file.size, init.videoTrackId);
+	const videoIndex = index.trackId === init.videoTrackId ? index : parsed === null ? null : reparseTail(parsed.tail, file.size, init.videoTrackId);
 	if (videoIndex === null) return null;
 	const { start, end, sampleIndex } = fragmentRangeFor(videoIndex, Math.max(0, args.epochMs - args.segmentStartMs) / 1e3 * init.videoTimescale);
 	if (start <= 0 || end <= start || end > file.size) return null;
@@ -2262,6 +2285,10 @@ var DEFAULT_BANDWIDTH = 1e6;
 * multiple missing segments) splits the ranges so real discontinuities show.
 */
 var RANGE_MERGE_GAP_MS = 5e3;
+/** Include the neighboring minute so a segment that starts in the previous
+* hour but covers the requested epoch is hydrated too. Recorder segments are
+* currently much shorter; the margin keeps this boundary future-safe. */
+var LOCATE_HYDRATE_MARGIN_MS = 6e4;
 /** Empty "no playback" manifest. */
 function noPlayback(deviceId) {
 	return {
@@ -2611,6 +2638,9 @@ function buildRecordingProvider(deps) {
 		},
 		getDeviceConfig: async ({ deviceId }) => loadDeviceConfig(deps.configStore, deviceId),
 		locateSegment: async ({ deviceId, profile, epochMs }) => {
+			const hydrateFromMs = Math.max(0, epochMs - LOCATE_HYDRATE_MARGIN_MS);
+			const hydrateToMs = epochMs + LOCATE_HYDRATE_MARGIN_MS;
+			if (deps.index.hydrationOf(deviceId, hydrateFromMs, hydrateToMs) !== "hydrated") await deps.hydrateWindow?.(deviceId, hydrateFromMs, hydrateToMs);
 			const seg = deps.index.segmentAt(deviceId, profile, epochMs);
 			if (seg) return {
 				kind: "segment",
@@ -2636,7 +2666,8 @@ function buildRecordingProvider(deps) {
 				const gop = await readGopRange(file, {
 					segmentStartMs: seg.startMs,
 					segmentDurMs: seg.durMs,
-					epochMs
+					epochMs,
+					seededIndex: deps.mfraFor?.(deviceId, profile, startMs)
 				});
 				if (gop !== null) return {
 					data: gop.data,
@@ -5405,6 +5436,7 @@ var RecorderV2Addon = class extends BaseAddon {
 			capacity: (root) => this.locationCapacity(root),
 			hydrateDevice: (deviceId, locations) => hydrateDeviceFromStorage(this.ctx.api, this.index, deviceId, locations, this.ctx.logger),
 			calendar: this.calendar,
+			mfraFor: (deviceId, profile, startMs) => this.mfraTables.get(deviceId, profile, startMs),
 			hydrateWindow: (deviceId, fromMs, toMs) => hydrateWindowFromStorage(this.index, deviceId, fromMs, toMs, this.resolvedLocations, this.ctx.logger),
 			onConfigChanged: (deviceId) => this.controller?.onConfigChanged(deviceId) ?? Promise.resolve(),
 			dataDir: this.ctx.dataDir,

package/dist/stream-broker/index.js

@@ -22095,9 +22095,9 @@ var SCRUB_ADJACENT_TOLERANCE_MS = 50;
 * feeder serves, arriving AFTER the landing. 16 at ~60 ms is ~0.6 MB, still
 * reads as travel, and leaves headroom for the landing GOP behind it.
 */
-var SEEK_ANIMATION_BUDGET_MS = 1e3;
+var SEEK_ANIMATION_BUDGET_MS = 250;
 var SEEK_ANIMATION_TICK_MS = 60;
-var SEEK_ANIMATION_MAX_STILLS = 16;
+var SEEK_ANIMATION_MAX_STILLS = 4;
 /**
 * Below this distance there is at most ONE intermediate keyframe (the camera
 * GOP is fixed at 4 s) — the landing burst already paints the target, so
@@ -22212,8 +22212,9 @@ var RecordedFeeder = class {
 	currentSegment = null;
 	/** Index (into `currentSegment.aus`) of the last video AU fed; -1 = none. */
 	lastFedVideoIdx = -1;
-	/** Serializes frame steps: a step arriving while one is in flight is dropped. */
+	/** Serializes frame steps without dropping rapid taps. */
 	stepInFlight = false;
+	pendingStepDirs = [];
 	/**
 	* Target epoch of the seek currently in flight (null when none). A rate
 	* change re-enters via seek(); while a seek is still resolving, `cursorMs`
@@ -22329,6 +22330,11 @@ var RecordedFeeder = class {
 	* seek bumps the token and silently abandons this one.
 	*/
 	async seek(epochMs, opts) {
+		const seekStartedAt = performance.now();
+		let locateMs = 0;
+		let travelMs = 0;
+		let loadMs = 0;
+		let firstFrameMs = 0;
 		const token = ++this.seekToken;
 		const wasScrubbing = this.scrubbing;
 		if (this.scrubbing) {
@@ -22355,11 +22361,13 @@ var RecordedFeeder = class {
 				this.clock.markDiscontinuity(SEEK_DISCONTINUITY_MS);
 				this.audioClock.markDiscontinuity(SEEK_DISCONTINUITY_MS);
 			}
+			const locateStartedAt = performance.now();
 			let loc = await this.withTimeout(this.deps.locate({
 				deviceId: this.deps.deviceId,
 				profile: this.deps.profile,
 				epochMs
 			}));
+			locateMs += performance.now() - locateStartedAt;
 			if (this.disposed || token !== this.seekToken) return;
 			let landMs = epochMs;
 			if (loc.kind === "gap") {
@@ -22377,11 +22385,13 @@ var RecordedFeeder = class {
 					this.deps.onState("gap");
 					return;
 				}
+				const snapLocateStartedAt = performance.now();
 				const snapped = await this.withTimeout(this.deps.locate({
 					deviceId: this.deps.deviceId,
 					profile: this.deps.profile,
 					epochMs: decision.snapMs
 				}));
+				locateMs += performance.now() - snapLocateStartedAt;
 				if (this.disposed || token !== this.seekToken) return;
 				if (snapped.kind !== "segment") {
 					this.deps.onLog?.("recorded:seek-no-footage", {
@@ -22407,23 +22417,88 @@ 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);
+				travelMs = performance.now() - travelStartedAt;
 				if (this.disposed || token !== this.seekToken) return;
 			}
 			this.cursorMs = loc.startMs;
-			const loaded = await this.loadAus(loc.startMs, this.rate !== 0);
+			const loadStartedAt = performance.now();
+			let prefixFed = false;
+			let gopFirst = false;
+			let stateAnnounced = false;
+			if (this.deps.readGop) {
+				const cached = this.scrubCache.covering(this.deps.profile, landMs);
+				let fragment;
+				if (cached) fragment = cached;
+				else {
+					const fragmentLoad = await this.loadScrubFragment(loc, landMs);
+					if (fragmentLoad === null) return;
+					fragment = fragmentLoad.seg;
+					this.scrubCache.put(this.deps.profile, fragment);
+				}
+				if (this.disposed || token !== this.seekToken) return;
+				const fragmentLoc = {
+					kind: "segment",
+					startMs: fragment.startMs,
+					durMs: fragment.durMs,
+					bytes: loc.bytes
+				};
+				this.feedPrefix(fragmentLoc, fragment.aus, landMs);
+				prefixFed = true;
+				gopFirst = true;
+				firstFrameMs = performance.now() - seekStartedAt;
+				this.deps.onState(this.rate === 0 ? "paused" : "playing");
+				this.deps.onPosition(this.cursorMs);
+				this.startPositionReports();
+				stateAnnounced = true;
+			}
+			const fullLoad = this.loadAus(loc.startMs, this.rate !== 0, this.deps.readGop ? void 0 : (video) => {
+				if (this.disposed || token !== this.seekToken) return;
+				this.feedPrefix(loc, video, landMs);
+				prefixFed = true;
+				firstFrameMs = performance.now() - seekStartedAt;
+			});
+			fullLoad.catch(() => {});
+			const loaded = await fullLoad;
+			loadMs = performance.now() - loadStartedAt;
 			if (this.disposed || token !== this.seekToken || loaded === null) return;
-			this.feedPrefix(loc, loaded.video, landMs);
+			if (!prefixFed) this.feedPrefix(loc, loaded.video, landMs);
+			if (gopFirst) {
+				this.currentSegment = {
+					startMs: loc.startMs,
+					durMs: loc.durMs,
+					aus: loaded.video
+				};
+				const targetPtsMs = (loaded.video[0]?.ptsMs ?? 0) + Math.max(0, this.cursorMs - loc.startMs);
+				this.lastFedVideoIdx = -1;
+				for (let i = 0; i < loaded.video.length; i++) {
+					const au = loaded.video[i];
+					if (!au || au.ptsMs > targetPtsMs) break;
+					this.lastFedVideoIdx = i;
+				}
+				if (this.clockHasAdvanced) {
+					this.clock.markSeek();
+					this.audioClock.markSeek();
+				}
+			}
 			if (this.rate === 0) {
-				this.deps.onState("paused");
+				if (!stateAnnounced) {
+					this.deps.onState("paused");
+					this.deps.onPosition(this.cursorMs);
+					this.startPositionReports();
+				}
+				this.logSeekReady(epochMs, seekStartedAt, locateMs, travelMs, loadMs, firstFrameMs, "paused");
+				return;
+			}
+			if (!stateAnnounced) {
+				this.deps.onState("playing");
 				this.deps.onPosition(this.cursorMs);
 				this.startPositionReports();
-				return;
 			}
-			this.deps.onState("playing");
-			this.deps.onPosition(this.cursorMs);
-			this.startPositionReports();
-			const lastFedAu = this.lastFedVideoIdx >= 0 ? loaded.video[this.lastFedVideoIdx] : void 0;
+			this.logSeekReady(epochMs, seekStartedAt, locateMs, travelMs, loadMs, firstFrameMs, "playing");
+			const firstFullAu = loaded.video[0];
+			const resumeAfterPtsMs = gopFirst ? firstFullAu ? firstFullAu.ptsMs + Math.max(0, this.cursorMs - loc.startMs) : null : this.lastFedVideoIdx >= 0 ? loaded.video[this.lastFedVideoIdx]?.ptsMs ?? null : null;
 			this.startAdvance({
 				prepared: {
 					startMs: loc.startMs,
@@ -22431,7 +22506,7 @@ var RecordedFeeder = class {
 					aus: loaded.video,
 					audio: loaded.audio
 				},
-				resumeAfterPtsMs: lastFedAu ? lastFedAu.ptsMs : null
+				resumeAfterPtsMs
 			});
 		} catch (err) {
 			if (!this.disposed && token === this.seekToken) {
@@ -22450,9 +22525,23 @@ var RecordedFeeder = class {
 				this.deps.onState("error");
 			}
 		} finally {
-			if (token === this.seekToken) this.inFlightSeekEpochMs = null;
+			if (token === this.seekToken) {
+				this.inFlightSeekEpochMs = null;
+				this.drainStepQueue();
+			}
 		}
 	}
+	logSeekReady(epochMs, startedAt, locateMs, travelMs, loadMs, firstFrameMs, state) {
+		this.deps.onLog?.("recorded:seek-ready", {
+			epochMs,
+			state,
+			totalMs: Math.round(performance.now() - startedAt),
+			locateMs: Math.round(locateMs),
+			travelMs: Math.round(travelMs),
+			loadMs: Math.round(loadMs),
+			firstFrameMs: Math.round(firstFrameMs)
+		});
+	}
 	/**
 	* Set playback rate. 0 pauses in place (the pacing loop aborts on its next
 	* guard check); any other value is clamped to [0.25, 4].
@@ -22470,10 +22559,12 @@ var RecordedFeeder = class {
 		if (next === this.rate) return;
 		this.rate = next;
 		if (next === 0) {
+			this.advanceToken++;
 			this.stopPositionReports();
 			this.deps.onState("paused");
 			return;
 		}
+		this.pendingStepDirs.length = 0;
 		this.clock.setRate(next);
 		this.seek(this.inFlightSeekEpochMs ?? this.cursorMs);
 	}
@@ -23079,10 +23170,19 @@ var RecordedFeeder = class {
 	* step is still in flight.
 	*/
 	stepFrame(dir) {
-		if (this.disposed || this.rate !== 0 || this.stepInFlight || this.scrubbing) return;
+		if (this.disposed || this.scrubbing) return;
+		if (this.rate !== 0) this.setRate(0);
+		if (this.pendingStepDirs.length < 16) this.pendingStepDirs.push(dir);
+		this.drainStepQueue();
+	}
+	drainStepQueue() {
+		if (this.disposed || this.scrubbing || this.rate !== 0 || this.stepInFlight || this.inFlightSeekEpochMs !== null) return;
+		const dir = this.pendingStepDirs.shift();
+		if (dir === void 0) return;
 		this.stepInFlight = true;
 		this.doStep(dir).catch(() => {}).finally(() => {
 			this.stepInFlight = false;
+			this.drainStepQueue();
 		});
 	}
 	async doStep(dir) {
@@ -23407,7 +23507,7 @@ var RecordedFeeder = class {
 	*  (latest-wins). Returns null on abort. Audio demux failures yield [] (audio
 	*  never blocks video). `wantAudio: false` skips the audio transcode entirely
 	*  (paused scrubs would throw it away). */
-	async loadAus(startMs, wantAudio = true) {
+	async loadAus(startMs, wantAudio = true, onVideoReady) {
 		const token = this.seekToken;
 		const bytes = await this.withTimeout(this.deps.readBytes({
 			deviceId: this.deps.deviceId,
@@ -23415,17 +23515,13 @@ var RecordedFeeder = class {
 			startMs
 		}));
 		if (this.disposed || token !== this.seekToken) return null;
-		const video = await this.withTimeout(this.deps.demux(bytes));
+		const audioPromise = wantAudio && this.deps.demuxAudio && this.resolveAudioPush() !== void 0 ? this.withTimeout(this.deps.demuxAudio(bytes)).catch(() => []) : Promise.resolve([]);
+		const videoPromise = this.withTimeout(this.deps.demux(bytes)).then((video) => {
+			if (!this.disposed && token === this.seekToken) onVideoReady?.(video);
+			return video;
+		});
+		const [video, audio] = await Promise.all([videoPromise, audioPromise]);
 		if (this.disposed || token !== this.seekToken) return null;
-		let audio = [];
-		if (wantAudio && this.deps.demuxAudio && this.resolveAudioPush() !== void 0) {
-			try {
-				audio = await this.withTimeout(this.deps.demuxAudio(bytes));
-			} catch {
-				audio = [];
-			}
-			if (this.disposed || token !== this.seekToken) return null;
-		}
 		return {
 			video,
 			audio
@@ -23536,10 +23632,12 @@ var TimelineSession = class {
 	}
 	async handleControl(msg) {
 		switch (msg.t) {
-			case "playRecorded":
+			case "playRecorded": {
+				const profileChanged = msg.profile !== this.profile;
 				this.profile = msg.profile;
-				await this.enterRecorded().seek(msg.epoch, { travelFromMs: this.lastPositionMs });
+				await (this.mode === "recorded" && this.feeder && !profileChanged ? this.feeder : this.enterRecorded()).seek(msg.epoch, { travelFromMs: this.lastPositionMs });
 				break;
+			}
 			case "seek":
 				await (this.mode === "recorded" && this.feeder ? this.feeder : this.enterRecorded()).seek(msg.epoch, { travelFromMs: this.lastPositionMs });
 				break;