Add start/end date filters to actor queries

Wire startDate/endDate through lexicons, PKL defs, TypeScript types, and
xrpc handlers to allow date-range filtering for actor albums, artists,
and songs.

Fix lexicon index mappings: swap artist getArtist/getArtistAlbums
entries, add feed.getFeed method, and reorder imports. Minor formatting
tweaks (scrobble likes filter, PKL whitespace).

apps/api/lexicons/actor/getActorAlbums.json

···
             "type": "integer",
             "description": "The offset for pagination",
             "minimum": 0
+          },
+          "startDate": {
+            "type": "string",
+            "description": "The start date to filter albums from (ISO 8601 format)",
+            "format": "datetime"
+          },
+          "endDate": {
+            "type": "string",
+            "description": "The end date to filter albums to (ISO 8601 format)",
+            "format": "datetime"
           }
         }
       },

apps/api/lexicons/actor/getActorArtists.json

···
             "type": "integer",
             "description": "The offset for pagination",
             "minimum": 0
+          },
+          "startDate": {
+            "type": "string",
+            "description": "The start date to filter albums from (ISO 8601 format)",
+            "format": "datetime"
+          },
+          "endDate": {
+            "type": "string",
+            "description": "The end date to filter albums to (ISO 8601 format)",
+            "format": "datetime"
           }
         }
       },

apps/api/lexicons/actor/getActorSongs.json

···
             "type": "integer",
             "description": "The offset for pagination",
             "minimum": 0
+          },
+          "startDate": {
+            "type": "string",
+            "description": "The start date to filter albums from (ISO 8601 format)",
+            "format": "datetime"
+          },
+          "endDate": {
+            "type": "string",
+            "description": "The end date to filter albums to (ISO 8601 format)",
+            "format": "datetime"
           }
         }
       },

apps/api/pkl/defs/actor/getActorAlbums.pkl

···
-amends  "../../schema/lexicon.pkl"
+amends "../../schema/lexicon.pkl"
 
 lexicon = 1
 id = "app.rocksky.actor.getActorAlbums"
···
           description = "The DID or handle of the actor"
           format = "at-identifier"
         }
-         ["limit"] = new IntegerType {
+        ["limit"] = new IntegerType {
           type = "integer"
           description = "The maximum number of albums to return"
           minimum = 1
···
           description = "The offset for pagination"
           minimum = 0
         }
+        ["startDate"] = new StringType {
+          description = "The start date to filter albums from (ISO 8601 format)"
+          format = "datetime"
+        }
+        ["endDate"] = new StringType {
+          description = "The end date to filter albums to (ISO 8601 format)"
+          format = "datetime"
+        }
       }
     }
     output {
···
       }
     }
   }
-}
+}

apps/api/pkl/defs/actor/getActorArtists.pkl

···
-amends  "../../schema/lexicon.pkl"
+amends "../../schema/lexicon.pkl"
 
 lexicon = 1
 id = "app.rocksky.actor.getActorArtists"
···
           description = "The DID or handle of the actor"
           format = "at-identifier"
         }
-         ["limit"] = new IntegerType {
+        ["limit"] = new IntegerType {
           type = "integer"
           description = "The maximum number of albums to return"
           minimum = 1
···
           description = "The offset for pagination"
           minimum = 0
         }
+        ["startDate"] = new StringType {
+          description = "The start date to filter albums from (ISO 8601 format)"
+          format = "datetime"
+        }
+        ["endDate"] = new StringType {
+          description = "The end date to filter albums to (ISO 8601 format)"
+          format = "datetime"
+        }
       }
     }
     output {
···
       }
     }
   }
-}
+}

apps/api/pkl/defs/actor/getActorSongs.pkl

···
-amends  "../../schema/lexicon.pkl"
+amends "../../schema/lexicon.pkl"
 
 lexicon = 1
 id = "app.rocksky.actor.getActorSongs"
···
           description = "The offset for pagination"
           minimum = 0
         }
+        ["startDate"] = new StringType {
+          description = "The start date to filter albums from (ISO 8601 format)"
+          format = "datetime"
+        }
+        ["endDate"] = new StringType {
+          description = "The end date to filter albums to (ISO 8601 format)"
+          format = "datetime"
+        }
       }
     }
