@audiofool/moondog 0.1.0 → 0.2.0-beta.2

package/src/profile/local-music-data.mjs

@@ -673,7 +673,7 @@ async function checkpointSqlite(filePath) {
   } catch (error) {
     fail(
       "local_music_data_busy",
-      "Local music data is busy. Close Moondog Studio and other Moondog processes before reset.",
+      "Local music data is busy. Close other Moondog windows and processes before reset.",
       { cause: error },
     );
   } finally {

package/src/profile/music-providers.mjs

@@ -1,8 +1,10 @@
 export const MUSIC_PROVIDER_LABELS = Object.freeze({
   spotify_account_data: "Spotify",
+  spotify_web_api: "Spotify",
   youtube_music: "YouTube Music",
+  lastfm: "Last.fm",
   qq_music: "QQ Music",
-  netease: "NetEase Cloud Music",
+  netease: "NetEase Music",
 });
 
 export function musicProviderLabel(system) {
@@ -10,16 +12,18 @@ export function musicProviderLabel(system) {
 }
 
 export function collectionCoverage(coverage) {
-  const spotify = coverage.collection_sources?.find((source) => source.system === "spotify_account_data");
+  // An export and a live library read are both Spotify; evidence is already deduplicated across them.
+  const spotify = (coverage.collection_sources ?? []).filter((source) => ["spotify_account_data", "spotify_web_api"].includes(source.system));
+  const total = (key) => spotify.reduce((sum, source) => sum + (source[key] ?? 0), 0);
   return {
     collection_tracks: coverage.collection_tracks ?? 0,
     collection_sources: coverage.collection_sources ?? [],
     saved_tracks: coverage.saved_tracks,
     playlist_memberships: coverage.playlist_memberships,
-    spotify_profile_evidence: spotify?.evidence_records ?? 0,
-    spotify_saved_tracks: spotify?.saved_tracks ?? 0,
-    spotify_saved_albums: spotify?.saved_albums ?? 0,
-    spotify_followed_artists: spotify?.followed_artists ?? 0,
-    spotify_playlist_memberships: spotify?.playlist_memberships ?? 0,
+    spotify_profile_evidence: total("evidence_records"),
+    spotify_saved_tracks: total("saved_tracks"),
+    spotify_saved_albums: total("saved_albums"),
+    spotify_followed_artists: total("followed_artists"),
+    spotify_playlist_memberships: total("playlist_memberships"),
   };
 }

package/src/profile/profile-exploration.mjs

@@ -0,0 +1,84 @@
+// The limits below apply to delivery, never to the corpus being analyzed.
+export const PROFILE_SECTIONS = Object.freeze([
+  "overview", "history_artists", "history_tracks", "recent_artists", "recent_tracks",
+  "history_years", "history_releases", "saved_tracks", "playlist_tracks", "saved_albums",
+  "followed_artists", "provider_genres", "listener_preferences", "listener_avoids",
+  "provider_evidence", "apple_tracks", "apple_artists", "apple_genres",
+]);
+
+const normalize = (value) => String(value ?? "").normalize("NFKC").toLocaleLowerCase("und");
+
+export function profileExplorationInput(value = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value) ||
+    Object.keys(value).some((key) => !["section", "query", "offset", "limit", "sort"].includes(key))) {
+    throw new TypeError("Profile exploration arguments are invalid");
+  }
+  const { section = "overview", query = "", offset = 0, limit = 12, sort = "ranked" } = value;
+  if (!PROFILE_SECTIONS.includes(section) || typeof query !== "string" || query.length > 256 ||
+    !Number.isSafeInteger(offset) || offset < 0 || !Number.isInteger(limit) || limit < 1 || limit > 20 ||
+    !["ranked", "least_played", "recent"].includes(sort)) {
+    throw new TypeError("Profile exploration selection is invalid");
+  }
+  if (sort !== "ranked" && !["history_tracks", "history_artists", "recent_tracks", "recent_artists", "apple_tracks"].includes(section)) {
+    throw new TypeError("This profile section supports ranked order only");
+  }
+  if (sort === "recent" && section === "apple_tracks") {
+    throw new TypeError("Apple library play counts have no event chronology");
+  }
+  return { section, query: query.trim(), offset, limit, sort };
+}
+
+export function exploreProfileCatalog({ listening, apple, input }) {
+  const { section, query, offset, limit, sort } = profileExplorationInput(input);
+  const catalog = { ...listening?.sections, ...apple?.sections };
+  const all = catalog[section] ?? [];
+  const needle = normalize(query);
+  let matches = all.filter((row) => !needle || [
+    row.name, row.label, row.artist_credit, row.release, row.genre, row.year, row.evidence_kind,
+    row.source_label, row.period, row.text, row.playlist_name, ...(row.playlist_names ?? []),
+  ]
+    .some((text) => normalize(text).includes(needle)));
+  if (sort !== "ranked") {
+    matches = matches.map((row, index) => ({ row, index })).sort((left, right) => {
+      const order = sort === "least_played"
+        ? (left.row.play_count ?? Number.MAX_SAFE_INTEGER) - (right.row.play_count ?? Number.MAX_SAFE_INTEGER)
+        : String(right.row.last_played_at ?? "").localeCompare(String(left.row.last_played_at ?? ""));
+      return order || left.index - right.index;
+    }).map(({ row }) => row);
+  }
+  const items = matches.slice(offset, offset + limit).map((row) => {
+    if (!needle || !row.playlist_names) return row;
+    // Search every membership, and keep matching names in the bounded display.
+    return { ...row, playlist_names: [...row.playlist_names].sort((left, right) =>
+      Number(normalize(right).includes(needle)) - Number(normalize(left).includes(needle))) };
+  });
+  return structuredClone({
+    schema_version: "profile-exploration/1",
+    analysis_scope: "all_retained_supported_data",
+    section,
+    coverage: { ...listening?.coverage, ...apple?.coverage },
+    sources: listening?.sources ?? [],
+    context: listening?.context ?? {},
+    section_note: section.startsWith("recent_")
+      ? "Recent rankings use the retained-history reference date and recent_window_days, not today's date."
+      : section === "history_releases"
+        ? "Release depth includes releases meeting release_minimum_distinct_tracks. It does not prove album completion."
+        : section === "provider_genres"
+          ? "Named provider genre labels only. Unresolved labels remain in provider_evidence."
+          : "Complete selected evidence section, before search and pagination.",
+    sections: Object.entries(catalog).map(([name, rows]) => ({ name, total: rows.length })),
+    total: all.length,
+    matched: matches.length,
+    offset,
+    next_offset: offset + items.length < matches.length ? offset + items.length : null,
+    items,
+    limitations: [
+      "All retained supported records contribute before search, sorting, or pagination. A page is a selection, not the complete profile.",
+      "History describes attention; library membership, saved tracks, ratings, provider labels, and explicit listener choices are separate signals.",
+      "Spotify private-session plays are excluded from behavioral analysis. Superseded export overlaps are not counted again.",
+      "Apple Music is a library snapshot. Its aggregate play counts are not dated plays and must not be added to Spotify event totals.",
+      "Apple preferred-track counts exclude active listener Avoids. Original library membership, ratings, and love states remain visible.",
+      "Provider genre labels describe catalog metadata, not measured sound. Absence from an export is not a dislike.",
+    ],
+  });
+}

