@joewinke/jatui 0.15.0 → 0.16.0

package/dist/components/VideoPlayer.svelte

@@ -22,6 +22,8 @@
 	// mos-5lzns.34 — presence (wind-down, resume-at-sentence, FLIP open).
 	export type { WindDownState, WindDownPhase, PresenceSource, VideoResumeStore, FlipSource } from '../video/presence';
 	export type { ResumePoint } from '../video/advisors/resume-point';
+	// mos-5lzns.35 — settings registry + panel.
+	export type { VideoSettingsStore, SettingValue, SettingSpec } from '../video/settings';
 </script>
 
 <script lang="ts">
@@ -219,6 +221,17 @@
 		type WindDownState
 	} from '../video/presence';
 	import type { ResumePoint } from '../video/advisors/resume-point';
+	import { idleDetectionSupported } from '../video/presence';
+	import {
+		createSettingsSession,
+		panelGroups,
+		VIDEO_SETTINGS,
+		type SettingAvailability,
+		type SettingsSession,
+		type SettingValue,
+		type VideoSettingsStore
+	} from '../video/settings';
+	import SettingsPanel from '../video/settings/SettingsPanel.svelte';
 
 	let {
 		src,
@@ -262,7 +275,7 @@
 		syncUrlTime = false,
 		luma = null,
 		markers = [],
-		oneAxis = true,
+		oneAxis: oneAxisProp = true,
 		onBandChange = undefined,
 		onMarkerClick = undefined,
 		onTimeUpdate = undefined,
@@ -271,35 +284,39 @@
 		night = $bindable(),
 		nightDepth = $bindable(NIGHT_DEPTH_DEFAULT),
 		nightWindow = null,
-		biasLight = true,
-		predictive = true,
-		strobeGuard = true,
+		biasLight: biasLightProp = true,
+		predictive: predictiveProp = true,
+		strobeGuard: strobeGuardProp = true,
 		onNightModeChange = undefined,
 		onNightBlind = undefined,
-		loudness = undefined,
-		loudnessTarget = AUDIO_TARGET_DEFAULT,
-		quietListening = undefined,
-		limiter = undefined,
+		loudness: loudnessProp = undefined,
+		loudnessTarget: loudnessTargetProp = AUDIO_TARGET_DEFAULT,
+		quietListening: quietListeningProp = undefined,
+		limiter: limiterProp = undefined,
 		onAudioState = undefined,
 		onAudioBroken = undefined,
-		smartSpeed = false,
-		speakerPace = false,
+		smartSpeed: smartSpeedProp = false,
+		speakerPace: speakerPaceProp = false,
 		speakerRates = null,
 		adSpans = null,
-		skipAds = false,
+		skipAds: skipAdsProp = false,
 		onRateChange = undefined,
-		windDown = undefined,
-		windDownAfter = WIND_DOWN_AFTER_DEFAULT,
-		windDownNightOnly = true,
-		idleDetection = false,
+		windDown: windDownProp = undefined,
+		windDownAfter: windDownAfterProp = WIND_DOWN_AFTER_DEFAULT,
+		windDownNightOnly: windDownNightOnlyProp = true,
+		idleDetection: idleDetectionProp = false,
 		onWindDown = undefined,
 		resumeKey = null,
 		resumeStore = undefined,
-		resumeSnap = true,
+		resumeSnap: resumeSnapProp = true,
 		onResume = undefined,
 		openFrom = undefined,
 		openPoster = null,
-		openMotion = true,
+		openMotion: openMotionProp = true,
+		settingsStore = undefined,
+		settingsPanel = false,
+		settingsHelpHref = null,
+		onSettingChange = undefined,
 		class: className = ''
 	}: {
 		src: string;
@@ -578,9 +595,68 @@
 		openPoster?: string | null;
 		/** Run the motion half of the open (default true). Off ⇒ poster only. */
 		openMotion?: boolean;
+		/**
+		 * Settings (mos-5lzns.35): where the viewer's standing choices live —
+		 * `{ get(id), set(id, value) }`, either may be async, keyed by the ids
+		 * in `VIDEO_SETTINGS`. jatui never persists on its own (no
+		 * localStorage, no API): a host with per-user state passes its own
+		 * adapter. Every stored value is coerced; junk reads as nothing.
+		 *
+		 * A stored choice overrides the matching prop — the prop is the
+		 * host's DEFAULT, the stored value is the viewer's decision. It never
+		 * creates a feature the host left out: a stored `audio.level` does
+		 * nothing on a player with no `loudness` prop. `night.mode` /
+		 * `night.depth` are written into the bindable `night` / `nightDepth`,
+		 * and `N` / the moon wheel are saved back through the store.
+		 */
+		settingsStore?: VideoSettingsStore;
+		/**
+		 * Show the settings panel (default off — inert): a gear in the control
+		 * strip and the `,` key open it. The panel is generated from the
+		 * registry and shows only rows for features THIS player has (host
+		 * opted in and the data exists). Without a `settingsStore`, choices
+		 * last while the player is mounted.
+		 */
+		settingsPanel?: boolean;
+		/** A host page explaining the settings — linked from the panel's footer. */
+		settingsHelpHref?: string | null;
+		/** The viewer changed a setting (panel, `N`, the moon wheel). Coerced value. */
+		onSettingChange?: (id: string, value: SettingValue) => void;
 		class?: string;
 	} = $props();
 