-   output {
+    output {
       encoding = "application/json"
       schema = new ObjectType {
         type = "object"
···
       }
     }
   }
-}
+}

apps/api/src/lexicon/index.ts

···
 import type * as AppRockskyApikeyGetApikeys from "./types/app/rocksky/apikey/getApikeys";
 import type * as AppRockskyApikeyRemoveApikey from "./types/app/rocksky/apikey/removeApikey";
 import type * as AppRockskyApikeyUpdateApikey from "./types/app/rocksky/apikey/updateApikey";
-import type * as AppRockskyArtistGetArtistAlbums from "./types/app/rocksky/artist/getArtistAlbums";
 import type * as AppRockskyArtistGetArtist from "./types/app/rocksky/artist/getArtist";
+import type * as AppRockskyArtistGetArtistAlbums from "./types/app/rocksky/artist/getArtistAlbums";
 import type * as AppRockskyArtistGetArtistListeners from "./types/app/rocksky/artist/getArtistListeners";
 import type * as AppRockskyArtistGetArtists from "./types/app/rocksky/artist/getArtists";
 import type * as AppRockskyArtistGetArtistTracks from "./types/app/rocksky/artist/getArtistTracks";
···
 import type * as AppRockskyDropboxGetMetadata from "./types/app/rocksky/dropbox/getMetadata";
 import type * as AppRockskyDropboxGetTemporaryLink from "./types/app/rocksky/dropbox/getTemporaryLink";
 import type * as AppRockskyFeedDescribeFeedGenerator from "./types/app/rocksky/feed/describeFeedGenerator";
+import type * as AppRockskyFeedGetFeed from "./types/app/rocksky/feed/getFeed";
 import type * as AppRockskyFeedGetFeedGenerator from "./types/app/rocksky/feed/getFeedGenerator";
 import type * as AppRockskyFeedGetFeedGenerators from "./types/app/rocksky/feed/getFeedGenerators";
-import type * as AppRockskyFeedGetFeed from "./types/app/rocksky/feed/getFeed";
 import type * as AppRockskyFeedGetFeedSkeleton from "./types/app/rocksky/feed/getFeedSkeleton";
 import type * as AppRockskyFeedGetNowPlayings from "./types/app/rocksky/feed/getNowPlayings";
 import type * as AppRockskyFeedSearch from "./types/app/rocksky/feed/search";
···
 import type * as AppRockskyPlayerGetPlaybackQueue from "./types/app/rocksky/player/getPlaybackQueue";
 import type * as AppRockskyPlayerNext from "./types/app/rocksky/player/next";
 import type * as AppRockskyPlayerPause from "./types/app/rocksky/player/pause";
+import type * as AppRockskyPlayerPlay from "./types/app/rocksky/player/play";
 import type * as AppRockskyPlayerPlayDirectory from "./types/app/rocksky/player/playDirectory";
 import type * as AppRockskyPlayerPlayFile from "./types/app/rocksky/player/playFile";
-import type * as AppRockskyPlayerPlay from "./types/app/rocksky/player/play";
 import type * as AppRockskyPlayerPrevious from "./types/app/rocksky/player/previous";
 import type * as AppRockskyPlayerSeek from "./types/app/rocksky/player/seek";
 import type * as AppRockskyPlaylistCreatePlaylist from "./types/app/rocksky/playlist/createPlaylist";
···
     this._server = server;
   }
 
-  getArtistAlbums<AV extends AuthVerifier>(
+  getArtist<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyArtistGetArtistAlbums.Handler<ExtractAuth<AV>>,
-      AppRockskyArtistGetArtistAlbums.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyArtistGetArtist.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtist.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.artist.getArtistAlbums"; // @ts-ignore
+    const nsid = "app.rocksky.artist.getArtist"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getArtist<AV extends AuthVerifier>(
+  getArtistAlbums<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
-      AppRockskyArtistGetArtist.Handler<ExtractAuth<AV>>,
-      AppRockskyArtistGetArtist.HandlerReqCtx<ExtractAuth<AV>>
+      AppRockskyArtistGetArtistAlbums.Handler<ExtractAuth<AV>>,
+      AppRockskyArtistGetArtistAlbums.HandlerReqCtx<ExtractAuth<AV>>
     >,
   ) {
-    const nsid = "app.rocksky.artist.getArtist"; // @ts-ignore
+    const nsid = "app.rocksky.artist.getArtistAlbums"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 
···
     >,
   ) {
     const nsid = "app.rocksky.feed.describeFeedGenerator"; // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg);
+  }
+
+  getFeed<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyFeedGetFeed.Handler<ExtractAuth<AV>>,
+      AppRockskyFeedGetFeed.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = "app.rocksky.feed.getFeed"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 
···
     return this._server.xrpc.method(nsid, cfg);
   }
 