package/src/profile/recorded-measures.mjs

@@ -0,0 +1,24 @@
+// Sources record different measures for each play. Spotify's extended history
+// records how long a play lasted and, for most plays, whether it was skipped.
+// Spotify account data records only the length. Last.fm and most ListenBrainz
+// listens record neither, and an Apple library counts plays for some tracks
+// only. A measure that no play recorded is unknown: it never becomes a zero
+// that reads as no listening time, never skipped, or unplayed.
+
+/** Whether all, some or none of `total` items recorded a measure. */
+export function recordedShare(total, recorded, atLeast = 1) {
+  if (recorded >= total * atLeast) return "all";
+  return recorded === 0 ? "none" : "some";
+}
+
+/**
+ * What a set of plays recorded: its listening time and its skips, each "all",
+ * "some" or "none". `timedPlayCount` counts plays with a recorded length, and
+ * `skipKnownCount` counts plays that say whether they were skipped.
+ */
+export function recordedMeasures({ playCount, timedPlayCount, skipKnownCount }) {
+  return {
+    time: recordedShare(playCount, timedPlayCount),
+    skips: recordedShare(playCount, skipKnownCount),
+  };
+}

package/src/profile/spotify-archive-taste.mjs

@@ -235,10 +235,6 @@ export function createSpotifyListeningProfileProjection(listening, options) {
   return createListeningProfileProjection(listening, options);
 }
 
-export function createSpotifyArchiveProfileProjection(listening, options) {
-  return createSpotifyListeningProfileProjection(listening, options);
-}
-
 function validatedArchivePaths(value) {
   if (
     !Array.isArray(value) ||