fix(user-flow): close offline-queue, export, session, ban & realtime gaps

Comprehensive user-flow review across guest/host/admin roles, then fixes with
e2e regression guards. Highlights:

- Offline upload queue auto-resumes on reconnect: network errors keep items
  pending (not error), 4xx are terminal (no infinite retry), quota exhaustion
  returns a distinct 413; queue cap + dedup.
- Export lifecycle: release atomically locks uploads; reopen invalidates and
  re-release regenerates the keepsake; workers claim their job atomically so a
  reopen->re-release can't corrupt the ZIP; startup re-spawns interrupted
  exports.
- Sessions slide on activity (no 30-day cliff); JWT expiry deferred to the
  revocable session row; sign-out-everywhere + revoke-on-PIN-reset.
- Ban always hides content (v_feed / find_visible_media / export filter
  is_banned) but stays a read-only ban per USER_JOURNEYS §10 — sessions are
  not revoked, read access + keepsake download preserved.
- Realtime: server-clock SSE delta cursor; event-closed/opened drive the UI
  live; feed_delta rate-limited; like returns {liked, like_count} to fix
  multi-device drift; lightbox live comments; diashow delta backfill.
- Forgotten-PIN in-app request flow; simultaneous same-name join returns 409;
  quota increment is transactional; operator floor.

Adds e2e/specs/10-flow-review/ (offline resume, export integrity, deterministic
anti-race guard) and updates existing specs for the new contracts.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

frontend/src/lib/event-state-store.ts

@@ -0,0 +1,44 @@
+import { writable } from 'svelte/store';
+import { api } from './api';
+import type { MeContextDto } from './types';
+
+/**
+ * Live event lock/release state, so the composer can reflect a close/reopen the *instant*
+ * it happens instead of a guest discovering the lock via a rejected upload. Seeded from
+ * `/me/context` on boot and kept current by the `event-closed`/`event-opened` SSE events
+ * (see the root layout, which subscribes once).
+ */
+export interface EventState {
+	uploadsLocked: boolean;
+	galleryReleased: boolean;
+}
+
+export const eventState = writable<EventState>({ uploadsLocked: false, galleryReleased: false });
+
+/** True when uploads are closed for any reason (event locked or gallery released). */
+export function uploadsClosed(s: EventState): boolean {
+	return s.uploadsLocked || s.galleryReleased;
+}
+
+/** Refresh from the server. Non-fatal on failure — the next SSE event reconciles. */
+export async function refreshEventState(): Promise<void> {
+	try {
+		const ctx = await api.get<MeContextDto>('/me/context');
+		eventState.set({
+			uploadsLocked: ctx.uploads_locked,
+			galleryReleased: ctx.gallery_released
+		});
+	} catch {
+		// non-fatal
+	}
+}
+
+/** Apply an `event-closed` SSE event (uploads just locked). */
+export function markClosed(): void {
+	eventState.update((s) => ({ ...s, uploadsLocked: true }));
+}
+
+/** Apply an `event-opened` SSE event (uploads reopened → release also cleared). */
+export function markOpened(): void {
+	eventState.set({ uploadsLocked: false, galleryReleased: false });
+}