-  getFeed<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppRockskyFeedGetFeed.Handler<ExtractAuth<AV>>,
-      AppRockskyFeedGetFeed.HandlerReqCtx<ExtractAuth<AV>>
-    >,
-  ) {
-    const nsid = "app.rocksky.feed.getFeed"; // @ts-ignore
-    return this._server.xrpc.method(nsid, cfg);
-  }
-
   getFeedSkeleton<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
···
     return this._server.xrpc.method(nsid, cfg);
   }
 
+  play<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      AppRockskyPlayerPlay.Handler<ExtractAuth<AV>>,
+      AppRockskyPlayerPlay.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = "app.rocksky.player.play"; // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg);
+  }
+
   playDirectory<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
···
     >,
   ) {
     const nsid = "app.rocksky.player.playFile"; // @ts-ignore
-    return this._server.xrpc.method(nsid, cfg);
-  }
-
-  play<AV extends AuthVerifier>(
-    cfg: ConfigOf<
-      AV,
-      AppRockskyPlayerPlay.Handler<ExtractAuth<AV>>,
-      AppRockskyPlayerPlay.HandlerReqCtx<ExtractAuth<AV>>
-    >,
-  ) {
-    const nsid = "app.rocksky.player.play"; // @ts-ignore
     return this._server.xrpc.method(nsid, cfg);
   }
 

apps/api/src/lexicon/lexicons.ts

···
               description: "The offset for pagination",
               minimum: 0,
             },
+            startDate: {
+              type: "string",
+              description:
+                "The start date to filter albums from (ISO 8601 format)",
+              format: "datetime",
+            },
+            endDate: {
+              type: "string",
+              description: "The end date to filter albums to (ISO 8601 format)",
+              format: "datetime",
+            },
           },
         },
         output: {
···
               type: "integer",
               description: "The offset for pagination",
               minimum: 0,
+            },
+            startDate: {
+              type: "string",
+              description:
+                "The start date to filter albums from (ISO 8601 format)",
+              format: "datetime",
+            },
+            endDate: {
+              type: "string",
+              description: "The end date to filter albums to (ISO 8601 format)",
+              format: "datetime",
             },
           },
         },
···
               type: "integer",
               description: "The offset for pagination",
               minimum: 0,
+            },
+            startDate: {
+              type: "string",
+              description:
+                "The start date to filter albums from (ISO 8601 format)",
+              format: "datetime",
+            },
+            endDate: {
+              type: "string",
+              description: "The end date to filter albums to (ISO 8601 format)",
+              format: "datetime",
             },
           },
         },
···
       },
     },
   },
