@freqhole/api-client 0.2.15 → 0.3.1

package/src/blobCachePolicy.test.ts

@@ -0,0 +1,199 @@
+// tests for the blob cache policy.
+//
+// the transports back their blob fetches with the Cache API and, before
+// `BlobFetchOptions` existed, wrote every blob they fetched unconditionally.
+// that made the sync-to-local path store the same audio twice: once in the
+// api cache (as a side effect of getting the bytes) and once in the library.
+//
+// `cache: "skip"` must suppress the write on *every* branch of the
+// fallback chain, since which branch runs depends on what the peer supports.
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { WasmTransport, type MiddenNodeLike } from "./WasmTransport.js";
+
+// minimal in-memory Cache API double. only the three methods the transports
+// use (`open`, `match`, `put`) are implemented.
+class FakeCache {
+  readonly entries = new Map<string, Response>();
+
+  async match(key: string): Promise<Response | undefined> {
+    return this.entries.get(key);
+  }
+
+  async put(key: string, response: Response): Promise<void> {
+    this.entries.set(key, response);
+  }
+}
+
+let fakeCache: FakeCache;
+
+beforeEach(() => {
+  fakeCache = new FakeCache();
+  vi.stubGlobal("caches", {
+    open: async () => fakeCache,
+  });
+  // jsdom/node have no URL.createObjectURL
+  vi.stubGlobal("URL", {
+    ...URL,
+    createObjectURL: () => "blob:fake",
+    revokeObjectURL: () => {},
+  });
+});
+
+const BYTES = new Uint8Array([1, 2, 3, 4]);
+const BLAKE3 = "a".repeat(64);
+
+/** a node whose only working download path is the one named. lets each test
+ * force a specific branch of the fallback chain. */
+function nodeWith(branch: "verified" | "api_request" | "by_id" | "legacy"): MiddenNodeLike {
+  const node: Partial<MiddenNodeLike> = {
+    node_id: () => "test-node",
+    api_request: async () => {
+      if (branch !== "api_request") throw new Error("api_request unavailable");
+      return {
+        status: 200,
+        body: JSON.stringify({
+          success: true,
+          data: { data: btoa(String.fromCharCode(...BYTES)), mime: "audio/mpeg" },
+        }),
+      };
+    },
+  };
+
+  if (branch === "verified") {
+    node.download_verified_with_ensure = async () => BYTES;
+  }
+  if (branch === "by_id") {
+    node.download_verified_by_id = async () => [BYTES, BLAKE3];
+  }
+  if (branch === "legacy") {
+    node.fetch_blob = async () => ({
+      data: () => BYTES,
+      content_type: () => "audio/mpeg",
+      size: () => BYTES.length,
+    });
+  }
+  return node as MiddenNodeLike;
+}
+
+const BRANCHES = ["verified", "api_request", "by_id", "legacy"] as const;
+
+describe("WasmTransport.fetchBlob cache policy", () => {
+  describe("default (no options) still writes to the Cache API", () => {
+    for (const branch of BRANCHES) {
+      it(`writes on the ${branch} branch`, async () => {
+        const transport = new WasmTransport(nodeWith(branch), "peer");
+        // the verified branch is only tried when a blake3 is supplied, and
+        // by_id/legacy are only reached when it is not.
+        await transport.fetchBlob("blob-1", branch === "verified" ? BLAKE3 : undefined);
+        expect(fakeCache.entries.size).toBe(1);
+      });
+    }
+  });
+
+  describe('cache: "skip" suppresses the write', () => {
+    for (const branch of BRANCHES) {
+      it(`does not write on the ${branch} branch`, async () => {
+        const transport = new WasmTransport(nodeWith(branch), "peer");
+        await transport.fetchBlob("blob-1", branch === "verified" ? BLAKE3 : undefined, {
+          cache: "skip",
+        });
+        expect(fakeCache.entries.size).toBe(0);
+      });
+    }
+  });
+
+  it("still returns the bytes when the write is skipped", async () => {
+    const transport = new WasmTransport(nodeWith("verified"), "peer");
+    const result = await transport.fetchBlob("blob-1", BLAKE3, { cache: "skip" });
+    expect(Array.from(result.data)).toEqual(Array.from(BYTES));
+  });
+
+  it('reads an existing cache entry even with cache: "skip"', async () => {
+    // "skip" suppresses writes only - bytes already cached are still served,
+    // so a sync does not re-fetch something already sitting in the cache.
+    await fakeCache.put(
+      "https://blob.local/blob-1",
+      new Response(BYTES, { headers: { "Content-Type": "audio/mpeg" } }),
+    );
+    const node = nodeWith("verified");
+    const spy = vi.fn(async () => BYTES);
+    node.download_verified_with_ensure = spy;
+
+    const transport = new WasmTransport(node, "peer");
+    const result = await transport.fetchBlob("blob-1", BLAKE3, { cache: "skip" });
+
+    expect(Array.from(result.data)).toEqual(Array.from(BYTES));
+    expect(spy).not.toHaveBeenCalled();
+  });
+});
+
+describe("WasmTransport.fetchBlobWithProgress cache policy", () => {
+  describe("default (no options) still writes to the Cache API", () => {
+    for (const branch of BRANCHES) {
+      it(`writes on the ${branch} branch`, async () => {
+        const transport = new WasmTransport(nodeWith(branch), "peer");
+        await transport.fetchBlobWithProgress(
+          "blob-1",
+          () => {},
+          branch === "verified" ? BLAKE3 : undefined,
+        );
+        expect(fakeCache.entries.size).toBe(1);
+      });
+    }
+  });
+
+  describe('cache: "skip" suppresses the write', () => {
+    for (const branch of BRANCHES) {
+      it(`does not write on the ${branch} branch`, async () => {
+        const transport = new WasmTransport(nodeWith(branch), "peer");
+        await transport.fetchBlobWithProgress(
+          "blob-1",
+          () => {},
+          branch === "verified" ? BLAKE3 : undefined,
+          undefined,
+          undefined,
+          { cache: "skip" },
+        );
+        expect(fakeCache.entries.size).toBe(0);
+      });
+    }
+  });
+
+  it("still reports progress when the write is skipped", async () => {
+    const transport = new WasmTransport(nodeWith("verified"), "peer");
+    const onProgress = vi.fn();
+    await transport.fetchBlobWithProgress("blob-1", onProgress, BLAKE3, undefined, undefined, {
+      cache: "skip",
+    });
+    expect(onProgress).toHaveBeenCalled();
+  });
+});
+
+describe("WasmTransport.getBlobUrl* cache policy", () => {
+  it('getBlobUrl with cache: "skip" does not write', async () => {
+    const transport = new WasmTransport(nodeWith("verified"), "peer");
+    await transport.getBlobUrl("blob-1", BLAKE3, { cache: "skip" });
+    expect(fakeCache.entries.size).toBe(0);
+  });
+
+  it("getBlobUrl writes by default", async () => {
+    const transport = new WasmTransport(nodeWith("verified"), "peer");
+    await transport.getBlobUrl("blob-1", BLAKE3);
+    expect(fakeCache.entries.size).toBe(1);
+  });
+
+  it('getBlobUrlWithProgress with cache: "skip" does not write', async () => {
+    const transport = new WasmTransport(nodeWith("verified"), "peer");
+    await transport.getBlobUrlWithProgress("blob-1", () => {}, BLAKE3, undefined, undefined, {
+      cache: "skip",
+    });
+    expect(fakeCache.entries.size).toBe(0);
+  });
+
+  it("getBlobUrlWithProgress writes by default", async () => {
+    const transport = new WasmTransport(nodeWith("verified"), "peer");
+    await transport.getBlobUrlWithProgress("blob-1", () => {}, BLAKE3);
+    expect(fakeCache.entries.size).toBe(1);
+  });
+});

