@joewinke/jatui 0.49.0 → 0.50.1

package/CLAUDE.md

@@ -177,7 +177,7 @@ Item-by-item review surfaces (MOS review-ux, design mos-z8vgx). One `VerdictOpti
 | `ThumbnailGrid` | Generic thumbnail strip (chimaro port) — image tiles with text-tile fallback, +N overflow counter, remove/add affordances. Decoupled from any media library: pass `{id, url, alt}` items, or a `cell` snippet for full control of tile contents. `removeMode` — `'hover'` (default) reveals the × on hover/focus and keeps it visible on coarse (touch) pointers (ContextMenuTrigger pattern); `'always'` pins it for touch-first flows. `gridCols` (e.g. `'grid-cols-2 sm:grid-cols-4'`) switches the strip to a responsive CSS grid with column-filling tiles. Items take optional `progress` (0–100): an upload ring draws around the tile and a tiny % occupies the remove-× corner, cross-fading into the × at 100 (same slot, no layout shift; per-tile `role="progressbar"`). | `items: ThumbnailItem[]` (`{id, url?, alt, progress?}`), `max`, `size` (`xs\|sm\|md\|lg`), `removable`+`onRemove`, `removeMode` (`hover\|always`), `addable`+`onAdd`, `onSelect`, `gridCols`, `class`, `cell` snippet |
 | `MediaWorkbench` | Full-featured image editor modal — upload, AI generate, AI edit, background removal, annotation canvas. **Preferred over `SmartImageEditor` for new image fields.** Two-column modal: preview left, 4 action tabs right (Generate, Edit, Remove BG, Annotate). Save uploads blob to `uploadEndpoint` or emits `onComplete`. Requires proxy endpoints from jst-23w1l.2. | `value` (bindable `string \| null`), `uploadEndpoint?` (default `/api/media`), `onComplete?`, `accept?` |
 | `MediaLightbox` | Full-screen media preview — z-9040 backdrop, arrow-key paging when given an array, `+/-/0` zoom, download action, Escape/backdrop close. **Use this for the general "just show it big" case** — replaces hand-rolled `fixed inset-0 z-[9040]` modals. For annotated / markup-overlaid image previews, use `ImageLightbox` instead. | `src?`, `filename?`, `kind?: 'image' \| 'video'`, `downloadUrl?`, `items?: MediaItem[]`, `initialIndex?`, `onClose?`, `zIndex?` |
-| `VideoPlayer` | **The default video surface — reach for this over a bare `<video controls>`.** One timeline band carrying a waveform-envelope scrubber, chapter flags (top edge), bookmark diamonds (bottom edge), diarized speaker colouring and scroll-to-zoom, plus an optional transcript pane (click to seek, active line auto-scroll, solo/skip per speaker, `Shift+T` toggle) and a "Talk time" legend (2+ speakers only; one voice gets no legend and no per-row name). **`kind="audio"` renders no stage**, and **`transport="band"`** (the audio default) drops the native `<video controls>` bar for a transport row on the band (play/pause, `now / total`, speed, mute + volume, fullscreen for video), so the band is the ONE timeline. A double-click on the picture toggles fullscreen (band transport; with native controls the browser owns the gesture), a buffering spinner shows while the media is waiting, and volume/mute survive a reload through `settingsStore` (else guarded localStorage). **Every intelligence prop is optional** — a bare mp4 still gets the scrubber, hover-time card, wheel volume and the full keyboard map (Space/K, arrows/J/L, vol/mute, −/= speed + Backspace reset, </> frame step, [/] chapters, B bookmark, t theater, ? help overlay), and each pane lights up as its data arrives (nothing shifts layout when diarization lands late). Wheel means volume over the video (shift = seek, alt = speed; a wheel/keyboard volume change also flashes a clear volume OSD — glyph, level bar and %, "Muted" at 0, opacity-only fade) and zoom over the band; Shift+wheel over the transcript steps line by line (a plain wheel over the transcript scrolls the pane natively — the page is never trapped). Internals live in `src/lib/video/` (band/keys/rate/deepLink/settings + contracts for audio/night/presence — see that README; gap audit vs the extension: `VIDEO-PLAYER-GAP-AUDIT.md`). | `src`, `kind?` (`'video' \| 'audio'`), `transport?` (`'native' \| 'band'`), `chapters?`, `speakers?`, `transcript?`, `bookmarks?`, `waveform?`, `talkTime?`, `startAt?`, `poster?`, `captionsSrc?`, `crossorigin?` (`'anonymous'` — what frame-reading features need), `syncUrlTime?` (`?t=` deep-link, opt-in), `transcriptPosition?` (`'below' \| 'side'`), `transcriptMaxHeight?` (pane bound — default `min(40vh, 28rem)` below, the player's height beside; the active-line follow scrolls only the pane; only a gesture that actually moves the PANE pauses it — a wheel that scrolls the page doesn't — behind a "Resume following" pill, and it resumes by itself on seek / line or chapter click / play after pause / `followResumeMs` (6000) idle while playing; a hovered chapter fills its whole span in the theme accent with full-height edges), `followResumeMs?`, `theater?` (bindable — theater mode, NOT fullscreen: control-bar button + `t`, the HOST lays the page out full-width; a side transcript moves below; remembered per viewer as the `player.theater` setting via `settingsStore`, else guarded localStorage), `theaterMode?` (`'width'` default — the host widens its page \| `'fill'` — the player becomes a fixed full-viewport dialog: `role="dialog"` + `aria-modal`, page scroll locked, Tab trapped, Esc/the button exits and returns focus, largest 16:9 stage that fits, transcript beside it ≥64rem else below, z from `--jatui-z-theater`; a remembered theater never fills on load, only a viewer gesture), `theaterButton?` (true), `onTheaterChange?`, `onTimeUpdate?`, `onAddBookmark?`, `onBookmarkContext?` |
+| `VideoPlayer` | **The default video surface — reach for this over a bare `<video controls>`.** One timeline band carrying a waveform-envelope scrubber, chapter flags (top edge), bookmark diamonds (bottom edge), diarized speaker colouring and scroll-to-zoom, plus an optional transcript pane (click to seek, active line auto-scroll, solo/skip per speaker, `Shift+T` toggle) and a "Talk time" legend (2+ speakers only; one voice gets no legend and no per-row name). **`kind="audio"` renders no stage**, and **`transport="band"`** (the audio default) drops the native `<video controls>` bar for a transport row on the band (play/pause, `now / total`, speed, mute + volume, fullscreen for video), so the band is the ONE timeline. A double-click on the picture toggles fullscreen (band transport; with native controls the browser owns the gesture), a buffering spinner shows while the media is waiting, and volume/mute survive a reload through `settingsStore` (else guarded localStorage). **Every intelligence prop is optional** — a bare mp4 still gets the scrubber, hover-time card, wheel volume and the full keyboard map (Space/K, arrows/J/L, vol/mute, −/= speed + Backspace reset, </> frame step, [/] chapters, B bookmark, t theater, ? help overlay), and each pane lights up as its data arrives (nothing shifts layout when diarization lands late). Wheel means volume over the video (shift = seek, alt = speed; a wheel/keyboard volume change also flashes a clear volume OSD — glyph, level bar and %, "Muted" at 0, opacity-only fade) and zoom over the band; Shift+wheel over the transcript steps line by line (a plain wheel over the transcript scrolls the pane natively — the page is never trapped); `/` opens an in-transcript search (only when a transcript exists and focus is not in a text field; the omnibar yields): matches highlight in place with a live `n / m` count (`aria-live`), Enter/Shift+Enter walk next/previous (seek + the line follows), Esc closes the search first in the Esc layering. Right-click a transcript line (or `Menu` / `Shift+F10` on a focused one) for the **line menu** — Play from here, Copy text, Copy text with timestamp (`[0:02] text`), Copy link at this time when `buildTimeLink` supplies the URL builder (without it the item is absent; `?t=` shape via `buildTimeUrl`); Escape closes and returns focus to the line, the player's keys are dead while it floats, and in fill theater Esc closes the menu without leaving the theater. Internals live in `src/lib/video/` (band/keys/rate/deepLink/settings + contracts for audio/night/presence — see that README; gap audit vs the extension: `VIDEO-PLAYER-GAP-AUDIT.md`). | `src`, `kind?` (`'video' \| 'audio'`), `transport?` (`'native' \| 'band'`), `chapters?`, `speakers?`, `transcript?`, `bookmarks?`, `waveform?`, `talkTime?`, `startAt?`, `poster?`, `captionsSrc?`, `crossorigin?` (`'anonymous'` — what frame-reading features need), `syncUrlTime?` (`?t=` deep-link, opt-in), `transcriptPosition?` (`'below' \| 'side'`), `transcriptMaxHeight?` (pane bound — default `min(40vh, 28rem)` below, the player's height beside; the active-line follow scrolls only the pane; only a gesture that actually moves the PANE pauses it — a wheel that scrolls the page doesn't — behind a "Resume following" pill, and it resumes by itself on seek / line or chapter click / play after pause / `followResumeMs` (6000) idle while playing; a hovered chapter fills its whole span in the theme accent with full-height edges), `followResumeMs?`, `transcriptLineMenu?` (true — right-click/`Menu`/`Shift+F10` on a transcript line opens the line menu; `false` leaves transcript lines to the browser's own context menu), `buildTimeLink?` ((sec) → URL for "Copy link at this time"; the host owns the address shape), `theater?` (bindable — theater mode, NOT fullscreen: control-bar button + `t`, the HOST lays the page out full-width; a side transcript moves below; remembered per viewer as the `player.theater` setting via `settingsStore`, else guarded localStorage), `theaterMode?` (`'width'` default — the host widens its page \| `'fill'` — the player becomes a fixed full-viewport dialog: `role="dialog"` + `aria-modal`, page scroll locked, Tab trapped, Esc/the button exits and returns focus, largest 16:9 stage that fits, transcript beside it ≥64rem else below, z from `--jatui-z-theater`; a remembered theater never fills on load, only a viewer gesture), `theaterButton?` (true), `onTheaterChange?`, `onTimeUpdate?`, `onAddBookmark?`, `onBookmarkContext?` |
 | `MediaCapture` | One-tap audio/selfie-video/screen(+mic) recording — a host-agnostic PRIMITIVE. Owns permission requests, MIME negotiation, the record/stop state machine, live self-preview, and mixes screen+mic audio into one track via AudioContext. Never uploads anything — hands the finished clip to `onCapture` as a Blob and the host decides what to do with it. `onCapture` may be async; the component shows "processing" until it resolves. | `onCapture: (result: MediaCaptureResult) => void \| Promise<void>`, `modes?` (default all three), `maxDurationMs?` (default 120000), `label?`, `hint?`, `compact?`, `disabled?` |
 | `MultimodalCaptureField` | "Upload a file, or record yourself going over it" as one input surface — composes `FileDropzone` (capped to one file) with `MediaCapture`. File and recording are independent (either, both, or neither); neither half uploads anything, same "validate and hand back" contract as `FileDropzone`. | `onFileSelected?`, `onFileRemoved?`, `onCapture?`, `onRecordingRemoved?`, `accept?`, `maxFileSize?`, `modes?`, `maxDurationMs?`, `file?`/`fileUrl?`/`fileName?`, `recordingSummary?` |
 | `ListenControl` | "Listen to this page" — a compact pill that expands into a TWO-ROW playback bar over the host's PER-SENTENCE audio (TTS): row 1 = play/pause · chapter chip + current sentence (full remaining width) · ONE settings pill ("1.25× · Sarah" → speed 0.75–2× + voice menu) · close; row 2 = prev/next sentence and −15s/+15s · a document-wide progress bar with chapter ticks (a hatched tail marks the not-yet-synthesized part), time, close. The host supplies an async `source` (sentences/paragraphs with ids → audio URLs, streamed page by page so playback starts on the first chunk while the rest synthesizes; pages merge by id so late URLs fill in) and gets `onSegmentChange(id)` at every boundary for highlight + scroll-follow. Media Session (lock-screen/headset controls, one document-wide position), keyboard scoped to the player (Space/K, ←/→ sentences, Shift+←/→ ±15s, [ / ] speed, Escape), speed+voice persisted in localStorage, `bind:api` for hosts wiring their own global keys, reduced-motion aware, token-only theming, never overflows its host (border-box, `max-width: 100%`, `min-width: 0` chain), fixed sticky mini-bar (same two rows) on narrow screens. Internals in `src/lib/listen/` (one timeline across per-sentence files — `buildTimeline` offsets; see `video/` for the doctrine). Demo synthesizes real WAVs locally. | `source`, `voices?`, `voiceId?` (bindable), `chapters?`, `title?`, `triggerLabel?`, `open?` (bindable), `preload?`, `estimateSec?`, `storageKey?`, `onSegmentChange?`, `onOpenChange?`, `api?` (bindable), `class?`, `children?` (custom trigger) |

package/dist/components/VideoPlayer.svelte

@@ -198,6 +198,7 @@
 		type VideoAdSpan
 	} from '../video/rate';
 	import { readTimeParam, WRITE_THROTTLE_MS, writeTimeParam } from '../video/deepLink';
+	import { isContextMenuKey, lineTextWithTime } from '../video/lineMenu';
 	import {
 		biasCells,
 		biasGradient,
@@ -275,6 +276,9 @@
 		type VideoSettingsStore
 	} from '../video/settings';
 	import SettingsPanel from '../video/settings/SettingsPanel.svelte';
+	import ContextMenu from './ContextMenu.svelte';
+	import type { ContextMenuItem } from './ContextMenu.types';
+	import { copyText } from '../utils/clipboard';
 
 	let {
 		src,
@@ -301,6 +305,8 @@
 		transcriptPosition = 'below',
 		transcriptMaxHeight,
 		followResumeMs = FOLLOW_RESUME_IDLE_MS,
+		transcriptLineMenu = true,
+		buildTimeLink = undefined,
 		theater = $bindable(false),
 		theaterMode = 'width',
 		theaterButton = true,
@@ -485,6 +491,24 @@
 		 * play after pause or the "Resume following" pill bring it back).
 		 */
 		followResumeMs?: number;
+		/**
+		 * Right-click a transcript line (or Context-menu / Shift+F10 on a
+		 * focused one) for the line's verbs (extension-library parity,
+		 * library.js:8458): Play from here, Copy text, Copy text with
+		 * timestamp — and, when `buildTimeLink` is supplied, Copy link at this
+		 * time. Default on: the menu only exists where a transcript exists.
+		 * Pass `false` to leave transcript lines to the browser's own context
+		 * menu.
+		 */
+		transcriptLineMenu?: boolean;
+		/**
+		 * Builds the shareable URL for "Copy link at this time" — the HOST
+		 * supplies it because only the host knows its page's address shape
+		 * (MOS builds `?t=90s` on its video page; `buildTimeUrl` in
+		 * video/deepLink.ts is exactly that builder). Without it the item is
+		 * simply not on the menu — the player never guesses a URL.
+		 */
+		buildTimeLink?: (sec: number) => string;
 		/**
 		 * Theater mode (jatui-ee2ty) — bindable. NOT fullscreen: the player
 		 * only says it wants the page's width; the HOST lays its page out
@@ -971,6 +995,15 @@
 	let searchMatchIdx = $state(-1);
 	let searchInputEl: HTMLInputElement | undefined = $state();
 
+	// ── Transcript line menu (jatui-3wl5x) ─────────────────────────────
+	// Right-click (or Context-menu / Shift+F10 on a focused row) opens the
+	// line's verb menu (extension library.js:8458). ONE panel serves the
+	// whole pane: opening re-points it at the row; closing clears the row.
+	let lineMenuOpen = $state(false);
+	let lineMenuX = $state(0);
+	let lineMenuY = $state(0);
+	let lineMenuSeg = $state<VideoTranscriptSegment | null>(null);
+
 	let zoomTimer: ReturnType<typeof setTimeout> | null = null;
 	let osdTimer: ReturnType<typeof setTimeout> | null = null;
 
@@ -3125,7 +3158,12 @@
 				!keysOpen &&
 				!searchOpen &&
 				!settingsOpen &&
-				!isFullscreen
+				!isFullscreen &&
+				// The line menu (jatui-3wl5x) owns Escape while it is open — the
+				// menu closes itself, the theater must not leave with it. The
+				// panel's own handler may already have closed it by the time this
+				// bubble-phase handler runs, hence the target check too.
+				!(lineMenuOpen || (e.target instanceof Element && e.target.closest('[role="menu"]')))
 			) {
 				e.preventDefault();
 				toggleTheater();
@@ -3146,6 +3184,13 @@
 		// 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;
 		// 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.
@@ -3443,6 +3488,70 @@
 		seekTo(seg.startSec);
 	}
 
+	// ── Transcript line menu (jatui-3wl5x, extension library.js:8458) ────
+	/** Right-click a line: the menu opens at the cursor. The row takes focus
+	 *  first — right-click alone doesn't move focus in every engine, and
+	 *  giving it the row means the menu's focus-return lands back on the
+	 *  line the menu was about (preventScroll: the row is already on screen). */
+	function onRowContextMenu(seg: VideoTranscriptSegment, e: MouseEvent) {
+		if (!transcriptLineMenu) return; // the browser's own menu stays
+		e.preventDefault();
+		rowRefs[seg.id]?.focus({ preventScroll: true });
+		openLineMenu(seg, e.clientX, e.clientY);
+	}
+	/** Context-menu key / Shift+F10 on a focused line: the same menu, anchored
+	 *  to the row (there is no cursor to place it at). */
+	function onRowMenuKey(seg: VideoTranscriptSegment, e: KeyboardEvent) {
+		if (!transcriptLineMenu || !isContextMenuKey(e)) return;
+		e.preventDefault();
+		const rect = rowRefs[seg.id]?.getBoundingClientRect();
+		openLineMenu(seg, rect?.left ?? 0, rect ? rect.bottom : 0);
+	}
+	function openLineMenu(seg: VideoTranscriptSegment, x: number, y: number) {
+		lineMenuSeg = seg;
+		lineMenuX = x;
+		lineMenuY = y;
+		lineMenuOpen = true;
+	}
+	/** "Play from here": seek to the line's start and play — the verb the
+	 *  click can't offer (a plain line click only seeks, never unpauses). */
+	function playFromLine(seg: VideoTranscriptSegment) {
+		seekTo(seg.startSec);
+		const v = videoEl;
+		if (v && v.paused) void v.play().catch(() => {});
+	}
+	/** One copy verb for all the payloads; the OSD and the polite region say
+	 *  what happened — a clipboard write is otherwise invisible. */
+	async function copyLine(label: string, payload: string) {
+		if (!payload) return;
+		const ok = await copyText(payload);
+		flashOsd(ok ? 'Copied' : 'Copy failed');
+		announce(ok ? `${label} copied` : 'Copy failed');
+	}
+	/** The menu's items for the row it is open on. `buildTimeLink` decides
+	 *  whether the link verb exists at all (the host owns the URL shape). */
+	const lineMenuItems = $derived.by<ContextMenuItem[]>(() => {
+		const seg = lineMenuSeg;
+		if (!seg) return [];
+		const items: ContextMenuItem[] = [
+			{ label: 'Play from here', icon: '▶', onSelect: () => playFromLine(seg) },
+			{ label: 'Copy text', icon: '⧉', onSelect: () => copyLine('Copy text', seg.text) },
+			{
+				label: 'Copy text with timestamp',
+				icon: '⧉',
+				onSelect: () => copyLine('Copy text with timestamp', lineTextWithTime(seg.text, seg.startSec, useHours))
+			}
+		];
+		if (buildTimeLink) {
+			items.push({
+				label: 'Copy link at this time',
+				icon: '🔗',
+				onSelect: () => copyLine('Copy link at this time', buildTimeLink(seg.startSec))
+			});
+		}
+		return items;
+	});
+
 	// ── 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. */
@@ -4297,6 +4406,8 @@
 							: filterDims(speakerKeyOf(seg), false, soloKey, mutedKeys)}
 						use:transcriptRowAction={seg}
 						onclick={() => onRowClick(seg)}
+						oncontextmenu={(e) => onRowContextMenu(seg, e)}
+						onkeydown={(e) => onRowMenuKey(seg, e)}
 					>
 						<span class="vp-row-time">{formatTime(seg.startSec, useHours)}</span>
 						{#if multiSpeaker}
@@ -4328,6 +4439,8 @@
 							: filterDims(speakerKeyOf(seg), false, soloKey, mutedKeys)}
 						use:transcriptRowAction={seg}
 						onclick={() => onRowClick(seg)}
+						oncontextmenu={(e) => onRowContextMenu(seg, e)}
+						onkeydown={(e) => onRowMenuKey(seg, e)}
 					>
 						<span class="vp-row-time">{formatTime(seg.startSec, useHours)}</span>
 						{#if multiSpeaker}
@@ -4394,6 +4507,22 @@
 			persisted={!!settingsStore}
 		/>
 	{/if}
+
+	{#if transcriptLineMenu && sortedSegments.length > 0}
+		<!-- Transcript line menu (jatui-3wl5x, extension library.js:8458): ONE
+		     panel serves the whole pane, re-pointed at the row it was opened
+		     from. Rendered inside the root so the fill-theater Tab trap keeps
+		     cycling through its items; position:fixed places it at the cursor
+		     (or the focused row) wherever this spot sits in the layout. -->
+		<ContextMenu
+			bind:open={lineMenuOpen}
+			x={lineMenuX}
+			y={lineMenuY}
+			items={lineMenuItems}
+			header={lineMenuSeg ? formatTime(lineMenuSeg.startSec, useHours) : undefined}
+			onClose={() => (lineMenuSeg = null)}
+		/>
+	{/if}
 </div>
 
 <style>

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

@@ -191,6 +191,24 @@ type $$ComponentProps = {
      * play after pause or the "Resume following" pill bring it back).
      */
     followResumeMs?: number;
+    /**
+     * Right-click a transcript line (or Context-menu / Shift+F10 on a
+     * focused one) for the line's verbs (extension-library parity,
+     * library.js:8458): Play from here, Copy text, Copy text with
+     * timestamp — and, when `buildTimeLink` is supplied, Copy link at this
+     * time. Default on: the menu only exists where a transcript exists.
+     * Pass `false` to leave transcript lines to the browser's own context
+     * menu.
+     */
+    transcriptLineMenu?: boolean;
+    /**
+     * Builds the shareable URL for "Copy link at this time" — the HOST
+     * supplies it because only the host knows its page's address shape
+     * (MOS builds `?t=90s` on its video page; `buildTimeUrl` in
+     * video/deepLink.ts is exactly that builder). Without it the item is
+     * simply not on the menu — the player never guesses a URL.
+     */
+    buildTimeLink?: (sec: number) => string;
     /**
      * 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

@@ -19,7 +19,9 @@ props + callback surfaces.
 | `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. |
