fluncle 0.184.0 → 0.186.0

package/bin/fluncle.mjs

@@ -561,7 +561,7 @@ function parseVersion(version) {
 var currentVersion;
 var init_version = __esm(() => {
   init_output();
-  currentVersion = "0.184.0".trim() ? "0.184.0".trim() : "0.1.0";
+  currentVersion = "0.186.0".trim() ? "0.186.0".trim() : "0.1.0";
 });
 
 // src/update-notifier.ts
@@ -1066,22 +1066,207 @@ var init_fresh = __esm(() => {
   init_output();
 });
 
+// src/commands/entity-browse.ts
+function entityRow(item) {
+  const count = `${item.trackCount} track${item.trackCount === 1 ? "" : "s"}`;
+  return `${item.name.padEnd(NAME_WIDTH)}  ${count}`;
+}
+function printEntityIndex(items, page, noun, command) {
+  if (items.length === 0) {
+    if (page.total === 0) {
+      console.log(`No ${noun.plural} in the archive yet.`);
+      return;
+    }
+    console.log(`Nothing on page ${page.page}. The archive holds ${page.total} ${noun.plural} across ${page.pageCount} pages.`);
+    return;
+  }
+  for (const item of items) {
+    console.log(entityRow(item));
+  }
+  if (page.pageCount > 1) {
+    const more = page.page < page.pageCount ? ` More with: fluncle ${command} --page ${page.page + 1}` : "";
+    console.log("");
+    console.log(`Page ${page.page} of ${page.pageCount}, ${page.total} ${noun.plural}.${more}`);
+  }
+}
+function entityDetailLines(name, slug, trackCount, findingCount) {
+  return [`${name}  (${slug})`, `Tracks: ${trackCount}`, `Findings: ${findingCount}`];
+}
+var NAME_WIDTH = 40;
+
+// src/commands/albums.ts
+var exports_albums = {};
+__export(exports_albums, {
+  albumsCommand: () => albumsCommand
+});
+async function albumsCommand({
+  json,
+  page,
+  slug
+}) {
+  if (slug) {
+    const response2 = await publicApiGet(`/api/v1/albums/${encodeURIComponent(slug)}`);
+    if (json) {
+      printJson2(response2);
+      return;
+    }
+    const { album } = response2;
+    const lines = entityDetailLines(album.name, album.slug, album.trackCount, album.findingCount);
+    if (album.releaseDate) {
+      lines.push(`Released: ${album.releaseDate.slice(0, 10)}`);
+    }
+    console.log(lines.join(`
+`));
+    return;
+  }
+  const response = await publicApiGet(`/api/v1/albums?page=${page}`);
+  if (json) {
+    printJson2(response);
+    return;
+  }
+  printEntityIndex(response.albums, response, { plural: "albums", singular: "album" }, "albums");
+}
+var init_albums = __esm(() => {
+  init_api();
+  init_output();
+});
+
 // src/commands/artists.ts
 var exports_artists = {};
 __export(exports_artists, {
-  artistsListCommand: () => artistsListCommand,
-  artistsGetCommand: () => artistsGetCommand
+  artistsCommand: () => artistsCommand
 });
-async function artistsListCommand() {
-  const response = await publicApiGet("/api/v1/artists");
-  return response.artists;
-}
-async function artistsGetCommand(slug) {
-  const response = await publicApiGet(`/api/v1/artists/${encodeURIComponent(slug)}`);
-  return response.artist;
+async function artistsCommand({
+  json,
+  page,
+  slug
+}) {
+  if (slug) {
+    const response2 = await publicApiGet(`/api/v1/artists/${encodeURIComponent(slug)}`);
+    if (json) {
+      printJson2(response2);
+      return;
+    }
+    const { artist } = response2;
+    const lines = entityDetailLines(artist.name, artist.slug, artist.trackCount, artist.findingCount);
+    if (artist.spotifyUrl) {
+      lines.push(`Spotify: ${artist.spotifyUrl}`);
+    }
+    console.log(lines.join(`
+`));
+    return;
+  }
+  const response = await publicApiGet(`/api/v1/artists?page=${page}`);
+  if (json) {
+    printJson2(response);
+    return;
+  }
+  printEntityIndex(response.artists, response, { plural: "artists", singular: "artist" }, "artists");
 }
 var init_artists = __esm(() => {
   init_api();
+  init_output();
+});
+
+// src/commands/labels.ts
+var exports_labels = {};
+__export(exports_labels, {
+  labelsCommand: () => labelsCommand
+});
+async function labelsCommand({
+  json,
+  page,
+  slug
+}) {
+  if (slug) {
+    const response2 = await publicApiGet(`/api/v1/labels/${encodeURIComponent(slug)}`);
+    if (json) {
+      printJson2(response2);
+      return;
+    }
+    const { label } = response2;
+    const lines = entityDetailLines(label.name, label.slug, label.trackCount, label.findingCount);
+    if (label.foundedLocation) {
+      lines.push(`Based: ${label.foundedLocation}`);
+    }
+    if (label.parentLabel) {
+      lines.push(`Imprint of: ${label.parentLabel.name}`);
+    }
+    console.log(lines.join(`
+`));
+    return;
+  }
+  const response = await publicApiGet(`/api/v1/labels?page=${page}`);
+  if (json) {
+    printJson2(response);
+    return;
+  }
+  printEntityIndex(response.labels, response, { plural: "labels", singular: "label" }, "labels");
+}
+var init_labels = __esm(() => {
+  init_api();
+  init_output();
+});
+
+// src/links.ts
+var spotifyPlaylistUrl2 = "https://open.spotify.com/playlist/1m5LADqpLjiBERdtqrIiL0", telegramUrl2 = "https://t.me/fluncle", webBaseUrl = "https://www.fluncle.com";
+
+// src/commands/search.ts
+var exports_search = {};
+__export(exports_search, {
+  searchCommand: () => searchCommand
+});
+function entityLine(entity) {
+  const kind = `${entity.kind[0]?.toUpperCase() ?? ""}${entity.kind.slice(1)}`;
+  return `${kind}  ${entity.name}  ${webBaseUrl}/${entity.kind}/${entity.slug}`;
+}
+function trackTable(hits) {
+  const coordWidth = hits.reduce((width, hit) => {
+    return Math.max(width, (hit.logId ?? COORD_FALLBACK2).length);
+  }, 0);
+  return hits.map((hit) => {
+    const coordinate2 = (hit.logId ?? COORD_FALLBACK2).padEnd(coordWidth);
+    return `${coordinate2}  ${hit.artists.join(", ")} — ${hit.title}`;
+  }).join(`
+`);
+}
+async function searchCommand({
+  json,
+  limit,
+  query
+}) {
+  const params = new URLSearchParams({ q: query });
+  if (limit !== undefined) {
+    params.set("limit", String(limit));
+  }
+  const response = await publicApiGet(`/api/v1/search/archive?${params.toString()}`);
+  if (json) {
+    printJson2(response);
+    return;
+  }
+  const blocks = [];
+  if (response.redirect) {
+    blocks.push(`Jump to ${webBaseUrl}${response.redirect}`);
+  }
+  if (response.entities.length > 0) {
+    blocks.push(response.entities.map(entityLine).join(`
+`));
+  }
+  if (response.results.length > 0) {
+    blocks.push(trackTable(response.results));
+  }
+  if (blocks.length === 0) {
+    console.log(`Nothing in the archive matches "${query}".`);
+    return;
+  }
+  console.log(blocks.join(`
+
+`));
+}
+var COORD_FALLBACK2 = "—";
+var init_search = __esm(() => {
+  init_api();
+  init_output();
 });
 
 // src/commands/galaxies.ts
@@ -1603,12 +1788,12 @@ var init_mixtapes = __esm(() => {
 
 // src/format.ts
 function coordinate2(track) {
-  return track.logId ?? COORD_FALLBACK2;
+  return track.logId ?? COORD_FALLBACK3;
 }
 function artistTitle(track) {
   return `${track.artists.join(", ")} — ${track.title}`;
 }
-var COORD_FALLBACK2 = "—";
+var COORD_FALLBACK3 = "—";
 var init_format = __esm(() => {
   init_util();
 });
@@ -1715,9 +1900,6 @@ var init_interactive = __esm(() => {
   init_output();
 });
 
-// src/links.ts
-var spotifyPlaylistUrl2 = "https://open.spotify.com/playlist/1m5LADqpLjiBERdtqrIiL0", telegramUrl2 = "https://t.me/fluncle";
-
 // src/open-external.ts
 async function openExternal(target) {
   const command = platformOpenCommand();
@@ -2260,7 +2442,7 @@ function parseVersion2(version) {
 var currentVersion2, latestReleaseUrl = "https://api.github.com/repos/mauricekleine/fluncle/releases/latest";
 var init_version2 = __esm(() => {
   init_output();
-  currentVersion2 = "0.184.0".trim() ? "0.184.0".trim() : "0.1.0";
+  currentVersion2 = "0.186.0".trim() ? "0.186.0".trim() : "0.1.0";
 });
 
 // ../../packages/registry/src/index.ts
@@ -2633,8 +2815,22 @@ var init_src = __esm(() => {
       apiFormat: "application/json",
       discoveryUrl: `${SITE}/api/v1/openapi.json`,
       exposedContent: [
-        "every artist with at least one published finding, finding-count ordered, as JSON",
-        "/api/v1/artists/{slug} — one artist's identity and finding count, as JSON"
+        "every album in the archive, alphabetical, paginated, as JSON",
+        "/api/v1/albums/{slug} — one album's identity, cover, and counts, as JSON"
+      ],
+      kind: "api",
+      name: "api.albums",
+      probeConfig: { cadenceMs: PROBE_CADENCE_MS, kind: "http", timeoutMs: PROBE_TIMEOUT_MS },
+      route: "/api/v1/albums",
+      url: `${SITE}/api/v1/albums`,
+      weights: { web: "secondary" }
+    },
+    {
+      apiFormat: "application/json",
+      discoveryUrl: `${SITE}/api/v1/openapi.json`,
+      exposedContent: [
+        "every artist in the archive, alphabetical, paginated, as JSON",
+        "/api/v1/artists/{slug} — one artist's identity, finding count, and track count, as JSON"
       ],
       kind: "api",
       name: "api.artists",
@@ -2643,6 +2839,20 @@ var init_src = __esm(() => {
       url: `${SITE}/api/v1/artists`,
       weights: { web: "secondary" }
     },
+    {
+      apiFormat: "application/json",
+      discoveryUrl: `${SITE}/api/v1/openapi.json`,
+      exposedContent: [
+        "every label in the archive, alphabetical, paginated, as JSON",
+        "/api/v1/labels/{slug} — one label's identity, lineage, and counts, as JSON"
+      ],
+      kind: "api",
+      name: "api.labels",
+      probeConfig: { cadenceMs: PROBE_CADENCE_MS, kind: "http", timeoutMs: PROBE_TIMEOUT_MS },
+      route: "/api/v1/labels",
+      url: `${SITE}/api/v1/labels`,
+      weights: { web: "secondary" }
+    },
     {
       apiFormat: "application/json",
       discoveryUrl: `${SITE}/api/v1/openapi.json`,
@@ -2920,12 +3130,12 @@ var init_src = __esm(() => {
     {
       apiFormat: "application/json+oembed",
       exposedContent: [
-        "the oEmbed 1.0 provider — a pasted /log, /mixtapes, or /artist link unfurls as a rich finding card (Discord/Notion/WordPress/Ghost/…)",
+        "the oEmbed 1.0 provider — a pasted /log link unfurls as a rich finding card, and a /artist, /label, /album, or /mixtapes link as a link card (Discord/Notion/WordPress/Ghost/…)",
         "html iframes the self-contained /embed/<logId> card; thumbnail is the finding's OG image"
       ],
       kind: "discovery",
       name: "discovery.oembed",
-      operatorNotes: 'GET /oembed?url=<a fluncle.com /log|/mixtapes|/artist URL>&format=json. Discovered via the `<link rel="alternate" type="application/json+oembed">` on the /log, mixtape, and /artist heads. XML → 501 (JSON only). No probeConfig — a bare GET without a valid `url` param is a 404, so there is no fixed URL to health-probe (like web.artist). The `rich` html frames /embed/<logId> (apps/web/src/routes/embed.$logId.ts), a standalone dark card served with a permissive `frame-ancestors *` CSP scoped to that route. Source: apps/web/src/routes/oembed.ts + src/lib/oembed.ts.',
+      operatorNotes: 'GET /oembed?url=<a fluncle.com /log|/mixtapes|/artist|/label|/album URL>&format=json — the provider resolves each. The auto-discovery `<link rel="alternate" type="application/json+oembed">` rides the /log, mixtape, and /artist heads today; a consumer unfurls a /label or /album link by hitting the provider directly (those page heads can advertise it later). XML → 501 (JSON only). No probeConfig — a bare GET without a valid `url` param is a 404, so there is no fixed URL to health-probe (like web.artist). The `rich` html frames /embed/<logId> (apps/web/src/routes/embed.$logId.ts), a standalone dark card served with a permissive `frame-ancestors *` CSP scoped to that route. Source: apps/web/src/routes/oembed.ts + src/lib/oembed.ts.',
       route: "/oembed",
       url: `${SITE}/oembed`,
       weights: { web: "tertiary" }
@@ -2994,11 +3204,32 @@ var init_src = __esm(() => {
     },
     {
       command: "fluncle artists",
-      exposedContent: ["every artist with at least one published finding (bare `slug` looks one up)"],
+      exposedContent: ["every artist Fluncle holds, A to Z (bare `slug` looks one up)"],
       kind: "cli",
       name: "cli.artists",
       weights: { cli: "secondary" }
     },
+    {
+      command: "fluncle albums",
+      exposedContent: ["every album Fluncle holds, A to Z (bare `slug` looks one up)"],
+      kind: "cli",
+      name: "cli.albums",
+      weights: { cli: "secondary" }
+    },
+    {
+      command: "fluncle labels",
+      exposedContent: ["every label Fluncle holds, A to Z (bare `slug` looks one up)"],
+      kind: "cli",
+      name: "cli.labels",
+      weights: { cli: "secondary" }
+    },
+    {
+      command: "fluncle search",
+      exposedContent: ["search the archive by coordinate, track, artist, label, or album"],
+      kind: "cli",
+      name: "cli.search",
+      weights: { cli: "secondary" }
+    },
     {
       command: "fluncle open",
       exposedContent: ["pick a track, open it in Spotify"],
@@ -3226,6 +3457,19 @@ var init_src = __esm(() => {
       title: "Artist edges",
       weights: { status: "hidden" }
     },
+    {
+      command: "fluncle admin backfills artist-credits",
+      exposedContent: [
+        "mint identity-true artists from MusicBrainz credits for slice 0's zero-matched residual → track_artists edges"
+      ],
+      kind: "cron",
+      name: "cron.artist-credits",
+      operatorNotes: "every 5m, run by a rave-02 HOST systemd timer (docs/agents/hermes/artist-credits-timer/). The MB CREDIT SWEEP (RFC artist-primary-capture, slice 1b): the sibling that completes what `backfill_artist_edges` (slice 0) could not. Slice 0's name-fold left a ~14.3k ZERO-MATCHED residual (a track it stamped but wrote no edge — no credited name folded to an existing identity), and those are exactly the tracks capture-authorization (slice 1) cannot reason about, since it matches BY IDENTITY through the `track_artists` graph. This sweep picks up that residual: for each zero-matched track carrying a MusicBrainz recording identity (`mb_recording_id`, or the `mb_<recording-mbid>` PK a crawler-born row carries), ONE paced `/recording/<mbid>?inc=artist-credits` lookup through the shared MusicBrainz client names its credited artists WITH their MB artist ids, and each resolves down a three-rung ladder: an EXACT `mbid` match, else an ADOPT (the credit name folds unambiguously onto an existing artist with no mbid — the common case, since the residual is dominated by compound credit strings like 'Sub Focus & Dimension' whose members Fluncle already holds as Spotify-keyed rows; adopting `coalesce`s the mbid onto that row instead of minting a duplicate, the split-identity guard), else a MINT of a fresh identity-true row (`mintArtistByMbid` — a real MBID is identity, the licence slice 0 lacked). Fail-closed on any ambiguity (a shared fold, or a fold whose row carries a different mbid) → mint, never a wrong merge. Then the `track_artists` edges are written. A zero-matched track with NO MB identity is TERMINALLY SKIPPED (stamped, never retried). METADATA / GRAPH IDENTITY ONLY — it certifies nothing and publishes nothing (agent tier, the `backfill_recording_mbids` precedent). Worker-paced (the box holds no MusicBrainz budget): a SMALL bounded batch per tick (each row is one ~1.1s MB call), 1 req/s, circuit-broken on a throttle, with a 60s response budget that pauses mid-page and resumes on the next request. The `tracks` row carries the durable per-row reliability state — its OWN `artist_credits_backfilled_at` stamp, DISTINCT from slice 0's `artist_edges_backfilled_at` (never disturbed). The ~14.3k residual drains at ~40/tick over ~a day and a half. Zero LLM tokens. Source: docs/agents/hermes/scripts/artist-credits-sweep.*. See docs/artist-relationship.md.",
+      probeConfig: { cadenceMs: 5 * MINUTE_MS, cronName: "fluncle-artist-credits", kind: "cron" },
+      statusDescription: "mints artists from MusicBrainz credits for the residual",
+      title: "Artist credits",
+      weights: { status: "hidden" }
+    },
     {
       command: "fluncle admin backfills label-lineage",
       exposedContent: [
@@ -4151,6 +4395,7 @@ __export(exports_admin_tracks, {
   backfillLastfmCommand: () => backfillLastfmCommand,
   backfillDiscogsCommand: () => backfillDiscogsCommand,
   backfillArtistEdgesCommand: () => backfillArtistEdgesCommand,
+  backfillArtistCreditsCommand: () => backfillArtistCreditsCommand,
   backfillAppleMusicCommand: () => backfillAppleMusicCommand,
   backfillAppleCatalogueCommand: () => backfillAppleCatalogueCommand
 });
@@ -4350,6 +4595,13 @@ async function backfillArtistEdgesCommand(limit, dryRun, cursor) {
   }
   return adminApiPost(`/api/admin/backfill/artist-edges?${params.toString()}`);
 }
+async function backfillArtistCreditsCommand(limit, dryRun, cursor) {
+  const params = new URLSearchParams({ dryRun: String(dryRun), limit: String(limit) });
+  if (cursor) {
+    params.set("cursor", cursor);
+  }
+  return adminApiPost(`/api/admin/backfill/artist-credits?${params.toString()}`);
+}
 async function vehiclesCommand(limit) {
   const tracks = await fetchAdminTracks({ hasVideo: true, max: limit, order: "desc" });
   return tracks.map((track) => ({
@@ -6781,7 +7033,7 @@ __export(exports_format, {
   artistTitle: () => artistTitle2
 });
 function coordinate3(track) {
-  return track.logId ?? COORD_FALLBACK3;
+  return track.logId ?? COORD_FALLBACK4;
 }
 function artistTitle2(track) {
   return `${track.artists.join(", ")} — ${track.title}`;
@@ -6812,7 +7064,7 @@ function vehicleRows(rows) {
     return Math.max(width, coordinate3(row).length);
   }, 0);
   return rows.map((row) => {
-    return `${coordinate3(row).padEnd(coordWidth)}  ${foundDate(row.addedAt)}  ${row.vehicle ?? COORD_FALLBACK3}  ·  ${row.register ?? COORD_FALLBACK3}`;
+    return `${coordinate3(row).padEnd(coordWidth)}  ${foundDate(row.addedAt)}  ${row.vehicle ?? COORD_FALLBACK4}  ·  ${row.register ?? COORD_FALLBACK4}`;
   });
 }
 function trackDetailLines(track) {
@@ -6829,7 +7081,7 @@ function trackDetailLines(track) {
   }
   return lines;
 }
-var COORD_FALLBACK3 = "—";
+var COORD_FALLBACK4 = "—";
 var init_format2 = __esm(() => {
   init_util();
 });
@@ -9026,9 +9278,25 @@ function addListenCommands(program2) {
       view: parseFreshView(options.view)
     });
   });
-  program2.command("artists").description("Browse artists in Fluncle's archive").argument("[slug]", "Artist slug (omit for the full list)").option("--json", "Print JSON", false).action(async (slug, options) => {
-    const { artistsListCommand: artistsListCommand2, artistsGetCommand: artistsGetCommand2 } = await Promise.resolve().then(() => (init_artists(), exports_artists));
-    await runArtists(slug, options, { artistsGetCommand: artistsGetCommand2, artistsListCommand: artistsListCommand2 });
+  program2.command("albums").description("Browse the albums in Fluncle's archive").argument("[slug]", "Album slug (omit for the A-to-Z list)").option("--page <n>", "Which page of the list (default 1)").option("--json", "Print JSON", false).action(async (slug, options) => {
+    const { albumsCommand: albumsCommand2 } = await Promise.resolve().then(() => (init_albums(), exports_albums));
+    await albumsCommand2({ json: options.json, page: parsePage(options.page), slug });
+  });
+  program2.command("artists").description("Browse the artists in Fluncle's archive").argument("[slug]", "Artist slug (omit for the A-to-Z list)").option("--page <n>", "Which page of the list (default 1)").option("--json", "Print JSON", false).action(async (slug, options) => {
+    const { artistsCommand: artistsCommand2 } = await Promise.resolve().then(() => (init_artists(), exports_artists));
+    await artistsCommand2({ json: options.json, page: parsePage(options.page), slug });
+  });
+  program2.command("labels").description("Browse the labels in Fluncle's archive").argument("[slug]", "Label slug (omit for the A-to-Z list)").option("--page <n>", "Which page of the list (default 1)").option("--json", "Print JSON", false).action(async (slug, options) => {
+    const { labelsCommand: labelsCommand2 } = await Promise.resolve().then(() => (init_labels(), exports_labels));
+    await labelsCommand2({ json: options.json, page: parsePage(options.page), slug });
+  });
+  program2.command("search").description("Search the archive for a track, artist, label, or album").argument("<query...>", "What to look for").option("--limit <n>", "Max results to return (1-50)").option("--json", "Print JSON", false).action(async (query, options) => {
+    const { searchCommand: searchCommand2 } = await Promise.resolve().then(() => (init_search(), exports_search));
+    await searchCommand2({
+      json: options.json,
+      limit: parseSearchLimit(options.limit),
+      query: query.join(" ")
+    });
   });
   program2.command("galaxies").description("Wander Fluncle's sonic galaxies").argument("[slug]", "Galaxy slug (omit for the full map)").option("--json", "Print JSON", false).action(async (slug, options) => {
     const { galaxiesListCommand: galaxiesListCommand2, galaxyGetCommand: galaxyGetCommand2 } = await Promise.resolve().then(() => (init_galaxies(), exports_galaxies));
@@ -9767,6 +10035,10 @@ function addAdminCommands(program2) {
     const { backfillArtistEdgesCommand: backfillArtistEdgesCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
     await runBackfillArtistEdges(options, backfillArtistEdgesCommand2);
   });
+  backfill.command("artist-credits").description("Mint identity-true artists from MusicBrainz credits for the zero-matched residual").option("--dry-run", "Report the eligible worklist without any vendor call or write", false).option("--limit <limit>", "Max worklist rows to visit", "40").option("--json", "Print JSON", false).action(async (options) => {
+    const { backfillArtistCreditsCommand: backfillArtistCreditsCommand2 } = await Promise.resolve().then(() => (init_admin_tracks(), exports_admin_tracks));
+    await runBackfillArtistCredits(options, backfillArtistCreditsCommand2);
+  });
   backfill.command("cover-masters").description("Resolve owned \u22641200\xB2 cover masters (album/artist) into R2").option("--kind <kind>", "Which entity to drain: album | artist", "album").option("--dry-run", "Report the eligible worklist without any fetch or write", false).option("--retry-none", "First re-queue a bounded batch of terminal none rows to pending, then run the pass", false).option("--limit <limit>", "Max entities to process", "50").option("--json", "Print JSON", false).action(async (options) => {
     const { backfillCoverMastersCommand: backfillCoverMastersCommand2 } = await Promise.resolve().then(() => (init_admin_covers(), exports_admin_covers));
     await runBackfillCoverMasters(options, backfillCoverMastersCommand2);
@@ -10814,6 +11086,57 @@ async function runBackfillArtistEdges(options, backfillArtistEdgesCommand2) {
   const verb = dryRun ? "Would write" : "Wrote";
   console.log(`${verb} ${edgesWritten} track_artists edge(s) over ${scanned} track(s): ${fullyMatched.length} fully matched, ${partiallyMatched.length} partially, ${zeroMatched.length} with none; ${unmatchedNames} credited name(s) left unmatched.`);
 }
+async function runBackfillArtistCredits(options, backfillArtistCreditsCommand2) {
+  const limit = parseListLimit(options.limit) ?? 40;
+  let cursor;
+  let dryRun = options.dryRun;
+  let scanned = 0;
+  let mintedArtists = 0;
+  let matchedArtists = 0;
+  let adoptedArtists = 0;
+  let edgesWritten = 0;
+  let skippedNoIdentity = 0;
+  let throttled = false;
+  while (scanned < limit) {
+    const remaining = limit - scanned;
+    const result = await backfillArtistCreditsCommand2(remaining, options.dryRun, cursor);
+    dryRun = result.dryRun;
+    scanned += result.scanned;
+    mintedArtists += result.mintedArtists;
+    matchedArtists += result.matchedArtists;
+    adoptedArtists += result.adoptedArtists;
+    edgesWritten += result.edgesWritten;
+    skippedNoIdentity += result.skippedNoIdentity;
+    if (!options.json) {
+      const verb2 = result.dryRun ? "would visit" : "visited";
+      console.log(`  \u2026${verb2} ${result.scanned}; minted ${result.mintedArtists}, adopted ${result.adoptedArtists}, matched ${result.matchedArtists} artist(s); wrote ${result.edgesWritten} edge(s); ${result.skippedNoIdentity} without a MusicBrainz identity`);
+    }
+    if (result.rateLimited) {
+      throttled = true;
+      break;
+    }
+    if (result.nextCursor === null) {
+      break;
+    }
+    cursor = result.nextCursor;
+  }
+  if (options.json) {
+    printJson({
+      adoptedArtists,
+      dryRun,
+      edgesWritten,
+      matchedArtists,
+      mintedArtists,
+      ok: true,
+      rateLimited: throttled,
+      scanned,
+      skippedNoIdentity
+    });
+    return;
+  }
+  const verb = dryRun ? "Would visit" : "Visited";
+  console.log(`${verb} ${scanned} track(s): minted ${mintedArtists}, adopted ${adoptedArtists}, matched ${matchedArtists} artist(s); wrote ${edgesWritten} track_artists edge(s); ${skippedNoIdentity} carried no MusicBrainz identity.`);
+}
 async function runArtistResolveQueue(options, listArtistsCommand2) {
   const limit = parseListLimit(options.limit);
   const result = await listArtistsCommand2(limit ?? 50);
@@ -11614,33 +11937,6 @@ async function runRecent(options, recentCommand3) {
   console.log(trackRows2(tracks).join(`
 `));
 }
-async function runArtists(slug, options, commands) {
-  if (slug) {
-    const artist = await commands.artistsGetCommand(slug);
-    if (options.json) {
-      printJson({ artist, ok: true });
-      return;
-    }
-    console.log(`${artist.name}  (${artist.slug})`);
-    console.log(`Findings: ${artist.findingCount}`);
-    if (artist.spotifyUrl) {
-      console.log(`Spotify: ${artist.spotifyUrl}`);
-    }
-    return;
-  }
-  const artists = await commands.artistsListCommand();
-  if (options.json) {
-    printJson({ artists, ok: true });
-    return;
-  }
-  if (artists.length === 0) {
-    console.log("No artists in the archive yet.");
-    return;
-  }
-  for (const a of artists) {
-    console.log(`${a.name.padEnd(40)} ${String(a.findingCount).padStart(3)} finding${a.findingCount === 1 ? "" : "s"}`);
-  }
-}
 async function runGalaxies(slug, options, commands) {
   if (slug) {
     const { findings, galaxy } = await commands.galaxyGetCommand(slug);
@@ -11860,6 +12156,23 @@ function parseListLimit(value) {
   }
   return limit;
 }
+function parsePage(value) {
+  const page = Number.parseInt(value ?? "1", 10);
+  if (!Number.isInteger(page) || page < 1) {
+    throw new Error("Page must be a positive integer");
+  }
+  return page;
+}
+function parseSearchLimit(value) {
+  if (value === undefined) {
+    return;
+  }
+  const limit = Number.parseInt(value, 10);
+  if (!Number.isInteger(limit) || limit < 1 || limit > 50) {
+    throw new Error("Limit must be an integer between 1 and 50");
+  }
+  return limit;
+}
 function parseFreshView(value) {
   const view = value ?? "all";
   if (view !== "all" && view !== "tracks" && view !== "albums") {
@@ -12425,6 +12738,7 @@ var stringOptions = new Set([
   "--model",
   "--note",
   "--order",
+  "--page",
   "--parent-id",
   "--plate",
   "--plate-background",
@@ -12472,6 +12786,13 @@ Listen:
   fluncle random [--json]                       The archive throws one back
   fluncle subscribe [email]                     Fresh bangers, every Friday
 
+Browse:
+  fluncle search <query> [--limit 20] [--json]      Search the archive for a track, artist, label, or album
+  fluncle artists [slug] [--page 1] [--json]        Artists in the archive, A to Z
+  fluncle albums [slug] [--page 1] [--json]         Albums in the archive, A to Z
+  fluncle labels [slug] [--page 1] [--json]         Labels in the archive, A to Z
+  fluncle fresh [--limit 10] [--view all] [--json]  What just came out, newest release first
+
 Share:
   fluncle submit [search-or-spotify-url]   Send a track for review
 

package/package.json

@@ -31,5 +31,5 @@
     "url": "git+https://github.com/mauricekleine/fluncle.git"
   },
   "type": "module",
-  "version": "0.184.0"
+  "version": "0.186.0"
 }