@joewinke/jatui 0.50.1 → 0.52.0

package/dist/components/VideoPlayer.svelte

@@ -26,6 +26,8 @@
 	export type { ResumePoint } from '../video/advisors/resume-point';
 	// mos-5lzns.35 — settings registry + panel.
 	export type { VideoSettingsStore, SettingValue, SettingSpec } from '../video/settings';
+	// jatui-8nu4g — frame capture (what the host's "set as poster" hook receives).
+	export type { VideoFrameCapture } from '../video/capture';
 </script>
 
 <script lang="ts">
@@ -199,6 +201,17 @@
 	} from '../video/rate';
 	import { readTimeParam, WRITE_THROTTLE_MS, writeTimeParam } from '../video/deepLink';
 	import { isContextMenuKey, lineTextWithTime } from '../video/lineMenu';
+	import {
+		CAPTURE_NO_CORS_MESSAGE,
+		CAPTURE_NO_FRAME_MESSAGE,
+		captureActions,
+		captureFilename,
+		clipboardImageSupported,
+		frameDrawSize,
+		isCrossOriginCaptureError,
+		type CaptureAction,
+		type VideoFrameCapture
+	} from '../video/capture';
 	import {
 		biasCells,
 		biasGradient,
@@ -267,6 +280,7 @@
 		SETTINGS_WRITE_DELAY_MS,
 		VIDEO_SETTINGS,
 		REMEMBERED_MUTED,
+		REMEMBERED_SPEAKER_SPEEDS,
 		REMEMBERED_TRANSCRIPT,
 		REMEMBERED_VOLUME,
 		type SettingAvailability,
@@ -307,6 +321,25 @@
 		followResumeMs = FOLLOW_RESUME_IDLE_MS,
 		transcriptLineMenu = true,
 		buildTimeLink = undefined,
+		/**
+		 * Frame capture (jatui-8nu4g, extension-library parity library.js:9262):
+		 * a camera button on the band transport and the `C` key open a menu of
+		 * the frame verbs — Save frame as PNG, Copy frame to clipboard (only
+		 * where the platform can actually write an image; otherwise save-only),
+		 * and Set as poster when `onCaptureFrame` is supplied. Video only —
+		 * audio has no frame to grab. Default on; `false` removes the button
+		 * and the key.
+		 */
+		frameCapture = true,
+		/**
+		 * The host's capture hook — fires with the grabbed frame (PNG Blob,
+		 * data URL, playback time, pixel size, suggested name) when the viewer
+		 * picks "Set as poster"; MOS Studio uploads it and pins the video's
+		 * poster. Without it the menu item simply doesn't exist. May be async;
+		 * the player waits for it before reporting done, and a rejection is
+		 * said, not hidden.
+		 */
+		onCaptureFrame = undefined,
 		theater = $bindable(false),
 		theaterMode = 'width',
 		theaterButton = true,
@@ -509,6 +542,17 @@
 		 * simply not on the menu — the player never guesses a URL.
 		 */
 		buildTimeLink?: (sec: number) => string;
+		/**
+		 * Frame capture (jatui-8nu4g) — see the destructure note above. Reads
+		 * the frame through a canvas, which a cross-origin video without CORS
+		 * taints: the export throws SecurityError and the player SAYS so
+		 * ("Can't capture this video (no CORS)") instead of failing silently.
+		 * Pass `crossorigin="anonymous"` for cross-origin media you want
+		 * frame-readable.
+		 */
+		frameCapture?: boolean;
+		/** The host's "set as poster" hook — receives a `VideoFrameCapture`. */
+		onCaptureFrame?: (capture: VideoFrameCapture) => void | Promise<void>;
 		/**
 		 * Theater mode (jatui-ee2ty) — bindable. NOT fullscreen: the player
 		 * only says it wants the page's width; the HOST lays its page out
@@ -1004,6 +1048,20 @@
 	let lineMenuY = $state(0);
 	let lineMenuSeg = $state<VideoTranscriptSegment | null>(null);
 
+	// ── Frame capture menu (jatui-8nu4g, extension library.js:9262) ────────
+	let captureMenuOpen = $state(false);
+	let captureMenuX = $state(0);
+	let captureMenuY = $state(0);
+	let captureBtnEl: HTMLButtonElement | undefined = $state();
+	/** Feature on: video only, and the host hasn't opted out. */
+	const frameCaptureOn = $derived(frameCapture && !isAudio);
+	/** Can this platform write an IMAGE to the clipboard? Static per page. */
+	const captureClipboardOk = $derived(clipboardImageSupported());
+	/** The verbs on the menu, in order — the pure decision, mapped to items. */
+	const captureMenuActions = $derived(
+		captureActions({ clipboardImage: captureClipboardOk, hostHook: onCaptureFrame != null })
+	);
+
 	let zoomTimer: ReturnType<typeof setTimeout> | null = null;
 	let osdTimer: ReturnType<typeof setTimeout> | null = null;
 
@@ -1488,6 +1546,7 @@
 			if (row.when === 'chapters') return sortedChapters.length > 0;
 		if (row.when === 'rail') return railOn;
 			if (row.when === 'bookmarks') return onAddBookmark != null;
+			if (row.when === 'capture') return frameCaptureOn;
 			if (row.when === 'transcript') return sortedSegments.length > 0;
 			if (row.when === 'comments') return socialMarkers.comments.length > 0;
 			if (row.when === 'night') return nightPresent;
@@ -1566,6 +1625,53 @@
 		resumeFollow();
 	}
 
