fix(toast): prefer evicting toasts that have been visible >= 1.5s during a burst

Fixes #80

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PPmy3tPq869XDW4njjVaKA

src/app/state/toast.ts

@@ -12,6 +12,7 @@ export type ToastNotif = {
   hashPath?: string; // overrides window.location.hash navigation when set
   onClick?: () => void; // custom click handler; skips hash navigation when set
   sticky?: boolean; // when true, does not auto-dismiss — use for action toasts that require a click
+  createdAt?: number; // set by toastQueueAtom when enqueued; used for #80 eviction ordering
 };
 
 // Build a "download complete" system toast. Kept folds-free here (the icon src is
@@ -50,22 +51,45 @@ const baseAtom = atom<ToastNotif[]>([]);
 // can't stack unbounded and cover the viewport.
 const MAX_TOASTS = 5;
 
+// #80 — a toast younger than this hasn't had a fair chance to be read yet, so
+// eviction prefers dropping an older, already-seen toast over a fresh one when
+// a burst arrives while several toasts are still on screen.
+const MIN_VISIBLE_MS = 1500;
+
+// Pick the index (within [0, excludeLastIndex)) of the toast to evict: prefer
+// the oldest non-sticky toast that's already been visible at least
+// MIN_VISIBLE_MS; if none qualifies yet (e.g. a burst that all arrived within
+// the same beat), fall back to the oldest non-sticky toast regardless of age
+// so the cap is still enforced. Sticky action toasts are never evicted.
+const findEvictionIndex = (toasts: ToastNotif[], excludeLastIndex: number, now: number): number => {
+  for (let i = 0; i < excludeLastIndex; i += 1) {
+    const t = toasts[i];
+    if (!t.sticky && now - (t.createdAt ?? now) >= MIN_VISIBLE_MS) return i;
+  }
+  for (let i = 0; i < excludeLastIndex; i += 1) {
+    if (!toasts[i].sticky) return i;
+  }
+  return -1;
+};
+
 // Write-only setter used in ClientNonUIFeatures
 export const toastQueueAtom = atom<ToastNotif[], [ToastNotif | null], void>(
   (get) => get(baseAtom),
   (get, set, notif) => {
     if (notif === null) return; // no-op guard
+    // Stamp in place (not a copy) so the queue keeps holding the exact object
+    // the caller passed in — callers/tests may rely on reference equality.
+    notif.createdAt = Date.now();
+    const now = notif.createdAt;
     const next = [...get(baseAtom), notif];
-    // Over cap: drop the oldest NON-sticky toasts (transient message/error
-    // toasts auto-dismiss anyway); never drop a sticky action toast, which
-    // requires a click. The `length - 1` bound excludes the just-appended
-    // newest, so a fresh toast is never the one dropped — if everything older
-    // is sticky the cap simply stretches rather than eating the new notice.
-    for (let i = 0; i < next.length - 1 && next.length > MAX_TOASTS; i += 1) {
-      if (!next[i].sticky) {
-        next.splice(i, 1);
-        i -= 1;
-      }
+    // The last index (the just-appended newest toast) is never a candidate, so
+    // a fresh toast is never the one dropped — if everything older is sticky
+    // (or, now, too young) the cap simply stretches rather than eating the new
+    // notice.
+    while (next.length > MAX_TOASTS) {
+      const idx = findEvictionIndex(next, next.length - 1, now);
+      if (idx === -1) break;
+      next.splice(idx, 1);
     }
     set(baseAtom, next);
   },