pmtiles-swarm 0.22.0 → 0.23.0

package/CHANGELOG.md

@@ -58,6 +58,13 @@
   `/api/categories`, filtered by the same `feedCategories` rule, so it can show nothing that was
   not already published — and it is not the console, which stays on the admin port.
   `publicIndex: false` turns it off, withdrawing the three paths it needs with it.
+- **A category can be previewed, and the preview is the category's own URL.** `/latest/<category>/preview`
+  reads the TileJSON beside it, so it renders whatever build is current rather than pinning to the
+  one that was newest when the link was made — the same URL a style holds, demonstrating itself.
+  The preview page now derives its source from wherever it is served instead of assembling one from
+  an infohash, so one page serves both forms.
+- **The public page gained a filter and a sort.** Search by name, infohash or category; order by name,
+  newest or largest. Both re-render from what was already loaded rather than asking the node again.
 - **`GET /latest/` lists the categories, without a credential.** Everything else under
   `/latest/` is public — the TileJSON, the torrent, the magnet, the per-category feed — so the
   index of what it offers belongs beside them rather than behind the console's door. The public
@@ -77,6 +84,12 @@
   never checked.
 
 ### 🐞 Bug fixes
+- **A mutable magnet had nowhere to announce.** `mutableMagnet()` was never passed trackers, so the
+  BEP 46 form carried `xt`, `xs`, `dn`, `s` and `ws` and no `tr=` at all. The infohash added in
+  0.21.0 was therefore unusable from a browser, which has neither DHT nor peer exchange to fall
+  back on and so had nothing to ask — leaving the web seed, which is just HTTP, as the only source.
+  The archive's own trackers are now lifted across in all three places one is built: the TileJSON's
+  torrent block, the `styleUrl` fragment, and the publisher's own magnet.
 - **The public front page could not read its own catalogue.** `/api/catalog` is on the list of
   paths that belong on a public listener, but that is a separate gate from the credential check,
   which guards everything under `/api/` except login and session — so on any node with

package/package.json

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

@@ -14,7 +14,7 @@ import {
   isPublicSurface,
 } from './auth.js';
 import { normalizeCategories } from './catalog.js';
-import { mutableMagnet } from './mutable.js';
+import { mutableMagnet, trackersFromMagnet } from './mutable.js';
 import { guessKind } from './library.js';
 import { QBittorrentEngine } from './engines/qbittorrent.js';
 import { RESTART_REQUIRED, redactConfig, saveConfig } from './config.js';
