feat(eventsnap): UX review batch-3 — feed virtualization, a11y/UX fixes, shared primitives

Frontend
- Feed: DOM-windowing via @tanstack/svelte-virtual (new VirtualFeed). The window
  virtualizer keeps the sticky header, pull-to-refresh, infinite-scroll sentinel and
  bottom nav working. List = dynamic measured heights keyed by upload id +
  anchorTo:start so an SSE prepend doesn't jump a scrolled reader; grid = measured
  square rows. Drops the content-visibility band-aid and the old FeedGrid.
  measureElement(null) on row unmount prevents ResizeObserver retention; stable
  option callbacks + guarded setOptions avoid O(n) re-measure on like/comment patches.
- Global: viewport-fit=cover (activates safe-area insets), lang=de, PWA manifest +
  maskable icon + apple-touch metas, prefers-reduced-motion, safe-area-top headers.
- Feed reactivity: like/comment SSE patch the single card in place; upload-processed
  debounced in-place merge; IntersectionObserver leak fixed; shared 60s clock.
- CLS: list cards reserve the skeleton aspect box.
- Destructive actions (promote/demote/unban, gallery release) routed through
  ConfirmSheet (host + admin).
- Export OOM: streamed download via single-use ticket instead of res.blob().
- Shared primitives: IconButton (44px hit area), scrollLock action; UploadSheet a11y.
- Polish: api timeout + non-JSON guard, focus-trap offsetParent fix, pull-to-refresh
  passive:false + guards, diashow keyboard a11y, Toaster assertive errors, dark-mode
  gaps, aria-pressed on like/chip state, CameraCapture mic-on-video + retry,
  ConfirmSheet spinner, upload beforeunload warning, emoji->SVG icons.

Backend
- social.rs: like/comment SSE broadcasts now carry the fresh count so feed clients
  patch one card in place instead of refetching page 1.
- admin.rs / main.rs: supporting changes for the above.

Verified: svelte-check 0 errors, frontend build clean, /feed SSR 200. Runtime feed
scroll-feel validation still owed (documented in FOLLOWUPS.md).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

frontend/src/lib/actions/doubletap.ts

@@ -1,9 +1,14 @@
-// Svelte action — fires a `doubletap` CustomEvent when two pointerup events occur
-// within `interval` ms on roughly the same spot. Used in the lightbox for the
-// Instagram-style "double-tap to like" gesture.
+// Svelte action — the single source of truth for tap gestures on a media element.
+// Fires a `doubletap` CustomEvent when two pointerup events occur within `interval`
+// ms on roughly the same spot (Instagram-style "double-tap to like"), and a
+// `singletap` CustomEvent once `interval` has elapsed with no second tap. Owning
+// both gestures in one place means a component no longer juggles its own debounce
+// timer alongside a separate onclick handler.
 //
 // Native `dblclick` exists, but on iOS Safari it also zooms the page; gating on
-// pointer events lets us preventDefault selectively and avoid the zoom.
+// pointer events lets us preventDefault selectively and avoid the zoom. Keyboard
+// activation still arrives as a normal `click` (detail === 0) — handle that on the
+// element itself for an immediate, latency-free open.
 
 import type { ActionReturn } from 'svelte/action';
 
