update scrobble lexicon

apps/api/lexicons/scrobble/defs.json

···
         "sha256": {
           "type": "string",
           "description": "The SHA256 hash of the scrobble data."
+        },
+        "liked": {
+          "type": "boolean"
+        },
+        "likesCount": {
+          "type": "integer"
         }
       }
     },

apps/api/pkl/defs/scrobble/defs.pkl

···
         description = "The SHA256 hash of the scrobble data."
       }
 
+      ["liked"] = new BooleanType {
+        type = "boolean"
+      }
+
+      ["likesCount"] = new IntegerType {
+        type = "integer"
+      }
     }
   }
 
···
       }
     }
   }
-}
+}

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 AppRockskyArtistGetArtist from "./types/app/rocksky/artist/getArtist";
 import type * as AppRockskyArtistGetArtistAlbums from "./types/app/rocksky/artist/getArtistAlbums";
+import type * as AppRockskyArtistGetArtist from "./types/app/rocksky/artist/getArtist";
 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;
   }
 
-  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);
   }
 
-  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);
   }
 
···
     >,
   ) {
     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

···
       },
     },
   },
-  AppRockskyArtistGetArtist: {
-    lexicon: 1,
-    id: "app.rocksky.artist.getArtist",
-    defs: {
-      main: {
-        type: "query",
-        description: "Get artist details",
-        parameters: {
-          type: "params",
-          required: ["uri"],
-          properties: {
-            uri: {
-              type: "string",
-              description: "The URI of the artist to retrieve details from",
-              format: "at-uri",
-            },
-          },
-        },
-        output: {
-          encoding: "application/json",
-          schema: {
-            type: "ref",
-            ref: "lex:app.rocksky.artist.defs#artistViewDetailed",
-          },
-        },
-      },
-    },
-  },
   AppRockskyArtistGetArtistAlbums: {
     lexicon: 1,
     id: "app.rocksky.artist.getArtistAlbums",
···
                 },
               },
             },
+          },
+        },
+      },
+    },
+  },
+  AppRockskyArtistGetArtist: {
+    lexicon: 1,
+    id: "app.rocksky.artist.getArtist",
+    defs: {
+      main: {
+        type: "query",
+        description: "Get artist details",
+        parameters: {
+          type: "params",
+          required: ["uri"],
+          properties: {
+            uri: {
+              type: "string",
+              description: "The URI of the artist to retrieve details from",
+              format: "at-uri",
+            },
+          },
+        },
+        output: {
+          encoding: "application/json",
+          schema: {
+            type: "ref",
+            ref: "lex:app.rocksky.artist.defs#artistViewDetailed",
           },
         },
       },
···
       },
     },
   },
-  AppRockskyFeedGetFeed: {
-    lexicon: 1,
-    id: "app.rocksky.feed.getFeed",
-    defs: {
-      main: {
-        type: "query",
-        description: "Get the feed by uri",
-        parameters: {
-          type: "params",
-          required: ["feed"],
-          properties: {
-            feed: {
-              type: "string",
-              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: "ref",
-            ref: "lex:app.rocksky.feed.defs#feedView",
-          },
-        },
-      },
-    },
-  },
   AppRockskyFeedGetFeedGenerator: {
     lexicon: 1,
     id: "app.rocksky.feed.getFeedGenerator",
···
           schema: {
             type: "ref",
             ref: "lex:app.rocksky.feed.defs#feedGeneratorsView",
+          },
+        },
+      },
+    },
+  },
+  AppRockskyFeedGetFeed: {
+    lexicon: 1,
+    id: "app.rocksky.feed.getFeed",
+    defs: {
+      main: {
+        type: "query",
+        description: "Get the feed by uri",
+        parameters: {
+          type: "params",
+          required: ["feed"],
+          properties: {
+            feed: {
+              type: "string",
+              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: "ref",
+            ref: "lex:app.rocksky.feed.defs#feedView",
           },
         },
       },
···
       },
     },
   },
-  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",
···
       },
     },
   },
+  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",
+            },
+          },
+        },
+      },
+    },
+  },
   AppRockskyGraphGetFollowers: {
     lexicon: 1,
     id: "app.rocksky.graph.getFollowers",
···
       },
     },
   },
-  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",
···
       },
     },
   },
+  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",
+            },
+          },
+        },
+      },
+    },
+  },
   AppRockskyPlayerPrevious: {
     lexicon: 1,
     id: "app.rocksky.player.previous",
···
           sha256: {
             type: "string",
             description: "The SHA256 hash of the scrobble data.",
+          },
+          liked: {
+            type: "boolean",
+          },
+          likesCount: {
+            type: "integer",
           },
         },
       },
···
   AppRockskyApikeyUpdateApikey: "app.rocksky.apikey.updateApikey",
   AppRockskyArtist: "app.rocksky.artist",
   AppRockskyArtistDefs: "app.rocksky.artist.defs",
-  AppRockskyArtistGetArtist: "app.rocksky.artist.getArtist",
   AppRockskyArtistGetArtistAlbums: "app.rocksky.artist.getArtistAlbums",
+  AppRockskyArtistGetArtist: "app.rocksky.artist.getArtist",
   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",
-  AppRockskyGraphFollow: "app.rocksky.graph.follow",
   AppRockskyGraphFollowAccount: "app.rocksky.graph.followAccount",
+  AppRockskyGraphFollow: "app.rocksky.graph.follow",
   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/scrobble/defs.ts

···
   uri?: string;
   /** The SHA256 hash of the scrobble data. */
   sha256?: string;
+  liked?: boolean;
+  likesCount?: number;
   [k: string]: unknown;
 }
 

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

···
 import { deepCamelCaseKeys } from "lib";
 import users from "schema/users";
 import { eq, or } from "drizzle-orm";
-import { HandlerAuth } from "@atproto/xrpc-server";
+import type { HandlerAuth } from "@atproto/xrpc-server";
 
 export default function (server: Server, ctx: Context) {
   const getActorCompatibility = (params: QueryParams, auth: HandlerAuth) =>