-| `deepLink.ts` | .28 (done) | `?t=` parse/format/read/write (replaceState, throttled, other params preserved). |
+| `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). |
+| `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. |
 | `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). |

package/dist/video/deepLink.d.ts

@@ -34,6 +34,15 @@ export declare function readTimeParam(url?: string | URL | null): number | null;
  * history API, same second) so the caller can skip the replaceState.
  */
 export declare function writeTimeParam(sec: number, url?: string | URL | null): boolean;
+/**
+ * Build the shareable URL for a time: the base URL (default: the current
+ * page) with its `t` param set — every other query param preserved. This is
+ * the builder MOS's "copy link at this time" uses (`?t=90s`) and the shape
+ * hosts pass as VideoPlayer's `buildTimeLink` prop. Null when there is no
+ * URL to build on (SSR, garbage base) — a builder that can't build returns
+ * nothing rather than throwing.
+ */
+export declare function buildTimeUrl(sec: number, url?: string | URL | null): string | null;
 /** Strip the `t` param (e.g. when the host unmounts the player opt-in). */
 export declare function clearTimeParam(url?: string | URL | null): boolean;
 /** Throttle for URL writes: at most one replaceState per WRITE_THROTTLE_MS. */

package/dist/video/deepLink.js

@@ -88,6 +88,26 @@ export function writeTimeParam(sec, url = typeof location !== 'undefined' ? loca
     history.replaceState(history.state, '', u);
     return true;
 }
+/**
+ * Build the shareable URL for a time: the base URL (default: the current
+ * page) with its `t` param set — every other query param preserved. This is
+ * the builder MOS's "copy link at this time" uses (`?t=90s`) and the shape
+ * hosts pass as VideoPlayer's `buildTimeLink` prop. Null when there is no
+ * URL to build on (SSR, garbage base) — a builder that can't build returns
+ * nothing rather than throwing.
+ */
+export function buildTimeUrl(sec, url = typeof location !== 'undefined' ? location.href : null) {
+    if (!url)
+        return null;
+    try {
+        const u = new URL(String(url), typeof location !== 'undefined' ? location.href : undefined);
+        u.searchParams.set('t', formatTimeParam(sec));
+        return u.toString();
+    }
+    catch {
+        return null;
+    }
+}
 /** Strip the `t` param (e.g. when the host unmounts the player opt-in). */
 export function clearTimeParam(url = typeof location !== 'undefined' ? location.href : null) {
     if (typeof history === 'undefined' || typeof history.replaceState !== 'function')

package/dist/video/keys.js

@@ -36,6 +36,10 @@ export const PLAYER_KEYS = [
     { keys: 't', description: 'Theater mode on / off', when: 'theater' },
     { keys: 'Shift+T', description: 'Cycle transcript layout: side / below / hidden', when: 'transcript' },
     { keys: '/', description: 'Search transcript', when: 'transcript' },
+    // jatui-3wl5x — right-click a line (or the keyboard's right-click on a
+    // focused one) for the line menu: play from here, copy text / with time /
+    // link at time (the link verb only when the host supplies buildTimeLink).
+    { keys: 'Menu / Shift+F10', description: 'On a transcript line: the line menu', when: 'transcript' },
     // Shift+wheel over the transcript pane steps PLAYBACK line by line —
     // a plain wheel there scrolls the pane natively and is never claimed.
     { keys: 'Shift+wheel', description: 'Over the transcript: steps line by line', when: 'transcript' },

package/dist/video/lineMenu.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Transcript line right-click menu (jatui-3wl5x — extension-library parity,
+ * library.js:8458): right-clicking a transcript line (or Context-menu /
+ * Shift+F10 on a focused one) offers the line's verbs — Play from here,
+ * Copy text, Copy text with timestamp, and — when the host supplies a URL
+ * builder — Copy link at this time (MOS builds `?t=`; `buildTimeUrl` in
+ * deepLink.ts is that builder for the host's `buildTimeLink` prop).
+ *
+ * The pure pieces live here so they stay node-testable; the component owns
+ * the DOM: which row opened the menu, where it opens, focus return.
+ */
+/**
+ * The context-menu key (`e.key === 'ContextMenu'`) or Shift+F10 — the
+ * keyboard's right-click. Engines dispatch one or the other depending on
+ * the keyboard; plain F10 stays the browser's own menu-bar key.
+ */
+export declare function isContextMenuKey(e: {
+    key: string;
+    shiftKey: boolean;
+}): boolean;
+/**
+ * A transcript line quoted with its timestamp — `[1:23] The line text`.
+ * The time renders in the row's own clock (hours form on long videos), so
+ * what lands on the clipboard is exactly what the viewer read on screen.
+ */
+export declare function lineTextWithTime(text: string, startSec: number, useHours: boolean): string;

package/dist/video/lineMenu.js

@@ -0,0 +1,28 @@
+/**
+ * Transcript line right-click menu (jatui-3wl5x — extension-library parity,
+ * library.js:8458): right-clicking a transcript line (or Context-menu /
+ * Shift+F10 on a focused one) offers the line's verbs — Play from here,
+ * Copy text, Copy text with timestamp, and — when the host supplies a URL
+ * builder — Copy link at this time (MOS builds `?t=`; `buildTimeUrl` in
+ * deepLink.ts is that builder for the host's `buildTimeLink` prop).
+ *
+ * The pure pieces live here so they stay node-testable; the component owns
+ * the DOM: which row opened the menu, where it opens, focus return.
+ */
+import { formatTime } from './time';
+/**
+ * The context-menu key (`e.key === 'ContextMenu'`) or Shift+F10 — the
+ * keyboard's right-click. Engines dispatch one or the other depending on
+ * the keyboard; plain F10 stays the browser's own menu-bar key.
+ */
+export function isContextMenuKey(e) {
+    return e.key === 'ContextMenu' || (e.key === 'F10' && e.shiftKey);
+}
+/**
+ * A transcript line quoted with its timestamp — `[1:23] The line text`.
+ * The time renders in the row's own clock (hours form on long videos), so
+ * what lands on the clipboard is exactly what the viewer read on screen.
+ */
+export function lineTextWithTime(text, startSec, useHours) {
+    return `[${formatTime(startSec, useHours)}] ${text}`;
+}

package/package.json

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