@@ -16,6 +21,7 @@ export interface DoubletapOptions {
 
 interface DoubletapAttributes {
 	'ondoubletap'?: (event: CustomEvent<void>) => void;
+	'onsingletap'?: (event: CustomEvent<void>) => void;
 }
 
 export function doubletap(
@@ -26,12 +32,21 @@ export function doubletap(
 	let lastTime = 0;
 	let lastX = 0;
 	let lastY = 0;
+	let singleTimer: ReturnType<typeof setTimeout> | null = null;
+
+	const clearSingle = () => {
+		if (singleTimer) {
+			clearTimeout(singleTimer);
+			singleTimer = null;
+		}
+	};
 
 	const onPointerUp = (e: PointerEvent) => {
 		const now = performance.now();
 		const dx = Math.abs(e.clientX - lastX);
 		const dy = Math.abs(e.clientY - lastY);
 		if (now - lastTime < interval && dx < MOVE_THRESHOLD && dy < MOVE_THRESHOLD) {
+			clearSingle(); // the pending single-tap was actually the first of a double
 			e.preventDefault();
 			node.dispatchEvent(new CustomEvent('doubletap'));
 			lastTime = 0; // reset so a triple-tap doesn't re-fire
@@ -40,6 +55,12 @@ export function doubletap(
 		lastTime = now;
 		lastX = e.clientX;
 		lastY = e.clientY;
+		// Defer the single-tap action until we're sure no second tap follows.
+		clearSingle();
+		singleTimer = setTimeout(() => {
+			singleTimer = null;
+			node.dispatchEvent(new CustomEvent('singletap'));
+		}, interval);
 	};
 
 	node.addEventListener('pointerup', onPointerUp);
@@ -49,6 +70,7 @@ export function doubletap(
 			interval = newOptions.interval ?? INTERVAL_MS;
 		},
 		destroy() {
+			clearSingle();
 			node.removeEventListener('pointerup', onPointerUp);
 		}
 	};

frontend/src/lib/actions/focus-trap.ts

@@ -17,8 +17,11 @@ const FOCUSABLE =
 	'a[href], area[href], input:not([disabled]):not([type="hidden"]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex]:not([tabindex="-1"]), [contenteditable="true"]';
 
 function focusables(root: HTMLElement): HTMLElement[] {
+	// `offsetParent` is null for any `position: fixed` element (and our sheets/modals
+	// are fixed), so it would wrongly drop their buttons. `getClientRects().length`
+	// is true whenever the element is actually rendered — fixed or not.
 	return Array.from(root.querySelectorAll<HTMLElement>(FOCUSABLE)).filter(
-		(el) => !el.hasAttribute('disabled') && el.offsetParent !== null
+		(el) => !el.hasAttribute('disabled') && el.getClientRects().length > 0
 	);
 }
 

frontend/src/lib/actions/pull-to-refresh.ts

@@ -22,8 +22,17 @@ export function pullToRefresh(
 ): ActionReturn<PullToRefreshOptions> {
 	let opts = options;
 	let startY = 0;
+	let startX = 0;
 	let pulling = false;
 	let triggered = false;
+	let intentLocked = false; // have we decided this gesture is a vertical pull?
+
+	// Distance the finger must travel before we commit to "this is a vertical pull"
+	// vs. a horizontal swipe or an incidental tap.
+	const INTENT_SLOP = 8;
+	// Rubber-band resistance: the sheet follows the finger at a fraction of 1:1 so
+	// the pull feels elastic rather than rigid.
+	const RESISTANCE = 0.5;
 
 	function scroller(): HTMLElement | (Window & typeof globalThis) {
 		return node.scrollHeight > node.clientHeight ? node : window;
@@ -40,17 +49,54 @@ export function pullToRefresh(
 		opts.onpull(Math.max(0, delta), Math.max(0, delta) / threshold);
 	}
 
+	function reset() {
+		pulling = false;
+		intentLocked = false;
+	}
+
 	function onTouchStart(e: TouchEvent) {
 		if (opts.disabled) return;
+		// Ignore pinch / multi-finger gestures entirely.
+		if (e.touches.length !== 1) {
+			reset();
+			return;
+		}
 		if (scrollTop() > 0) return;
 		startY = e.touches[0].clientY;
+		startX = e.touches[0].clientX;
 		pulling = true;
 		triggered = false;
+		intentLocked = false;
 	}
 
 	function onTouchMove(e: TouchEvent) {
 		if (!pulling || triggered) return;
-		const delta = e.touches[0].clientY - startY;
+		// A second finger landing mid-gesture cancels the pull.
+		if (e.touches.length !== 1) {
+			reset();
+			return;
+		}
+
+		const rawDy = e.touches[0].clientY - startY;
+		const dx = e.touches[0].clientX - startX;
+
+		// Decide intent once, after the finger has moved past the slop. A
+		// horizontal-dominant or upward move is not a pull — bail and let the
+		// browser scroll normally.
+		if (!intentLocked) {
+			if (Math.abs(rawDy) < INTENT_SLOP && Math.abs(dx) < INTENT_SLOP) return;
+			if (rawDy <= 0 || Math.abs(rawDy) <= Math.abs(dx)) {
+				reset();
+				return;
+			}
+			intentLocked = true;
+		}
+
+		// Committed vertical pull at the top edge: stop the browser's own
+		// overscroll / pull-to-refresh from competing for the gesture.
+		if (e.cancelable) e.preventDefault();
+
+		const delta = rawDy * RESISTANCE;
 		reportPull(delta);
 		if (delta > (opts.threshold ?? 60)) {
 			triggered = true;
@@ -60,11 +106,12 @@ export function pullToRefresh(
 
 	function onTouchEnd() {
 		if (pulling && !triggered) reportPull(0);
-		pulling = false;
+		reset();
 	}
 
 	node.addEventListener('touchstart', onTouchStart, { passive: true });
-	node.addEventListener('touchmove', onTouchMove, { passive: true });
+	// Non-passive so we can preventDefault() once a top-edge pull is in progress.
+	node.addEventListener('touchmove', onTouchMove, { passive: false });
 	node.addEventListener('touchend', onTouchEnd);
 	node.addEventListener('touchcancel', onTouchEnd);
 

frontend/src/lib/actions/scroll-lock.ts

@@ -0,0 +1,50 @@
+// Body scroll-lock for open dialogs/sheets. While any locker is active, the
+// document body can't scroll behind the overlay. Ref-counted so that nested or
+// stacked dialogs (e.g. a ConfirmSheet opened from the LightboxModal) don't let
+// the first one to close unlock the page out from under the others. Compensates
+// for the vanished scrollbar width so the layout doesn't jump on lock.
+
+import type { ActionReturn } from 'svelte/action';
+
+let lockCount = 0;
+let savedOverflow = '';
+let savedPaddingRight = '';
+
+function lock() {
+	if (typeof document === 'undefined') return;
+	if (lockCount === 0) {
+		const body = document.body;
+		const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+		savedOverflow = body.style.overflow;
+		savedPaddingRight = body.style.paddingRight;
+		body.style.overflow = 'hidden';
+		if (scrollbarWidth > 0) {
+			const current = parseFloat(getComputedStyle(body).paddingRight) || 0;
+			body.style.paddingRight = `${current + scrollbarWidth}px`;
+		}
+	}
+	lockCount++;
+}
+
+function unlock() {
+	if (typeof document === 'undefined') return;
+	lockCount = Math.max(0, lockCount - 1);
+	if (lockCount === 0) {
+		document.body.style.overflow = savedOverflow;
+		document.body.style.paddingRight = savedPaddingRight;
+	}
+}
+
+/**
+ * Locks body scroll for the lifetime of the node. Mount the node only while the
+ * dialog is open (e.g. inside `{#if open}` or alongside a `class:` toggle) so the
+ * action's create/destroy line up with open/close.
+ */
+export function scrollLock(node: HTMLElement): ActionReturn {
+	lock();
+	return {
+		destroy() {
+			unlock();
+		}
+	};
+}