feat(files): download from anywhere — a link box, a pasted link, the palette; the running downloads in a tray

- Files toolbar link box (paste button, Enter); a lone http(s) link pasted onto any page opens the one
  app-wide download dialog, which now names the link; the palette's "Download from a link…" focuses
  the box on its history entry.
- The download tray, bottom right on every page: what waits, runs, is paused or failed (reason +
  Retry, the queue's right-click / "…" menu), and what finished in this tab as "Done · Open" until
  closed; folds to a pill (per-account pref); closed, it stays shut — across a reload — until the
  work changes or something finishes. Back to top steps up over it, the page end keeps clear.
- A finish is announced once: "Downloaded: …", whether a phone plays it, Copy link + Open (toasts
  and notices may carry a second action).
- The inbox's ready notice opens the file in its folder: download_done carries job_id + folder_id.
- GET /api/downloads is the queue only (in flight, failed, finished in the last 10 minutes), with
  each row's source key.

frontend/src/lib/downloadQueue.ts

@@ -0,0 +1,59 @@
+import { api, type QueueJob } from "./api";
+import { createStore } from "./store";
+
+// The download queue as this tab has watched it: which jobs it has seen finish. The tray shows them
+// ("Done · Open") until it is closed, and announces each once (the done notice).
+//
+// Watched where the queue is FETCHED, not in a component's effect: every reader of the queue (the
+// tray, the Downloads page) fetches through `fetchQueue`, so a finish is seen once whichever of them
+// polled, and nothing has to diff the previous render's data.
+
+/** The statuses a job leaves on its own: it is waiting, or working. */
+export const IN_FLIGHT: ReadonlySet<string> = new Set(["queued", "running", "paused"]);
+
+let lastSeen: Map<number, string> | null = null;
+const finished = createStore<QueueJob[]>([]);
+const unannounced = createStore<QueueJob[]>([]);
+
+/** Note a fresh queue: a job that is done now and was not on the last look has just finished. The
+ *  first look only learns what is there — a file finished before this tab opened is old news. */
+export function noteQueue(jobs: QueueJob[]): void {
+  const before = lastSeen;
+  lastSeen = new Map(jobs.map((j) => [j.id, j.status]));
+  if (!before) return;
+  const done = jobs.filter((j) => j.status === "done" && before.get(j.id) !== "done");
+  if (done.length === 0) return;
+  const ids = new Set(done.map((j) => j.id));
+  finished.set((list) => [...done, ...list.filter((j) => !ids.has(j.id))]);
+  unannounced.set((list) => [...list, ...done]);
+}
+
+/** The queue, noted (see above). Every reader of `qk.downloads()` fetches with this. */
+export async function fetchQueue(): Promise<QueueJob[]> {
+  const jobs = await api.downloads();
+  noteQueue(jobs);
+  return jobs;
+}
+
+/** The jobs this tab saw finish, newest first, until the tray is closed. */
+export const useFinished = (): QueueJob[] => finished.useValue();
+
+/** The tray was closed: what finished is no longer shown. */
+export const clearFinished = (): void => finished.set([]);
+
+/** The finishes not yet announced — the render subscription that wakes the announcer. */
+export const useUnannounced = (): QueueJob[] => unannounced.useValue();
+
+/** Take the finishes to announce, clearing them: each is announced once. */
+export function takeUnannounced(): QueueJob[] {
+  const list = unannounced.get();
+  if (list.length) unannounced.set([]);
+  return list;
+}
+
+/** Forget what was watched (a test starts from a tab that has looked at nothing). */
+export function resetQueueWatch(): void {
+  lastSeen = null;
+  finished.set([]);
+  unannounced.set([]);
+}