+	// ── Per-speaker manual speed (E73, jatui-p3m3u) ──────────────────
+	// Extension parity (library.js:4605): the chip menu's "this speaker at
+	// 1.5×". Remembered per viewer through the remembered-settings split (the
+	// host's settingsStore, else this browser's localStorage) — a choice made
+	// before the load-time read resolves wins, like every remembered state.
+	const localSpeedStore = localSettingsStore();
+	let speedsTouched = false;
+	let viewerSpeakerSpeeds = $state<Record<string, number>>({});
+
+	/** Set (or, with rate 1/null, clear) one speaker's manual speed and save it. */
+	function setSpeakerSpeed(key: string, rate: number | null) {
+		const next = { ...viewerSpeakerSpeeds };
+		const r = rate == null || rate === 1 ? null : Math.min(16, Math.max(0.0625, rate));
+		if (r != null) next[key] = r;
+		else delete next[key];
+		viewerSpeakerSpeeds = next;
+		speedsTouched = true;
+		writeRemembered(
+			settingsStore ?? localSpeedStore,
+			REMEMBERED_SPEAKER_SPEEDS.id,
+			Object.keys(next).length > 0 ? { ...next } : {}
+		);
+	}
+
+	function speakerSpeedOf(key: string): number {
+		return viewerSpeakerSpeeds[key] ?? 1;
+	}
+
+	// The load-time read, once: a junk store reads as nothing stored, and a
+	// choice made before the read resolves wins (the settings session's rule).
+	$effect(() => {
+		const store = settingsStore ?? localSpeedStore;
+		let cancelled = false;
+		untrack(() => {
+			void Promise.resolve(store.get(REMEMBERED_SPEAKER_SPEEDS.id))
+				.then((raw) => {
+					if (cancelled || speedsTouched) return;
+					const v = REMEMBERED_SPEAKER_SPEEDS.coerce(raw);
+					if (v !== undefined) viewerSpeakerSpeeds = v;
+				})
+				.catch(() => {});
+		});
+		return () => {
+			cancelled = true;
+		};
+	});
+
 	// ── Speed + rate composer (video/rate/*, mos-5lzns.32) ──────────────────
 	// rate = base × speaker × silence. `base` is the only rate a human chose
 	// and the only one the OSD reports; the advisors multiply into the APPLIED
@@ -1574,10 +1680,27 @@
 	// exactly `base` — the contract in video/rate/compose.ts.
 	const rateTurns = $derived(toRateTurns(speakers));
 	const rateSegments = $derived(toRateSegments(transcript));
+	// E73 (jatui-p3m3u) — the viewer's hand-set per-speaker speeds (the chip
+	// menu, remembered per viewer). They multiply with the automatic advisor
+	// and the base, whatever either is doing; an empty map is the identity.
+	// The chip/legend keys a speaker by IDENTITY (speakerKeyOf), the rate
+	// composer keys by NAME (speakerNameOf) — the index bridges the two.
+	const viewerSpeedByName = $derived.by(() => {
+		const keys = Object.keys(viewerSpeakerSpeeds);
+		if (keys.length === 0) return null;
+		const out: Record<string, number> = {};
+		for (const key of keys) {
+			const info = speakerIndex.get(key);
+			const name = info && info.name !== 'Unknown speaker' ? info.name : key;
+			out[name] = viewerSpeakerSpeeds[key];
+		}
+		return out;
+	});
 	const rateAdvisors = $derived({
 		speakerRates: speakerPace
 			? speakerRateMap({ turns: rateTurns, segments: rateSegments, manual: speakerRates, measure: true })
 			: null,
+		manual: viewerSpeedByName,
 		turns: rateTurns,
 		silence: smartSpeed ? silenceMapFor(waveform, effectiveDuration) : null
 	});
@@ -3184,13 +3307,14 @@
 		// Space/Enter on a focused button activates THAT button (play, a
 		// speaker chip, a transcript row); toggling playback too would undo it.
 		if (tag === 'BUTTON' && (e.key === ' ' || e.key === 'Enter')) return;
-		// The transcript line menu (jatui-3wl5x) owns the keyboard while it is
-		// open: arrows/Enter drive it (its panel preventDefaults what it uses,
-		// which the defaultPrevented guard above already yields to), Escape
-		// closes it, and nothing else drives the player underneath a floating
-		// menu. Tab is the shared ContextMenu's own behaviour (focus moves out
-		// with the menu still up; click/Escape dismiss it).
-		if (lineMenuOpen) return;
+		// The transcript line menu (jatui-3wl5x) and the frame-capture menu
+		// (jatui-8nu4g) own the keyboard while they are open: arrows/Enter drive
+		// them (their panel preventDefaults what it uses, which the
+		// defaultPrevented guard above already yields to), Escape closes, and
+		// nothing else drives the player underneath a floating menu. Tab is the
+		// shared ContextMenu's own behaviour (focus moves out with the menu
+		// still up; click/Escape dismiss it).
+		if (lineMenuOpen || captureMenuOpen) return;
 		// mos-777hj — the chapter rail owns j/k (listNav) and Enter/Space (row
 		// activation) while focus is inside it; without this guard a rail `k`
 		// would also toggle play/pause and a rail `j` also seek ±5s.
@@ -3357,6 +3481,15 @@
 					cycleNight();
 				}
 				return;
+			case 'c':
+			case 'C':
+				// Frame capture (jatui-8nu4g): video only; `frameCapture={false}`
+				// removes the key with the button. Off ⇒ not ours — no
+				// preventDefault, the page may keep it.
+				if (!frameCaptureOn) return;
+				e.preventDefault();
+				openCaptureMenuAtTrigger();
+				return;
 			case 'Home':
 				seekTo(0);
 				break;
@@ -3552,6 +3685,157 @@
 		return items;
 	});
 
