pmtiles-swarm 0.36.0 → 0.37.2

package/CHANGELOG.md

@@ -7,6 +7,68 @@
 ### 🐞 Bug fixes
 - _...Add new stuff here..._
 
+## 0.37.2
+### ✨ Features and improvements
+
+### 🐞 Bug fixes
+- **Pausing an archive now stops it.** Reported from the field: an archive was paused, the row read
+  `paused`, and it went on downloading at 8.4 MiB/s. Nothing in the chain refused — the pause was
+  asked for, reported as done, and never happened.
+
+  Three faults in a line. `LibtorrentEngine` had no `pause` or `resume` at all, so there was no way
+  to stop a libtorrent torrent from here. `CompositeEngine.pause` answered for its primary alone,
+  so an archive held by a secondary reported as not stopped when it was. And `Library.pause` tested
+  only that the engine *had* a pause method and threw away what it answered — a composite has one
+  whatever its engines can do, so the `false` went into a void, the fallback never ran, and
+  `paused: true` went into the catalog regardless. The console prefers that flag to the engine's
+  live state, which is why the row said `paused` while Down and Up kept moving.
+
+  Requires pmtiles-torrent 0.9.0, which adds the `pause` and `resume` the sidecar never had — and
+  makes them stick. `handle.pause()` alone is not a stop: libtorrent's auto-manager clears the
+  paused flag again within about a second, so pausing that way produces a torrent that describes
+  itself as paused while it transfers. That would have reproduced this exact symptom one layer
+  deeper.
+
+  Nothing was left in a bad state by this: because the pause never took effect, no archive was
+  half-stopped and no resume data is wrong. They were seeding and downloading throughout.
+
+## 0.37.1
+### ✨ Features and improvements
+- **Cancel now sits in the row it cancels.** Collected into a bar underneath the list, each button
+  had to repeat the whole filename to say which add it stopped — two of those filled a line, and
+  pressing the right one meant matching a long name against the list above it. The rows carry their
+  own, and an add that cannot be cancelled keeps an empty cell so the columns stay lined up.
+
+### 🐞 Bug fixes
+
+## 0.37.0
+### ✨ Features and improvements
+- **An archive being hashed can now be cancelled, and says how far through it is.** 0.36.0 moved
+  hashing into a process of its own, which made both possible; this connects them to the console.
+  A local add is now registered with an AbortController, so `DELETE /api/adds?url=<path>` ends the
+  hasher and the Cancel button beside it works. Nothing is lost by pressing it: the archive is the
+  caller's own file and hashing only ever read it.
+
+  Shutdown reaches these too. A hasher left behind when the node exits is an orphan reading the
+  disk for hours, answering to nothing.
+
+  The piece the hasher has reached is converted to bytes against the file size — the console draws
+  one progress bar for adds and labels it in bytes — so a long hash reads `hashing 698 GiB · 41.2%
+  · 12m` instead of `hashing 698 GiB · 3m`. The hourly log line carries the percentage as well. An
+  add hashing in this process rather than out of it still reports no figure, because there is none
+  to report, and the bar is left off rather than pinned at zero.
+
+### 🐞 Bug fixes
+- **Cancelling a hash no longer answers by hashing the same archive here instead.** A creator that
+  fails falls back to hashing in the node's own process, deliberately, since a torrent matters more
+  than the format of a torrent — and a cancelled hash arrives as a creator that failed. So the
+  button would have answered "stop reading 698 GiB" by reading 698 GiB again, in the process
+  serving tiles, where nothing can interrupt it at all. A creator that fails for any other reason
+  still falls back.
+- **A cancel arriving during the MD5 pass is no longer ignored until it finishes.** With `md5` on,
+  the archive is read twice, and only the second read took a signal — so cancelling during the
+  first one waited out most of an hour of disk on a planet archive before it took effect.
+
 ## 0.36.0
 ### ✨ Features and improvements
 - **Hashing an archive now happens in a process of its own.** Building the torrent for a 698 GiB

