@sinequa/atomic-angular 1.16.0 → 1.17.0

package/fesm2022/sinequa-atomic-angular-document-workspaces.mjs

@@ -132,8 +132,8 @@ function withDocumentCountAdjusted(workspaces, id, delta) {
  * touches the cache once the server has answered, so a rejected call leaves
  * the state as it was — the call site reports the error.
  *
- * `addDocuments` alone stays purely local: it is the upload flow's optimistic
- * pre-transfer cache update.
+ * `addDocuments`, `discardDocuments` and `patchDocument` stay purely local. The upload
+ * flow no longer uses them: the list is the index, and only the listing writes to it.
  */
 const WorkspacesStore = signalStore({ providedIn: "root" }, withDevtools("Workspaces"), withState(initialState$1), withComputed(({ workspaces, pagination, selectedIds }) => ({
     hasMore: computed(() => workspaces().length < pagination().total && workspaces().length < MAX_LOADED_WORKSPACES),
@@ -353,17 +353,16 @@ const WorkspacesStore = signalStore({ providedIn: "root" }, withDevtools("Worksp
             return merged;
         },
         /**
-         * Local only — the upload flow renders a document optimistically, before
-         * its bytes are even sent; the server persists it separately once the
-         * transfer completes.
+         * Local only: adds documents to the cache without calling the API. The upload
+         * flow does not use it (a file enters the list once the listing returns it).
          */
         addDocuments(workspaceId, documents) {
             setDocuments(workspaceId, [...(store.documents()[workspaceId] ?? []), ...documents]);
             adjustDocumentCount(workspaceId, documents.length);
         },
         /**
-         * Local only, the counterpart of {@link addDocuments}: forgets documents the
-         * server never persisted — an upload cancelled before it finished.
+         * Local only, the counterpart of {@link addDocuments}: forgets documents without
+         * calling the API.
          * `removeDocuments` is the one that deletes on the server.
          */
         discardDocuments(workspaceId, documentIds) {
@@ -372,7 +371,7 @@ const WorkspacesStore = signalStore({ providedIn: "root" }, withDevtools("Worksp
             setDocuments(workspaceId, after);
             adjustDocumentCount(workspaceId, after.length - before.length);
         },
-        /** Replaces one cached document (status/progress updates coming from the upload flow), matched by id. */
+        /** Local only: merges a patch into one cached document, matched by id. */
         patchDocument(workspaceId, documentId, patch) {
             patchState(store, state => ({
                 documents: {
@@ -437,7 +436,8 @@ const initialState = {
     workspaces: [],
     connection: null,
     clearedCount: 0,
-    jobIndexing: {}
+    jobIndexing: {},
+    ignoredJobs: {}
 };
 const FINISHED = ["done", "error", "rejected"];
 const FAILED = ["error", "rejected"];
@@ -493,6 +493,45 @@ function phaseProgress(uploads, jobIndexing) {
 function updateOne(uploads, id, change) {
     return uploads.map(upload => (upload.id === id ? change(upload) : upload));
 }
+/** `ignored` plus the jobs of `uploads`. */
+function withIgnored(ignored, uploads) {
+    const next = { ...ignored };
+    for (const upload of uploads)
+        next[jobOf(upload)] = true;
+    return next;
+}
+/** The row standing for a whole job, whose files the API does not list: `<jobId>/`. */
+const remoteJobRowId = (jobId) => `${jobId}/`;
+/** Where a whole job stands, as one row: what the API says of its two phases. */
+function remoteJobState(job) {
+    if (job.uploadStatus === "uploading")
+        return { status: "uploading", percent: job.uploadProgress?.percentage ?? 0 };
+    if (job.uploadStatus === "upload_interrupted")
+        return { status: "error", percent: 0 };
+    if (job.indexingStatus === "complete")
+        return { status: "done", percent: 100 };
+    if (job.indexingStatus === "failed" || job.indexingStatus === "interrupted")
+        return { status: "error", percent: 0 };
+    // The job's aggregate indexing percentage lives in `jobIndexing`: no file has its own.
+    return { status: "indexing", percent: 0 };
+}
+/**
+ * The rows a job started elsewhere shows as: one per file the API names (errors and
+ * rejections, the only per-file data it has), and one for the job itself — unless a
+ * named file already explains why it failed.
+ */
+function remoteRows({ job, workspaceId, mine }) {
+    const base = { type: "doc", workspaceId, retryable: false, percent: 0, remote: { mine } };
+    const files = [
+        ...(job.errors ?? []).map(e => ({ ...base, id: `${job.jobId}/${e.fileName}`, name: e.fileName, status: "error", message: e.error ?? undefined })),
+        ...(job.rejected ?? []).map(r => ({ ...base, id: `${job.jobId}/${r.fileName}`, name: r.fileName, status: "rejected", message: r.reason }))
+    ];
+    const state = remoteJobState(job);
+    if (state.status === "error" && files.length)
+        return files;
+    return [{ ...base, ...state, id: remoteJobRowId(job.jobId), name: "" }, ...files];
+}
+const sameRow = (a, b) => a.status === b.status && a.percent === b.percent && a.message === b.message && a.workspaceId === b.workspaceId && a.remote?.mine === b.remote?.mine;
 /**
  * The state of every upload the tracker follows — pure state, no I/O.
  *
@@ -515,6 +554,13 @@ const UploadTrackerStore = signalStore({ providedIn: "root" }, withDevtools("Upl
     }),
     /** Everything is over and nothing failed: the panel celebrates, then dismisses itself. */
     allDone: computed(() => uploads().length > 0 && uploads().every(u => u.status === "done")),
+    /** Everything is over, whether it worked or not: nothing moves any more, and the panel may be closed. */
+    settled: computed(() => uploads().length > 0 && uploads().every(isFinished)),
+    /**
+     * A failure on an upload of the current user's. It is theirs to read and close: the panel
+     * stays until they do. A failure on someone else's upload is only worth the usual delay.
+     */
+    authorFailed: computed(() => uploads().some(u => isFailed(u) && (!u.remote || u.remote.mine))),
     /** Per workspace, how far each phase is — what the tracker's progress bars show. */
     progress: computed(() => {
         const byWorkspace = new Map();
@@ -638,22 +684,62 @@ const UploadTrackerStore = signalStore({ providedIn: "root" }, withDevtools("Upl
             patchState(store, { uploads: next, jobIndexing });
         return changed;
     },
+    /**
+     * Feeds in the jobs the status API reports that this client is not following — the ones
+     * another user started, or its own from before a page reload. Each becomes a row (see
+     * `remoteRows`), updated on every call; a job this client sent itself is left to the
+     * local rows, and so is one the user already got rid of.
+     *
+     * @returns Whether anything changed, which paces the poller.
+     */
+    applyRemoteJobs(entries) {
+        const current = store.uploads();
+        const ignored = store.ignoredJobs();
+        const ownJobs = new Set(current.filter(u => !u.remote).map(jobOf));
+        const rows = new Map(current.map(u => [u.id, u]));
+        const workspaces = [...store.workspaces()];
+        let changed = false;
+        for (const entry of entries) {
+            if (ignored[entry.job.jobId] || ownJobs.has(entry.job.jobId))
+                continue;
+            for (const row of remoteRows(entry)) {
+                const known = rows.get(row.id);
+                if (known && sameRow(known, row))
+                    continue;
+                rows.set(row.id, known ? { ...known, ...row } : row);
+                changed = true;
+            }
+            if (!workspaces.some(w => w.id === entry.workspaceId)) {
+                workspaces.push({ id: entry.workspaceId, name: entry.workspaceName });
+                changed = true;
+            }
+        }
+        if (changed)
+            patchState(store, { uploads: [...rows.values()], workspaces });
+        return changed;
+    },
     setConnection(connection) {
         patchState(store, { connection });
     },
     remove(id) {
-        patchState(store, state => ({ uploads: state.uploads.filter(u => u.id !== id) }));
+        patchState(store, state => {
+            const uploads = state.uploads.filter(u => u.id !== id);
+            // The job is forgotten once its last row is gone; while one is left, the job is still followed.
+            const gone = state.uploads.filter(u => u.id === id && !uploads.some(other => jobOf(other) === jobOf(u)));
+            return { uploads, ignoredJobs: withIgnored(state.ignoredJobs, gone) };
+        });
     },
     /** Drops a finished workspace's files from the tracker; they stay counted as indexed. */
     removeWorkspace(workspaceId) {
         patchState(store, state => ({
             uploads: state.uploads.filter(u => u.workspaceId !== workspaceId),
             workspaces: state.workspaces.filter(w => w.id !== workspaceId),
-            clearedCount: state.clearedCount + state.uploads.filter(u => u.workspaceId === workspaceId).length
+            clearedCount: state.clearedCount + state.uploads.filter(u => u.workspaceId === workspaceId).length,
+            ignoredJobs: withIgnored(state.ignoredJobs, state.uploads.filter(u => u.workspaceId === workspaceId))
         }));
     },
     reset() {
-        patchState(store, initialState);
+        patchState(store, state => ({ ...initialState, ignoredJobs: withIgnored(state.ignoredJobs, state.uploads) }));
     }
 })));
 
@@ -744,6 +830,12 @@ function isJobTerminal(job) {
 function allJobs(res) {
     return (res.containers ?? []).flatMap(c => c.jobs ?? []);
 }
+/** Like {@link allJobs}, but keeps the workspace each job belongs to. */
+function containerJobs(res) {
+    return (res.containers ?? []).flatMap(c => (c.jobs ?? []).map(job => ({ job, containerId: c.containerId, containerName: c.containerName })));
+}
+/** How long the panel stays on screen once every upload is over. */
+const FINISHED_UPLOAD_VISIBLE_MS = 2 * 60 * 1000;
 
 /**
  * `crypto.randomUUID()` is only available in a secure context (HTTPS, or HTTP on
@@ -969,9 +1061,6 @@ const UPLOAD_FACTORY = new InjectionToken("UPLOAD_FACTORY", {
     factory: () => createTusUpload
 });
 
-// One page is enough to refresh what the open workspace shows: the detail view
-// itself loads page 1 at the same size.
-const DOCUMENT_STATUS_PAGE_SIZE = 100;
 /**
  * Sends files to a workspace and follows them until they are indexed.
  *
@@ -986,6 +1075,10 @@ const DOCUMENT_STATUS_PAGE_SIZE = 100;
  * speaks for both. What the user sees lives in `UploadTrackerStore`; this
  * service only writes to it.
  *
+ * It never writes a file into a workspace's list: the list is the index, and a file
+ * enters it only once the container listing returns it. What the service does for the
+ * list is re-read that listing while something is in progress.
+ *
  * Root-scoped: an upload must outlive the view that started it. It registers its
  * window and auth listeners once, and removes them when the application is destroyed.
  */
@@ -1053,37 +1146,20 @@ class UploadService {
         const jobId = generateUUID();
         const fileCount = files.length;
         const totalBytes = files.reduce((total, f) => total + f.size, 0);
-        const uploadedBy = this.currentUser.user()?.name;
-        const now = new Date().toISOString();
-        const documents = files.map(file => ({
-            // A provisional id, which is also the key the tracker and this service follow the
-            // file by. It is NOT the server's: the listing names a document
-            // `/DocUpload/…|<containerId>/<fileName>`, and that is what DELETE and move expect.
-            // The first listing that shows the file swaps it in (see `adoptServerId`), so until
-            // then the document has no real id to act on.
-            id: `${jobId}/${file.name}`,
-            name: file.name,
-            workspaceId: workspace.id,
-            type: getDocumentType(file.name),
-            createdAt: now,
-            size: file.size,
-            status: "uploading",
-            percent: 0,
-            jobId,
-            uploadedBy
-        }));
-        this.workspaces.addDocuments(workspace.id, documents);
-        this.tracker.track(documents.map(d => ({ id: d.id, name: d.name, type: d.type })), workspace.id, workspace.name);
-        documents.forEach((document, i) => {
-            this.inFlight.add(document.id);
-            this.startUpload(document, files[i], { jobId, fileCount, totalBytes }, options.endpoint);
+        // The id is the key the tracker and this service follow the file by. It is NOT the
+        // server's: the listing names a document `/DocUpload/…|<containerId>/<fileName>`.
+        const items = files.map(file => ({ id: `${jobId}/${file.name}`, workspaceId: workspace.id }));
+        this.tracker.track(files.map((file, i) => ({ id: items[i].id, name: file.name, type: getDocumentType(file.name) })), workspace.id, workspace.name);
+        items.forEach((item, i) => {
+            this.inFlight.add(item.id);
+            this.startUpload(item, files[i], { jobId, fileCount, totalBytes }, options.endpoint);
         });
         this.poller.start();
-        return documents.map(d => d.id);
+        return items.map(item => item.id);
     }
     /**
      * Abandons a transfer and forgets it: stops it, and drops the file from the
-     * tracker and from the workspace's cached documents. Works while it is sending
+     * tracker. Works while it is sending
      * and once it has failed; once the bytes are in, indexing is the server's and
      * there is nothing left to cancel.
      *
@@ -1100,7 +1176,6 @@ class UploadService {
         this.inFlight.delete(id);
         this.clearRetryNotice(id);
         this.tracker.remove(id);
-        this.workspaces.discardDocuments(entry.workspaceId, [this.storedId(entry.workspaceId, id)]);
         try {
             await entry.handle.abort(true);
         }
@@ -1115,7 +1190,6 @@ class UploadService {
         if (!entry || entry.refused || upload?.status !== "error")
             return;
         this.tracker.restart(id);
-        this.patchStored(entry.workspaceId, id, { status: "uploading", percent: 0 });
         this.inFlight.add(id);
         entry.handle.resume();
         this.poller.start();
@@ -1132,17 +1206,15 @@ class UploadService {
     }
     /**
      * Tells the service which workspace is open, so the status polling can be
-     * scoped to it (the API documents that as the cheaper lookup) and refresh what
-     * it shows. `null` when none is. Starts the polling when the workspace holds
-     * documents that are not finished yet: a page reload loses every local tus
-     * handle, so the listing is the only way to know.
+     * scoped to it (the API documents that as the cheaper lookup) and re-read its
+     * listing. `null` when none is. Starts the polling: a page reload loses every
+     * local tus handle and the listing no longer says what is in progress, so the
+     * status API is the only way to know. The loop stops by itself after one tick
+     * when nothing is.
      */
     watch(workspaceId) {
         this.focusedWorkspaceId = workspaceId;
-        if (!workspaceId)
-            return;
-        const unfinished = this.workspaces.documentsOf(workspaceId).some(d => d.status === "uploading" || d.status === "indexing");
-        if (unfinished)
+        if (workspaceId)
             this.poller.start();
     }
     startPolling() {
@@ -1152,11 +1224,11 @@ class UploadService {
         this.poller.stop();
     }
     // ── sending ──
-    startUpload(document, file, job, endpoint) {
-        const workspaceId = document.workspaceId;
+    startUpload(item, file, job, endpoint) {
+        const workspaceId = item.workspaceId;
         if (!endpoint) {
-            this.inFlight.delete(document.id);
-            this.markError(document);
+            this.inFlight.delete(item.id);
+            this.markError(item);
             return;
         }
         const entry = {
@@ -1178,25 +1250,25 @@ class UploadService {
                             // again once the user is back.
                             void this.recoverSessionAndResume();
                             if (this.signedOut) {
-                                this.clearRetryNotice(document.id);
+                                this.clearRetryNotice(item.id);
                                 return false;
                             }
                         }
                         else if (FATAL_UPLOAD_STATUSES.has(status)) {
                             entry.refused = true;
-                            this.clearRetryNotice(document.id);
+                            this.clearRetryNotice(item.id);
                             return false;
                         }
                         // tus waits retryDelays[attempt] before this attempt and passes that same
                         // index here, so the banner's countdown is the real delay, not an estimate.
-                        this.noteRetryScheduled(document.id, attempt);
+                        this.noteRetryScheduled(item.id, attempt);
                         return true;
                     },
                     // Anything that came back cleanly means the connection works again for this
                     // upload, whatever the retry bookkeeping still says.
                     responded: status => {
                         if (status < 400)
-                            this.noteHealthy(document.id);
+                            this.noteHealthy(item.id);
                     },
                     // A recovery kicked off by a previous 401 may still be in flight, and
                     // carrying the token it is fetching is the entire point of this retry.
@@ -1209,67 +1281,42 @@ class UploadService {
                         // processed: on a fast transfer a stale event can still arrive after
                         // success moved the file to indexing. Drop anything that comes once the
                         // upload phase is over, so it cannot stomp the indexing percentage.
-                        if (this.tracker.uploads().find(u => u.id === document.id)?.status !== "uploading")
+                        if (this.tracker.uploads().find(u => u.id === item.id)?.status !== "uploading")
                             return;
-                        this.tracker.setProgress(document.id, bytesTotal ? (bytesUploaded / bytesTotal) * 100 : 0);
+                        this.tracker.setProgress(item.id, bytesTotal ? (bytesUploaded / bytesTotal) * 100 : 0);
                     },
                     success: () => {
                         // Bytes are in; indexing is now the server's business, so the poller owns
                         // this document from here. Nothing left to resume.
-                        this.noteHealthy(document.id);
-                        this.uploads.delete(document.id);
-                        this.markIndexing(document);
+                        this.noteHealthy(item.id);
+                        this.uploads.delete(item.id);
+                        this.markIndexing(item);
                         this.poller.start();
                     },
                     failed: () => {
                         // The handle is kept: the retry budget is spent, but the upload is not lost —
                         // `retry()` can pick it up again and tus resumes from the server's offset.
-                        this.clearRetryNotice(document.id);
-                        this.inFlight.delete(document.id);
-                        this.markError(document, { retryable: !entry.refused });
+                        this.clearRetryNotice(item.id);
+                        this.inFlight.delete(item.id);
+                        this.markError(item, { retryable: !entry.refused });
                     }
                 }
             })
         };
-        this.uploads.set(document.id, entry);
+        this.uploads.set(item.id, entry);
         entry.handle.begin();
     }
-    // ── what a document's state change writes where ──
-    // A document has two names. The tracker, `inFlight` and `uploads` know it by its
-    // provisional key (`<jobId>/<fileName>`, which never changes); the workspace store
-    // knows it by whatever id it holds right now — the same key until the server's id
-    // is adopted, the server's after. These helpers bridge the two.
-    /** The key a cached document is followed by in the tracker. */
-    keyOf(document) {
-        return document.jobId ? `${document.jobId}/${document.name}` : document.id;
-    }
-    /** The id the workspace store holds for the file followed under `key`. */
-    storedId(workspaceId, key) {
-        return this.workspaces.documentsOf(workspaceId).find(d => this.keyOf(d) === key)?.id ?? key;
-    }
-    patchStored(workspaceId, key, patch) {
-        this.workspaces.patchDocument(workspaceId, this.storedId(workspaceId, key), patch);
-    }
-    markIndexing(document) {
-        const key = this.keyOf(document);
-        this.patchStored(document.workspaceId, key, { status: "indexing" });
-        this.tracker.setIndexing(key);
-    }
-    markComplete(document) {
-        const key = this.keyOf(document);
-        this.patchStored(document.workspaceId, key, { status: null });
-        this.tracker.setDone(key);
-    }
-    markError(document, options = {}) {
-        const key = this.keyOf(document);
-        this.patchStored(document.workspaceId, key, { status: "error" });
-        this.tracker.setError(key, options);
+    // ── what a file's state change writes ──
+    markIndexing(item) {
+        this.tracker.setIndexing(item.id);
+    }
+    markError(item, options = {}) {
+        this.tracker.setError(item.id, options);
     }
     // ── following indexing ──
     //
-    // There are two endpoints, at two grains, and both are needed:
-    //   - GET .../container/{id}/documents -> status + percent PER DOCUMENT
-    //   - GET .../document-upload/status   -> aggregate, errors[] and rejected[] PER JOB
+    //   - GET .../document-upload/status   -> the tracker: aggregate, errors[] and rejected[] PER JOB
+    //   - GET .../container/{id}/documents -> the workspace's list, which is the index and nothing else
     async pollUploadStatus(signal) {
         try {
             const result = await this.runPollTick(signal);
@@ -1294,84 +1341,51 @@ class UploadService {
         // the tracker still follows a batch after the user navigates away from it.
         const response = await fetchUploadStatus(workspaceId ? { containerId: workspaceId } : {}, { signal });
         const jobs = allJobs(response);
-        // Both halves can move on their own — a rejection can surface with no workspace
-        // open at all — so the tick reports the union, otherwise the idle backoff would
-        // widen while things are still happening.
-        let changed = this.tracker.applyJobs(jobs);
+        // Jobs started elsewhere come first, so that `applyJobs` finds their rows to update.
+        const remote = await this.remoteJobs(response, signal);
+        let changed = this.tracker.applyRemoteJobs(remote);
+        changed = this.tracker.applyJobs(jobs) || changed;
         this.settleFinishedUploads();
-        let pending = jobs.some(job => !isJobTerminal(job));
-        if (workspaceId) {
-            const listing = await listContainerDocuments(workspaceId, { page: 1, pageSize: DOCUMENT_STATUS_PAGE_SIZE }, { signal });
-            const applied = this.applyDocumentStatuses(workspaceId, listing.documents);
-            pending = pending || applied.pending;
-            changed = changed || applied.changed;
-        }
+        const pending = jobs.some(job => !isJobTerminal(job));
+        // The list follows the index, not the status: a file shows up once the listing returns it.
+        // The last tick of a loop reads it too, which is when a file that just got indexed comes in.
+        if (workspaceId)
+            changed = (await this.refreshListing(workspaceId, signal)) || changed;
         return { pending: pending || this.inFlight.size > 0, changed };
     }
     /**
-     * The job-level status can finish a file the document listing has not reported
-     * (no workspace open, or a listing that lags): mirror what the tracker now says
-     * onto the cached document and release the poller's hold on it.
+     * The jobs of the response the panel should show although this client did not send
+     * them. The server decides which ones the response holds — those in progress or just
+     * ended, on the workspaces the user can write to — so none is filtered by role or date
+     * here; only, with a workspace open, those that belong to it are kept. Whether the user
+     * started one is read from `initiatedBy`, which is their `userId`, so it holds after a
+     * page reload too.
      */
-    settleFinishedUploads() {
-        for (const upload of this.tracker.uploads()) {
-            if (upload.status !== "done" || !this.inFlight.has(upload.id))
+    async remoteJobs(response, signal) {
+        const me = (await this.currentUser.whenReady())?.id;
+        if (signal.aborted)
+            return [];
+        const entries = [];
+        for (const { job, containerId, containerName } of containerJobs(response)) {
+            if (this.focusedWorkspaceId && this.focusedWorkspaceId !== containerId)
                 continue;
-            this.inFlight.delete(upload.id);
-            this.patchStored(upload.workspaceId, upload.id, { status: null });
+            const workspaceName = this.workspaces.workspace(containerId)?.name ?? containerName;
+            entries.push({ job, workspaceId: containerId, workspaceName, mine: !!me && job.initiatedBy === me });
         }
+        return entries;
     }
-    applyDocumentStatuses(workspaceId, wireDocuments) {
-        const locals = this.workspaces.documentsOf(workspaceId);
-        let pending = false;
-        let changed = false;
-        for (const wire of wireDocuments) {
-            const next = mapDocumentStatus(wire.status);
-            if (next === "uploading" || next === "indexing")
-                pending = true;
-            // The listing names a document `/DocUpload/…|<containerId>/<fileName>`, ours is
-            // `<jobId>/<fileName>`: the (job, name) pair is what both sides agree on.
-            const document = locals.find(d => d.id === wire.id || (!!wire.jobId && d.jobId === wire.jobId && d.name === wire.name));
-            if (!document)
-                continue;
-            const key = this.keyOf(document);
-            // From now on the store holds the id the server will recognise: delete and move send it.
-            if (document.id !== wire.id)
-                this.workspaces.patchDocument(workspaceId, document.id, { id: wire.id });
-            // While tus is still sending, the local byte-level progress is ahead of anything
-            // the server can report: it owns the percentage until tus hands over. An error
-            // is the one thing worth taking early.
-            if (this.inFlight.has(key) && document.status === "uploading") {
-                if (next === "error") {
-                    this.inFlight.delete(key);
-                    this.markError(document);
-                    changed = true;
-                }
-                continue;
-            }
-            if (next === "indexing" && document.status !== "indexing") {
-                this.markIndexing(document);
-                changed = true;
-            }
-            else if (next === null && document.status !== null) {
-                this.inFlight.delete(key);
-                this.markComplete(document);
-                changed = true;
-            }
-            else if (next === "error" && document.status !== "error") {
-                this.inFlight.delete(key);
-                this.markError(document);
-                changed = true;
-            }
-            else if (next === "uploading" && typeof wire.percent === "number" && document.percent !== wire.percent) {
-                // Not ours to transfer (another user's upload, or our own seen again after a
-                // reload): the server's percentage is all there is.
-                this.workspaces.patchDocument(workspaceId, wire.id, { percent: wire.percent });
-                this.tracker.setProgress(key, wire.percent);
-                changed = true;
-            }
+    /** Re-reads the workspace's listing. @returns Whether it differs from what was shown. */
+    async refreshListing(workspaceId, signal) {
+        const before = JSON.stringify(this.workspaces.documentsOf(workspaceId));
+        await this.workspaces.loadDocuments(workspaceId, signal);
+        return JSON.stringify(this.workspaces.documentsOf(workspaceId)) !== before;
+    }
+    /** The job-level status can finish a file this client was still holding the poller for: release it. */
+    settleFinishedUploads() {
+        for (const upload of this.tracker.uploads()) {
+            if (upload.status === "done")
+                this.inFlight.delete(upload.id);
         }
-        return { pending, changed };
     }
     // ── connection loss & session recovery ──
     //
@@ -3147,6 +3161,7 @@ class WorkspaceList {
     createRequested = output();
     store = inject(WorkspacesStore);
     dialogs = inject(DialogService);
+    uploads = inject(UploadService);
     transloco = inject(TranslocoService);
     tabs = TABS;
     viewMode = signal("grid", ...(ngDevMode ? [{ debugName: "viewMode" }] : []));
@@ -3174,9 +3189,13 @@ class WorkspaceList {
         const changed = JSON.stringify(this.store.workspaces()) !== before;
         if (changed)
             this.selection.exit(); // the ticks belonged to the list that was there before
+        // An upload someone else is running on a workspace listed here: only the status API tells.
+        // It stops by itself after a tick when nothing is moving.
+        this.uploads.startPolling();
         return changed;
     }, { intervalMs: 20_000, maxIntervalMs: 120_000 });
     constructor() {
+        this.uploads.startPolling();
         void this.load();
     }
     /** Shows what is cached at once and refreshes behind it, or loads for the first time. */
@@ -3511,6 +3530,15 @@ function truncateName(name, max) {
     }
     return `${name.slice(0, max - 1)}…`;
 }
+/**
+ * What to call a tracked row: the file's name — or, for a job started elsewhere whose files
+ * the status API does not list, whose job it is.
+ */
+function uploadLabel(upload, max) {
+    if (upload.name)
+        return { text: truncateName(upload.name, max) };
+    return trackerMessage(upload.remote?.mine ? "ownUpload" : "remoteUpload");
+}
 /** `m:ss` for a duration in ms, clamped at 0 so a late tick cannot go negative. */
 function formatClock(ms) {
     const seconds = Math.max(0, Math.round(ms / 1000));
@@ -5792,10 +5820,10 @@ class WorkspaceDetail {
     /** The background refresh found the workspace gone from the server (deleted elsewhere). */
     deletedElsewhere = signal(false, ...(ngDevMode ? [{ debugName: "deletedElsewhere" }] : []));
     workspace = computed(() => this.store.workspace(this.workspaceId()), ...(ngDevMode ? [{ debugName: "workspace" }] : []));
-    // Only what is really uploaded or being indexed is listed: transfers and failures
-    // belong to the upload tracker, not to the workspace. A document with no status at
-    // all is one the server does not track — it is simply there, so it stays listed.
-    documents = computed(() => this.store.documentsOf(this.workspaceId()).filter(d => d.status !== "uploading" && d.status !== "error"), ...(ngDevMode ? [{ debugName: "documents" }] : []));
+    // The list is the index: only a document the listing returns as indexed is shown. Transfers,
+    // indexing and failures belong to the upload tracker, not to the workspace. A document with no
+    // status at all is one the server does not track — it is simply there, so it stays listed.
+    documents = computed(() => this.store.documentsOf(this.workspaceId()).filter(d => !d.status), ...(ngDevMode ? [{ debugName: "documents" }] : []));
     previewed = computed(() => this.documents().find(d => d.id === this.previewedDocumentId()) ?? null, ...(ngDevMode ? [{ debugName: "previewed" }] : []));
     /** The width the user dragged the preview to, if they did. */
     userPreviewWidth = signal(null, ...(ngDevMode ? [{ debugName: "userPreviewWidth" }] : []));
@@ -5848,8 +5876,9 @@ class WorkspaceDetail {
             return false; // the user moved to another workspace meanwhile
         const documentsChanged = JSON.stringify(this.store.documentsOf(id)) !== beforeDocuments;
         const workspaceChanged = JSON.stringify(this.store.workspace(id)) !== beforeWorkspace;
-        if (documentsChanged)
-            this.uploads.watch(id); // a document that just appeared may still be indexing for someone else
+        // Every tick, changed or not: an upload someone else just started shows no document yet, and the
+        // tracker only learns of it from the status API. It stops by itself after a tick when nothing is moving.
+        this.uploads.watch(id);
         return documentsChanged || workspaceChanged;
     }, { intervalMs: 15_000, maxIntervalMs: 90_000 });
     constructor() {
@@ -7114,6 +7143,10 @@ class UploadTrackerSection {
         const uploads = this.uploads();
         return uploads.length ? Math.round(uploads.reduce((sum, u) => sum + u.percent, 0) / uploads.length) : 0;
     }, ...(ngDevMode ? [{ debugName: "average" }] : []));
+    /** The translation key standing for a row with no file name: a job started elsewhere. Only read when `name` is empty. */
+    label(upload) {
+        return upload.remote?.mine ? "documentWorkspaces.tracker.ownUpload" : "documentWorkspaces.tracker.remoteUpload";
+    }
     round(value) {
         return Math.round(value);
     }
@@ -7190,8 +7223,8 @@ class UploadTrackerSection {
             <span
               class="min-w-0 flex-1 truncate text-xs text-(--font-neutral-black)"
               [class.text-(--font-error-base)]="upload.status === 'error' || upload.status === 'rejected'"
-              [attr.title]="upload.name"
-              >{{ upload.name }}</span
+              [attr.title]="upload.name || (label(upload) | transloco)"
+              >{{ upload.name || (label(upload) | transloco) }}</span
             >
             @if (upload.message) {
               <span class="max-w-40 shrink truncate text-[11px] text-(--font-neutral-muted)" [attr.title]="upload.message">{{ upload.message }}</span>
@@ -7200,9 +7233,12 @@ class UploadTrackerSection {
             @switch (upload.status) {
               @case ("uploading") {
                 <span class="shrink-0 text-xs text-(--font-neutral-muted) tabular-nums">{{ round(upload.percent) }}%</span>
-                <button class="w-6" variant="ghost" size="xs" [iconOnly]="true" [attr.aria-label]="'documentWorkspaces.tracker.cancelUpload' | transloco" [tooltip]="'documentWorkspaces.tracker.cancelUpload' | transloco" (click)="discard.emit(upload.id)">
-                  <x-mark-icon />
-                </button>
+                <!-- A transfer this client does not hold cannot be stopped from here, and nor can it be closed while it goes on. -->
+                @if (!upload.remote) {
+                  <button class="w-6" variant="ghost" size="xs" [iconOnly]="true" [attr.aria-label]="'documentWorkspaces.tracker.cancelUpload' | transloco" [tooltip]="'documentWorkspaces.tracker.cancelUpload' | transloco" (click)="discard.emit(upload.id)">
+                    <x-mark-icon />
+                  </button>
+                }
               }
               @case ("indexing") {
                 <!-- No percentage here: the server only reports one per job, shown by the bar above. -->
@@ -7332,8 +7368,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.29", ngImpo
             <span
               class="min-w-0 flex-1 truncate text-xs text-(--font-neutral-black)"
               [class.text-(--font-error-base)]="upload.status === 'error' || upload.status === 'rejected'"
-              [attr.title]="upload.name"
-              >{{ upload.name }}</span
+              [attr.title]="upload.name || (label(upload) | transloco)"
+              >{{ upload.name || (label(upload) | transloco) }}</span
             >
             @if (upload.message) {
               <span class="max-w-40 shrink truncate text-[11px] text-(--font-neutral-muted)" [attr.title]="upload.message">{{ upload.message }}</span>
@@ -7342,9 +7378,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.29", ngImpo
             @switch (upload.status) {
               @case ("uploading") {
                 <span class="shrink-0 text-xs text-(--font-neutral-muted) tabular-nums">{{ round(upload.percent) }}%</span>
-                <button class="w-6" variant="ghost" size="xs" [iconOnly]="true" [attr.aria-label]="'documentWorkspaces.tracker.cancelUpload' | transloco" [tooltip]="'documentWorkspaces.tracker.cancelUpload' | transloco" (click)="discard.emit(upload.id)">
-                  <x-mark-icon />
-                </button>
+                <!-- A transfer this client does not hold cannot be stopped from here, and nor can it be closed while it goes on. -->
+                @if (!upload.remote) {
+                  <button class="w-6" variant="ghost" size="xs" [iconOnly]="true" [attr.aria-label]="'documentWorkspaces.tracker.cancelUpload' | transloco" [tooltip]="'documentWorkspaces.tracker.cancelUpload' | transloco" (click)="discard.emit(upload.id)">
+                    <x-mark-icon />
+                  </button>
+                }
               }
               @case ("indexing") {
                 <!-- No percentage here: the server only reports one per job, shown by the bar above. -->
@@ -7385,7 +7424,9 @@ const SECTION_ORDER = ["uploading", "indexing", "done", "error", "rejected"];
 const FLASH_MS = 3000;
 const PEEK_MS = 3500;
 const WORKSPACE_COMPLETE_MS = 3500;
-const AUTO_DISMISS_MS = 3000;
+// How long a panel whose uploads are all over stays: long enough to read the outcome, even of an
+// upload someone else started and the user was not watching.
+const AUTO_DISMISS_MS = FINISHED_UPLOAD_VISIBLE_MS;
 const DISMISS_ANIMATION_MS = 320;
 const HOVER_LEAVE_MS = 250;
 // The text on the strip leaves, then the new one comes: half a transition each.
@@ -7472,7 +7513,7 @@ class UploadTracker {
         const failed = this.store.failed();
         const severalWorkspaces = this.store.workspaces().length > 1;
         // One file is named, several are counted.
-        const label = (uploads, key, max) => uploads.length === 1 ? { text: truncateName(uploads[0].name, max) } : trackerMessage(key, { count: uploads.length });
+        const label = (uploads, key, max) => uploads.length === 1 ? uploadLabel(uploads[0], max) : trackerMessage(key, { count: uploads.length });
         const chips = [];
         if (groups.uploading.length)
             chips.push({ kind: "uploading", busy: true, message: trackerMessage("uploadingCount", { count: groups.uploading.length }) });
@@ -7492,11 +7533,11 @@ class UploadTracker {
             return peek.message;
         const failed = this.store.failed();
         if (failed.length)
-            return failed.length === 1 ? { text: truncateName(failed[0].name, 22) } : trackerMessage("errorCount", { count: failed.length });
+            return failed.length === 1 ? uploadLabel(failed[0], 22) : trackerMessage("errorCount", { count: failed.length });
         const { uploading, indexing, done } = this.store.byStatus();
         const active = uploading.length + indexing.length;
         if (done.length && !active)
-            return done.length === 1 ? { text: truncateName(done[0].name, 22) } : trackerMessage("indexedCount", { count: done.length });
+            return done.length === 1 ? uploadLabel(done[0], 22) : trackerMessage("indexedCount", { count: done.length });
         return trackerMessage("fileCount", { count: active });
     }, ...(ngDevMode ? [{ debugName: "pillMessage" }] : []));
     state = computed(() => (this.mode() !== "minimized" ? "normal" : this.hover() ? "minimized-hover" : "minimized"), ...(ngDevMode ? [{ debugName: "state" }] : []));
@@ -7526,10 +7567,12 @@ class UploadTracker {
                     this.completeWorkspace(complete);
             });
         });
-        // Everything indexed: hold the success message for a moment, then go away.
+        // Everything is over: hold the outcome for a while, then go away — unless a failure of the
+        // user's own is there to be read, which stays until they close it. A new upload cancels
+        // this (nothing is settled any more), and the delay starts afresh when it ends.
         effect(() => {
-            const allDone = this.store.allDone();
-            untracked(() => (allDone ? this.startAutoDismiss() : this.cancelAutoDismiss()));
+            const leaves = this.store.settled() && !this.store.authorFailed();
+            untracked(() => (leaves ? this.startAutoDismiss() : this.cancelAutoDismiss()));
         });
         // The strip of a minimized panel says what is going on; when that changes, the text is swapped, not cut.
         effect(() => {
@@ -7590,9 +7633,9 @@ class UploadTracker {
         }
         this.mode.update(mode => (mode === "expanded" ? "inline" : "expanded"));
     }
-    /** Minimizes while there is work going on; once everything is over, closes for good. */
+    /** Minimizes while there is work going on; once everything is over (failures included), closes for good. */
     dismiss() {
-        if (this.store.allDone() || this.mode() === "minimized") {
+        if (this.store.settled() || this.mode() === "minimized") {
             this.reset();
         }
         else {
@@ -7648,14 +7691,14 @@ class UploadTracker {
         const failed = finished.filter(isFailed);
         if (done.length) {
             const last = done[done.length - 1];
-            const message = { text: truncateName(last.name, this.mode() === "minimized" ? 22 : 30) };
+            const message = uploadLabel(last, this.mode() === "minimized" ? 22 : 30);
             if (this.mode() === "minimized")
                 this.notify(message, "success");
             else if (this.mode() === "inline" && !this.store.allDone())
                 this.showFlash(message);
         }
         if (failed.length && this.mode() === "minimized") {
-            this.notify({ text: truncateName(failed[failed.length - 1].name, 22) }, "error");
+            this.notify(uploadLabel(failed[failed.length - 1], 22), "error");
         }
     }
     /**
@@ -7710,8 +7753,9 @@ class UploadTracker {
     startAutoDismiss() {
         if (this.dismissTimer)
             return;
-        // The success message is in the header: make sure it can be seen.
-        this.mode.set("inline");
+        // The success message is in the header: make sure it can be seen. Failures are in the sections: leave those open.
+        if (this.store.allDone())
+            this.mode.set("inline");
         this.dismissTimer = this.replaceTimer(null, AUTO_DISMISS_MS, () => {
             this.dismissTimer = null;
             this.dismissing.set(true);
@@ -7847,8 +7891,8 @@ class UploadTracker {
               variant="ghost"
               size="xs"
               [iconOnly]="true"
-              [attr.aria-label]="(mode() === 'minimized' || store.allDone() ? 'documentWorkspaces.common.close' : 'documentWorkspaces.common.minimize') | transloco"
-              [tooltip]="(mode() === 'minimized' || store.allDone() ? 'documentWorkspaces.common.close' : 'documentWorkspaces.common.minimize') | transloco"
+              [attr.aria-label]="(mode() === 'minimized' || store.settled() ? 'documentWorkspaces.common.close' : 'documentWorkspaces.common.minimize') | transloco"
+              [tooltip]="(mode() === 'minimized' || store.settled() ? 'documentWorkspaces.common.close' : 'documentWorkspaces.common.minimize') | transloco"
               (click)="dismiss(); $event.stopPropagation()">
               <x-mark-icon />
             </button>
@@ -8053,8 +8097,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.29", ngImpo
               variant="ghost"
               size="xs"
               [iconOnly]="true"
-              [attr.aria-label]="(mode() === 'minimized' || store.allDone() ? 'documentWorkspaces.common.close' : 'documentWorkspaces.common.minimize') | transloco"
-              [tooltip]="(mode() === 'minimized' || store.allDone() ? 'documentWorkspaces.common.close' : 'documentWorkspaces.common.minimize') | transloco"
+              [attr.aria-label]="(mode() === 'minimized' || store.settled() ? 'documentWorkspaces.common.close' : 'documentWorkspaces.common.minimize') | transloco"
+              [tooltip]="(mode() === 'minimized' || store.settled() ? 'documentWorkspaces.common.close' : 'documentWorkspaces.common.minimize') | transloco"
               (click)="dismiss(); $event.stopPropagation()">
               <x-mark-icon />
             </button>