-  AppRockskyArtistGetArtistAlbums: {
+  AppRockskyArtistGetArtist: {
     lexicon: 1,
-    id: "app.rocksky.artist.getArtistAlbums",
+    id: "app.rocksky.artist.getArtist",
     defs: {
       main: {
         type: "query",
-        description: "Get artist's albums",
+        description: "Get artist details",
         parameters: {
           type: "params",
           required: ["uri"],
           properties: {
             uri: {
               type: "string",
-              description: "The URI of the artist to retrieve albums from",
+              description: "The URI of the artist to retrieve details from",
               format: "at-uri",
             },
           },
···
         output: {
           encoding: "application/json",
           schema: {
-            type: "object",
-            properties: {
-              albums: {
-                type: "array",
-                items: {
-                  type: "ref",
-                  ref: "lex:app.rocksky.album.defs#albumViewBasic",
-                },
-              },
-            },
+            type: "ref",
+            ref: "lex:app.rocksky.artist.defs#artistViewDetailed",
           },
         },
       },
     },
   },
-  AppRockskyArtistGetArtist: {
+  AppRockskyArtistGetArtistAlbums: {
     lexicon: 1,
-    id: "app.rocksky.artist.getArtist",
+    id: "app.rocksky.artist.getArtistAlbums",
     defs: {
       main: {
         type: "query",
-        description: "Get artist details",
+        description: "Get artist's albums",
         parameters: {
           type: "params",
           required: ["uri"],
           properties: {
             uri: {
               type: "string",
-              description: "The URI of the artist to retrieve details from",
+              description: "The URI of the artist to retrieve albums from",
               format: "at-uri",
             },
           },
···
         output: {
           encoding: "application/json",
           schema: {
-            type: "ref",
-            ref: "lex:app.rocksky.artist.defs#artistViewDetailed",
+            type: "object",
+            properties: {
+              albums: {
+                type: "array",
+                items: {
+                  type: "ref",
+                  ref: "lex:app.rocksky.album.defs#albumViewBasic",
+                },
+              },
+            },
           },
         },
       },
···
       },
     },
   },
-  AppRockskyFeedGetFeedGenerator: {
+  AppRockskyFeedGetFeed: {
     lexicon: 1,
-    id: "app.rocksky.feed.getFeedGenerator",
+    id: "app.rocksky.feed.getFeed",
     defs: {
       main: {
         type: "query",
-        description: "Get information about a feed generator",
+        description: "Get the feed by uri",
         parameters: {
           type: "params",
           required: ["feed"],
           properties: {
             feed: {
               type: "string",
-              description: "AT-URI of the feed generator record.",
+              description: "The feed URI.",
               format: "at-uri",
             },
+            limit: {
+              type: "integer",
+              description: "The maximum number of scrobbles to return",
+              minimum: 1,
+            },
+            cursor: {
+              type: "string",
+              description: "The cursor for pagination",
+            },
           },
         },
         output: {
           encoding: "application/json",
           schema: {
-            type: "object",
-            properties: {
-              view: {
-                type: "ref",
-                ref: "lex:app.rocksky.feed.defs#feedGeneratorView",
-              },
-            },
+            type: "ref",
+            ref: "lex:app.rocksky.feed.defs#feedView",
           },
         },
       },
     },
   },
-  AppRockskyFeedGetFeedGenerators: {
+  AppRockskyFeedGetFeedGenerator: {
     lexicon: 1,
-    id: "app.rocksky.feed.getFeedGenerators",
+    id: "app.rocksky.feed.getFeedGenerator",
     defs: {
       main: {
         type: "query",
-        description: "Get all feed generators",
+        description: "Get information about a feed generator",
         parameters: {
           type: "params",
+          required: ["feed"],
           properties: {
-            size: {
-              type: "integer",
-              description: "The maximum number of feed generators to return.",
-              minimum: 1,
+            feed: {
+              type: "string",
+              description: "AT-URI of the feed generator record.",
+              format: "at-uri",
             },
           },
         },
         output: {
           encoding: "application/json",
           schema: {
-            type: "ref",
-            ref: "lex:app.rocksky.feed.defs#feedGeneratorsView",
+            type: "object",
+            properties: {
+              view: {
+                type: "ref",
+                ref: "lex:app.rocksky.feed.defs#feedGeneratorView",
+              },
+            },
           },
         },
       },
     },
   },
-  AppRockskyFeedGetFeed: {
+  AppRockskyFeedGetFeedGenerators: {
     lexicon: 1,
-    id: "app.rocksky.feed.getFeed",
+    id: "app.rocksky.feed.getFeedGenerators",
     defs: {
       main: {
         type: "query",
-        description: "Get the feed by uri",
+        description: "Get all feed generators",
         parameters: {
           type: "params",
-          required: ["feed"],
           properties: {
-            feed: {
-              type: "string",
-              description: "The feed URI.",
-              format: "at-uri",
-            },
-            limit: {
+            size: {
               type: "integer",
-              description: "The maximum number of scrobbles to return",
+              description: "The maximum number of feed generators to return.",
               minimum: 1,
             },
-            cursor: {
-              type: "string",
-              description: "The cursor for pagination",
-            },
           },
         },
         output: {
           encoding: "application/json",
           schema: {
             type: "ref",
-            ref: "lex:app.rocksky.feed.defs#feedView",
+            ref: "lex:app.rocksky.feed.defs#feedGeneratorsView",
           },
         },
       },
···
       },
     },
   },
+  AppRockskyGraphFollow: {
+    lexicon: 1,
+    id: "app.rocksky.graph.follow",
+    defs: {
+      main: {
+        type: "record",
+        description:
+          "Record declaring a social 'follow' relationship of another account.",
+        key: "tid",
+        record: {
+          type: "object",
+          required: ["createdAt", "subject"],
+          properties: {
+            createdAt: {
+              type: "string",
+              format: "datetime",
+            },
+            subject: {
+              type: "string",
+              format: "did",
+            },
+            via: {
+              type: "ref",
+              ref: "lex:com.atproto.repo.strongRef",
+            },
+          },
+        },
+      },
+    },
+  },
   AppRockskyGraphFollowAccount: {
     lexicon: 1,
     id: "app.rocksky.graph.followAccount",
···
                 description:
                   "A cursor value to pass to subsequent calls to get the next page of results.",
               },
-            },
-          },
-        },
-      },
-    },
-  },
-  AppRockskyGraphFollow: {
-    lexicon: 1,
-    id: "app.rocksky.graph.follow",
-    defs: {
-      main: {
-        type: "record",
-        description:
-          "Record declaring a social 'follow' relationship of another account.",
-        key: "tid",
-        record: {
-          type: "object",
-          required: ["createdAt", "subject"],
-          properties: {
-            createdAt: {
-              type: "string",
-              format: "datetime",
-            },
-            subject: {
-              type: "string",
-              format: "did",
-            },
-            via: {
-              type: "ref",
-              ref: "lex:com.atproto.repo.strongRef",
             },
           },
         },
···
       },
     },
   },
+  AppRockskyPlayerPlay: {
+    lexicon: 1,
+    id: "app.rocksky.player.play",
+    defs: {
+      main: {
+        type: "procedure",
+        description: "Resume playback of the currently paused track",
+        parameters: {
+          type: "params",
+          properties: {
+            playerId: {
+              type: "string",
+            },
+          },
+        },
+      },
+    },
+  },
   AppRockskyPlayerPlayDirectory: {
     lexicon: 1,
     id: "app.rocksky.player.playDirectory",
···
               type: "string",
             },
             fileId: {
-              type: "string",
-            },
-          },
-        },
-      },
-    },
-  },
-  AppRockskyPlayerPlay: {
-    lexicon: 1,
-    id: "app.rocksky.player.play",
-    defs: {
-      main: {
-        type: "procedure",
-        description: "Resume playback of the currently paused track",
-        parameters: {
-          type: "params",
-          properties: {
-            playerId: {
               type: "string",
             },
           },
···
   AppRockskyApikeyUpdateApikey: "app.rocksky.apikey.updateApikey",
   AppRockskyArtist: "app.rocksky.artist",
   AppRockskyArtistDefs: "app.rocksky.artist.defs",
-  AppRockskyArtistGetArtistAlbums: "app.rocksky.artist.getArtistAlbums",
   AppRockskyArtistGetArtist: "app.rocksky.artist.getArtist",
+  AppRockskyArtistGetArtistAlbums: "app.rocksky.artist.getArtistAlbums",
   AppRockskyArtistGetArtistListeners: "app.rocksky.artist.getArtistListeners",
   AppRockskyArtistGetArtists: "app.rocksky.artist.getArtists",
   AppRockskyArtistGetArtistTracks: "app.rocksky.artist.getArtistTracks",
···
   AppRockskyFeedDefs: "app.rocksky.feed.defs",
   AppRockskyFeedDescribeFeedGenerator: "app.rocksky.feed.describeFeedGenerator",
   AppRockskyFeedGenerator: "app.rocksky.feed.generator",
+  AppRockskyFeedGetFeed: "app.rocksky.feed.getFeed",
   AppRockskyFeedGetFeedGenerator: "app.rocksky.feed.getFeedGenerator",
   AppRockskyFeedGetFeedGenerators: "app.rocksky.feed.getFeedGenerators",
-  AppRockskyFeedGetFeed: "app.rocksky.feed.getFeed",
   AppRockskyFeedGetFeedSkeleton: "app.rocksky.feed.getFeedSkeleton",
   AppRockskyFeedGetNowPlayings: "app.rocksky.feed.getNowPlayings",
   AppRockskyFeedSearch: "app.rocksky.feed.search",
···
   AppRockskyGoogledriveGetFile: "app.rocksky.googledrive.getFile",
   AppRockskyGoogledriveGetFiles: "app.rocksky.googledrive.getFiles",
   AppRockskyGraphDefs: "app.rocksky.graph.defs",
-  AppRockskyGraphFollowAccount: "app.rocksky.graph.followAccount",
   AppRockskyGraphFollow: "app.rocksky.graph.follow",
+  AppRockskyGraphFollowAccount: "app.rocksky.graph.followAccount",
   AppRockskyGraphGetFollowers: "app.rocksky.graph.getFollowers",
   AppRockskyGraphGetFollows: "app.rocksky.graph.getFollows",
   AppRockskyGraphGetKnownFollowers: "app.rocksky.graph.getKnownFollowers",
···
   AppRockskyPlayerGetPlaybackQueue: "app.rocksky.player.getPlaybackQueue",
   AppRockskyPlayerNext: "app.rocksky.player.next",
   AppRockskyPlayerPause: "app.rocksky.player.pause",
+  AppRockskyPlayerPlay: "app.rocksky.player.play",
   AppRockskyPlayerPlayDirectory: "app.rocksky.player.playDirectory",
   AppRockskyPlayerPlayFile: "app.rocksky.player.playFile",
-  AppRockskyPlayerPlay: "app.rocksky.player.play",
   AppRockskyPlayerPrevious: "app.rocksky.player.previous",
   AppRockskyPlayerSeek: "app.rocksky.player.seek",
   AppRockskyPlaylistCreatePlaylist: "app.rocksky.playlist.createPlaylist",

apps/api/src/lexicon/types/app/rocksky/actor/getActorAlbums.ts

···
   limit?: number;
   /** The offset for pagination */
   offset?: number;
+  /** The start date to filter albums from (ISO 8601 format) */
+  startDate?: string;
+  /** The end date to filter albums to (ISO 8601 format) */
+  endDate?: string;
 }
 
 export type InputSchema = undefined;

apps/api/src/lexicon/types/app/rocksky/actor/getActorArtists.ts

···
   limit?: number;
   /** The offset for pagination */
   offset?: number;
+  /** The start date to filter albums from (ISO 8601 format) */
+  startDate?: string;
+  /** The end date to filter albums to (ISO 8601 format) */
+  endDate?: string;
 }
 
 export type InputSchema = undefined;

apps/api/src/lexicon/types/app/rocksky/actor/getActorSongs.ts

···
   limit?: number;
   /** The offset for pagination */
   offset?: number;
+  /** The start date to filter albums from (ISO 8601 format) */
+  startDate?: string;
+  /** The end date to filter albums to (ISO 8601 format) */
+  endDate?: string;
 }
 
 export type InputSchema = undefined;

apps/api/src/xrpc/app/rocksky/actor/getActorAlbums.ts

···
           skip: params.offset || 0,
           take: params.limit || 10,
         },