+	// ── Frame capture (jatui-8nu4g, extension library.js:9262) ─────────────
+	// The camera button (band transport) and the `C` key both open ONE menu
+	// of frame verbs. The extension also burned a caption into the frame and
+	// ran OCR on it — deliberately not ported (the player has no OCR budget;
+	// hosts that want it can run it on the hook's dataUrl).
+
+	/** Open the menu anchored to the camera button (a click) — or, on a
+	 *  native transport with no button, the stage (`C` still works there);
+	 *  the position:fixed panel is viewport-clamped by floating-ui, so the
+	 *  anchor is a hint, not a law. */
+	function openCaptureMenuAtTrigger() {
+		const rect =
+			captureBtnEl?.getBoundingClientRect() ??
+			stageWrapEl?.getBoundingClientRect() ??
+			rootEl?.getBoundingClientRect();
+		captureMenuX = rect?.left ?? 0;
+		captureMenuY = rect ? rect.bottom + 6 : 0;
+		captureMenuOpen = true;
+	}
+
+	/** The current frame as a canvas at natural size. Null when there is
+	 *  nothing to grab yet — no metadata (videoWidth is 0 until it) or no
+	 *  decoded frame (drawImage refuses to make up pixels). Callers SAY
+	 *  null — never a silent no-op. */
+	function captureCanvas(): { canvas: HTMLCanvasElement; width: number; height: number } | null {
+		const size = frameDrawSize(videoEl);
+		if (!size || !videoEl) return null;
+		const canvas = document.createElement('canvas');
+		canvas.width = size.width;
+		canvas.height = size.height;
+		const ctx = canvas.getContext('2d');
+		if (!ctx) return null;
+		try {
+			ctx.drawImage(videoEl, 0, 0, size.width, size.height);
+		} catch {
+			return null; // no decoded frame yet (readyState too low)
+		}
+		return { canvas, width: size.width, height: size.height };
+	}
+
+	/** canvas.toBlob as a promise. A tainted canvas throws SecurityError out
+	 *  of toBlob itself — re-thrown here so every verb can check the NAME. */
+	function canvasToPng(canvas: HTMLCanvasElement): Promise<Blob> {
+		return new Promise((resolve, reject) => {
+			try {
+				canvas.toBlob(
+					(blob) => (blob ? resolve(blob) : reject(new Error('toBlob produced no blob'))),
+					'image/png'
+				);
+			} catch (e) {
+				reject(e);
+			}
+		});
+	}
+
+	function flashNoFrame() {
+		flashOsd(CAPTURE_NO_FRAME_MESSAGE);
+		announce('No frame yet — wait until the video has loaded a picture');
+	}
+
+	/** The taint verdict, said twice: OSD for the eye, polite region for the
+	 *  screen reader — a silent failure would read as a broken button. */
+	function flashNoCors() {
+		flashOsd(CAPTURE_NO_CORS_MESSAGE);
+		announce(`${CAPTURE_NO_CORS_MESSAGE} — the video host must allow cross-origin reads (CORS) to export frames.`);
+	}
+
+	function flashCaptureFailed(what: string) {
+		flashOsd(`${what} failed`);
+		announce(`${what} failed`);
+	}
+
+	/** Save frame as PNG: draw → toBlob → anchor download. A cross-origin
+	 *  video without CORS throws SecurityError out of toBlob itself —
+	 *  caught, said, never silent. */
+	function saveFrame() {
+		const c = captureCanvas();
+		if (!c) return flashNoFrame();
+		try {
+			c.canvas.toBlob((blob) => {
+				if (!blob) return flashCaptureFailed('Capture');
+				const url = URL.createObjectURL(blob);
+				const a = document.createElement('a');
+				a.href = url;
+				a.download = captureFilename(currentTime);
+				document.body.appendChild(a);
+				a.click();
+				a.remove();
+				setTimeout(() => URL.revokeObjectURL(url), 1000);
+				flashOsd('Frame saved');
+				announce('Frame saved as PNG');
+			}, 'image/png');
+		} catch (e) {
+			if (isCrossOriginCaptureError(e)) flashNoCors();
+			else flashCaptureFailed('Capture');
+		}
+	}
+
+	/** Copy frame: ClipboardItem carrying a PROMISE for the blob — the write
+	 *  call lands inside the click's user-gesture budget while the pixels
+	 *  encode async (Safari's gesture timer is the constraint). Unsupported
+	 *  platforms never get here: the item is omitted, save-only degrade. */
+	async function copyFrame() {
+		const c = captureCanvas();
+		if (!c) return flashNoFrame();
+		try {
+			await navigator.clipboard.write([new ClipboardItem({ 'image/png': canvasToPng(c.canvas) })]);
+			flashOsd('Copied');
+			announce('Frame copied to clipboard');
+		} catch (e) {
+			if (isCrossOriginCaptureError(e)) return flashNoCors();
+			flashCaptureFailed('Copy');
+		}
+	}
+
+	/** Set as poster: hand the frame to the host. MOS Studio uploads the
+	 *  blob and pins the video's poster; other hosts own their meaning. The
+	 *  host's rejection is said, not hidden. */
+	async function sendFrameToHost() {
+		const c = captureCanvas();
+		if (!c) return flashNoFrame();
+		try {
+			const blob = await canvasToPng(c.canvas);
+			const dataUrl = c.canvas.toDataURL('image/png');
+			const capture: VideoFrameCapture = {
+				blob,
+				dataUrl,
+				timeSec: currentTime,
+				width: c.width,
+				height: c.height,
+				name: captureFilename(currentTime)
+			};
+			await onCaptureFrame?.(capture);
+			flashOsd('Frame captured');
+			announce('Frame sent to host');
+		} catch (e) {
+			if (isCrossOriginCaptureError(e)) return flashNoCors();
+			flashCaptureFailed('Set as poster');
+		}
+	}
+
+	/** The menu's items for the verbs this page can actually run. */
+	const captureMenuItems = $derived.by<ContextMenuItem[]>(() => {
+		const verbs: Record<CaptureAction, ContextMenuItem> = {
+			save: { label: 'Save frame as PNG', icon: '⤓', onSelect: saveFrame },
+			copy: { label: 'Copy frame to clipboard', icon: '⧉', onSelect: copyFrame },
+			poster: { label: 'Set as poster', icon: '🖼️', onSelect: sendFrameToHost }
+		};
+		return captureMenuActions.map((a) => verbs[a]);
+	});
+
 	// ── Transcript search (jatui-xmtnv) ───────────────────────────────────
 	/** `/`: open the box (showing the transcript if it was hidden) and hand
 	 *  it focus once it mounts — the effect below lands it. */
@@ -3679,6 +3963,31 @@
 		return t.speakerIdentity ?? t.speakerName ?? UNKNOWN_KEY;
 	}
 