package/docs/publishing.md

@@ -79,6 +79,25 @@ A magnet, a `.torrent` URL and an uploaded `.torrent` are metadata rather than
 data, so there is nothing slow to wait for: those still answer `201` with the
 entry.
 
+### Stopping one that is running
+
+`DELETE /api/adds?url=…` stops an add before it has produced a torrent, and the
+console offers it as a Cancel button beside each one. The identifier is whatever
+the add was started with — the URL for a remote one, the path for a local one.
+
+What it costs differs by kind. A **remote** add is deleting a partial download,
+deliberately: somebody said stop, and leaving a few hundred gigabytes behind
+after that is waste nobody will ever find again. A **local** add deletes
+nothing. The archive is your own file and hashing only ever read it, so
+cancelling costs the hashing done so far and not a byte of data. If `publishDir`
+moved the file, that already happened — it is the cheap irreversible step and it
+goes first — so the archive stays where it was published to.
+
+`GET /api/adds` reports each one's progress while it runs. A local add hashing
+out of process says how far through the archive it is; one that has fallen back
+to hashing in the node's own process reports no figure at all, because there is
+none to report, and cancelling it stops the wait rather than the read.
+
 ### When the source URL is not published
 
 Adding from a URL registers that URL as a web seed by default, because it is by

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmtiles-swarm",
-  "version": "0.36.0",
+  "version": "0.37.2",
   "description": "BitTorrent distribution for PMTiles map archives: create torrents, watch folders, publish and subscribe to RSS feeds, and seed through qBittorrent or an embedded client",
   "type": "module",
   "main": "src/index.js",
@@ -46,7 +46,7 @@
     "maplibre-gl": "^6.2.0",
     "parse-torrent": "^11.0.24",
     "pmtiles": "^4.4.1",