+        start_date: params.startDate,
+        end_date: params.endDate,
       }),
     catch: (error) => new Error(`Failed to retrieve albums: ${error}`),
   });

apps/api/src/xrpc/app/rocksky/actor/getActorArtists.ts

···
           skip: params.offset || 0,
           take: params.limit || 10,
         },
+        start_date: params.startDate,
+        end_date: params.endDate,
       }),
     catch: (error) => new Error(`Failed to retrieve artists: ${error}`),
   });

apps/api/src/xrpc/app/rocksky/actor/getActorSongs.ts

···
           skip: params.offset || 0,
           take: params.limit || 10,
         },
+        start_date: params.startDate,
+        end_date: params.endDate,
       }),
     catch: (error) => new Error(`Failed to retrieve tracks: ${error}`),
   });

apps/api/src/xrpc/app/rocksky/scrobble/getScrobbles.ts

···
   const likesMap = new Map<string, { count: number; liked: boolean }>();
 
   for (const trackId of trackIds) {
-    const trackLikes = likes.filter(
-      (l) => l.loved_tracks.trackId === trackId,
-    );
+    const trackLikes = likes.filter((l) => l.loved_tracks.trackId === trackId);
     likesMap.set(trackId, {
       count: trackLikes.length,
       liked: trackLikes.some((l) => l.users?.did === currentUserDid),