package/src/codegen/routes.ts

@@ -61,6 +61,31 @@ export const routes = {
     update_username: { method: 'POST', path: '/api/auth/profile/update-username', req: s.UpdateUsernameRequestSchema, resp: s.WhoAmIResponseSchema, auth: { type: 'authenticated' } as const },
     whoami: { method: 'GET', path: '/api/auth/whoami', req: null, resp: s.WhoAmIResponseSchema, auth: { type: 'authenticated' } as const },
   },
+  entities: {
+    add_entities_tags: { method: 'POST', path: '/api/entities/tags/add', req: s.AddEntitiesTagsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    add_entity_taxon: { method: 'POST', path: '/api/entities/taxons/add', req: s.AddEntityTaxonRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    add_entity_url: { method: 'POST', path: '/api/entities/urls/add', req: s.AddEntityUrlRequestSchema, resp: s.EntityUrlSchema, auth: { type: 'role', role: 'admin' } as const },
+    add_playlist_item: { method: 'POST', path: '/api/entities/playlists/items/add', req: s.AddPlaylistItemRequestSchema, resp: s.PlaylistItemSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    add_playlist_items: { method: 'POST', path: '/api/entities/playlists/items/add-bulk', req: s.AddPlaylistItemsRequestSchema, resp: s.PlaylistItemSchema.array(), auth: { type: 'owner_or', role: 'admin' } as const },
+    get_entities_tags: { method: 'POST', path: '/api/entities/tags/get', req: s.GetEntitiesTagsRequestSchema, resp: s.EntityTagCountSchema.array(), auth: { type: 'authenticated' } as const },
+    get_entity_images: { method: 'POST', path: '/api/entities/images/get', req: s.GetEntityImagesRequestSchema, resp: s.ImageMetadataSchema.array(), auth: { type: 'authenticated' } as const },
+    get_entity_taxons: { method: 'POST', path: '/api/entities/taxons/get', req: s.GetEntityTaxonsRequestSchema, resp: s.EntityTaxonLinkSchema.array(), auth: { type: 'authenticated' } as const },
+    get_entity_urls: { method: 'POST', path: '/api/entities/urls/get', req: s.GetEntityUrlsRequestSchema, resp: s.EntityUrlSchema.array(), auth: { type: 'authenticated' } as const },
+    get_favorite_status_bulk: { method: 'POST', path: '/api/entities/favorites/status-bulk', req: s.GetFavoriteStatusBulkRequestSchema, resp: s.FavoriteStatusItemSchema.array(), auth: { type: 'authenticated' } as const },
+    get_rating_stats: { method: 'POST', path: '/api/entities/ratings/stats', req: s.GetRatingStatsRequestSchema, resp: s.RatingStatsSchema, auth: { type: 'authenticated' } as const },
+    get_rating_status_bulk: { method: 'POST', path: '/api/entities/ratings/status-bulk', req: s.GetRatingStatusBulkRequestSchema, resp: s.RatingStatusItemSchema.array(), auth: { type: 'authenticated' } as const },
+    list_entity_type_tags: { method: 'POST', path: '/api/entities/tags/list-by-type', req: s.ListEntityTypeTagsRequestSchema, resp: s.EntityTagCountSchema.array(), auth: { type: 'authenticated' } as const },
+    list_playlist_items: { method: 'POST', path: '/api/entities/playlists/items/list', req: s.ListPlaylistItemsRequestSchema, resp: s.PlaylistItemSchema.array(), auth: { type: 'authenticated' } as const },
+    remove_entities_tags: { method: 'POST', path: '/api/entities/tags/remove', req: s.RemoveEntitiesTagsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    remove_entity_taxon: { method: 'POST', path: '/api/entities/taxons/remove', req: s.RemoveEntityTaxonRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    remove_entity_url: { method: 'POST', path: '/api/entities/urls/remove', req: s.RemoveEntityUrlRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    remove_playlist_item: { method: 'POST', path: '/api/entities/playlists/items/remove', req: s.RemovePlaylistItemRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    remove_playlist_items: { method: 'POST', path: '/api/entities/playlists/items/remove-bulk', req: s.RemovePlaylistItemsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    remove_rating: { method: 'POST', path: '/api/entities/ratings/remove', req: s.RemoveRatingRequestSchema, resp: s.RemoveRatingResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    reorder_playlist_items: { method: 'POST', path: '/api/entities/playlists/items/reorder', req: s.ReorderPlaylistItemsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    set_favorite: { method: 'POST', path: '/api/entities/favorites/set', req: s.SetFavoriteRequestSchema, resp: s.SetFavoriteResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    set_rating: { method: 'POST', path: '/api/entities/ratings/set', req: s.SetRatingRequestSchema, resp: s.SetRatingResponseSchema, auth: { type: 'role', role: 'member' } as const },
+  },
   music: {
     activity_feed: { method: 'POST', path: '/api/analytics/feed', req: s.FeedRequestSchema, resp: s.FeedResponseSchema, auth: { type: 'authenticated' } as const },
     add_album_taxon: { method: 'POST', path: '/api/taxonomy/album-links/add', req: s.AddAlbumTaxonRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
@@ -84,7 +109,7 @@ export const routes = {
     confirm_mb_match: { method: 'POST', path: '/api/albums/mb-confirm', req: s.ConfirmMbMatchRequestSchema, resp: s.MbMatchActionResponseSchema, auth: { type: 'role', role: 'admin' } as const },
     create_artist: { method: 'POST', path: '/api/music/artists', req: s.CreateArtistRequestSchema, resp: s.ArtistSchema, auth: { type: 'role', role: 'admin' } as const },
     create_fetch_job: { method: 'POST', path: '/api/music/fetch', req: s.FetchMediaParamsSchema, resp: s.JobResponseSchema, auth: { type: 'role', role: 'member' } as const },
-    create_listen_session: { method: 'POST', path: '/api/analytics/sessions', req: s.CreateListenSessionRequestSchema, resp: s.ListenSessionSchema, auth: { type: 'role', role: 'member' } as const },
+    create_playback_session: { method: 'POST', path: '/api/analytics/sessions', req: s.CreatePlaybackSessionRequestSchema, resp: s.PlaybackSessionSchema, auth: { type: 'authenticated' } as const },
     create_playlist: { method: 'POST', path: '/api/music/playlists', req: s.CreatePlaylistRequestSchema, resp: s.PlaylistSchema, auth: { type: 'role', role: 'member' } as const },
     create_precheck_fetch_job: { method: 'POST', path: '/api/music/fetch/precheck', req: s.PreCheckFetchParamsSchema, resp: s.JobResponseSchema, auth: { type: 'role', role: 'member' } as const },
     create_taxon: { method: 'POST', path: '/api/taxonomy/taxons/create', req: s.CreateTaxonRequestSchema, resp: s.TaxonSchema, auth: { type: 'role', role: 'admin' } as const },
@@ -93,7 +118,7 @@ export const routes = {
     delete_artist: { method: 'POST', path: '/api/artists/delete', req: s.DeleteArtistRequestSchema, resp: s.DeleteArtistResponseSchema, auth: { type: 'role', role: 'admin' } as const },
     delete_feed_event: { method: 'POST', path: '/api/analytics/feed/delete', req: s.DeleteFeedEventRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
     delete_image: { method: 'POST', path: '/api/music/images/delete', req: s.DeleteImageRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
-    delete_listen_session: { method: 'POST', path: '/api/analytics/sessions/delete', req: s.DeleteListenSessionRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    delete_playback_session: { method: 'POST', path: '/api/analytics/sessions/delete', req: s.DeletePlaybackSessionRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
     delete_playlist: { method: 'POST', path: '/api/playlists/delete', req: s.DeletePlaylistRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
     delete_song: { method: 'POST', path: '/api/songs/delete', req: s.DeleteSongRequestSchema, resp: s.DeleteSongResponseSchema, auth: { type: 'role', role: 'admin' } as const },
     delete_tag: { method: 'POST', path: '/api/tags/delete', req: s.DeleteTagRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
@@ -118,12 +143,11 @@ export const routes = {
     get_enrichment_progress: { method: 'POST', path: '/api/music/albums/enrichment/progress', req: s.GetEnrichmentProgressRequestSchema, resp: s.GetEnrichmentProgressResponseSchema, auth: { type: 'role', role: 'admin' } as const },
     get_fetch_job: { method: 'POST', path: '/api/music/fetch/status', req: s.GetJobRequestSchema, resp: s.JobResponseSchema, auth: { type: 'authenticated' } as const },
     get_job_status: { method: 'POST', path: '/api/jobs/status', req: s.GetJobsStatusRequestSchema, resp: s.GetJobsStatusResponseSchema, auth: { type: 'authenticated' } as const },
-    get_listen_session: { method: 'POST', path: '/api/analytics/sessions/get', req: s.GetListenSessionRequestSchema, resp: s.ListenSessionSchema, auth: { type: 'authenticated' } as const },
     get_musicbrainz_release: { method: 'POST', path: '/api/musicbrainz/release', req: s.GetReleaseRequestSchema, resp: s.MbReleaseDetailSchema, auth: { type: 'role', role: 'admin' } as const },
+    get_playback_session: { method: 'POST', path: '/api/analytics/sessions/get', req: s.GetPlaybackSessionRequestSchema, resp: s.PlaybackSessionSchema, auth: { type: 'authenticated' } as const },
     get_playlist_by_id: { method: 'POST', path: '/api/music/playlists/get', req: s.GetPlaylistRequestSchema, resp: s.PlaylistSchema, auth: { type: 'authenticated' } as const },
     get_playlist_etag: { method: 'POST', path: '/api/music/playlists/etag', req: s.GetPlaylistRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
     get_playlist_images: { method: 'POST', path: '/api/playlists/images', req: s.GetPlaylistRequestSchema, resp: z.string().array(), auth: { type: 'authenticated' } as const },
-    get_rating_stats: { method: 'POST', path: '/api/ratings/stats', req: s.GetRatingStatsRequestSchema, resp: s.RatingStatsSchema, auth: { type: 'authenticated' } as const },
     get_tag: { method: 'POST', path: '/api/tags/get', req: s.GetTagRequestSchema, resp: s.TagSchema, auth: { type: 'authenticated' } as const },
     get_taxon: { method: 'POST', path: '/api/taxonomy/taxons/get', req: s.GetTaxonRequestSchema, resp: s.TaxonSchema, auth: { type: 'authenticated' } as const },
     get_taxon_ancestors: { method: 'POST', path: '/api/taxonomy/taxons/ancestors', req: s.GetTaxonRequestSchema, resp: s.TaxonRefSchema.array(), auth: { type: 'authenticated' } as const },
@@ -135,13 +159,13 @@ export const routes = {
     list_beloved: { method: 'POST', path: '/api/favorites/beloved', req: s.ListBelovedRequestSchema, resp: s.ListBelovedResponseSchema, auth: { type: 'authenticated' } as const },
     list_favorites: { method: 'POST', path: '/api/favorites/list', req: s.ListFavoritesRequestSchema, resp: s.ListFavoritesResponseSchema, auth: { type: 'role', role: 'member' } as const },
     list_jobs: { method: 'POST', path: '/api/jobs/list', req: s.ListJobsRequestSchema, resp: s.JobResponseSchema.array(), auth: { type: 'authenticated' } as const },
-    list_listen_sessions: { method: 'POST', path: '/api/analytics/sessions/list', req: s.ListListenSessionsRequestSchema, resp: s.ListListenSessionsResponseSchema, auth: { type: 'authenticated' } as const },
     list_pending_import_review: { method: 'POST', path: '/api/music/import/pending', req: s.ListPendingReviewRequestSchema, resp: s.PendingReviewSessionSchema.array(), auth: { type: 'authenticated' } as const },
+    list_playback_sessions: { method: 'POST', path: '/api/analytics/sessions/list', req: s.ListPlaybackSessionsRequestSchema, resp: s.ListPlaybackSessionsResponseSchema, auth: { type: 'authenticated' } as const },
     list_playlists: { method: 'POST', path: '/api/music/playlists/list', req: s.QueryParamsSchema, resp: s.PlaylistsQueryResultSchema, auth: { type: 'authenticated' } as const },
     list_related_artists: { method: 'POST', path: '/api/related-artists/list', req: s.ListRelatedArtistsRequestSchema, resp: s.ListRelatedArtistsResponseSchema, auth: { type: 'authenticated' } as const },
     list_related_artists_batch: { method: 'POST', path: '/api/related-artists/list-batch', req: s.ListRelatedArtistsBatchRequestSchema, resp: s.ListRelatedArtistsBatchResponseSchema, auth: { type: 'authenticated' } as const },
     list_tags: { method: 'GET', path: '/api/tags/list', req: null, resp: s.TagSchema.array(), auth: { type: 'authenticated' } as const },
-    list_taxon_kinds: { method: 'POST', path: '/api/taxonomy/kinds/list', req: null, resp: s.TaxonKindSchema.array(), auth: { type: 'authenticated' } as const },
+    list_taxon_kinds: { method: 'POST', path: '/api/taxonomy/kinds/list', req: s.ListTaxonKindsRequestSchema, resp: s.TaxonKindSchema.array(), auth: { type: 'authenticated' } as const },
     list_taxon_parents_for_kind: { method: 'POST', path: '/api/taxonomy/parents/list-by-kind', req: s.ListTaxonParentsForKindRequestSchema, resp: s.TaxonParentEdgeSchema.array(), auth: { type: 'authenticated' } as const },
     list_taxons_by_kind: { method: 'POST', path: '/api/taxonomy/taxons/list-by-kind', req: s.ListTaxonsByKindRequestSchema, resp: s.TaxonSchema.array(), auth: { type: 'authenticated' } as const },
     listening_history: { method: 'POST', path: '/api/analytics/listening-history', req: s.ListeningHistoryRequestSchema, resp: s.ListeningHistoryResponseSchema, auth: { type: 'authenticated' } as const },
@@ -163,12 +187,12 @@ export const routes = {
     query_taxons: { method: 'POST', path: '/api/taxonomy/taxons/query', req: s.QueryTaxonsRequestSchema, resp: s.TaxonsQueryResultSchema, auth: { type: 'authenticated' } as const },
     recent_songs: { method: 'POST', path: '/api/songs/recent', req: s.RecentSongsRequestSchema, resp: s.SongSchema.array(), auth: { type: 'authenticated' } as const },
     recently_added_albums: { method: 'POST', path: '/api/music/relations/recently-added-albums', req: s.RecentlyAddedAlbumsRequestSchema, resp: s.RecentlyAddedAlbumsResponseSchema, auth: { type: 'authenticated' } as const },
-    record_play: { method: 'POST', path: '/api/analytics/play', req: s.RecordPlayRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    record_play: { method: 'POST', path: '/api/analytics/play', req: s.RecordPlayRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
     record_playlist_play: { method: 'POST', path: '/api/playlists/record-play', req: s.GetPlaylistRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
+    record_video_play: { method: 'POST', path: '/api/analytics/video-play', req: s.RecordVideoPlayRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
     reject_mb_match: { method: 'POST', path: '/api/albums/mb-reject', req: s.RejectMbMatchRequestSchema, resp: s.MbMatchActionResponseSchema, auth: { type: 'role', role: 'admin' } as const },
     remove_album_taxon: { method: 'POST', path: '/api/taxonomy/album-links/remove', req: s.RemoveAlbumTaxonRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
     remove_albums_tags: { method: 'POST', path: '/api/tags/albums/remove', req: s.RemoveAlbumsTagsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
-    remove_rating: { method: 'POST', path: '/api/ratings/remove', req: s.RemoveRatingRequestSchema, resp: s.RemoveRatingResponseSchema, auth: { type: 'role', role: 'member' } as const },
     remove_songs_from_playlist: { method: 'POST', path: '/api/playlists/remove-songs', req: s.RemoveSongsFromPlaylistRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
     remove_taxon_parent: { method: 'POST', path: '/api/taxonomy/parents/remove', req: s.RemoveTaxonParentRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
     reorder_playlist_songs: { method: 'POST', path: '/api/playlists/reorder', req: s.ReorderPlaylistSongsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner_or', role: 'admin' } as const },
@@ -177,10 +201,8 @@ export const routes = {
     search: { method: 'POST', path: '/api/music/search', req: s.SearchRequestSchema, resp: s.SearchResponseSchema, auth: { type: 'authenticated' } as const },
     search_musicbrainz_releases: { method: 'POST', path: '/api/musicbrainz/search/releases', req: s.SearchReleasesRequestSchema, resp: s.MbSearchReleasesResponseSchema, auth: { type: 'role', role: 'admin' } as const },
     set_album_taxons: { method: 'POST', path: '/api/taxonomy/album-links/set', req: s.SetAlbumTaxonsRequestSchema, resp: s.AlbumTaxonLinkSchema.array(), auth: { type: 'role', role: 'admin' } as const },
-    set_favorite: { method: 'POST', path: '/api/favorites/set', req: s.SetFavoriteRequestSchema, resp: s.SetFavoriteResponseSchema, auth: { type: 'role', role: 'member' } as const },
     set_mb_lookup_status: { method: 'POST', path: '/api/albums/set-mb-lookup-status', req: s.SetMbLookupStatusRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
     set_primary_image: { method: 'POST', path: '/api/music/images/set-primary', req: s.SetPrimaryImageRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
-    set_rating: { method: 'POST', path: '/api/ratings/set', req: s.SetRatingRequestSchema, resp: s.SetRatingResponseSchema, auth: { type: 'role', role: 'member' } as const },
     set_related_artist_bandcamp: { method: 'POST', path: '/api/related-artists/set-bandcamp', req: s.SetRelatedArtistBandcampRequestSchema, resp: s.RelatedArtistApiSchema, auth: { type: 'role', role: 'admin' } as const },
     set_scalar_attribute: { method: 'POST', path: '/api/taxonomy/scalars/set', req: s.SetScalarAttributeRequestSchema, resp: s.ScalarAttributeSchema, auth: { type: 'role', role: 'admin' } as const },
     set_taxon_color: { method: 'POST', path: '/api/taxonomy/taxons/set-color', req: s.SetTaxonColorRequestSchema, resp: s.TaxonSchema, auth: { type: 'role', role: 'admin' } as const },
@@ -201,13 +223,53 @@ export const routes = {
     update_album: { method: 'POST', path: '/api/albums/update', req: s.UpdateAlbumRequestSchema, resp: s.AlbumSchema, auth: { type: 'role', role: 'admin' } as const },
     update_artist: { method: 'POST', path: '/api/artists/update', req: s.UpdateArtistRequestSchema, resp: s.ArtistSchema, auth: { type: 'role', role: 'admin' } as const },
     update_artist_metadata: { method: 'POST', path: '/api/artists/update-metadata', req: s.UpdateArtistMetadataRequestSchema, resp: s.UpdateArtistMetadataResponseSchema, auth: { type: 'role', role: 'admin' } as const },
-    update_listen_session_progress: { method: 'POST', path: '/api/analytics/sessions/progress', req: s.UpdateListenSessionProgressRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner' } as const },
-    update_listen_session_songs: { method: 'POST', path: '/api/analytics/sessions/songs', req: s.UpdateListenSessionSongsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner' } as const },
-    update_listen_session_status: { method: 'POST', path: '/api/analytics/sessions/status', req: s.UpdateListenSessionStatusRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner' } as const },
+    update_playback_session_items: { method: 'POST', path: '/api/analytics/sessions/items', req: s.UpdatePlaybackSessionItemsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner' } as const },
+    update_playback_session_progress: { method: 'POST', path: '/api/analytics/sessions/progress', req: s.UpdatePlaybackSessionProgressRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner' } as const },
+    update_playback_session_status: { method: 'POST', path: '/api/analytics/sessions/status', req: s.UpdatePlaybackSessionStatusRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'owner' } as const },
     update_playlist: { method: 'POST', path: '/api/playlists/update', req: s.UpdatePlaylistRequestSchema, resp: s.PlaylistSchema, auth: { type: 'owner_or', role: 'admin' } as const },
     update_songs: { method: 'POST', path: '/api/songs/update', req: s.UpdateSongsRequestSchema, resp: s.UpdateSongsResultSchema, auth: { type: 'role', role: 'admin' } as const },
     upload_image: { method: 'POST', path: '/api/upload/image', req: null, resp: s.ImageUploadResponseSchema, auth: { type: 'role', role: 'member' } as const },
     upload_music: { method: 'POST', path: '/api/upload/music', req: null, resp: s.MusicUploadResponseSchema, auth: { type: 'role', role: 'member' } as const },
     upload_music_by_blake3: { method: 'POST', path: '/api/upload/music-by-blake3', req: s.UploadMusicByBlake3RequestSchema, resp: s.MusicUploadResponseSchema, auth: { type: 'role', role: 'member' } as const },
   },
+  video: {
+    bulk_delete_videos: { method: 'POST', path: '/api/video/videos/bulk-delete', req: s.BulkDeleteVideosRequestSchema, resp: s.BulkDeleteVideosResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    create_video: { method: 'POST', path: '/api/video/videos', req: s.CreateVideoRequestSchema, resp: s.VideoSchema, auth: { type: 'role', role: 'admin' } as const },
+    create_video_season: { method: 'POST', path: '/api/video/seasons', req: s.CreateVideoSeasonRequestSchema, resp: s.VideoSeasonSchema, auth: { type: 'role', role: 'admin' } as const },
+    create_video_series: { method: 'POST', path: '/api/video/series', req: s.CreateVideoSeriesRequestSchema, resp: s.VideoSeriesSchema, auth: { type: 'role', role: 'admin' } as const },
+    delete_video: { method: 'POST', path: '/api/video/videos/delete', req: s.DeleteVideoRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    delete_video_rendition: { method: 'POST', path: '/api/video/videos/renditions/delete', req: s.DeleteVideoRenditionRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    delete_video_season: { method: 'POST', path: '/api/video/seasons/delete', req: s.DeleteVideoSeasonRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    delete_video_series: { method: 'POST', path: '/api/video/series/delete', req: s.DeleteVideoSeriesRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'role', role: 'admin' } as const },
+    get_playback_progress: { method: 'POST', path: '/api/video/progress/get', req: s.GetPlaybackProgressRequestSchema, resp: s.PlaybackProgressSchema.array(), auth: { type: 'authenticated' } as const },
+    get_video: { method: 'POST', path: '/api/video/videos/get', req: s.GetVideoRequestSchema, resp: s.VideoSchema, auth: { type: 'authenticated' } as const },
+    get_video_renditions: { method: 'POST', path: '/api/video/videos/renditions', req: s.GetVideoRenditionsRequestSchema, resp: s.VideoRenditionSchema.array(), auth: { type: 'authenticated' } as const },
+    get_video_season: { method: 'POST', path: '/api/video/seasons/get', req: s.GetVideoSeasonRequestSchema, resp: s.VideoSeasonSchema, auth: { type: 'authenticated' } as const },
+    get_video_series: { method: 'POST', path: '/api/video/series/get', req: s.GetVideoSeriesRequestSchema, resp: s.VideoSeriesSchema, auth: { type: 'authenticated' } as const },
+    get_video_series_detail: { method: 'POST', path: '/api/video/series/detail', req: s.GetVideoSeriesRequestSchema, resp: s.SeriesDetailSchema, auth: { type: 'authenticated' } as const },
+    get_video_with_metadata: { method: 'POST', path: '/api/video/videos/get-with-metadata', req: s.GetVideoRequestSchema, resp: s.VideoWithMetadataSchema, auth: { type: 'authenticated' } as const },
+    list_pending_video_import_review: { method: 'POST', path: '/api/video/import/pending', req: s.ListPendingVideoReviewRequestSchema, resp: s.PendingVideoReviewSessionSchema.array(), auth: { type: 'authenticated' } as const },
+    list_playback_progress: { method: 'POST', path: '/api/video/progress/list', req: s.ListPlaybackProgressRequestSchema, resp: s.PlaybackProgressSchema.array(), auth: { type: 'authenticated' } as const },
+    list_video_seasons: { method: 'POST', path: '/api/video/seasons/list', req: s.ListVideoSeasonsRequestSchema, resp: s.VideoSeasonSchema.array(), auth: { type: 'authenticated' } as const },
+    list_video_series: { method: 'POST', path: '/api/video/series/list', req: s.ListVideoSeriesRequestSchema, resp: s.VideoSeriesSchema.array(), auth: { type: 'authenticated' } as const },
+    list_videos_by_season: { method: 'POST', path: '/api/video/videos/list-by-season', req: s.ListVideosBySeasonRequestSchema, resp: s.VideoSchema.array(), auth: { type: 'authenticated' } as const },
+    list_videos_by_series: { method: 'POST', path: '/api/video/videos/list-by-series', req: s.ListVideosBySeriesRequestSchema, resp: s.VideoSchema.array(), auth: { type: 'authenticated' } as const },
+    list_videos_unattached: { method: 'POST', path: '/api/video/videos/list-unattached', req: s.ListVideosUnattachedRequestSchema, resp: s.VideoSchema.array(), auth: { type: 'authenticated' } as const },
+    mark_video_group_reviewed: { method: 'POST', path: '/api/video/import/mark-reviewed', req: s.MarkVideoGroupReviewedRequestSchema, resp: s.VideoImportReviewOkSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    move_video_review: { method: 'POST', path: '/api/video/import/move-video', req: s.MoveVideoReviewRequestSchema, resp: s.VideoImportReviewOkSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    patch_video_group_review: { method: 'POST', path: '/api/video/import/patch-group', req: s.PatchVideoGroupReviewRequestSchema, resp: s.VideoImportReviewOkSchema, auth: { type: 'owner_or', role: 'admin' } as const },
+    query_video_series: { method: 'POST', path: '/api/video/series/query', req: s.QueryParamsSchema, resp: s.SeriesQueryResultSchema, auth: { type: 'authenticated' } as const },
+    query_videos: { method: 'POST', path: '/api/video/videos/query', req: s.QueryVideosRequestSchema, resp: s.VideosQueryResultSchema, auth: { type: 'authenticated' } as const },
+    recently_added_videos: { method: 'POST', path: '/api/video/relations/recently-added-videos', req: s.RecentlyAddedVideosRequestSchema, resp: s.RecentlyAddedVideosResponseSchema, auth: { type: 'authenticated' } as const },
+    sync_video_by_blake3: { method: 'POST', path: '/api/sync/video-by-blake3', req: s.SyncVideoByBlake3RequestSchema, resp: s.SyncVideoByBlake3ResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    unassigned_videos: { method: 'POST', path: '/api/video/relations/unassigned-videos', req: s.UnassignedVideosRequestSchema, resp: s.UnassignedVideosResponseSchema, auth: { type: 'authenticated' } as const },
+    update_video_season: { method: 'POST', path: '/api/video/seasons/update', req: s.UpdateVideoSeasonRequestSchema, resp: s.VideoSeasonSchema, auth: { type: 'role', role: 'admin' } as const },
+    update_video_series: { method: 'POST', path: '/api/video/series/update', req: s.UpdateVideoSeriesRequestSchema, resp: s.VideoSeriesSchema, auth: { type: 'role', role: 'admin' } as const },
+    update_videos: { method: 'POST', path: '/api/video/videos/update', req: s.UpdateVideosRequestSchema, resp: s.UpdateVideosResultSchema, auth: { type: 'role', role: 'admin' } as const },
+    upload_video: { method: 'POST', path: '/api/upload/video', req: null, resp: s.VideoUploadResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    upload_video_by_blake3: { method: 'POST', path: '/api/upload/video-by-blake3', req: s.UploadVideoByBlake3RequestSchema, resp: s.VideoUploadResponseSchema, auth: { type: 'role', role: 'member' } as const },
+    upsert_playback_progress: { method: 'POST', path: '/api/video/progress/upsert', req: s.UpsertPlaybackProgressRequestSchema, resp: s.PlaybackProgressSchema, auth: { type: 'authenticated' } as const },
+    video_pending: { method: 'POST', path: '/api/video/import/video-pending', req: s.VideoPendingRequestSchema, resp: s.VideoPendingResponseSchema, auth: { type: 'authenticated' } as const },
+    videos_by_value: { method: 'POST', path: '/api/video/relations/videos-by-value', req: s.VideosByValueRequestSchema, resp: s.VideosByValueResponseSchema, auth: { type: 'authenticated' } as const },
+  },
 } as const;