pmtiles-swarm 0.65.0 → 0.66.0

package/CHANGELOG.md

@@ -4,6 +4,31 @@
 ### ✨ Features and improvements
 - _...Add new stuff here..._
 
+### 🐞 Bug fixes
+- _...Add new stuff here..._
+
+## 0.66.0
+### ✨ Features and improvements
+- **An export asks where it should go, and what to call it.** **Export to archive** now opens a
+  dialog instead of a confirmation, because there is something to decide. The save location uses
+  the same picker every other destination in this console uses, so a location named once under
+  Settings is offered here too — a baked planet is hundreds of gigabytes and which disk it lands on
+  is not a detail. The name and description default to the stack's and can be changed.
+
+  The filename is shown as the name is typed. A name is not a filename — separators and the
+  characters Windows refuses become dashes, and the date is appended so successive builds do not
+  collide — and a preview promising one thing while the server writes another would be worse than
+  no preview at all. A test asserts the browser's rule and `safeSegment` agree.
+
+### 🐞 Bug fixes
+- **A save location the node did not know was silently ignored.** The export resolved it after the
+  merge and swallowed the error, so naming a location that did not exist, or one that could not be
+  written, meant an hour of merging answered with a shrug and the archive on the default disk. It
+  is resolved before anything starts and the error is allowed through, which is what lets the
+  dialog put it beside the field that caused it.
+
+
+
 ### 🐞 Bug fixes
 - _...Add new stuff here..._
 

package/docs/tile-stacks.md

@@ -730,6 +730,20 @@ worth writing at all.
 planet bake is hours, and a request that waited for the archive is a request
 nothing could hold open. `DELETE` on the same address stops it.
 
+The button opens a dialog rather than a confirmation, because there is
+something to decide. **Where it lands** uses the same picker every other
+destination in this console uses, so a location named once under Settings is
+offered here too — and a baked planet is hundreds of gigabytes, so which disk it
+goes on is not a detail. The location is resolved _before_ anything is merged:
+a name this node does not know, or a path it cannot write, is the caller's
+mistake and they can fix it, but only if they are told now rather than an hour
+later.
+
+**What it is called** defaults to the stack's title and can be changed, as can
+the description. The dialog shows the filename as the name is typed, because a
+name is not a filename — the same sanitising the server does, and a preview that
+promised something else would be worse than no preview.
+
 A bake has two halves and they are watched in two places, deliberately. Merging
 is about a stack, so it is reported on the stack — tiles written, tiles skipped,
 the zoom it is working through. What happens afterwards is an archive being

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmtiles-swarm",
-  "version": "0.65.0",
+  "version": "0.66.0",
   "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",

package/src/api.js