@@ -80,6 +80,10 @@ function styleUrlFor(category, newest, base) {
         // of this URL — a client that cannot reach the tiles.json in front of
         // it, or cannot resolve a public key, still has something to join.
         infoHash: newest.infoHash,
+        // Somewhere to announce it, lifted from the archive's own magnet. A
+        // fragment carrying an infohash and no tracker gives a browser
+        // something to join and nobody to ask for it.
+        trackers: trackersFromMagnet(newest.magnet),
         salt: newest.mutable.salt ?? category,
         // The category, since that is what this magnet resolves to.
         name: newest.mutable.salt ?? category,
@@ -1802,6 +1806,11 @@ export function createApp({
             // newest build's own magnet, which pins that build but still
             // beats a blank map when the fallback is needed at all.
             styleUrl: servable ? styleUrlFor(category, newest, base) : null,
+            // Points at the category, not at a build. The page reads the
+            // TileJSON beside it, so it renders whatever is current — which
+            // makes it the same URL a style holds, demonstrating itself rather
+            // than pinning to today's infohash.
+            preview: servable ? `${base}/latest/${category}/preview` : null,
             torrent: `${base}/latest/${category}/archive.torrent`,
             magnet: `${base}/latest/${category}/magnet`,
             feed: `${base}/feed/${category}.xml`,
@@ -1973,6 +1982,17 @@ export function createApp({
   // shareable and says what it shows. The page reads the TileJSON next to it —
   // which is a complete, valid TileJSON already, so nothing here has to invent
   // a source description.
+  // The same page for a category, which is the more useful one to hand
+  // somebody: it reads /latest/<category>/tiles.json, so it renders whatever
+  // build is current rather than pinning to the one that happened to be newest
+  // when the link was made. That is exactly what a style points at, so this is
+  // the URL demonstrating itself.
+  //
+  // The page works out which by its own path, so there is nothing to pass.
+  app.get('/latest/:category/preview', (_req, res) => {
+    res.sendFile(path.join(here, 'web', 'preview.html'));
+  });
+
   app.get('/archives/:infoHash/preview', (_req, res) => {
     res.sendFile(path.join(here, 'web', 'preview.html'));
   });

package/src/mutable.js

@@ -90,6 +90,22 @@ function rawPublicKey(publicKey) {
  * @param {string} [options.salt] - Salt, when one key publishes several archives.
  * @returns {string} - A BEP 46 magnet URI.
  */
+/**
+ * The trackers a magnet announces to.
+ *
+ * A BEP 46 magnet is assembled rather than parsed from a torrent, so it has no
+ * announce list of its own — but the archive it names does, in the plain magnet
+ * beside it. Lifting them across is what makes the mutable form joinable: an
+ * infohash with nowhere to announce is an infohash a browser cannot act on,
+ * having neither DHT nor peer exchange to fall back on.
+ * @param {string} [magnet] - A magnet URI to read `tr=` out of.
+ * @returns {string[]} - The announce URLs, in the order they appeared.
+ */
+export function trackersFromMagnet(magnet) {
+  if (typeof magnet !== 'string' || !magnet.startsWith('magnet:?')) return [];
+  return new URLSearchParams(magnet.slice('magnet:?'.length)).getAll('tr');
+}
+
 export function mutableMagnet(publicKey, options = {}) {
   // Buffer.from(string) would read hex as UTF-8 and produce a 64-byte key, so
   // the two forms have to be told apart rather than coerced.

package/src/publisher.js

@@ -17,7 +17,11 @@
  * docs/internals.md — "Why a third DHT".
  */
 
-import { mutableMagnet, publishInfoHash } from './mutable.js';
+import {
+  mutableMagnet,
+  publishInfoHash,
+  trackersFromMagnet,
+} from './mutable.js';
 
 /** Republish well inside the ~2h a DHT keeps an item. */
 const DEFAULT_INTERVAL_MS = 30 * 60 * 1000;
@@ -197,6 +201,9 @@ export class MutablePublisher {
       // The current build, for a client that cannot resolve the key. Absent
       // when no entry was given, which leaves the series-only form.
       infoHash: entry?.infoHash,
+      // Somewhere to announce it, lifted from the archive's own magnet. An
+      // infohash with no tracker beside it is one a browser cannot act on.
+      trackers: trackersFromMagnet(entry?.magnet),
       salt: category,
       // The category rather than the build. This magnet resolves to whichever
       // archive is current, so naming one of them dates the string the moment

package/src/tilejson.js

@@ -1,4 +1,4 @@
-import { mutableMagnet } from './mutable.js';
+import { mutableMagnet, trackersFromMagnet } from './mutable.js';
 import { TileStore } from './tiles.js';
 
 /**
@@ -106,6 +106,9 @@ function buildTorrentBlock(entry, root) {
         // can join from this string alone rather than having to come back for
         // an infohash.
         infoHash: entry.infoHash,
+        // And somewhere to announce it. Without these the infohash above is
+        // unusable from a page: no DHT, no peer exchange, nothing to ask.
+        trackers: trackersFromMagnet(entry.magnet),
         salt: entry.mutable.salt,
         // The category, not this build: the record resolves to whichever
         // archive is current, and `dn` is a label the metadata replaces.

package/src/web/preview.html

@@ -79,8 +79,17 @@
       import * as maplibregl from '/vendor/maplibre-gl/maplibre-gl.mjs';
       import MaplibreInspect from '/vendor/maplibre-gl-inspect/maplibre-gl-inspect.mjs';
 
-      const infoHash = location.pathname.split('/')[2];
-      const tileJsonUrl = `/archives/${infoHash}/tiles.json`;
+      // Derived from wherever this page is served rather than assembled from
+      // an infohash, so one page previews both an archive and a category:
+      //   /archives/<infohash>/preview  ->  /archives/<infohash>/tiles.json
+      //   /latest/<category>/preview    ->  /latest/<category>/tiles.json
+      // The second is the one worth having, because it is what a style should
+      // actually point at — it follows the newest build instead of pinning to
+      // the one that happened to be current when the link was made.
+      const tileJsonUrl = location.pathname.replace(
+        /\/preview\/?$/,
+        '/tiles.json',
+      );
       const $ = (id) => document.getElementById(id);
 
       const fail = (message) => {
@@ -104,7 +113,7 @@
       const vector =
         vectorLayers.length > 0 || /\.(pbf|mvt)(\?|$)/.test(tilejson.tiles?.[0] ?? '');
 
-      $('name').textContent = tilejson.name ?? infoHash;
+      $('name').textContent = tilejson.name ?? tileJsonUrl;
       $('summary').textContent =
         `${vector ? 'vector' : 'raster'} · z${tilejson.minzoom ?? 0}–${tilejson.maxzoom ?? 14}` +
         (vector

package/src/web/public.html

@@ -159,6 +159,42 @@
         display: block;
         margin-bottom: 1.5rem;
       }
+      .toolbar {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 0.6rem 0.9rem;
+        align-items: center;
+        margin-bottom: 1.5rem;
+      }
+      .toolbar input[type='search'] {
+        flex: 1 1 18rem;
+        min-width: 0;
+        padding: 0.45rem 0.6rem;
+        border: 1px solid var(--line);
+        border-radius: 6px;
+        background: var(--card);
+        color: inherit;
+        font: inherit;
+      }
+      .toolbar label {
+        display: inline-flex;
+        align-items: center;
+        gap: 0.4rem;
+        color: var(--muted);
+        font-size: 0.9rem;
+      }
+      .toolbar select {
+        padding: 0.35rem 0.4rem;
+        border: 1px solid var(--line);
+        border-radius: 6px;
+        background: var(--card);
+        color: inherit;
+        font: inherit;
+      }
+      .count {
+        color: var(--muted);
+        font-size: 0.85rem;
+      }
     </style>
   </head>
   <body>
@@ -176,6 +212,25 @@
         </p>
       </noscript>
 
+      <div class="toolbar" id="toolbar" hidden>
+        <input
+          type="search"
+          id="filter"
+          placeholder="Filter by name or category…"
+          autocomplete="off"
+          spellcheck="false"
+        />
+        <label>
+          Sort
+          <select id="sort">
+            <option value="name">name</option>
+            <option value="newest">newest first</option>
+            <option value="largest">largest first</option>
+          </select>
+        </label>
+        <span class="count" id="count"></span>
+      </div>
+
       <div id="categories"></div>
       <div id="archives"><p class="empty">Loading…</p></div>
 
@@ -337,6 +392,9 @@
           };
           const ends = entry.endpoints;
           if (ends.tileJson) add(ends.tileJson, 'TileJSON');
+          // The newest build's preview, which is what "show me this
+          // category" means.
+          if (ends.preview) add(ends.preview, 'preview');
           if (ends.torrent) add(ends.torrent, '.torrent');
           if (ends.magnet) add(ends.magnet, 'magnet');
           if (ends.feed) add(ends.feed, 'RSS');
@@ -407,6 +465,58 @@
         });
       };
 
+      // Held so the filter and the sort re-render from memory rather than
+      // asking the node again on every keystroke.
+      let loadedArchives = [];
+      let loadedCategories = [];
+
+      const matches = (text, needle) =>
+        String(text ?? '')
+          .toLowerCase()
+          .includes(needle);
+
+      const sorters = {
+        name: (a, b) => String(a.name ?? '').localeCompare(String(b.name ?? '')),
+        newest: (a, b) =>
+          new Date(b.createdAt ?? 0) - new Date(a.createdAt ?? 0),
+        largest: (a, b) => (b.size ?? 0) - (a.size ?? 0),
+      };
+
+      // Re-renders both lists against the current filter and sort.
+      const apply = () => {
+        const needle = (document.getElementById('filter').value ?? '')
+          .trim()
+          .toLowerCase();
+        const order = document.getElementById('sort').value;
+
+        const archives = loadedArchives
+          .filter(
+            (archive) =>
+              needle === '' ||
+              matches(archive.name, needle) ||
+              matches(archive.infoHash, needle) ||
+              (archive.categories ?? []).some((c) => matches(c, needle)),
+          )
+          .sort(sorters[order] ?? sorters.name);
+
+        const categories = loadedCategories.filter(
+          (entry) =>
+            needle === '' ||
+            matches(entry.category, needle) ||
+            matches(entry.newest?.name, needle),
+        );
+
+        renderCategories(categories);
+        render(archives);
+
+        const count = document.getElementById('count');
+        count.textContent =
+          needle === ''
+            ? `${loadedArchives.length} archives, ${loadedCategories.length} categories`
+            : `${archives.length} of ${loadedArchives.length} archives, ` +
+              `${categories.length} of ${loadedCategories.length} categories`;
+      };
+
       const load = async () => {
         let archives = null;
 
@@ -440,7 +550,9 @@
           }
         }
 
-        render(archives.filter((archive) => archive.infoHash));
+        loadedArchives = archives.filter((archive) => archive.infoHash);
+        document.getElementById('toolbar').hidden = false;
+        apply();
 
         // /latest/ rather than /api/categories: the same list, without a
         // credential. This is the part most visitors actually want -- an
@@ -451,13 +563,17 @@
           const response = await fetch('/latest/');
           if (response.ok) {
             const body = await response.json();
-            renderCategories(body.categories ?? []);
+            loadedCategories = body.categories ?? [];
+            apply();
           }
         } catch {
           // Nothing to say. The archives above are the substance.
         }
       };
 
+      document.getElementById('filter').addEventListener('input', apply);
+      document.getElementById('sort').addEventListener('change', apply);
+
       load();
     </script>
   </body>