+	// ── Settings overlay (mos-5lzns.35) ─────────────────────────────────────
+	// The viewer's stored/panel choices, coerced, keyed by registry id. Each
+	// feature reads the EFFECTIVE value below under its prop's own name, so
+	// no reader changed: the choice wins over the host's prop, but a
+	// presence-gated feature (prop left undefined) stays absent whatever is
+	// stored. night / nightDepth are bindable and written directly instead.
+	let userSettings = $state<Record<string, SettingValue>>({});
+	function chosen<T>(id: string, prop: T): T {
+		const v = userSettings[id];
+		return (v === undefined ? prop : v) as T;
+	}
+	function chosenIfPresent<T>(id: string, prop: T | undefined): T | undefined {
+		return prop === undefined ? undefined : chosen(id, prop);
+	}
+	const oneAxis = $derived(chosen('player.oneAxis', oneAxisProp));
+	const biasLight = $derived(chosen('night.bias', biasLightProp));
+	const predictive = $derived(chosen('player.predictive', predictiveProp));
+	const strobeGuard = $derived(chosen('player.strobeGuard', strobeGuardProp));
+	const loudness = $derived(chosenIfPresent('audio.level', loudnessProp));
+	const loudnessTarget = $derived(chosen('audio.target', loudnessTargetProp));
+	const quietListening = $derived(chosenIfPresent('audio.quiet', quietListeningProp));
+	const limiter = $derived(chosenIfPresent('audio.limiter', limiterProp));
+	const smartSpeed = $derived(chosen('player.smartSpeed', smartSpeedProp));
+	const speakerPace = $derived(chosen('player.speakerRate', speakerPaceProp));
+	const skipAds = $derived(chosen('player.skipAds', skipAdsProp));
+	const windDown = $derived(chosenIfPresent('sleep.enabled', windDownProp));
+	const windDownAfter = $derived(chosen('sleep.after', windDownAfterProp));
+	const windDownNightOnly = $derived(chosen('sleep.nightOnly', windDownNightOnlyProp));
+	const idleDetection = $derived(chosen('sleep.desktopIdle', idleDetectionProp));
+	const resumeSnap = $derived(chosen('player.resumeSnap', resumeSnapProp));
+	const openMotion = $derived(chosen('player.openMotion', openMotionProp));
+
 	// prefers-reduced-motion gate for autoplay: an autoplaying clip IS motion, so
 	// under the reduce preference the video holds on its poster instead. Tracked
 	// live (media query listener) so a mid-session preference flip is honoured, and
@@ -778,6 +854,7 @@
 			if (row.when === 'transcript') return sortedSegments.length > 0;
 			if (row.when === 'comments') return socialMarkers.comments.length > 0;
 			if (row.when === 'night') return nightPresent;