+	// ── Chip speed menu (E73, jatui-p3m3u) ──────────────────────────────────
+	// One menu open at a time; a click anywhere else closes it.
+	let speedMenuKey = $state<string | null>(null);
+	const SPEED_CHOICES = [0.75, 1, 1.25, 1.5, 1.75, 2, 3];
+
+	function toggleSpeedMenu(key: string) {
+		speedMenuKey = speedMenuKey === key ? null : key;
+	}
+	function pickSpeakerSpeed(key: string, name: string, rate: number) {
+		setSpeakerSpeed(key, rate);
+		speedMenuKey = null;
+		flashOsd(rate === 1 ? `${name} · 1×` : `${name} · ${formatSpeedLabel(rate)}`);
+	}
+	$effect(() => {
+		if (speedMenuKey == null) return;
+		const close = (e: PointerEvent) => {
+			// A press inside the open menu (or on its trigger) is the menu's own
+			// click — the buttons close it themselves.
+			if ((e.target as Element | null)?.closest?.('.vp-speed-menu')) return;
+			speedMenuKey = null;
+		};
+		document.addEventListener('pointerdown', close);
+		return () => document.removeEventListener('pointerdown', close);
+	});
+
 	function submitBookmark() {
 		onAddBookmark?.(currentTime, bookmarkLabel.trim());
 		bookmarkLabel = '';
@@ -4160,6 +4469,26 @@
 						aria-valuetext="{Math.round((mutedNow ? 0 : volumeLevel) * 100)}%"
 						oninput={onVolumeInput}
 					/>
+					{#if frameCaptureOn}
+						<!-- Frame capture (jatui-8nu4g): opens the frame verbs menu
+						     (save PNG / copy / set as poster). A picture verb, so it
+						     sits with the picture verbs at the end of the cluster. -->
+						<button
+							type="button"
+							class="vp-tbtn"
+							bind:this={captureBtnEl}
+							aria-haspopup="menu"
+							aria-expanded={captureMenuOpen}
+							aria-label="Capture frame"
+							title="Capture frame · C"
+							onclick={openCaptureMenuAtTrigger}
+						>
+							<svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+								<path d="M3 8.6A1.6 1.6 0 0 1 4.6 7h3.4l1.3-2.2h5.4L16 7h3.4A1.6 1.6 0 0 1 21 8.6v8.8a1.6 1.6 0 0 1-1.6 1.6H4.6A1.6 1.6 0 0 1 3 17.4z" />
+								<circle cx="12" cy="13" r="3.2" />
+							</svg>
+						</button>
+					{/if}
 					{#if !isAudio}
 						<button
 							type="button"
@@ -4201,6 +4530,7 @@
 						{@const key = talkTimeKey(tt)}
 						{@const name = tt.speakerName ?? 'Unknown speaker'}
 						<span class="vp-legend-item">
+							<span class="vp-speed-menu">
 							<button
 								type="button"
 								class="vp-chip"
@@ -4219,6 +4549,37 @@
 								{name}
 								<span class="vp-chip-time">{formatDuration(tt.seconds)}</span>
 							</button>
+							<!-- E73: this speaker's own speed, remembered. 1× is the
+							     reset; the composer clamps the product. -->
+							<button
+								type="button"
+								class="vp-chip-speed"
+								class:on={speakerSpeedOf(key) !== 1}
+								onclick={() => toggleSpeedMenu(key)}
+								aria-expanded={speedMenuKey === key}
+								aria-haspopup="menu"
+								aria-label="Speed for {name}: {formatSpeedLabel(speakerSpeedOf(key))}"
+								title="Speed for {name}"
+							>
+								{formatSpeedLabel(speakerSpeedOf(key))}
+							</button>
+							{#if speedMenuKey === key}
+								<div class="vp-speed-pop" role="menu" aria-label="Speed for {name}">
+									{#each SPEED_CHOICES as choice (choice)}
+										<button
+											type="button"
+											role="menuitemradio"
+											aria-checked={speakerSpeedOf(key) === choice}
+											class="vp-speed-opt"
+											class:current={speakerSpeedOf(key) === choice}
+											onclick={() => pickSpeakerSpeed(key, name, choice)}
+										>
+											{formatSpeedLabel(choice)}{choice === 1 ? ' (reset)' : ''}
+										</button>
+									{/each}
+								</div>
+							{/if}
+							</span>
 							<button
 								type="button"
 								class="vp-mute"
@@ -4523,6 +4884,22 @@
 			onClose={() => (lineMenuSeg = null)}
 		/>
 	{/if}
+
+	{#if frameCaptureOn}
+		<!-- Frame-capture menu (jatui-8nu4g, extension library.js:9262): ONE
+		     panel, opened at the camera button (click) or wherever the `C` key
+		     was pressed from (anchored to the stage on a native transport).
+		     Rendered inside the root so the fill-theater Tab trap keeps cycling
+		     through its items; position:fixed + floating-ui place it wherever
+		     this spot sits in the layout. The header is the frame's own clock. -->
+		<ContextMenu
+			bind:open={captureMenuOpen}
+			x={captureMenuX}
+			y={captureMenuY}
+			items={captureMenuItems}
+			header={formatTime(currentTime, useHours)}
+		/>
+	{/if}
 </div>
 
 <style>
@@ -5499,6 +5876,66 @@
 		border-color: var(--color-primary);
 	}
 
+	/* E73 — per-speaker speed trigger + its menu. The wrapper is the
+	   click-outside boundary: a press inside stays the menu's own click. */
+	.vp-speed-menu {
+		position: relative;
+		display: inline-flex;
+		align-items: center;
+	}
+
+	.vp-chip-speed {
+		padding: var(--jatui-space-xs, 2px) var(--jatui-space-xs, 2px);
+		background: none;
+		border: none;
+		border-radius: var(--jatui-radius-selector, 0.375rem);
+		color: color-mix(in oklch, var(--color-base-content) 60%, transparent);
+		font-size: inherit;
+		font-variant-numeric: tabular-nums;
+		cursor: pointer;
+	}
+
+	.vp-chip-speed.on {
+		color: var(--color-primary);
+		font-weight: 600;
+	}
+
+	.vp-speed-pop {
+		position: absolute;
+		z-index: 30;
+		top: calc(100% + 4px);
+		left: 0;
+		display: flex;
+		flex-direction: column;
+		min-width: 7rem;
+		padding: var(--jatui-space-sm, 4px);
+		background: var(--color-base-100);
+		border: var(--jatui-border-w, 1px) solid color-mix(in oklch, var(--color-base-content) 15%, transparent);
+		border-radius: var(--jatui-radius-selector, 0.375rem);
+		box-shadow: 0 4px 12px rgb(0 0 0 / 0.25);
+	}
+
+	.vp-speed-opt {
+		padding: var(--jatui-space-xs, 2px) var(--jatui-space-md, 6px);
+		background: none;
+		border: none;
+		border-radius: var(--jatui-radius-selector, 0.375rem);
+		color: var(--color-base-content);
+		font-size: inherit;
+		font-variant-numeric: tabular-nums;
+		text-align: left;
+		cursor: pointer;
+	}
+
+	.vp-speed-opt:hover {
+		background: color-mix(in oklch, var(--color-base-content) 8%, transparent);
+	}
+
+	.vp-speed-opt.current {
+		color: var(--color-primary);
+		font-weight: 600;
+	}
+
 	.vp-chip-clear {
 		background: none;
 		color: var(--color-primary);

package/dist/components/VideoPlayer.svelte.d.ts

@@ -9,6 +9,7 @@ export type { VideoAdSpan, RateReport } from '../video/rate';
 export type { WindDownState, WindDownPhase, PresenceSource, VideoResumeStore, FlipSource } from '../video/presence';
 export type { ResumePoint } from '../video/advisors/resume-point';
 export type { VideoSettingsStore, SettingValue, SettingSpec } from '../video/settings';
+export type { VideoFrameCapture } from '../video/capture';
 /**
      * VideoPlayer — one video surface for everything, from a bare mp4 to a
      * fully-analysed recording.
@@ -71,6 +72,7 @@ import { type BandState } from '../video/band/axis';
 import { type VideoLumaTrack } from '../video/band/luma';
 import { type VideoMarker } from '../video/band/markers';
 import { type RateReport, type VideoAdSpan } from '../video/rate';
+import { type VideoFrameCapture } from '../video/capture';
 import { type NightMode, type NightWindow } from '../video/night/clock';
 import { type AudioBrokenReason, type AudioState } from '../video/audio';
 import { type FlipSource, type VideoResumeStore, type WindDownState } from '../video/presence';
@@ -209,6 +211,17 @@ type $$ComponentProps = {
      * simply not on the menu — the player never guesses a URL.
      */
     buildTimeLink?: (sec: number) => string;
+    /**
+     * Frame capture (jatui-8nu4g) — see the destructure note above. Reads
+     * the frame through a canvas, which a cross-origin video without CORS
+     * taints: the export throws SecurityError and the player SAYS so
+     * ("Can't capture this video (no CORS)") instead of failing silently.
+     * Pass `crossorigin="anonymous"` for cross-origin media you want
+     * frame-readable.
+     */
+    frameCapture?: boolean;
+    /** The host's "set as poster" hook — receives a `VideoFrameCapture`. */
+    onCaptureFrame?: (capture: VideoFrameCapture) => void | Promise<void>;
     /**
      * Theater mode (jatui-ee2ty) — bindable. NOT fullscreen: the player
      * only says it wants the page's width; the HOST lays its page out

package/dist/video/README.md

@@ -18,8 +18,9 @@ props + callback surfaces.
 | `band.ts` | .28 (done) — extended by **.30** | The timeline band: zoom window (`BandWindow`, `zoomAt`, `followPlayhead`), hit tests (`segmentAt`, `chapterAt`, `biasToSegmentStart`, `nearestBookmark`), and `paintBand` (canvas). .30 adds one-axis arbitration + the light ribbon; its state lives HERE. |
 | `band/` | **.30** (done) | `window.ts` — the zoom-window math (moved out of band.ts, re-exported there; shared by every band layer without an import cycle). `axis.ts` — one-axis four-state arbitration (`resolveAxis`, `BandState`, the churn-guarded microtask `createBandReporter`), `playheadX` (the one "where you are" mapping — ≤0.2px agreement) and `overviewBracket`. `luma.ts` — the light track (`VideoLumaTrack`, the sidecar verbatim) → ribbon (`v² × 0.55`, max-per-interval). `markers.ts` — `VideoMarker` comments (clustered dots) + like heat. |
 | `keys.ts` | .28 (done) | The keyboard map — `PLAYER_KEYS` (the `?` overlay renders it), `chapterJump`, `FRAME_STEP_SEC`. Every key that exists is in the map; a key not in the map doesn't exist. |
-| `rate.ts` + `rate/` | .28 contract — **.32** (done) | `rate.ts` is the barrel. `compose.ts` — the contract (`composeRate`, clamp [0.0625, 16], `shouldWriteRate`'s 0.001 deadband with an exact return to base), the `SPEED_STEPS` staircase, `formatSpeedLabel`. `speaker.ts` — props → `advisors/speaker-rate`; manual rates keyed by NAME always beat measured. `silence.ts` — waveform → `advisors/smart-speed` map + boost + the OSD saving claim. `ads.ts` — `adSpans` ∪ `ad: true` turns; skip only when PLAYBACK runs into an ad, never when a seek lands in one. `tick.ts` — the component's own 120ms loop's one-tick decision. None of them write `playbackRate`; they advise. |
+| `rate.ts` + `rate/` | .28 contract — **.32** (done) | `rate.ts` is the barrel. `compose.ts` — the contract (`composeRate`, clamp [0.0625, 16], `shouldWriteRate`'s 0.001 deadband with an exact return to base), the `SPEED_STEPS` staircase, `formatSpeedLabel`. `speaker.ts` — props → `advisors/speaker-rate`; manual rates keyed by NAME always beat measured. `silence.ts` — waveform → `advisors/smart-speed` map + boost + the OSD saving claim. `ads.ts` — `adSpans` ∪ `ad: true` turns; skip only when PLAYBACK runs into an ad, never when a seek lands in one. `tick.ts` — the component's own 120ms loop's one-tick decision. `manual` (E73, jatui-p3m3u) — the viewer's remembered per-speaker speeds from the chip menu, multiplying with the automatic advisor; the composer clamps the product. None of them write `playbackRate`; they advise. |
 | `deepLink.ts` | .28 (done) | `?t=` parse/format/read/write (replaceState, throttled, other params preserved) + `buildTimeUrl` (jatui-3wl5x) — the `?t=` URL builder hosts pass as `buildTimeLink` (MOS's "copy link at this time" shape). |
+| `capture.ts` | **jatui-8nu4g** (done) | The frame-capture menu's pure pieces (extension-library parity, library.js:9262): `captureFilename` (the frame clock as the name — `frame-1m30s.png`, junk times clamp to 0), `clipboardImageSupported` (secure context + `navigator.clipboard.write` + `ClipboardItem` — false ⇒ save-only degrade, the Copy row is OMITTED, never dead), `captureActions` (which verbs the menu carries — save always, copy only where the platform can write an image, poster only when the host supplied `onCaptureFrame`), `frameDrawSize` (null before metadata — a 0×0 canvas is never a valid capture), `isCrossOriginCaptureError` (the SecurityError NAME is the contract — a tainted canvas throws SecurityError out of toBlob/toDataURL itself) and `VideoFrameCapture` (what the host's "set as poster" hook receives: blob, dataUrl, timeSec, width, height, name). The component owns the canvas and the `<video>` (drawImage / toBlob / toDataURL / download / clipboard calls live there); a cross-origin video without CORS is SAID — `CAPTURE_NO_CORS_MESSAGE` on the OSD + polite region, never a silent no-op. |
 | `lineMenu.ts` | **jatui-3wl5x** | The transcript line right-click menu's pure pieces: `isContextMenuKey` (the keyboard's right-click — Context-menu key or Shift+F10) and `lineTextWithTime` (`[1:23] text`, the row's own clock). The component owns the DOM — which row opened it, cursor vs row anchoring, focus return — and the menu itself is the shared `ContextMenu`. |
 | `transcriptSearch.ts` | **jatui-xmtnv** (E25/E57) | The transcript search + wheel line-scrub pure helpers: `searchHits` (case-insensitive, non-overlapping), `highlightRowHtml` (`<mark>`s around matches, everything else escaped — host transcript text is never markup), `pickMatch` (Enter walks matches from the playhead, wrapping), `lineScrubTarget` + `transcriptWheelDecision`/`effectiveWheelDelta` (Shift+wheel steps a line per ~100px notch; a plain wheel is never claimed). The component owns the box, focus, Esc layering and the `n / m` count. |
 | `settings.ts` + `settings/` | **.35** (done) — knobs added by .30–.34 | `settings.ts` is the barrel. `registry.ts` — `VIDEO_SETTINGS`: id, group, label, **mandatory hint**, the prop it drives, the availability gate (`when`); `coerce` never throws (hostile values, throwing `valueOf`, Symbols → undefined). Labels/hints are the single source for the panel AND a host help page. `store.ts` — the host-supplied `VideoSettingsStore` (`get`/`set`, either async; jatui never persists on its own) and `createSettingsSession`: coerced reads, a choice made on screen beats a late read, per-id debounced writes flushed on close. `panel.ts` — `panelGroups` (rows only for features this player has — omitted, never disabled), value formatting, radio stepping. `SettingsPanel.svelte` — the generated dialog (switch / radio group / range, focus trap, Esc/`,` close, focus handed back). `remembered.ts` (jatui-xz6so) — remembered MEDIA state (E12: volume + mute survive a reload), coerced like settings and persisted through the same store split (`settingsStore`, else guarded localStorage) but deliberately never panel rows: remembering is not configuring. In the component a stored choice overlays its prop but never creates a presence-gated feature; `night`/`nightDepth` are written through their bindings and `N`/the moon wheel are saved back. The one permission ask is `sleep.desktopIdle` turned on, from that click. A knob lands WITH its reader. |

package/dist/video/capture.d.ts

@@ -0,0 +1,90 @@
+/**
+ * VideoPlayer frame capture (jatui-8nu4g — extension-library parity,
+ * library.js:9262) — the capture menu's PURE pieces, per the advisor
+ * doctrine: no DOM here, no element, no settings reads. The component owns
+ * the canvas and the `<video>` (the drawImage / toBlob / toDataURL /
+ * download / clipboard calls live there); everything that DECIDES lives in
+ * this file so it stays node-testable.
+ *
+ * The verbs: Save frame as PNG (always), Copy frame to clipboard (only
+ * where the platform can actually write an image — secure context +
+ * `navigator.clipboard.write` + `ClipboardItem` — otherwise the item is
+ * OMITTED, never a dead menu row), and Set as poster (only when the host
+ * supplies `onCaptureFrame`; the host owns what "poster" means).
+ *
+ * Cross-origin video without CORS taints the canvas: toBlob/toDataURL
+ * throw SecurityError. The component catches that and says so —
+ * `CAPTURE_NO_CORS_MESSAGE` — never a silent no-op.
+ */
+/** The OSD + polite-region message for a tainted canvas (no CORS). */
+export declare const CAPTURE_NO_CORS_MESSAGE = "Can't capture this video (no CORS)";
+/** The message when there is no decodable frame to grab yet. */
+export declare const CAPTURE_NO_FRAME_MESSAGE = "No frame yet";
+/**
+ * The suggested download name for the frame at `sec`: `frame-1m30s.png`,
+ * `frame-1h02m30s.png` on long videos, seconds zero-padded. A junk time
+ * (negative, NaN) clamps to 0 — a filename never carries NaN.
+ */
+export declare function captureFilename(sec: number): string;
+/** The pieces of the platform a clipboard IMAGE write needs. */
+export interface ClipboardImageEnv {
+    /** `navigator.clipboard?.write` — undefined off a secure context. */
+    clipboardWrite?: unknown;
+    /** `window.isSecureContext`. */
+    isSecureContext?: boolean;
+    /** The global `ClipboardItem` constructor. */
+    clipboardItem?: unknown;
+}
+/**
+ * Can this platform write an image to the clipboard? A clipboard image
+ * write needs a secure context (navigator.clipboard only exists on HTTPS /
+ * localhost), the `write` method, and the `ClipboardItem` constructor.
+ * False ⇒ the component degrades to save-only: the Copy item is omitted,
+ * never rendered dead.
+ */
+export declare function clipboardImageSupported(env?: ClipboardImageEnv): boolean;
+/** The capture menu's verbs, in menu order. */
+export type CaptureAction = 'save' | 'copy' | 'poster';
+/**
+ * Which verbs the capture menu carries. Save is always there; Copy only
+ * where the platform can write an image (degrade to save-only); the poster
+ * hook only when the host supplied `onCaptureFrame`. Omitted — never
+ * disabled — matching the settings-panel doctrine.
+ */
+export declare function captureActions(opts?: {
+    clipboardImage?: boolean;
+    hostHook?: boolean;
+}): CaptureAction[];
+/** What `onCaptureFrame` receives when the viewer picks "Set as poster". */
+export interface VideoFrameCapture {
+    /** The frame as an `image/png` Blob — upload it, attach it, store it. */
+    blob: Blob;
+    /** The same frame as a PNG data URL — preview without an objectURL lifecycle. */
+    dataUrl: string;
+    /** Playback time the frame was grabbed at (seconds). */
+    timeSec: number;
+    /** Natural frame dimensions in px. */
+    width: number;
+    height: number;
+    /** Suggested filename — `captureFilename(timeSec)`. */
+    name: string;
+}
+/**
+ * The natural frame size to draw at, or null before metadata has landed
+ * (videoWidth/videoHeight are 0 until then — there is nothing to grab yet,
+ * and a 0×0 canvas is never a valid capture).
+ */
+export declare function frameDrawSize(video: {
+    videoWidth?: number | null;
+    videoHeight?: number | null;
+}): {
+    width: number;
+    height: number;
+} | null;
+/**
+ * A SecurityError from the canvas means the media's bytes are not readable
+ * from this origin (cross-origin without CORS) — the export path, not the
+ * player, is refusing. Other engines word it differently; the NAME is the
+ * contract.
+ */
+export declare function isCrossOriginCaptureError(e: unknown): boolean;

package/dist/video/capture.js

@@ -0,0 +1,104 @@
+/**
+ * VideoPlayer frame capture (jatui-8nu4g — extension-library parity,
+ * library.js:9262) — the capture menu's PURE pieces, per the advisor
+ * doctrine: no DOM here, no element, no settings reads. The component owns
+ * the canvas and the `<video>` (the drawImage / toBlob / toDataURL /
+ * download / clipboard calls live there); everything that DECIDES lives in
+ * this file so it stays node-testable.
+ *
+ * The verbs: Save frame as PNG (always), Copy frame to clipboard (only
+ * where the platform can actually write an image — secure context +
+ * `navigator.clipboard.write` + `ClipboardItem` — otherwise the item is
+ * OMITTED, never a dead menu row), and Set as poster (only when the host
+ * supplies `onCaptureFrame`; the host owns what "poster" means).
+ *
+ * Cross-origin video without CORS taints the canvas: toBlob/toDataURL
+ * throw SecurityError. The component catches that and says so —
+ * `CAPTURE_NO_CORS_MESSAGE` — never a silent no-op.
+ */
+/** The OSD + polite-region message for a tainted canvas (no CORS). */
+export const CAPTURE_NO_CORS_MESSAGE = "Can't capture this video (no CORS)";
+/** The message when there is no decodable frame to grab yet. */
+export const CAPTURE_NO_FRAME_MESSAGE = 'No frame yet';
+/**
+ * The suggested download name for the frame at `sec`: `frame-1m30s.png`,
+ * `frame-1h02m30s.png` on long videos, seconds zero-padded. A junk time
+ * (negative, NaN) clamps to 0 — a filename never carries NaN.
+ */
+export function captureFilename(sec) {
+    const t = Number.isFinite(sec) ? Math.max(0, Math.floor(sec)) : 0;
+    const h = Math.floor(t / 3600);
+    const m = Math.floor((t % 3600) / 60);
+    const s = t % 60;
+    const ss = String(s).padStart(2, '0');
+    const clock = h > 0 ? `${h}h${String(m).padStart(2, '0')}m${ss}s` : `${m}m${ss}s`;
+    return `frame-${clock}.png`;
+}
+/**
+ * Reads the real platform (SSR/node safe — every global behind a typeof).
+ * Isolated from the predicate so tests inject fakes instead of stubbing
+ * globals.
+ */
+function currentClipboardImageEnv() {
+    if (typeof navigator === 'undefined')
+        return { isSecureContext: false, clipboardItem: undefined };
+    const clip = navigator.clipboard;
+    let item = undefined;
+    try {
+        // Reference the global indirectly: a bare `typeof ClipboardItem` is
+        // fine, but keeping it in one place documents that ONLY its existence
+        // matters here, not what it can hold.
+        item = typeof ClipboardItem === 'function' ? ClipboardItem : undefined;
+    }
+    catch {
+        item = undefined;
+    }
+    return {
+        clipboardWrite: clip?.write,
+        isSecureContext: typeof window !== 'undefined' ? window.isSecureContext === true : false,
+        clipboardItem: item
+    };
+}
+/**
+ * Can this platform write an image to the clipboard? A clipboard image
+ * write needs a secure context (navigator.clipboard only exists on HTTPS /
+ * localhost), the `write` method, and the `ClipboardItem` constructor.
+ * False ⇒ the component degrades to save-only: the Copy item is omitted,
+ * never rendered dead.
+ */
+export function clipboardImageSupported(env = currentClipboardImageEnv()) {
+    return typeof env.clipboardWrite === 'function' && env.isSecureContext === true && typeof env.clipboardItem === 'function';
+}
+/**
+ * Which verbs the capture menu carries. Save is always there; Copy only
+ * where the platform can write an image (degrade to save-only); the poster
+ * hook only when the host supplied `onCaptureFrame`. Omitted — never
+ * disabled — matching the settings-panel doctrine.
+ */
+export function captureActions(opts = {}) {
+    const actions = ['save'];
+    if (opts.clipboardImage)
+        actions.push('copy');
+    if (opts.hostHook)
+        actions.push('poster');
+    return actions;
+}
+/**
+ * The natural frame size to draw at, or null before metadata has landed
+ * (videoWidth/videoHeight are 0 until then — there is nothing to grab yet,
+ * and a 0×0 canvas is never a valid capture).
+ */
+export function frameDrawSize(video) {
+    const w = video?.videoWidth ?? 0;
+    const h = video?.videoHeight ?? 0;
+    return w > 0 && h > 0 ? { width: w, height: h } : null;
+}
+/**
+ * A SecurityError from the canvas means the media's bytes are not readable
+ * from this origin (cross-origin without CORS) — the export path, not the
+ * player, is refusing. Other engines word it differently; the NAME is the
+ * contract.
+ */
+export function isCrossOriginCaptureError(e) {
+    return e instanceof DOMException && e.name === 'SecurityError';
+}

package/dist/video/keys.d.ts

@@ -11,8 +11,9 @@
  * none yet).
  * Deliberately NOT ported: F/M (favourite/file-under — library-app verbs,
  * not player verbs). N (night cycle) landed with the night module
- * (mos-5lzns.33) and `,` (settings) with the settings panel
- * (mos-5lzns.35), each gated on the host opting in.
+ * (mos-5lzns.33), `,` (settings) with the settings panel (mos-5lzns.35) and
+ * C (frame capture) with the capture menu (jatui-8nu4g, extension
+ * library.js:9262), each gated on the host opting in.
  */
 export interface PlayerKeyRow {
     /** Keycap label as shown in the help overlay — `/`-separated alternates. */
@@ -22,7 +23,7 @@ export interface PlayerKeyRow {
      * Availability gate: the row is only advertised (and the key only bound)
      * when the feature's data exists. Undefined ⇒ always active.
      */
-    when?: 'chapters' | 'rail' | 'bookmarks' | 'transcript' | 'comments' | 'night' | 'settings' | 'theater';
+    when?: 'chapters' | 'rail' | 'bookmarks' | 'capture' | 'transcript' | 'comments' | 'night' | 'settings' | 'theater';
 }
 /** Order follows the help overlay: transport, seek, volume, speed, structure. */
 export declare const PLAYER_KEYS: PlayerKeyRow[];

package/dist/video/keys.js

@@ -11,8 +11,9 @@
  * none yet).
  * Deliberately NOT ported: F/M (favourite/file-under — library-app verbs,
  * not player verbs). N (night cycle) landed with the night module
- * (mos-5lzns.33) and `,` (settings) with the settings panel
- * (mos-5lzns.35), each gated on the host opting in.
+ * (mos-5lzns.33), `,` (settings) with the settings panel (mos-5lzns.35) and
+ * C (frame capture) with the capture menu (jatui-8nu4g, extension
+ * library.js:9262), each gated on the host opting in.
  */
 /** Order follows the help overlay: transport, seek, volume, speed, structure. */
 export const PLAYER_KEYS = [
@@ -32,6 +33,10 @@ export const PLAYER_KEYS = [
     // and "people's reactions to it" sit under one hand (mos-5lzns.30).
     { keys: '{ / }', description: 'Previous / next comment', when: 'comments' },
     { keys: 'B', description: 'Bookmark at the current time', when: 'bookmarks' },
+    // C (jatui-8nu4g, extension library.js:9262) — the frame-capture menu:
+    // save the current frame as PNG, copy it (where the platform can write
+    // images), and set as poster when the host supplies the hook. Video only.
+    { keys: 'C', description: 'Frame capture: save PNG / copy / set as poster', when: 'capture' },
     // t = theater, YouTube's key; the transcript moved to Shift+T (jatui-ee2ty).
     { keys: 't', description: 'Theater mode on / off', when: 'theater' },
     { keys: 'Shift+T', description: 'Cycle transcript layout: side / below / hidden', when: 'transcript' },

package/dist/video/rate/tick.d.ts

@@ -17,6 +17,13 @@ export declare const RATE_TICK_MS = 120;
 export interface RateAdvisors {
     /** null ⇒ the speaker advisor is off (collapses to 1). */
     speakerRates: RateMap | null;
+    /**
+     * Viewer hand-set per-speaker speeds (the chip menu, remembered). They
+     * MULTIPLY with the automatic advisor — "this speaker at 1.5×" is the
+     * viewer's intent and stands on top of whatever the pace advisor measured.
+     * null/empty ⇒ 1 (the identity; see compose.ts).
+     */
+    manual?: RateMap | null;
     turns: RateTurn[];
     /** null ⇒ smart speed is off or has no map yet (collapses to 1). */
     silence: SilenceMap | null;

package/dist/video/rate/tick.js

@@ -5,11 +5,14 @@ import { speakerFactor } from './speaker';
 export const RATE_TICK_MS = 120;
 /** The composed rate at playhead `t` for the human's `base`. */
 export function adviseRate(base, t, a) {
-    const speaker = speakerFactor(t, a.turns, a.speakerRates);
+    const speaker = speakerFactor(t, a.turns, a.speakerRates) * speakerFactor(t, a.turns, a.manual ?? null);
     const silence = silenceFactor(t, a.silence, a.boost ?? null);
     return { speaker, silence, rate: composeRate(base, speaker, silence).rate };
 }
 /** Is any advisor able to move the rate? False ⇒ the loop need not run. */
 export function advisorsActive(a) {
-    return !!a.silence || (!!a.speakerRates && a.turns.length > 0 && Object.keys(a.speakerRates).length > 0);
+    const manual = a.manual;
+    return (!!a.silence ||
+        (!!manual && a.turns.length > 0 && Object.keys(manual).length > 0) ||
+        (!!a.speakerRates && a.turns.length > 0 && Object.keys(a.speakerRates).length > 0));
 }

package/dist/video/settings/remembered.d.ts

@@ -35,5 +35,15 @@ export declare const REMEMBERED_VOLUME: RememberedSpec<number>;
  */
 export type TranscriptLayout = 'side' | 'below' | 'hidden';
 export declare const REMEMBERED_TRANSCRIPT: RememberedSpec<TranscriptLayout>;
+/**
+ * Remembered per-speaker playback speed (E73, jatui-p3m3u) — the chip menu's
+ * "this speaker at 1.5×" survives a reload. A record keyed by speaker NAME
+ * (the display name in the legend), coerced entry-by-entry: junk names and
+ * rates outside the composer's clamp range drop out, so a hostile store reads
+ * as nothing stored rather than a speed of 10⁹. Composed multiplicatively
+ * with the user's speed and the automatic pace advisor by the rate composer
+ * (rate/tick.ts), which clamps the product.
+ */
+export declare const REMEMBERED_SPEAKER_SPEEDS: RememberedSpec<Record<string, number>>;
 /** Whether playback starts muted. */
 export declare const REMEMBERED_MUTED: RememberedSpec<boolean>;

package/dist/video/settings/remembered.js

@@ -39,6 +39,40 @@ export const REMEMBERED_TRANSCRIPT = {
         return undefined;
     }
 };
+/**
+ * Remembered per-speaker playback speed (E73, jatui-p3m3u) — the chip menu's
+ * "this speaker at 1.5×" survives a reload. A record keyed by speaker NAME
+ * (the display name in the legend), coerced entry-by-entry: junk names and
+ * rates outside the composer's clamp range drop out, so a hostile store reads
+ * as nothing stored rather than a speed of 10⁹. Composed multiplicatively
+ * with the user's speed and the automatic pace advisor by the rate composer
+ * (rate/tick.ts), which clamps the product.
+ */
+export const REMEMBERED_SPEAKER_SPEEDS = {
+    id: 'player.speakerSpeeds',
+    default: {},
+    coerce(raw) {
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+            return undefined;
+        const src = raw;
+        const out = {};
+        let any = false;
+        for (const [k, v] of Object.entries(src)) {
+            const name = k.trim();
+            try {
+                const n = typeof v === 'number' ? v : typeof v === 'string' && v.trim() !== '' ? Number(v) : NaN;
+                if (name && Number.isFinite(n) && n >= 0.0625 && n <= 16) {
+                    out[name] = n;
+                    any = true;
+                }
+            }
+            catch {
+                /* a throwing valueOf is a value not stored */
+            }
+        }
+        return any ? out : undefined;
+    }
+};
 /** Whether playback starts muted. */
 export const REMEMBERED_MUTED = {
     id: 'player.muted',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joewinke/jatui",
-  "version": "0.50.1",
+  "version": "0.52.0",
   "private": false,
   "description": "Shared Svelte 5 component library for JAT projects",
   "type": "module",