@@ -3181,6 +3181,8 @@ export function createApp({
           categories: req.body?.categories,
           location: req.body?.location,
           savePath: req.body?.savePath,
+          name: req.body?.name,
+          description: req.body?.description,
         });
         return res.status(202).json({ bake: job });
       } catch (error) {

package/src/bake-jobs.js

@@ -113,9 +113,21 @@ export class BakeManager {
       throw error;
     }
 
+    // Resolved before anything starts, and allowed to throw. A location that
+    // does not exist or cannot be written is the caller's mistake and they can
+    // fix it -- but only if they are told now. Checked at the end instead, it
+    // is an hour of merging answered with a shrug and the default disk.
+    const publishDir =
+      options.publishDir ?? (await this.#savePath(options)) ?? undefined;
+
+    // What the archive will be called, which the caller may have chosen. The
+    // file follows it; the date is what keeps successive builds apart.
+    const archiveName = options.name?.trim() || resolved.stack.title || stackId;
+
     const job = {
       stackId,
       title: resolved.stack.title ?? stackId,
+      archiveName,
       phase: 'merging',
       startedAt: new Date().toISOString(),
       written: 0,
@@ -126,7 +138,8 @@ export class BakeManager {
       finishedAt: null,
       error: null,
       infoHash: null,
-      name: bakedName(resolved, { when: new Date() }),
+      name: bakedName(resolved, { when: new Date(), name: archiveName }),
+      publishDir,
     };
     this.#jobs.set(stackId, job);
 
@@ -171,6 +184,7 @@ export class BakeManager {
         workDir,
         destination,
         format,
+        options,
       );
     } finally {
       await pixels?.close().catch(() => {});
@@ -185,7 +199,7 @@ export class BakeManager {
       // Moved out of the working directory as it is taken on, so a finished
       // archive does not live among the checkpoint files of the job that made
       // it.
-      publishDir: options.publishDir ?? (await this.#savePath(options)),
+      publishDir: job.publishDir,
       mode: 'mirror',
     });
 
@@ -205,7 +219,16 @@ export class BakeManager {
    * @param {string} format - The output format.
    * @returns {Promise<void>} - Resolves when the file is written.
    */
-  async #merge(job, resolved, codec, pixels, workDir, destination, format) {
+  async #merge(
+    job,
+    resolved,
+    codec,
+    pixels,
+    workDir,
+    destination,
+    format,
+    options,
+  ) {
     // Read through the tile store rather than off the disk, so a cache-mode
     // source is scanned the same way it is served: its directories come out of
     // the swarm, and the store holds them to its own byte budget.
@@ -249,8 +272,8 @@ export class BakeManager {
       header: { format },
       pauseMs: this.#config.stacks?.bakePauseMs ?? 0,
       metadata: {
-        name: resolved.stack.title ?? job.stackId,
-        description: resolved.stack.description,
+        name: job.archiveName,
+        description: options.description ?? resolved.stack.description,
         attribution: resolved.stack.attribution,
         encoding: resolved.stack.output?.encoding,
         encodingFactors: resolved.stack.output,
@@ -273,9 +296,10 @@ export class BakeManager {
    * @returns {Promise<string|undefined>} - A path, or undefined for the default.
    */
   async #savePath(options) {
-    const explicit = await this.#library
-      .resolveSavePath(options)
-      .catch(() => undefined);
+    // Not caught. `resolveSavePath` refuses a name this node does not know and
+    // a path it cannot write, and both are worth refusing rather than quietly
+    // putting hundreds of gigabytes somewhere else.
+    const explicit = await this.#library.resolveSavePath(options);
     return explicit ?? this.#config.savePath ?? undefined;
   }
 
@@ -295,6 +319,8 @@ export class BakeManager {
       skipped: job.skipped,
       zoom: job.zoom,
       name: job.name,
+      archiveName: job.archiveName,
+      publishDir: job.publishDir ?? null,
       infoHash: job.infoHash,
       error: job.error,
     };

package/src/bake.js

@@ -232,12 +232,16 @@ function stamp(when = new Date()) {
  * map and two files cannot share a path. The archive's *name* is not dated --
  * see `bakedMetadata` -- so a rebuild keeps its identity the way every other
  * rebuild here does.
+ *
+ * Follows the name it is given, so renaming an export in the dialog renames the
+ * file too. A name and a filename that disagree is a small thing that costs an
+ * afternoon the first time somebody goes looking on disk.
  * @param {object} resolved - The resolved stack.
- * @param {object} [options] - `when`, and `suffix` to break a tie.
+ * @param {object} [options] - `name` to override the stack's, `when`, `suffix`.
  * @returns {string} - A filename.
  */
 export function bakedName(resolved, options = {}) {
-  const title = resolved.stack.title ?? resolved.stack.id;
+  const title = options.name ?? resolved.stack.title ?? resolved.stack.id;
   const slug = safeSegment(title) || 'stack';
   const tail = options.suffix ? `-${options.suffix}` : '';
   return `${slug}-${stamp(options.when)}${tail}.pmtiles`;

package/src/web/index.html

@@ -644,6 +644,59 @@
       </form>
     </dialog>
 
+    <dialog id="bake-dialog">
+      <form method="dialog" id="bake-form">
+        <h2>Export to archive</h2>
+        <div class="sub" style="margin-bottom:0.8rem">
+          Runs the recipe over its sources and writes the result as a real
+          archive, with its own infohash, seeded like any other. It reads every
+          tile the sources hold, so it can take hours — and it can be stopped,
+          which keeps the work for the next run to carry on from.
+        </div>
+
+        <div class="field">
+          <label>Stack</label>
+          <div class="sub"><code id="bake-stack"></code></div>
+        </div>
+
+        <div class="field">
+          <label for="bake-name">Name</label>
+          <input id="bake-name" placeholder="Terrain" />
+          <div class="sub">
+            What the archive is called, and what a rebuild of it keeps — so
+            leave the date out of it. The file gets one:
+            <code id="bake-filename"></code>
+          </div>
+        </div>
+
+        <div class="field">
+          <label for="bake-description">Description</label>
+          <input id="bake-description" placeholder="Bathymetry under terrain" />
+          <div class="sub">
+            Optional. The date this was baked is added to whatever is here.
+          </div>
+        </div>
+
+        <div id="bake-location"></div>
+
+        <div class="field">
+          <label for="bake-categories">Categories</label>
+          <input id="bake-categories" placeholder="terrain, weekly" />
+          <div class="sub">
+            Comma separated. What the archive is filed under once it is added,
+            which is what <code>/latest/&lt;category&gt;/</code> follows. Left
+            empty, it takes the stack's own.
+          </div>
+        </div>
+
+        <div class="sub" id="bake-error" style="color: var(--danger)"></div>
+        <menu>
+          <button value="cancel">Cancel</button>
+          <button id="bake-go" value="default">Export</button>
+        </menu>
+      </form>
+    </dialog>
+
     <dialog id="adopt-dialog">
       <form method="dialog" id="adopt-form">
         <h2>Adopt existing torrents</h2>
@@ -7678,6 +7731,87 @@ Every piece is hashed against the ` +
       $('stacks-add').onclick = () =>
         openStackDialog().catch((e) => toast(e.message));
 
+      /**
+       * Asks where an export should land before starting it.
+       *
+       * A dialog rather than a confirm, because there is something to decide:
+       * a baked planet is hundreds of gigabytes and the disk it goes on is not
+       * a detail. The same picker every other destination in this console
+       * uses, so a location named once under Settings is offered here too.
+       * @param {string} id - The stack to export.
+       * @returns {Promise<void>} - Resolves once it is asked for or dismissed.
+       */
+      async function openBakeDialog(id, stack) {
+        $('bake-stack').textContent = id;
+        $('bake-error').textContent = '';
+        $('bake-name').value = stack?.title ?? id;
+        $('bake-description').value = stack?.description ?? '';
+        $('bake-categories').value = (stack?.categories ?? []).join(', ');
+        showBakeFilename();
+        $('bake-location').innerHTML = locationPicker('bake-loc');
+        await fillLocations('bake-loc');
+        $('bake-dialog').showModal();
+      }
+
+      /**
+       * Shows what the file will be called, as the name is typed.
+       *
+       * The same rules the server applies, because a name is not a filename:
+       * separators and the characters Windows refuses become dashes, and the
+       * date is appended so successive builds do not collide. Seeing that
+       * before pressing the button beats finding it on disk afterwards.
+       * @returns {void}
+       */
+      function showBakeFilename() {
+        const typed = $('bake-name').value.trim() || $('bake-stack').textContent;
+        const slug =
+          typed
+            .replace(/[/\\<>:"|?*\u0000-\u001f\u007f -]/g, '-')
+            .replace(/-{2,}/g, '-')
+            .replace(/^[.\s-]+/, '')
+            .replace(/[.\s-]+$/, '')
+            .slice(0, 120) || 'stack';
+        const day = new Date().toISOString().slice(0, 10).replaceAll('-', '');
+        $('bake-filename').textContent = `${slug}-${day}.pmtiles`;
+      }
+
+      $('bake-name').addEventListener('input', showBakeFilename);
+
+      $('bake-form').addEventListener('submit', async (event) => {
+        if (event.submitter?.value === 'cancel') return;
+        event.preventDefault();
+
+        const id = $('bake-stack').textContent;
+        const categories = $('bake-categories')
+          .value.split(',')
+          .map((one) => one.trim())
+          .filter(Boolean);
+        const name = $('bake-name').value.trim();
+        const description = $('bake-description').value.trim();
+
+        try {
+          await api(`/api/stacks/${encodeURIComponent(id)}/bake`, {
+            method: 'POST',
+            body: {
+              ...chosenLocation('bake-loc'),
+              ...(categories.length > 0 ? { categories } : {}),
+              ...(name ? { name } : {}),
+              ...(description ? { description } : {}),
+            },
+          });
+        } catch (error) {
+          // Kept open, because the answer is usually something to change here
+          // -- a location that does not exist, or a codec that is not
+          // installed -- rather than something to go away and think about.
+          $('bake-error').textContent = error.message;
+          return;
+        }
+
+        $('bake-dialog').close();
+        toast(`Exporting ${id}`);
+        loadStacks().catch((e) => toast(e.message));
+      });
+
       // Editing and deleting hang off the list, which is redrawn on every
       // change, so they are delegated the same way the source rows are.
       $('stacks-list').addEventListener('click', async (event) => {
@@ -7686,27 +7820,11 @@ Every piece is hashed against the ` +
         const bake = event.target.dataset.stackBake;
         const stopBake = event.target.dataset.stackBakeStop;
         if (bake !== undefined) {
-          // Confirmed, because it is not a small thing: it reads every tile
-          // every source holds, writes a whole archive, and then hashes it.
-          if (
-            !confirm(
-              `Run "${bake}" over its sources and write the result as a new ` +
-                'archive?\n\nThis reads every tile the sources hold and can ' +
-                'take hours. It can be stopped, and stopping keeps the work.',
-            )
-          ) {
-            return;
-          }
-          try {
-            await api(`/api/stacks/${encodeURIComponent(bake)}/bake`, {
-              method: 'POST',
-              body: {},
-            });
-            toast(`Exporting ${bake}`);
-          } catch (error) {
-            toast(error.message);
-          }
-          loadStacks().catch((e) => toast(e.message));
+          const { stacks } = await api('/api/stacks');
+          await openBakeDialog(
+            bake,
+            stacks.find((one) => one.id === bake),
+          ).catch((e) => toast(e.message));
         } else if (stopBake !== undefined) {
           try {
             await api(`/api/stacks/${encodeURIComponent(stopBake)}/bake`, {