feat(desktop): upload progress on the taskbar button (cinny-desktop #10)

Upload atoms now also report into an app-wide `uploadProgressAtom`, and
`aggregateUploadProgress` turns every in-flight upload into one taskbar
state: byte-weighted percentage while uploading, indeterminate until a
size is known, red after a failure (held 4 s, then cleared), none when
done. Cancelled uploads just disappear. `useTauriTaskbarProgress` sends it
to the native `set_taskbar_progress`, at most ~4 times a second, always
ending on the latest state.

Verified with a throttled 6 MB upload: 0% → 99% at 250 ms steps, then
cleared; with the upload request aborted: 0% → error → cleared after 4 s.

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

src/app/state/uploadProgress.ts

@@ -0,0 +1,67 @@
+import { atom } from 'jotai';
+import type { TUploadContent } from '../utils/matrix';
+
+/**
+ * [cinny-desktop #10] Every in-flight upload across all rooms, so the desktop
+ * taskbar can show one combined progress bar. Written by `createUploadAtom`
+ * (state/upload.ts) as its uploads start, progress, finish or fail.
+ */
+export type UploadProgressEntry = {
+  loaded: number;
+  total: number;
+  failed: boolean;
+  /** ms timestamp of the last change; stale entries are ignored. */
+  updatedAt: number;
+};
+
+export const uploadProgressAtom = atom(new Map<TUploadContent, UploadProgressEntry>());
+
+export type TaskbarProgress =
+  | { status: 'none' }
+  | { status: 'indeterminate' }
+  | { status: 'normal'; progress: number }
+  | { status: 'error'; progress: number };
+
+/** An upload with no update for this long is treated as abandoned. */
+export const UPLOAD_STALE_MS = 2 * 60_000;
+
+/**
+ * Combine every upload into one taskbar state: the byte-weighted percentage
+ * while anything is uploading (indeterminate while no size is known yet), red
+ * when an upload failed and nothing else is running, nothing otherwise.
+ */
+export const aggregateUploadProgress = (
+  entries: Iterable<UploadProgressEntry>,
+  now: number,
+): TaskbarProgress => {
+  let loaded = 0;
+  let total = 0;
+  let active = 0;
+  let failed = 0;
+  let failedLoaded = 0;
+  let failedTotal = 0;
+  Array.from(entries).forEach((e) => {
+    if (now - e.updatedAt > UPLOAD_STALE_MS) return;
+    if (e.failed) {
+      failed += 1;
+      failedLoaded += e.loaded;
+      failedTotal += e.total;
+      return;
+    }
+    active += 1;
+    loaded += Math.min(e.loaded, e.total);
+    total += e.total;
+  });
+  if (active > 0) {
+    if (total <= 0) return { status: 'indeterminate' };
+    return { status: 'normal', progress: Math.min(100, Math.floor((loaded / total) * 100)) };
+  }
+  if (failed > 0) {
+    return {
+      status: 'error',
+      progress:
+        failedTotal > 0 ? Math.min(100, Math.floor((failedLoaded / failedTotal) * 100)) : 100,
+    };
+  }
+  return { status: 'none' };
+};