+			if (row.when === 'settings') return settingsPanel;
 			return true;
 		})
 	);
@@ -1254,6 +1331,7 @@
 	function setNightMode(mode: NightMode) {
 		night = mode;
 		onNightModeChange?.(mode);
+		rememberSetting('night.mode', mode);
 	}
 	function cycleNight() {
 		if (night === undefined) return;
@@ -1268,6 +1346,7 @@
 		e.stopPropagation();
 		if (!nightArmedNow) setNightMode('on');
 		nightDepth = nudgeDepth(nightDepth, e.deltaY < 0 ? 1 : -1);
+		rememberSetting('night.depth', nightDepth);
 		flashOsd(`Night ${Math.round(clampDepth(nightDepth) * 100)}%`);
 	}
 
@@ -1630,6 +1709,149 @@
 		};
 	});
 
+	// ── Settings session + panel (mos-5lzns.35) ─────────────────────────────
+	// No store and no panel ⇒ no session: the player behaves exactly as
+	// before. The session reads the host's store once per store identity,
+	// coerces every value, and lets a choice made on screen beat a late read.
+	let settingsSession: SettingsSession | null = null;
+	let settingsOpen = $state(false);
+	let settingsBtnEl: HTMLButtonElement | undefined = $state();
+	let rootEl: HTMLDivElement | undefined = $state();
+
+	/** Land one coerced value: bindables are written, everything else overlays its prop. */
+	function applySetting(id: string, v: SettingValue) {
+		if (id === 'night.mode') {
+			if (night !== undefined && night !== v) {
+				night = v as NightMode;
+				onNightModeChange?.(night);
+			}
+			return;
+		}
+		if (id === 'night.depth') {
+			if (night !== undefined) nightDepth = v as number;
+			return;
+		}
+		userSettings[id] = v;
+	}
+
+	$effect(() => {
+		const store = settingsStore;
+		if (!store && !settingsPanel) return;
+		const session = untrack(() =>
+			createSettingsSession({
+				store,
+				onValue: (id, v, source) => {
+					applySetting(id, v);
+					if (source === 'user') onSettingChange?.(id, v);
+				}
+			})
+		);
+		settingsSession = session;
+		return () => {
+			session.close();
+			if (settingsSession === session) settingsSession = null;
+		};
+	});
+
+	/** A viewer choice from outside the panel (N, the moon wheel) — saved like a panel change. */
+	function rememberSetting(id: string, v: SettingValue) {
+		settingsSession?.change(id, v);
+	}
+
+	/** Rows exist only for features this player has: host opted in AND the data is here. */
+	const settingsAvailable = $derived<SettingAvailability>({
+		waveform: hasWave,
+		speakers: sortedTurns.length > 0 && sortedSegments.length > 0,
+		ads: normalizeAdSpans(adSpans, speakers).length > 0,
+		loudness: loudnessProp !== undefined,
+		quiet: quietListeningProp !== undefined,
+		limiter: limiterProp !== undefined,
+		night: nightPresent,
+		nightLuma: nightPresent && lumaSeries != null,
+		flashes: nightFlashes.length > 0,
+		windDown: windDownProp !== undefined,
+		idle: windDownProp !== undefined && idleDetectionSupported(),
+		resume: resumeKey != null,
+		open: openFrom !== undefined
+	});
+	const settingsGroups = $derived(settingsOpen ? panelGroups(settingsAvailable) : []);
+	/** What the player is doing right now, per id — the panel shows exactly this. */
+	const settingsValues = $derived.by(() => {
+		const byProp: Record<string, SettingValue | undefined> = {
+			night,
+			nightDepth,
+			biasLight,
+			predictive,
+			strobeGuard,
+			loudness,
+			loudnessTarget,
+			quietListening,
+			limiter,
+			smartSpeed,
+			speakerPace,
+			skipAds,
+			windDown,
+			windDownAfter,
+			windDownNightOnly,
+			idleDetection,
+			resumeSnap,
+			openMotion,
+			oneAxis
+		};
+		const out: Record<string, SettingValue> = {};
+		for (const spec of VIDEO_SETTINGS) {
+			const v = byProp[spec.prop];
+			out[spec.id] = v === undefined || v === null ? spec.default : v;
+		}
+		return out;
+	});
+
+	function openSettings() {
+		if (!settingsPanel) return;
+		keysOpen = false;
+		settingsOpen = true;
+	}
+	function closeSettings() {
+		settingsOpen = false;
+		settingsSession?.flush();
+		// Focus goes back where it came from (the gear), else the player —
+		// never to a detached node (the gear is gone when the host turned
+		// the panel off).
+		queueMicrotask(() => (settingsBtnEl?.isConnected ? settingsBtnEl : rootEl)?.focus());
+	}
+	// The host turned the panel off while it was open: close it properly, so
+	// focus is handed back instead of being dropped with the dialog.
+	$effect(() => {
+		if (!settingsPanel && untrack(() => settingsOpen)) untrack(closeSettings);
+	});
+
+	function desktopWanted(): boolean {
+		return windOn && idleDetection === true;
+	}
+
+	function onPanelChange(id: string, v: SettingValue) {
+		// Turning the desktop signal on is the ONE place the panel may lead to a
+		// permission prompt: an explicit opt-in, asked synchronously inside the
+		// click that made it (the API needs the gesture). Never on load.
+		if (id === 'sleep.desktopIdle' && v === true && idleDetection !== true && !idleAskInFlight) {
+			// In flight: the gesture listeners must not ask again while this
+			// prompt is still unanswered (maybeAskIdle checks the same flag).
+			idleAskInFlight = true;
+			idleAskPending = false;
+			void requestIdleDetection().then((r) => {
+				idleAskInFlight = false;
+				// Read at resolve time: by then the change below has landed.
+				if (r === 'granted' && desktopWanted()) {
+					idleAskPending = false;
+					startDesktop();
+				} else if (r === 'denied') {
+					idleAskPending = false;
+				}
+			});
+		}
+		settingsSession?.change(id, v);
+	}
+
 	// A new source is a new video: nothing carries over.
 	$effect(() => {
 		void src;
@@ -2059,6 +2281,10 @@
 		const v = videoEl;
 		if (!v) return;
 
+		// The settings panel stops its own keys; anything that still arrives
+		// while it is open (focus on the backdrop) must not drive the player.
+		if (settingsOpen) return;
+
 		// The help overlay takes over Escape while it's open.
 		if (keysOpen) {
 			if (e.key === 'Escape' || e.key === '?') {
@@ -2073,6 +2299,11 @@
 				e.preventDefault();
 				keysOpen = true;
 				return;
+			case ',':
+				if (!settingsPanel) break;
+				e.preventDefault();
+				openSettings();
+				return;
 			case ' ':
 			case 'k':
 				v.paused ? v.play() : v.pause();
@@ -2269,6 +2500,7 @@
 <!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
 <div
 	class="vp-root {className}"
+	bind:this={rootEl}
 	class:vp-side={transcriptPosition === 'side' && sortedSegments.length > 0 && transcriptVisible}
 	class:vp-one-axis={nativeBarHidden}
 	class:vp-night-capable={nightPresent}
@@ -2522,6 +2754,25 @@
 						</svg>
 					</button>
 				{/if}
+				{#if settingsPanel}
+					<button
+						type="button"
+						class="vp-night-btn vp-settings-btn"
+						class:active={settingsOpen}
+						aria-label="Settings"
+						aria-haspopup="dialog"
+						aria-expanded={settingsOpen}
+						title="Settings · ,"
+						bind:this={settingsBtnEl}
+						onclick={() => (settingsOpen ? closeSettings() : openSettings())}
+					>
+						<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+							<path d="M4 7h10M18 7h2M4 17h4M12 17h8" />
+							<circle cx="16" cy="7" r="2" />
+							<circle cx="10" cy="17" r="2" />
+						</svg>
+					</button>
+				{/if}
 			</span>
 			<span>{formatTime(effectiveDuration, useHours)}</span>
 		</div>
@@ -2660,6 +2911,17 @@
 			</div>
 		</div>
 	{/if}
+
+	{#if settingsOpen}
+		<SettingsPanel
+			groups={settingsGroups}
+			values={settingsValues}
+			onchange={onPanelChange}
+			onclose={closeSettings}
+			helpHref={settingsHelpHref}
+			persisted={!!settingsStore}
+		/>
+	{/if}
 </div>
 
 <style>

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

@@ -7,6 +7,7 @@ export type { AudioState, AudioStatus, AudioBrokenReason } from '../video/audio/
 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';
 import type { VideoBookmark, VideoChapter, VideoSpeakerTalkTime, VideoSpeakerTurn, VideoTranscriptSegment, VideoWaveform } from '../video/types';
 import { type BandState } from '../video/band/axis';
 import { type VideoLumaTrack } from '../video/band/luma';
@@ -16,6 +17,7 @@ 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';
 import type { ResumePoint } from '../video/advisors/resume-point';
+import { type SettingValue, type VideoSettingsStore } from '../video/settings';
 type $$ComponentProps = {
     src: string;
     poster?: string | null;
@@ -288,6 +290,33 @@ type $$ComponentProps = {
     openPoster?: string | null;
     /** Run the motion half of the open (default true). Off ⇒ poster only. */
     openMotion?: boolean;
+    /**
+     * Settings (mos-5lzns.35): where the viewer's standing choices live —
+     * `{ get(id), set(id, value) }`, either may be async, keyed by the ids
+     * in `VIDEO_SETTINGS`. jatui never persists on its own (no
+     * localStorage, no API): a host with per-user state passes its own
+     * adapter. Every stored value is coerced; junk reads as nothing.
+     *
+     * A stored choice overrides the matching prop — the prop is the
+     * host's DEFAULT, the stored value is the viewer's decision. It never
+     * creates a feature the host left out: a stored `audio.level` does
+     * nothing on a player with no `loudness` prop. `night.mode` /
+     * `night.depth` are written into the bindable `night` / `nightDepth`,
+     * and `N` / the moon wheel are saved back through the store.
+     */
+    settingsStore?: VideoSettingsStore;
+    /**
+     * Show the settings panel (default off — inert): a gear in the control
+     * strip and the `,` key open it. The panel is generated from the
+     * registry and shows only rows for features THIS player has (host
+     * opted in and the data exists). Without a `settingsStore`, choices
+     * last while the player is mounted.
+     */
+    settingsPanel?: boolean;
+    /** A host page explaining the settings — linked from the panel's footer. */
+    settingsHelpHref?: string | null;
+    /** The viewer changed a setting (panel, `N`, the moon wheel). Coerced value. */
+    onSettingChange?: (id: string, value: SettingValue) => void;
     class?: string;
 };
 declare const VideoPlayer: import("svelte").Component<$$ComponentProps, {

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export { default as VideoPlayer } from './components/VideoPlayer.svelte';
 export type { VideoChapter, VideoSpeakerTurn, VideoTranscriptSegment, VideoBookmark, VideoWaveform, VideoSpeakerTalkTime, VideoLumaTrack, VideoMarker, BandState, BandAxis, NightMode, NightWindow, AudioState, AudioStatus, AudioBrokenReason, VideoAdSpan, RateReport, WindDownState, WindDownPhase, PresenceSource, VideoResumeStore, FlipSource, } from './components/VideoPlayer.svelte';
 export { speakerRateMap, toRateTurns, toRateSegments } from './video/rate';
 export { idleDetectionSupported, idleDetectionPermission, requestIdleDetection, localResumeStore, flipOpen, flipClose, clearPoster, type IdlePermission } from './video/presence';
+export { VIDEO_SETTINGS, SETTING_GROUPS, settingSpec, settingValue, coerce as coerceVideoSetting, memorySettingsStore, panelGroups as videoSettingsGroups, formatSettingValue, type VideoSettingsStore, type SettingSpec as VideoSettingSpec, type SettingValue as VideoSettingValue, type SettingOption as VideoSettingOption, type SettingWhen as VideoSettingWhen, type SettingAvailability as VideoSettingAvailability } from './video/settings';
 export { buildSilenceMap, boostAt, estimateSaving, type SilenceMap, type SilenceWave, type SilenceOpts, type BoostOpts } from './video/advisors/smart-speed';
 export { speakerPace, suggestRates, rateAt, describeRates, type SpeakerPace, type SpeakerPaceRow, type RateMap, type RateTurn, type RateSegment, type SuggestOpts } from './video/advisors/speaker-rate';
 export { snapResume, resumeLabel, type ResumePoint, type ResumeReason, type ResumeCtx, type ResumeOpts } from './video/advisors/resume-point';

package/dist/index.js

@@ -22,6 +22,11 @@ export { speakerRateMap, toRateTurns, toRateSegments } from './video/rate';
 // the default resume store, and the FLIP pair for a host animating its own
 // theater shell (e.g. flipClose back onto the card).
 export { idleDetectionSupported, idleDetectionPermission, requestIdleDetection, localResumeStore, flipOpen, flipClose, clearPoster } from './video/presence';
+// Settings (mos-5lzns.35): the registry is the single source for the
+// player's panel AND a host's help page (labels + hints), the store adapter
+// type a host implements for per-user persistence, and `coerce` for a host
+// that reads the same values elsewhere. jatui never persists settings itself.
+export { VIDEO_SETTINGS, SETTING_GROUPS, settingSpec, settingValue, coerce as coerceVideoSetting, memorySettingsStore, panelGroups as videoSettingsGroups, formatSettingValue } from './video/settings';
 // Pure advisors (mos-5lzns.27): the extension-library self-test modules,
 // ported verbatim. They measure and advise; the player's feature tasks
 // (.31 audio / .32 rate / .34 presence) consume them. qrCanvas is the one

package/dist/video/README.md

@@ -19,7 +19,7 @@ props + callback surfaces.
 | `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. |
 | `deepLink.ts` | .28 (done) | `?t=` parse/format/read/write (replaceState, throttled, other params preserved). |
-| `settings.ts` | shared — knobs added by .30–.34 | `coerce` (never throws, never junk) + `VIDEO_SETTINGS` registry. A knob lands WITH its reader. |
+| `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). 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. |
 | `audio.ts` + `audio/` | **.31** (done) | `audio.ts` is the barrel. `rider.ts` — pure: RMS dBFS (silence → null), the 12 dB relative-gated loud estimate (rise 0.08 / forget 0.01), want-gain clamped 0.3–1.35, the asymmetric ride (down 0.15 / up 0.02), limiter constants + `compressorMakeupDb`/`limiterTrim` (DynamicsCompressor's automatic makeup, cancelled by a trim node), `routeSafety` (only blob:/data: or a `crossorigin` load — a same-origin URL may redirect cross-origin and route to SILENCE). `graph.ts` — `createAudioSession`: source → gain → quiet chain → limiter → trim → destination, analyser on the source. Context first, route last: the element is taken only when a feature is on, the source is route-safe and `ctx.state === 'running'` (gestures resume + retry; never navigator.userActivation). After routing it watches: an unsafe src or bit-exact zeros while audibly playing ⇒ `broken` (`unsafe-src` / `silent`) via `onBroken`. A construction throw is a permanent `build-failed` (context closed if the element wasn't taken; kept with source → destination if it was). Level off cancels before it sets; limiter moves are ramped. The element never enters the module — the component passes a `route` closure. |
 | `night.ts` + `night/` | **.33** (done) | `night.ts` is the barrel. `meter.ts` — 32×18 frame bytes → Rec.709 luma + blown share, asymmetric smoothing, bias-light cells from the same bytes. `levels.ts` — luma → brightness/saturation/warmth/vignette off `NIGHT_FLOOR` 0.34, blind fixed level, the light-theme surround. `clock.ts` — local-clock `auto` window + the `N` auto/on/off cycle (no hyprsunset). `track.ts` — prediction (only ever adds dimming), flash intervals, `composeNight` (darker at once, brighter released per tick — never a jump). |
 | `presence.ts` + `presence/` | **.34** (done) | `presence.ts` is the barrel. `winddown.ts` — pure: `shouldBeginWindDown` (a locked screen skips the wait; a desktop source with no reading holds — never guess), the 20s linear fade levels (volume `1−p`, picture `1−0.92p`), the hint (the page source says it is guessing from less). `idle.ts` — Chromium's Idle Detection API, feature-detected (`IdleDetector` + secure context); `startDesktopWatch` never prompts (start() rejects unless already granted ⇒ page fallback), `requestIdleDetection` is the ONE prompting call and the player makes it only with `idleDetection` on, from a gesture inside it. `resume.ts` — the host-supplied `VideoResumeStore` (localStorage default; jatui never calls an API), the data → advisor mapping, and `planResumeSnap` (wait for boundaries, drop once the user moved > 2.5s, skip `exact`/`start`); the snapping itself is `advisors/resume-point`, not re-derived. `flip.ts` — `open-transition.js` ported: FLIP over WAAPI, two keyframes, origin restated in both, poster on every path, a no-op under prefers-reduced-motion except the poster, `flipClose` holds and the next open releases on every path. |

package/dist/video/keys.d.ts

@@ -7,10 +7,10 @@
  * Space play/pause, ←/→ seek, ↑/↓ volume, M mute, −/= speed, Backspace reset
  * speed, </> frame step, [/] chapter jumps, B bookmark, T transcript, ?
  * shortcuts, Home/End. Deliberately NOT ported: F/M (favourite/file-under —
- * library-app verbs, not player verbs), `,` (settings —
- * jatui is prop-driven; a settings module arrives with the features that need
- * one), `/` (transcript search — the pane has none yet). N (night cycle)
- * landed with the night module (mos-5lzns.33), gated on the host opting in.
+ * library-app verbs, not player verbs), `/` (transcript search — the pane
+ * has none yet). 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.
  */
 export interface PlayerKeyRow {
     /** Keycap label as shown in the help overlay — `/`-separated alternates. */
@@ -20,7 +20,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' | 'bookmarks' | 'transcript' | 'comments' | 'night';
+    when?: 'chapters' | 'bookmarks' | 'transcript' | 'comments' | 'night' | 'settings';
 }
 /** Order follows the help overlay: transport, seek, volume, speed, structure. */
 export declare const PLAYER_KEYS: PlayerKeyRow[];

package/dist/video/keys.js

@@ -7,10 +7,10 @@
  * Space play/pause, ←/→ seek, ↑/↓ volume, M mute, −/= speed, Backspace reset
  * speed, </> frame step, [/] chapter jumps, B bookmark, T transcript, ?
  * shortcuts, Home/End. Deliberately NOT ported: F/M (favourite/file-under —
- * library-app verbs, not player verbs), `,` (settings —
- * jatui is prop-driven; a settings module arrives with the features that need
- * one), `/` (transcript search — the pane has none yet). N (night cycle)
- * landed with the night module (mos-5lzns.33), gated on the host opting in.
+ * library-app verbs, not player verbs), `/` (transcript search — the pane
+ * has none yet). 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.
  */
 /** Order follows the help overlay: transport, seek, volume, speed, structure. */
 export const PLAYER_KEYS = [
@@ -30,6 +30,7 @@ export const PLAYER_KEYS = [
     { keys: 'T', description: 'Show / hide the transcript', when: 'transcript' },
     { keys: 'N', description: 'Night dimming: auto / on / off', when: 'night' },
     { keys: 'Home / End', description: 'Jump to start / end' },
+    { keys: ',', description: 'Settings', when: 'settings' },
     { keys: '?', description: 'Toggle this help' }
 ];
 /** Band-local keys (band focused): advertised by the band's aria, not the overlay. */