@audiofool/moondog 0.3.0-beta.10 → 0.3.0-beta.12

package/src/integrations/public-playlists.mjs

@@ -54,6 +54,30 @@ async function boundedJson(response) {
   catch { throw new Error("The service changed its playlist response or requires sign-in. No music was imported."); }
 }
 
+// A NetEase playlist, as { code, result: { id, name, privacy, trackCount, tracks } }. NetEase's web player reads
+// playlists with v6, which answers every public one, a listener's Liked songs among them, with all its song ids but
+// details for only the first few without a sign-in; the rest come from song/detail, 200 at a time, in the
+// playlist's order. The older endpoint, which some playlists answer with code 20001, is the fallback.
+const NETEASE_SONGS_MAX = 3000;
+async function neteasePlaylist(id, fetchImpl) {
+  const referer = "https://music.163.com/";
+  const current = await boundedJson(await responseFor(`https://music.163.com/api/v6/playlist/detail?id=${id}&n=100000`, fetchImpl, referer)).catch(() => null);
+  const playlist = current?.code === 200 ? current.playlist : null;
+  if (!playlist || !Array.isArray(playlist.trackIds)) {
+    return boundedJson(await responseFor(`https://music.163.com/api/playlist/detail?id=${id}`, fetchImpl, referer));
+  }
+  const ids = playlist.trackIds.map((entry) => String(entry?.id ?? "")).filter((value) => numericId.test(value)).slice(0, NETEASE_SONGS_MAX);
+  const songs = new Map((Array.isArray(playlist.tracks) ? playlist.tracks : []).map((song) => [String(song?.id ?? ""), song]));
+  const missing = ids.filter((songId) => !songs.has(songId));
+  for (let start = 0; start < missing.length; start += 200) {
+    const batch = missing.slice(start, start + 200);
+    const detail = await boundedJson(await responseFor(`https://music.163.com/api/song/detail/?ids=${encodeURIComponent(`[${batch.join(",")}]`)}`, fetchImpl, referer));
+    for (const song of Array.isArray(detail?.songs) ? detail.songs : []) songs.set(String(song?.id ?? ""), song);
+  }
+  return { code: 200, result: { id: playlist.id, name: playlist.name, coverImgUrl: playlist.coverImgUrl, privacy: playlist.privacy, trackCount: playlist.trackCount ?? ids.length,
+    tracks: ids.map((songId) => songs.get(songId)).filter(Boolean) } };
+}
+
 /** A public QQ Music or NetEase playlist by its share link: { provider, id, url, name, total, rows, skipped }. */
 export async function fetchPublicPlaylist({ input, provider, fetchImpl = fetch }) {
   let url = playlistLink(input);
@@ -70,10 +94,9 @@ export async function fetchPublicPlaylist({ input, provider, fetchImpl = fetch }
   if (!identity) throw new Error("Open this share link in your browser, then copy the full playlist page URL. Song, album and private playlist links are not supported.");
   if (provider && ["qq_music", "netease"].includes(provider) && provider !== identity.provider) throw new Error("This link belongs to another service. Go back and choose that service, or paste the matching playlist link.");
   const qq = identity.provider === "qq_music";
-  const endpoint = qq
-    ? `https://c.y.qq.com/qzone/fcg-bin/fcg_ucc_getcdinfo_byids_cp.fcg?type=1&json=1&utf8=1&onlysong=0&disstid=${identity.id}&format=json`
-    : `https://music.163.com/api/playlist/detail?id=${identity.id}`;
-  const data = await boundedJson(await responseFor(endpoint, fetchImpl, qq ? "https://y.qq.com/" : "https://music.163.com/"));
+  const data = qq
+    ? await boundedJson(await responseFor(`https://c.y.qq.com/qzone/fcg-bin/fcg_ucc_getcdinfo_byids_cp.fcg?type=1&json=1&utf8=1&onlysong=0&disstid=${identity.id}&format=json`, fetchImpl, "https://y.qq.com/"))
+    : await neteasePlaylist(identity.id, fetchImpl);
   const playlist = qq ? data?.cdlist?.[0] : data?.result;
   if ((qq ? data?.code !== 0 || data?.subcode !== 0 : data?.code !== 200) || !playlist
     || (qq ? Number(playlist.dir_show) === 0 : Number(playlist.privacy) === 10)) throw new Error("This playlist is unavailable publicly. Choose a playlist you can open without signing in; no account password or cookies are needed.");
@@ -91,10 +114,14 @@ export async function fetchPublicPlaylist({ input, provider, fetchImpl = fetch }
       title: musicText(qq ? song.songname : song.name),
       artist: musicText(Array.isArray(artists) ? artists.map((artist) => musicText(artist?.name)).filter(Boolean).join(", ") : ""),
       album: musicText(qq ? song.albumname : (song.album ?? song.al)?.name),
+      // NetEase names each album cover on its own image host; it is shown over https.
+      ...(!qq && /^https?:\/\/p[0-9]+\.music\.126\.net\//u.test((song.album ?? song.al)?.picUrl ?? "") ? { artwork: (song.album ?? song.al).picUrl.replace(/^http:/u, "https:") } : {}),
       playlistId: identity.id, playlistName: name, position: index + 1, member: "public-playlist.json",
     };
   }).filter((row) => row.id && row.title);
-  return { provider: identity.provider, id: identity.id, url: url.href, name, total, rows, skipped: songs.length - rows.length };
+  // NetEase's own image host, shown over https, as a song's cover is.
+  const cover = !qq && /^https?:\/\/p[0-9]+\.music\.126\.net\//u.test(playlist.coverImgUrl ?? "") ? playlist.coverImgUrl.replace(/^http:/u, "https:") : null;
+  return { provider: identity.provider, id: identity.id, url: url.href, name, total, rows, skipped: songs.length - rows.length, ...(cover ? { cover } : {}) };
 }
 
 export async function readPublicPlaylist({ input, subjectId, capturedAt, provider, fetchImpl = fetch }) {

package/src/integrations/spotify/service.mjs

@@ -905,10 +905,15 @@ export function createSpotifyService(options = {}) {
       if (!playlist) fail("spotify_playlist_unavailable", "Spotify did not describe this playlist.");
       const page = await client.getPlaylistItems({ playlistId, limit: SPOTIFY_SERVICE_LIMITS.playlistItemsPageMax, offset: 0 }, { signal })
         .catch((error) => (signal?.aborted ? Promise.reject(error) : null));
-      return { name: playlist.name, uri: playlist.uri, tracks_total: playlist.tracks_total ?? null,
+      return { name: playlist.name, uri: playlist.uri, tracks_total: playlist.tracks_total ?? null, ...(playlist.image ? { image: playlist.image } : {}),
         tracks: page ? page.items.map((entry) => entry.item).filter(Boolean) : null };
     },
 
+    // Only a playlist's cover, for one imported before Moondog kept it.
+    async readPlaylistCover({ playlistId } = {}, { signal } = {}) {
+      return (await client.getPlaylist({ playlistId: requiredPlaylistId(String(playlistId ?? "")) }, { signal }))?.image ?? null;
+    },
+
     // A whole playlist for the listener's library: its name, whether the signed-in listener owns it, and its
     // songs page by page, up to 2,000. Spotify's own editorial playlists answer most apps with not found.
     async readPlaylist({ playlistId } = {}, { signal } = {}) {

package/src/integrations/spotify/web-api-client.mjs

@@ -160,14 +160,18 @@ function normalizeArtistNames(rawArtists) {
 }
 
 // Cover art a window can draw: one Spotify CDN image, the largest that is at most 640 pixels.
-function coverImage(images) {
+function coverImage(images, allowed = /^https:\/\/i\.scdn\.co\/image\/[A-Za-z0-9_-]{1,128}$/u) {
   const usable = (Array.isArray(images) ? images : []).filter((image) =>
-    typeof image?.url === "string" && /^https:\/\/i\.scdn\.co\/image\/[A-Za-z0-9_-]{1,128}$/u.test(image.url));
+    typeof image?.url === "string" && allowed.test(image.url));
   const sized = usable.filter((image) => !Number.isInteger(image.width) || image.width <= 640)
     .sort((left, right) => (right.width ?? 0) - (left.width ?? 0));
   return (sized[0] ?? usable.at(-1))?.url;
 }
 
+// A playlist's cover lives on more hosts than an album's: one a listener uploaded on image-cdn-*.spotifycdn.com, the
+// four-album mosaic on mosaic.scdn.co. The window's image policy (renderer/index.html) names the same two domains.
+const PLAYLIST_COVER = /^https:\/\/[a-z0-9-]{1,40}\.(?:scdn\.co|spotifycdn\.com)\/[A-Za-z0-9_/-]{1,200}$/u;
+
 // A track's album, kept so a song played alone can go on into the rest of its album.
 // Hosts keep it next to the track URI and never show it to the model.
 function albumUri(raw) {
@@ -462,6 +466,8 @@ function normalizePlaylist(payload, { includeControlMetadata = false } = {}) {
     const snapshotId = safeText(payload.snapshot_id, 128);
     if (ownerId) playlist.owner_id = ownerId;
     if (snapshotId) playlist.snapshot_id = snapshotId;
+    const cover = coverImage(payload.images, PLAYLIST_COVER);
+    if (cover) playlist.image = cover;
   }
   const tracksTotal = safeInteger(
     payload.items?.total ?? payload.tracks?.total,

package/src/integrations/web/deepseek-web.mjs

@@ -69,7 +69,7 @@ export function createDeepSeekWebResearch({ apiKey, fetch: fetchImpl = globalThi
     if (status !== 200) throw serviceError(status, body);
     const title = typeof body.title === "string" && body.title.trim() ? clip(body.title.trim(), 300) : url;
     return webResult({ provider: "deepseek", kind: "read", status: "found", retrievedAt,
-      summary: clip(text, webLimits.textChars), truncated: text.length > webLimits.textChars,
+      summary: clip(text, webLimits.fullTextChars), truncated: text.length > webLimits.fullTextChars,
       sources: [{ title, url, snippet: "", published_at: null }] });
   }
 

package/src/integrations/web/web-research.mjs

@@ -1,3 +1,4 @@
+import { readModelRoles } from "../../runtime/pi/model-roles.mjs";
 import { createPersistentCredentialStore } from "../../runtime/pi/persistent-credential-store.mjs";
 import { createBraveWebResearch } from "./brave-web.mjs";
 import { createCodexWebResearch } from "./codex-web.mjs";
@@ -5,8 +6,13 @@ import { createDeepSeekWebResearch } from "./deepseek-web.mjs";
 import { failure, webProviderName } from "./web-result.mjs";
 
 // Search goes to the first backend that is set up; reading needs a backend that can open pages.
-// MOONDOG_WEB_SEARCH_PROVIDER and MOONDOG_WEB_READ_PROVIDER pick one instead.
+// The web search role in Settings (model-roles.json) picks one instead, and MOONDOG_WEB_SEARCH_PROVIDER
+// and MOONDOG_WEB_READ_PROVIDER pick over that. As in Hermes Agent, a call that fails on the chosen
+// backend is tried once more on each other backend that is set up, so one service being down or out
+// of credit doesn't leave the agent without the web.
 const order = Object.freeze({ search: ["deepseek", "brave", "codex"], read: ["deepseek", "codex"] });
+// Failures that another backend would only repeat.
+const final = new Set(["web_cancelled", "web_input_invalid", "web_url_invalid"]);
 const providerIds = Object.freeze({ deepseek: "deepseek", brave: "brave", codex: "codex_cli" });
 const keys = Object.freeze({
   deepseek: { credential: "deepseek", variable: "DEEPSEEK_API_KEY" },
@@ -33,43 +39,103 @@ export async function createWebResearch({
   credentials = createPersistentCredentialStore(environment),
   fetch = globalThis.fetch,
   createCodex = createCodexWebResearch,
+  readRoles = readModelRoles,
   now,
 } = {}) {
-  let current = { backends: {}, choices: {} };
+  let current = { backends: {}, choices: {}, found: {} };
+
+  // A backend whose key did not change keeps its cache. A working Codex stays; one that was not ready
+  // is checked again, since the listener may have signed in since.
+  async function backendFor(name, found, previous) {
+    if (name === "codex") {
+      const kept = previous?.backends.codex;
+      return kept?.publicStatus().state === "configured" ? kept : createCodex({ environment, now });
+    }
+    const kept = previous?.backends[name] && previous.found[name]?.key === found[name]?.key;
+    return kept ? previous.backends[name] : { deepseek: createDeepSeekWebResearch, brave: createBraveWebResearch }[name]({ apiKey: found[name]?.key, fetch, now });
+  }
 
   async function load(previous) {
     const found = {
       deepseek: await readKey(credentials, environment, keys.deepseek),
       brave: await readKey(credentials, environment, keys.brave),
     };
+    const role = (await readRoles(environment).catch(() => ({}))).web_search?.service ?? null;
     const choices = {};
     for (const kind of ["search", "read"]) {
       const wanted = environment[`MOONDOG_WEB_${kind.toUpperCase()}_PROVIDER`]?.trim().toLowerCase();
-      if (wanted) choices[kind] = order[kind].includes(wanted) ? { name: wanted, override: true } : { name: null, reason: "web_provider_unknown", wanted };
+      if (wanted) choices[kind] = order[kind].includes(wanted) ? { name: wanted, selectedBy: `MOONDOG_WEB_${kind.toUpperCase()}_PROVIDER` } : { name: null, reason: "web_provider_unknown", wanted };
+      // Brave only searches, so with Brave chosen a read still goes to the first backend that can.
+      else if (role && order[kind].includes(role)) choices[kind] = { name: role, selectedBy: "settings" };
       else choices[kind] = { name: order[kind].find((name) => name !== "codex" && found[name]) ?? "codex" };
     }
     const backends = {};
     for (const name of new Set(Object.values(choices).map((choice) => choice.name).filter(Boolean))) {
-      // A backend whose key did not change keeps its cache.
-      const create = { deepseek: createDeepSeekWebResearch, brave: createBraveWebResearch }[name];
-      if (create) {
-        const kept = previous?.backends[name] && previous.found[name]?.key === found[name]?.key;
-        backends[name] = kept ? previous.backends[name] : create({ apiKey: found[name]?.key, fetch, now });
-      }
-      // A working Codex stays; one that was not ready is checked again, since the listener may have signed in since.
-      if (name === "codex") {
-        const kept = previous?.backends.codex;
-        backends.codex = kept?.publicStatus().state === "configured" ? kept : await createCodex({ environment, now });
-      }
+      backends[name] = await backendFor(name, found, previous);
     }
     return { backends, choices, found };
   }
 
+  // The other backends a failed call can go to: ones with a key, and Codex once it is signed in.
+  async function alternatives(kind, tried) {
+    const names = [];
+    for (const name of order[kind]) {
+      if (name === tried) continue;
+      if (name !== "codex" && !current.found[name]) continue;
+      current.backends[name] ??= await backendFor(name, current.found, null);
+      if (name === "codex" && current.backends.codex.publicStatus().state !== "configured") continue;
+      names.push(name);
+    }
+    return names;
+  }
+
+  async function research(kind, input, options) {
+    const first = backend(kind);
+    const name = current.choices[kind].name;
+    let failed;
+    try {
+      const result = await first[kind](input, options);
+      // A page the chosen backend could not read may open on another.
+      if (kind === "search" || result.status !== "unavailable") return result;
+      failed = result;
+    } catch (error) {
+      if (final.has(error?.code) || options?.signal?.aborted) throw error;
+      failed = error;
+    }
+    for (const other of await alternatives(kind, name)) {
+      try {
+        const result = await current.backends[other][kind](input, options);
+        if (kind === "search" || result.status !== "unavailable") return { ...result, fallback_from: providerIds[name] };
+      } catch (error) {
+        if (final.has(error?.code) || options?.signal?.aborted) throw error;
+      }
+    }
+    if (failed instanceof Error) throw failed;
+    return failed;
+  }
+
+  /** Each service, whether it is set up for each operation, and which one the role chose; for Settings. */
+  async function services() {
+    const role = (await readRoles(environment).catch(() => ({}))).web_search?.service ?? null;
+    current.backends.codex ??= await backendFor("codex", current.found, null);
+    const codex = current.backends.codex.publicStatus().state === "configured";
+    return {
+      chosen: role,
+      search: operationStatus("search"),
+      read: operationStatus("read"),
+      services: order.search.map((name) => {
+        const ready = name === "codex" ? codex : Boolean(current.found[name]);
+        return { id: name, provider: providerIds[name], name: webProviderName(providerIds[name]), ready,
+          search: ready, read: ready && order.read.includes(name) };
+      }),
+    };
+  }
+
   function operationStatus(kind) {
     const choice = current.choices[kind];
     if (!choice?.name) return { provider: null, state: "unavailable", reason: choice?.reason ?? "web_provider_unknown", ...(choice?.wanted ? { requested: choice.wanted } : {}) };
     const provider = providerIds[choice.name];
-    const override = choice.override ? { selected_by: `MOONDOG_WEB_${kind.toUpperCase()}_PROVIDER` } : {};
+    const override = choice.selectedBy ? { selected_by: choice.selectedBy } : {};
     if (choice.name === "codex") {
       const codex = current.backends.codex.publicStatus();
       return { provider, state: codex.state, ...(codex.reason ? { reason: codex.reason } : {}), ...override };
@@ -103,8 +169,9 @@ export async function createWebResearch({
   current = await load();
   return {
     publicStatus,
-    search: async (input, options) => backend("search").search(input, options),
-    read: async (input, options) => backend("read").read(input, options),
+    services,
+    search: (input, options) => research("search", input, options),
+    read: (input, options) => research("read", input, options),
     /** Reads keys and settings again, after /auth or /reload. */
     async refresh() {
       const previous = current;

package/src/integrations/web/web-result.mjs

@@ -4,8 +4,12 @@ import Ajv from "ajv";
 
 // Every web backend returns this one result shape, checked by the same rules,
 // so the agent and the screen never need to know which service answered.
+// After Hermes Agent's web tools: a search gives five sources unless the agent asks for up to ten,
+// and a read keeps the page's whole text, handing it out a window at a time; the agent asks for the
+// next window with next_offset instead of losing everything past the first.
 export const webLimits = Object.freeze({
-  sources: 5, snippetChars: 800, textChars: 12_000, cacheMs: 300_000, cacheEntries: 32, responseBytes: 2_000_000,
+  sources: 5, maxSources: 10, snippetChars: 1200, textChars: 15_000, fullTextChars: 200_000,
+  cacheMs: 300_000, cacheEntries: 32, responseBytes: 2_000_000,
 });
 
 // What each backend's text is, so the agent can tell a search engine's snippet from a model's summary.
@@ -19,13 +23,14 @@ export function webProviderName(provider) {
   return backends[provider]?.name ?? null;
 }
 
-const resultSchema = {
+// A backend's result holds a page's whole text; the agent's holds one window of it.
+const resultSchema = (textChars) => ({
   type: "object", additionalProperties: false,
   properties: {
     status: { type: "string", enum: ["found", "not_found", "unavailable"] },
-    summary: { type: "string", maxLength: webLimits.textChars },
+    summary: { type: "string", maxLength: textChars },
     sources: {
-      type: "array", maxItems: webLimits.sources,
+      type: "array", maxItems: webLimits.maxSources,
       items: {
         type: "object", additionalProperties: false,
         properties: {
@@ -39,8 +44,11 @@ const resultSchema = {
     },
   },
   required: ["status", "summary", "sources"],
-};
-const validate = new Ajv({ strict: false }).compile(resultSchema);
+});
+const ajv = new Ajv({ strict: false });
+const validate = ajv.compile(resultSchema(webLimits.fullTextChars));
+const validateWindow = ajv.compile(resultSchema(webLimits.textChars));
+const offsetOf = (value) => (Number.isInteger(value) && value >= 0 ? value : null);
 
 export function failure(code, message) {
   return Object.assign(new Error(message), { code });
@@ -101,7 +109,7 @@ export function webResult({ provider, kind, status, summary = "", sources = [],
 export function projectWebResearchResult(value) {
   const payload = { status: value?.status, summary: value?.summary, sources: value?.sources };
   const backend = backends[value?.provider];
-  if (!validate(payload) || (payload.status === "found" && !payload.sources.length) ||
+  if (!validateWindow(payload) || (payload.status === "found" && !payload.sources.length) ||
       !backend?.content[value.kind] || value.evidence !== backend.evidence || !Number.isFinite(Date.parse(value.retrieved_at))) {
     throw failure("web_output_invalid", `${backend?.name ?? "The web service"} returned an invalid or unsourced research result.`);
   }
@@ -110,6 +118,9 @@ export function projectWebResearchResult(value) {
     retrieved_at: new Date(value.retrieved_at).toISOString(), from_cache: value.from_cache === true,
     content_kind: backend.content[value.kind], trust: "untrusted_web_content", evidence: backend.evidence,
     ...(value.truncated === true ? { truncated: true } : {}),
+    ...(value.kind === "read" && offsetOf(value.total_chars) !== null ? {
+      text_offset: offsetOf(value.text_offset) ?? 0, total_chars: value.total_chars, next_offset: offsetOf(value.next_offset),
+    } : {}),
     summary: cleanText(payload.summary), sources: projectSources(payload.sources),
   };
 }
@@ -131,14 +142,46 @@ export function searchSources(items) {
     if (snippet) seen.add(snippet);
     const date = typeof item.published_at === "string" ? cleanText(item.published_at).slice(0, 100) : "";
     sources.push({ title, url, snippet, published_at: date || null });
-    if (sources.length === webLimits.sources) break;
+    if (sources.length === webLimits.maxSources) break;
   }
   return sources;
 }
 
+// One window of a page's text, ending at a line or word break near the limit when there is one.
+function textWindow(text, offset) {
+  let end = Math.min(text.length, offset + webLimits.textChars);
+  if (end < text.length) {
+    const floor = offset + Math.floor(webLimits.textChars * 0.8);
+    const lineBreak = text.lastIndexOf("\n", end);
+    const space = text.lastIndexOf(" ", end);
+    end = lineBreak > floor ? lineBreak : space > floor ? space : end;
+  }
+  return { summary: text.slice(offset, end), end };
+}
+
+/** What one call asked for: up to `limit` sources of a search, or the window of a read from `offset`. */
+function windowed(result, kind, { limit, offset }) {
+  if (kind === "search") return { ...result, sources: result.sources.slice(0, limit) };
+  const text = result.summary;
+  if (offset > 0 && offset >= text.length) {
+    throw failure("web_input_invalid", `The page has ${text.length} characters, so offset ${offset} is past its end.`);
+  }
+  const { summary, end } = textWindow(text, offset);
+  const more = end < text.length;
+  return { ...result, summary, text_offset: offset, total_chars: text.length, next_offset: more ? end : null,
+    ...(more || result.truncated ? { truncated: true } : {}) };
+}
+
+function integerIn(value, minimum, maximum, fallback, message) {
+  if (value === undefined) return fallback;
+  if (!Number.isInteger(value) || value < minimum || value > maximum) throw failure("web_input_invalid", message);
+  return value;
+}
+
 /**
  * The parts every backend shares: one query or URL in, a cancellable request,
- * and a five-minute process-local cache of found results.
+ * and a five-minute process-local cache of found results. The cache keeps the whole result, so a
+ * smaller limit or a later window of the same page needs no second request.
  */
 export function createWebOperations({ unavailable = () => null, queryChars = 500, run, now = () => new Date() }) {
   const cache = new Map();
@@ -146,9 +189,14 @@ export function createWebOperations({ unavailable = () => null, queryChars = 500
   async function research(kind, input, { signal } = {}) {
     const blocked = unavailable(kind);
     if (blocked) throw blocked;
-    if (!input || typeof input !== "object" || Object.keys(input).some((key) => key !== (kind === "search" ? "query" : "url"))) {
+    const allowed = kind === "search" ? ["query", "limit"] : ["url", "offset"];
+    if (!input || typeof input !== "object" || Object.keys(input).some((key) => !allowed.includes(key))) {
       throw failure("web_input_invalid", "Supply one search query or public URL.");
     }
+    const view = {
+      limit: integerIn(input.limit, 1, webLimits.maxSources, webLimits.sources, `Ask for 1 to ${webLimits.maxSources} search results.`),
+      offset: integerIn(input.offset, 0, webLimits.fullTextChars, 0, "The offset must be a whole number of characters, from 0."),
+    };
     const value = kind === "read" ? publicWebUrl(input.url) : typeof input.query === "string" ? input.query.trim() : input.query;
     if (typeof value !== "string" || !value) throw failure("web_input_invalid", "The web query or URL is empty.");
     if (value.length > (kind === "search" ? queryChars : 2048)) {
@@ -158,7 +206,7 @@ export function createWebOperations({ unavailable = () => null, queryChars = 500
     const key = `${kind}:${value}`;
     const cached = cache.get(key);
     if (cached && now().getTime() - Date.parse(cached.retrieved_at) < webLimits.cacheMs) {
-      return { ...structuredClone(cached), from_cache: true };
+      return windowed({ ...structuredClone(cached), from_cache: true }, kind, view);
     }
     const controller = new AbortController();
     active.add(controller);
@@ -168,7 +216,7 @@ export function createWebOperations({ unavailable = () => null, queryChars = 500
         cache.set(key, result);
         if (cache.size > webLimits.cacheEntries) cache.delete(cache.keys().next().value);
       }
-      return structuredClone(result);
+      return windowed(structuredClone(result), kind, view);
     } finally {
       active.delete(controller);
     }

package/src/profile/listening-history-store.mjs

@@ -844,6 +844,7 @@ export class ListeningHistoryStore {
   #coverageSources = null;
   #evidence = null;
   #ledgerChanges = 0;
+  #listeningDays = null;
 
   constructor(database) {
     this.#database = database;
@@ -2058,6 +2059,59 @@ export class ListeningHistoryStore {
       ...(started.length ? { moondog_started_plays: started.length } : {}), top_artists: artists });
   }
 
+  // The listener's own plays a local day at a time, for the window's taste record: every day's plays, the
+  // same for the most played artists, and the plays Moondog started, kept apart as recentAttention keeps
+  // them. Counts and artist names only. Kept until the stored plays change, since a long history is many rows.
+  listeningDays({ subjectId, artists = 8 } = {}) {
+    if (this.#closed) throw new Error("Listening history store is closed");
+    if (!isUuid(subjectId)) throw new TypeError("A valid profile subject is required");
+    if (!Number.isSafeInteger(artists) || artists < 0 || artists > 20) throw new TypeError("Artist count is invalid");
+    const subject = subjectId.toLowerCase();
+    const version = `${this.listeningDataVersion()}:${subject}:${artists}`;
+    if (this.#listeningDays?.version === version) return structuredClone(this.#listeningDays.value);
+    const effective = `e.subject_id = ?
+      AND NOT EXISTS (SELECT 1 FROM listening_event_supersessions s WHERE s.superseded_event_id = e.listening_event_id)
+      AND NOT EXISTS (SELECT 1 FROM listening_event_mirrors m WHERE m.mirror_event_id = e.listening_event_id)`;
+    const suggestions = this.#suggestionsForMatching();
+    const since = suggestions.length ? new Date(Date.parse(suggestions[0].requested_at) - SUGGESTION_WINDOW.beforeMs).toISOString() : null;
+    const started = !since ? [] : markMoondogStartedPlays(this.#database.prepare(`SELECT
+      e.listening_event_id, e.record_json AS event_json, t.record_json AS track_json FROM listening_events e
+      JOIN track_refs t ON t.track_ref_id = e.track_ref_id AND t.revision = e.track_ref_revision
+      WHERE ${effective} AND e.occurred_at >= ?`)
+      .all(subject, since).map((row) => ({ id: row.listening_event_id, event: JSON.parse(row.event_json), track: JSON.parse(row.track_json) })),
+    suggestions).rows.filter((row) => row.moondog_suggestion_id).map((row) => row.id);
+    const own = `${effective} AND e.listening_event_id NOT IN (SELECT value FROM json_each(?))`;
+    const left = JSON.stringify(started);
+    const pairs = (rows) => rows.map((row) => [row.day, row.plays]);
+    const days = this.#database.prepare(`SELECT date(e.occurred_at, 'localtime') AS day, COUNT(*) AS plays
+      FROM listening_events e WHERE ${own} GROUP BY day ORDER BY day`).all(subject, left);
+    let value = null;
+    if (days.length) {
+      const credited = `FROM listening_events e
+        JOIN track_refs t ON t.track_ref_id = e.track_ref_id AND t.revision = e.track_ref_revision
+        JOIN json_each(t.record_json, '$.artist_credits') a
+        WHERE ${own} AND json_extract(a.value, '$.name') IS NOT NULL`;
+      const top = artists === 0 ? [] : this.#database.prepare(`SELECT json_extract(a.value, '$.name') AS name, COUNT(*) AS plays
+        ${credited} GROUP BY name ORDER BY plays DESC, name LIMIT ?`).all(subject, left, artists);
+      const byArtist = new Map(top.map((row) => [row.name, []]));
+      if (top.length) {
+        for (const row of this.#database.prepare(`SELECT json_extract(a.value, '$.name') AS name,
+          date(e.occurred_at, 'localtime') AS day, COUNT(*) AS plays
+          ${credited} AND json_extract(a.value, '$.name') IN (SELECT value FROM json_each(?))
+          GROUP BY name, day ORDER BY day`).iterate(subject, left, JSON.stringify(top.map((artist) => artist.name)))) {
+          byArtist.get(row.name)?.push([row.day, row.plays]);
+        }
+      }
+      const moondog = started.length ? this.#database.prepare(`SELECT date(occurred_at, 'localtime') AS day, COUNT(*) AS plays
+        FROM listening_events WHERE listening_event_id IN (SELECT value FROM json_each(?)) GROUP BY day ORDER BY day`).all(left) : [];
+      value = { first_day: days[0].day, last_day: days.at(-1).day, days: pairs(days),
+        artists: top.map((artist) => ({ name: artist.name, plays: artist.plays, days: byArtist.get(artist.name) })),
+        moondog_days: pairs(moondog) };
+    }
+    this.#listeningDays = { version, value };
+    return structuredClone(value);
+  }
+
   // Which spans of time the stored plays cover, and where plays may be missing.
   listeningCoverage({ subjectId } = {}) {
     if (this.#closed) throw new Error("Listening history store is closed");