-    "pmtiles-torrent": "^0.8.0",
+    "pmtiles-torrent": "^0.9.0",
     "webtorrent": "^3.0.21"
   },
   "engines": {

package/src/engines/composite.js

@@ -543,26 +543,40 @@ export class CompositeEngine {
 
   /**
    * Stops offering an archive, everywhere.
+   *
+   * Answers for the whole composite rather than for the primary alone. An
+   * archive can be held by a secondary and not by the primary, and reporting
+   * the primary's "no" for it told the caller nothing was stopped when
+   * something was -- which is a false negative that costs data, since the
+   * caller's answer to a pause it cannot get is to remove the torrent instead.
    * @param {string} infoHash - The archive.
-   * @returns {Promise<boolean>} - Whether the primary paused it.
+   * @returns {Promise<boolean>} - Whether any engine stopped it.
    */
   async pause(infoHash) {
+    let stopped = false;
     for (const engine of this.#secondaries) {
-      await engine.pause?.(infoHash).catch(() => {});
+      stopped = (await engine.pause?.(infoHash).catch(() => false)) || stopped;
     }
-    return this.#primary.pause ? this.#primary.pause(infoHash) : false;
+    const primary = this.#primary.pause
+      ? await this.#primary.pause(infoHash)
+      : false;
+    return primary || stopped;
   }
 
   /**
    * Offers it again, everywhere.
    * @param {string} infoHash - The archive.
-   * @returns {Promise<boolean>} - Whether the primary resumed it.
+   * @returns {Promise<boolean>} - Whether any engine started it.
    */
   async resume(infoHash) {
+    let started = false;
     for (const engine of this.#secondaries) {
-      await engine.resume?.(infoHash).catch(() => {});
+      started = (await engine.resume?.(infoHash).catch(() => false)) || started;
     }
-    return this.#primary.resume ? this.#primary.resume(infoHash) : false;
+    const primary = this.#primary.resume
+      ? await this.#primary.resume(infoHash)
+      : false;
+    return primary || started;
   }
 
   /**

package/src/engines/libtorrent.js

@@ -415,6 +415,57 @@ export class LibtorrentEngine {
     }
   }
 
+  /**
+   * Stops a torrent, leaving its data and its place in the session alone.
+   *
+   * Not removal. The bytes stay, the resume data stays, and starting it again
+   * costs nothing -- which is the whole reason this exists rather than the
+   * remove-and-re-add a missing pause used to fall back to. Re-adding a
+   * 698 GiB archive means hashing the store again to arrive where it already
+   * was.
+   * @param {string} infoHash - The archive to stop.
+   * @returns {Promise<boolean>} - Whether it was stopped.
+   */
+  async pause(infoHash) {
+    await this.#stopStart('pause', infoHash);
+    return true;
+  }
+
+  /**
+   * Offers a stopped torrent again.
+   * @param {string} infoHash - The archive to start.
+   * @returns {Promise<boolean>} - Whether it was started.
+   */
+  async resume(infoHash) {
+    await this.#stopStart('resume', infoHash);
+    return true;
+  }
+
+  /**
+   * Pause and resume differ only in the word, including how they fail.
+   * @param {string} op - 'pause' or 'resume'.
+   * @param {string} infoHash - The archive.
+   * @returns {Promise<object>} - The sidecar's answer.
+   */
+  async #stopStart(op, infoHash) {
+    try {
+      return await this.#call(op, { infoHash });
+    } catch (error) {
+      // An older sidecar answers "unknown op", which is true and useless: it
+      // reads as a bug in the request rather than as a package that needs
+      // updating. Worth saying plainly, because before 0.9.0 there was no
+      // pause here at all -- the request reached the catalog and stopped, so
+      // the console showed `paused` beside an archive still transferring.
+      if (/unknown op/i.test(error.message)) {
+        throw new Error(
+          `this sidecar cannot ${op}; pmtiles-torrent 0.9.0 or newer is needed`,
+          { cause: error },
+        );
+      }
+      throw error;
+    }
+  }
+
   async list() {
     // A node that is shutting down still has a console polling it and a sweep
     // or two in flight. Answering "the sidecar exited" to each of them fills
@@ -627,9 +678,7 @@ export class LibtorrentEngine {
       child.on('close', (code, signal) => {
         if (failure) return finish(failure);
         if (result) return finish();
-        const why = signal
-          ? `killed by ${signal}`
-          : `exited with code ${code}`;
+        const why = signal ? `killed by ${signal}` : `exited with code ${code}`;
         finish(
           new Error(
             `hashing produced nothing (${why})${stderr ? `: ${stderr.trim()}` : ''}`,

package/src/library.js

@@ -272,17 +272,25 @@ export class Library {
     options.onValidated?.({ path: absolute, kind: identified.kind });
 
     // Tracked from here so the console has something to show while the hash
-    // runs. Registered without an AbortController, unlike a remote add: there
-    // is no cancelling a hash in progress, since neither libtorrent's creator
-    // nor create-torrent takes a signal. cancelAdd() skips entries without a
-    // controller, so this is inert there rather than a button that lies.
+    // runs, and so it can be stopped. Hashing an archive this size is minutes
+    // at best and hours for a planet, all of it reading the disk everything
+    // else is served from; realising it was the wrong file should not mean
+    // waiting it out or killing the process.
+    //
+    // What it cancels is the hash. A publishDir move has already happened by
+    // here — deliberately, since it is the cheap irreversible step — so a
+    // cancelled add leaves the archive where it was published to, not where it
+    // was picked from. Nothing else is touched: hashing only ever reads.
+    const controller = new AbortController();
     const { size } = await fs.stat(absolute).catch(() => ({ size: undefined }));
     this.#running.set(requested, {
+      controller,
       name: path.basename(absolute),
       startedAt: new Date().toISOString(),
-      // No byte count: hashing reports nothing until it is done, so a progress
-      // bar here would sit at zero and then vanish. `total` is the size it is
-      // working through, which with the start time is enough to show it moving.
+      // Absent until the hasher says otherwise, rather than zero: a zero is
+      // drawn as a bar that has not moved, and an out-of-process hasher is not
+      // guaranteed — config can ask for v1, and create-torrent reports nothing
+      // at all. Then it is honestly unknown rather than stuck at 0%.
       received: undefined,
       total: size,
       phase: 'hashing',
@@ -302,6 +310,21 @@ export class Library {
         webSeeds: [...new Set(webSeeds)],
         comment: options.comment,
         md5: options.md5 ?? this.#config.md5,
+        signal: controller.signal,
+        // Pieces in, bytes out. The console draws one progress bar for adds and
+        // labels it in bytes, and a piece count means nothing beside a download
+        // measured in gigabytes — so it is converted here, where the file size
+        // is known, rather than teaching the console a second unit. Accurate to
+        // within one piece, which at 4 MiB against a planet archive is four
+        // parts in a million.
+        onHashProgress: ({ piece, pieces }) => {
+          const state = this.#running.get(requested);
+          if (!state || !pieces || !size) return;
+          state.received = Math.min(
+            size,
+            Math.round(((piece + 1) / pieces) * size),
+          );
+        },
       });
 
       return await this.#register(created, {
@@ -380,6 +403,10 @@ export class Library {
    * trade-off: v2 clients gain per-file merkle trees and 16 KiB block
    * verification, and v1 clients see an ordinary torrent. An engine that is
    * only seeding is still the right one to ask for that.
+   *
+   * Everything the caller passes goes through, `signal` and `onProgress`
+   * included. Those are what make a hash out here cancellable and visible, and
+   * naming the fields it forwards would quietly drop them.
    * @returns {Function | undefined} - A creator, or undefined to use the default.
    */
   #creator() {
@@ -616,13 +643,18 @@ export class Library {
   }
 
   /**
-   * Stops an in-flight remote add, and discards what it had downloaded.
+   * Stops an in-flight add, and discards what it had downloaded.
+   *
+   * Local adds too, now that hashing happens in a process of its own and that
+   * process can be ended. A local add discards nothing — the archive is the
+   * caller's own file and was only ever read — so what it costs is the hashing
+   * done so far and nothing else.
    *
-   * Only a remote one. A local add is listed alongside them but holds no
-   * controller, because a hash in progress cannot be interrupted — neither
-   * libtorrent's creator nor create-torrent takes a signal. It is skipped
-   * below rather than special-cased, and reports as nothing cancelled.
-   * @param {string} [url] - The source URL, or all of them when omitted.
+   * An add hashing in this process rather than out of it still cannot be
+   * interrupted, and libtorrent's hashing never checks for interruption
+   * either. Cancelling such an add stops the caller waiting and frees the
+   * console of it; the read finishes on its own.
+   * @param {string} [url] - The source URL or path, or all of them when omitted.
    * @returns {string[]} - The URLs cancelled.
    */
   cancelAdd(url) {
@@ -679,10 +711,12 @@ export class Library {
     return [...this.#running.entries()].map(([url, state]) => ({
       url,
       name: state.name,
-      // Left absent rather than zeroed for a hash, which reports nothing until
-      // it finishes. A zero here is indistinguishable from a download that has
-      // not moved, and the console draws the two differently.
-      received: state.phase === 'hashing' ? undefined : (state.received ?? 0),
+      // Absent means unknown, not zero. A hash reports where it has got to
+      // only when it runs out of process; the in-process fallback reports
+      // nothing at all, and a bar pinned at 0% for forty minutes says "stuck"
+      // when the honest answer is "no idea, still working". A download always
+      // knows, so it is 0 there from the start.
+      received: state.received ?? (state.phase === 'hashing' ? undefined : 0),
       total: state.total,
       startedAt: state.startedAt,
       phase: state.phase ?? 'fetching',
@@ -1832,11 +1866,24 @@ export class Library {
       throw error;
     }
 
-    if (this.#engine.pause) {
-      await this.#engine.pause(infoHash);
-    } else {
+    // Whether it actually stopped, not whether something was asked.
+    //
+    // This tested only that the engine *had* a pause method and threw the
+    // answer away. A composite has one whatever its engines can do, so a
+    // primary with no pause of its own returned false into a void: the
+    // fallback below never ran, `paused: true` went into the catalog, and the
+    // console -- which prefers that flag to the engine's live state -- showed
+    // `paused` beside an archive still transferring at 8 MiB/s. The button did
+    // nothing and said it had worked.
+    const stopped = this.#engine.pause
+      ? await this.#engine.pause(infoHash)
+      : false;
+    if (!stopped) {
       // Removing without its data is a pause an engine cannot refuse; resume
-      // adds it back and it rechecks what is already on disk.
+      // adds it back and it rechecks what is already on disk. A last resort,
+      // because that recheck is the whole store -- tens of minutes for a
+      // planet archive -- which is why an engine that can really pause is
+      // worth the two operations it takes.
       await this.#engine
         .remove(infoHash, { deleteData: false })
         .catch(() => {});
@@ -1920,9 +1967,14 @@ export class Library {
       throw error;
     }
 
-    if (this.#engine.resume) {
-      await this.#engine.resume(infoHash);
-    } else {
+    // Same as pause: the answer decides, not the presence of a method. An
+    // archive stopped by the fallback above is not in the engine at all, so a
+    // resume it merely claimed would leave the catalog saying the archive was
+    // running while nothing held it.
+    const started = this.#engine.resume
+      ? await this.#engine.resume(infoHash)
+      : false;
+    if (!started) {
       await this.#readd({ ...entry, paused: false });
     }
     await this.#tiles?.invalidate(infoHash).catch(() => {});

package/src/torrent-create.js

@@ -19,7 +19,9 @@ import { DEFAULT_SUFFIX } from './incomplete.js';
  * @property {number} [pieceLength] - Piece size in bytes; must be a power of two.
  * @property {string[]} [trackers] - Announce URLs.
  * @property {string[]} [webSeeds] - BEP 19 url-list entries.
- * @property {AbortSignal} [signal] - Cancels a download in progress.
+ * @property {AbortSignal} [signal] - Cancels a download or a hash in progress.
+ * @property {Function} [onProgress] - Called with {phase, received, total} as the archive arrives.
+ * @property {Function} [onHashProgress] - Called with {piece, pieces} as it is hashed.
  * @property {boolean} [md5] - Also compute an MD5 of the archive.
  * @property {boolean} [includeSourceAsWebSeed] - Publish the source URL as a web seed. Default true.
  * @property {string} [comment] - Free-text comment.
@@ -64,9 +66,22 @@ export async function createTorrentFromFile(filePath, options = {}) {
     `[hash] ${what}: reading ${stat.size} bytes ${passes} to build the torrent`,
   );
   const startedAt = Date.now();
+
+  // Where the hash has got to, for the heartbeat. A hasher that reports pieces
+  // turns "still hashing after 41m" into something that says whether waiting
+  // longer is worth it; one that does not says exactly what it said before.
+  let reached;
+  const onHashProgress = (progress) => {
+    reached = progress;
+    options.onHashProgress?.(progress);
+  };
+
   const heartbeat = setInterval(() => {
     const minutes = Math.round((Date.now() - startedAt) / 60000);
-    console.log(`[hash] ${what}: still hashing after ${minutes}m`);
+    const far = reached?.pieces
+      ? ` (${(((reached.piece + 1) / reached.pieces) * 100).toFixed(1)}%)`
+      : '';
+    console.log(`[hash] ${what}: still hashing after ${minutes}m${far}`);
   }, 60000);
   heartbeat.unref?.();
   options.onProgress?.({
@@ -78,12 +93,14 @@ export async function createTorrentFromFile(filePath, options = {}) {
   try {
     // A second read of the archive, which is why it is opt-in. Nothing else
     // here touches these bytes again once the piece hashes are done.
-    const md5Digest = options.md5 ? await md5File(filePath) : undefined;
+    const md5Digest = options.md5
+      ? await md5File(filePath, options.signal)
+      : undefined;
     const built = await buildTorrent(
       filePath,
       path.basename(filePath),
       stat.size,
-      { ...options, md5Digest },
+      { ...options, md5Digest, onHashProgress },
     );
     const seconds = Math.round((Date.now() - startedAt) / 1000);
     console.log(`[hash] ${what}: torrent built in ${seconds}s`);
@@ -618,13 +635,18 @@ function delay(ms, signal) {
  * on disk it is a second full read. See docs/internals.md — "Why the MD5 is
  * opt-in".
  * @param {string} filePath - The file to hash.
+ * @param {AbortSignal} [signal] - Stops the read.
  * @returns {Promise<string>} - Lowercase hex digest.
  */
-async function md5File(filePath) {
+async function md5File(filePath, signal) {
   const { createReadStream } = await import('node:fs');
   const { createHash } = await import('node:crypto');
   const hash = createHash('md5');
-  await pipelineAsync(createReadStream(filePath), hash);
+  // Cancellable like the piece hashing it precedes. This is a second full read
+  // of the archive, so a cancel arriving during it would otherwise be ignored
+  // for as long as the pass it was meant to stop — for a planet archive, most
+  // of an hour of disk after somebody pressed the button.
+  await pipelineAsync(createReadStream(filePath), hash, { signal });
   return hash.digest('hex');
 }
 
@@ -655,6 +677,13 @@ async function buildTorrent(input, name, size, options) {
         private: options.private ?? false,
         createdBy: 'pmtiles-swarm',
         format: options.format ?? 'hybrid',
+        // Both only mean anything to a creator that hashes out of process,
+        // which is the whole reason there is one. `onProgress` here is the
+        // creator's own shape — {piece, pieces} — and is deliberately not the
+        // {phase, received, total} one this module reports to its caller; they
+        // describe different things and were briefly the same name.
+        signal: options.signal,
+        onProgress: options.onHashProgress,
       });
 
       const madeBy = await parseTorrent(built.torrentFile);
@@ -670,6 +699,15 @@ async function buildTorrent(input, name, size, options) {
         md5: options.md5Digest,
       };
     } catch (error) {
+      // Unless what stopped it was somebody stopping it.
+      //
+      // Falling back here would answer "cancel this hash" by starting the same
+      // hash again in this process, where it cannot be cancelled at all — so
+      // the button would make a 698 GiB read strictly worse than leaving it
+      // alone. Cancelling is a decision about the archive, not a fault to
+      // route around.
+      if (options.signal?.aborted) throw error;
+
       // A torrent is more important than the format of a torrent.
       //
       // Said with what it costs, though, because the fallback is not a smaller

package/src/web/index.html

@@ -309,6 +309,16 @@
       .piecerow { display: grid; grid-template-columns: 7rem 1fr 4rem; gap: 0.6rem; align-items: center; margin-bottom: 0.5rem; }
       .piecerow > .label { font-size: 0.8rem; color: var(--muted); }
       .piecerow > .value { font-size: 0.8rem; color: var(--muted); text-align: right; }
+      /* Like a piecerow, but the label is a filename rather than a fixed word,
+         and each row carries its own Cancel. A separate class because the
+         piecerow's 7rem label and 4rem value are sized for "downloaded" and
+         "41%": an archive name in 7rem wraps onto three lines, and the naming
+         of the buttons had to repeat the whole filename to say which was
+         which. */
+      .addrow { display: grid; grid-template-columns: minmax(0, 1fr) auto auto auto; gap: 0.6rem; align-items: center; margin-bottom: 0.5rem; }
+      .addrow > .label { font-size: 0.8rem; color: var(--muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+      .addrow > .value { font-size: 0.8rem; color: var(--muted); text-align: right; white-space: nowrap; }
+      .addrow > button { padding: 0.15rem 0.55rem; font-size: 0.75rem; }
 
       button.speed { border-color: var(--line); color: var(--muted); }
       button.speed.on { border-color: var(--warn); color: var(--warn); }
@@ -923,7 +933,6 @@
           box.innerHTML = '';
           return;
         }
-        const cancellable = running.filter((add) => add.cancellable !== false);
         box.innerHTML = `
           <h3 style="margin:1.2rem 0 0.5rem">Being added, before a torrent exists</h3>
           <div class="sub" style="margin-bottom:0.6rem">
@@ -934,9 +943,10 @@
           </div>
           ${running
             .map((add) => {
-              // Hashing reports nothing until it is done, so there is no
-              // percentage to draw — only how big the file is and how long it
-              // has been going. A bar pinned at zero for twenty minutes says
+              // A hash says how far through it is when it runs out of process,
+              // and says nothing when it falls back to hashing in this one. So
+              // the percentage is drawn where there is one and left out where
+              // there is not — a bar pinned at zero for twenty minutes says
               // "stuck" when the honest answer is "no idea, still working".
               const hashing = add.phase === 'hashing';
               const pct =
@@ -947,32 +957,39 @@
                 ? duration(Date.now() - new Date(add.startedAt).getTime())
                 : null;
               const value = hashing
-                ? `hashing${add.total ? ` ${bytes(add.total)}` : ''}${
-                    elapsed ? ` · ${elapsed}` : ''
-                  }`
+                ? [
+                    `hashing${add.total ? ` ${bytes(add.total)}` : ''}`,
+                    pct == null ? null : `${pct.toFixed(1)}%`,
+                    elapsed,
+                  ]
+                    .filter(Boolean)
+                    .join(' · ')
                 : pct == null
                   ? bytes(add.received)
                   : `${pct.toFixed(1)}%`;
+              const name = add.name ?? add.url.split('/').pop() ?? add.url;
+              // Cancel sits in the row it cancels, so the button does not have
+              // to name the archive to say which one it is. Named, they were as
+              // wide as the filename — two of them filled a line, and reading
+              // one meant matching a long name against the list above it.
+              //
+              // An add with no controller keeps an empty cell rather than
+              // losing one, so the rows above and below it stay lined up.
+              const stop =
+                add.cancellable === false
+                  ? '<span></span>'
+                  : `<button data-cancel="${escapeHtml(add.url)}" title="Cancel ${escapeHtml(
+                      name,
+                    )}" aria-label="Cancel ${escapeHtml(name)}">Cancel</button>`;
               return `
-                <div class="piecerow">
-                  <span class="label" title="${escapeHtml(add.url)}">${escapeHtml(
-                    add.name ?? add.url.split('/').pop() ?? add.url,
-                  )}</span>
+                <div class="addrow">
+                  <span class="label" title="${escapeHtml(add.url)}">${escapeHtml(name)}</span>
                   <span class="track"><i style="width:${pct == null ? 0 : pct.toFixed(1)}%"></i></span>
                   <span class="value">${value}</span>
+                  ${stop}
                 </div>`;
             })
-            .join('')}
-          <div class="bar" style="margin-top:0.5rem">
-            ${cancellable
-              .map(
-                (add) =>
-                  `<button data-cancel="${escapeHtml(add.url)}">Cancel ${escapeHtml(
-                    add.name ?? add.url.split('/').pop() ?? '',
-                  )}</button>`,
-              )
-              .join('')}
-          </div>`;
+            .join('')}`;
 
         for (const button of box.querySelectorAll('[data-cancel]')) {
           button.onclick = async () => {
@@ -2370,7 +2387,7 @@ Every piece is hashed against the ` +
             kind === 'url'
               ? 'fetching — watch the log'
               : kind === 'path'
-                ? 'hashing — watch the log'
+                ? 'hashing — progress is below'
                 : 'added',
           );
           refresh();