@freqhole/api-client 0.3.7 → 0.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freqhole/api-client",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "type": "module",
   "repository": {
     "type": "git",

package/src/WasmTransport.test.ts

@@ -0,0 +1,106 @@
+// tests for WasmTransport.upload()'s iroh-blobs chunked path - added while
+// replacing a whole-file `file.arrayBuffer()` buffer-then-import call with
+// genuine chunked streaming into `start_import()`'s ImportSession (no
+// base64 involved at any point here - a direct wasm-bindgen call, unlike
+// the tauri-IPC chunked path in CharnelTransport.ts). covers: chunking
+// across multiple `push()` calls, real per-chunk progress, TempTag release,
+// and the fallback to `import_blob` for older node builds without
+// `start_import`.
+
+import { describe, expect, it, vi } from "vitest";
+import { WasmTransport } from "./WasmTransport";
+import type { MiddenNodeLike } from "./WasmTransport";
+
+function fakeFile(sizeBytes: number, name = "song.mp3"): File {
+  const bytes = new Uint8Array(sizeBytes).fill(7);
+  return new File([bytes], name, { type: "audio/mpeg" });
+}
+
+function fakeApiResponse() {
+  return {
+    status: 200,
+    body: JSON.stringify({ success: true, data: { job_id: "job-1" } }),
+  };
+}
+
+describe("WasmTransport.upload() via iroh-blobs (chunked, no base64)", () => {
+  it("streams a large file across multiple push() calls instead of one whole-buffer import_blob call", async () => {
+    const pushed: number[] = [];
+    const session = {
+      push: vi.fn(async (chunk: Uint8Array) => {
+        pushed.push(chunk.byteLength);
+      }),
+      finish: vi.fn(async () => "blake3hash"),
+      abort: vi.fn(),
+    };
+    const node: Partial<MiddenNodeLike> = {
+      node_id: () => "local-node",
+      import_blob: vi.fn(async () => "should-not-be-used"),
+      start_import: vi.fn(() => session),
+      release_blob: vi.fn(),
+      api_request: vi.fn(async () => fakeApiResponse()),
+    };
+    const transport = new WasmTransport(node as MiddenNodeLike, "peer-1");
+
+    // 4MB chunk size -> a 9MB file should push 3 chunks (4, 4, 1 MB).
+    const fileSize = 9 * 1024 * 1024;
+    const formData = new FormData();
+    formData.set("file", fakeFile(fileSize));
+
+    const onProgress = vi.fn();
+    await transport.upload("/api/upload/music", formData, onProgress);
+
+    expect(node.import_blob).not.toHaveBeenCalled();
+    expect(session.push).toHaveBeenCalledTimes(3);
+    expect(pushed.reduce((a, b) => a + b, 0)).toBe(fileSize);
+    expect(session.finish).toHaveBeenCalledTimes(1);
+    expect(node.release_blob).toHaveBeenCalledWith("blake3hash");
+
+    // progress is real and monotonically increasing, ending at the full size.
+    expect(onProgress).toHaveBeenCalled();
+    const calls = onProgress.mock.calls.map((c) => c[0] as number);
+    expect(calls[calls.length - 1]).toBe(fileSize);
+    expect([...calls].sort((a, b) => a - b)).toEqual(calls);
+  });
+
+  it("falls back to a single import_blob call when start_import isn't available", async () => {
+    const node: Partial<MiddenNodeLike> = {
+      node_id: () => "local-node",
+      import_blob: vi.fn(async () => "blake3hash"),
+      release_blob: vi.fn(),
+      api_request: vi.fn(async () => fakeApiResponse()),
+    };
+    const transport = new WasmTransport(node as MiddenNodeLike, "peer-1");
+
+    const formData = new FormData();
+    formData.set("file", fakeFile(1024));
+    await transport.upload("/api/upload/music", formData);
+
+    expect(node.import_blob).toHaveBeenCalledTimes(1);
+  });
+
+  it("aborts the import session and propagates the error if a push() fails", async () => {
+    const session = {
+      push: vi.fn(async () => {
+        throw new Error("push failed");
+      }),
+      finish: vi.fn(async () => "should-not-be-called"),
+      abort: vi.fn(),
+    };
+    const node: Partial<MiddenNodeLike> = {
+      node_id: () => "local-node",
+      import_blob: vi.fn(async () => "should-not-be-used"),
+      start_import: vi.fn(() => session),
+      release_blob: vi.fn(),
+      api_request: vi.fn(async () => fakeApiResponse()),
+    };
+    const transport = new WasmTransport(node as MiddenNodeLike, "peer-1");
+
+    const formData = new FormData();
+    formData.set("file", fakeFile(1024));
+
+    await expect(transport.upload("/api/upload/music", formData)).rejects.toThrow("upload failed");
+    expect(session.abort).toHaveBeenCalledTimes(1);
+    expect(session.finish).not.toHaveBeenCalled();
+  });
+});

package/src/WasmTransport.ts

@@ -97,6 +97,12 @@ export interface MiddenNodeLike {
   download_verified?(peer_addr: string, blake3_hash: string): Promise<Uint8Array>;
   // download blob with automatic ensure + retry - optional
   download_verified_with_ensure?(peer_addr: string, blake3_hash: string): Promise<Uint8Array>;
+  // download blob DIRECTLY into this node's own local store, never
+  // returning bytes to JS - see
+  // `download_verified_to_store_with_ensure`'s doc comment in
+  // lib/midden/src/lib.rs. use instead of download_verified_with_ensure
+  // whenever the caller only needs the blob to become locally servable.
+  download_verified_to_store_with_ensure?(peer_addr: string, blake3_hash: string): Promise<void>;
   // download blob by ID with on-demand blake3 computation - optional
   // returns [Uint8Array, string] but typed as any[] for wasm-bindgen compatibility
   download_verified_by_id?(peer_addr: string, blob_id: string): Promise<any[]>;
@@ -153,6 +159,35 @@ export interface MiddenNodeLike {
   // phase 1. optional because charnel's CharnelTransport has no wasm
   // accept-loop equivalent (yet).
   accept?(): Promise<BiStreamLike | null>;
+  // snapshot of this node's own OUTGOING blob transfers currently in
+  // flight (this node serving a blob to a peer) - see
+  // docs/transfer-unification-plan.md phase 1 (bucket A). does NOT cover
+  // incoming/download transfers - iroh-blobs only instruments the serving
+  // side; downloads are tracked via the on_progress callbacks the
+  // download_verified_* methods above already take.
+  get_active_transfers?(): Promise<ActiveTransferLike[]>;
+  // pause every in-flight DOWNLOAD of this blake3 hash (no effect on
+  // outgoing/serving transfers - only the puller can pace a pull).
+  // the partial stays pinned in the local store; resuming just means
+  // calling a download_verified_* method again with the same hash.
+  // returns how many downloads were flagged (0 = none in flight).
+  download_cancel_by_blake3?(blake3_hash: string): Promise<number>;
+  // pin a hash against gc (keep a paused partial download alive).
+  protect_blob?(blake3_hash: string): Promise<void>;
+  // remove a gc pin added by protect_blob or a cancelled download.
+  unprotect_blob?(blake3_hash: string): Promise<void>;
+}
+
+/**
+ * one outgoing blob transfer in flight, as returned by
+ * `get_active_transfers()` - see `ActiveTransfer` in reliquary's
+ * `gate.rs` / `WorkerActiveTransfer` in reliquary's worker contract.
+ */
+export interface ActiveTransferLike {
+  peerId: string;
+  blake3: string;
+  bytesSent: number;
+  totalSize: number;
 }
 
 /**
@@ -392,14 +427,9 @@ export class WasmTransport implements Transport {
   async upload(
     path: string,
     formData: FormData,
-    _onProgress?: (loaded: number, total: number) => void,
+    onProgress?: (loaded: number, total: number) => void,
     metadata?: UploadMetadata,
   ): Promise<TransportResponse> {
-    // no byte-level progress possible here - unlike CharnelTransport's tauri
-    // IPC path (which self-chunks and can report per-chunk progress), the
-    // midden wasm binding's `import_blob(bytes)` is a single opaque call
-    // with no progress callback exposed, and the base64 fallback also sends
-    // one JSON request.
     const file = formData.get("file") as File | null;
     if (!file) {
       return {
@@ -422,7 +452,7 @@ export class WasmTransport implements Transport {
     // available - chunked/verified streaming, no base64/raw-bytes framing.
     const blobPullPaths = ["/api/upload/music", "/api/upload/video"];
     if (blobPullPaths.includes(path) && this.node.import_blob) {
-      return this.uploadViaIrohBlobs(path, file, metadata);
+      return this.uploadViaIrohBlobs(path, file, onProgress, metadata);
     }
 
     // fallback: base64 encode and send via api_request (works for image uploads)
@@ -435,21 +465,55 @@ export class WasmTransport implements Transport {
    * 2. tell remote peer the hash via `${path}-by-blake3` (e.g. /api/upload/music-by-blake3)
    * 3. remote peer pulls the blob from us via iroh-blobs verified streaming
    * 4. release the TempTag so local GC can reclaim the blob
+   *
+   * streams the file into `start_import()`'s chunked `ImportSession` in
+   * bounded slices (mirrors `CharnelTransport.uploadMediaViaBytes`'s same
+   * chunk size) instead of reading the whole file into one buffer via
+   * `file.arrayBuffer()` - this is a direct wasm-bindgen call (`push`
+   * takes a `Uint8Array` straight through, no JSON/IPC boundary to cross),
+   * so there's no base64 involved at any point, unlike the tauri-IPC
+   * chunked path. this also yields real per-chunk progress, previously
+   * unavailable here (a single opaque `import_blob(wholeBytes)` call had
+   * nothing to report between start and finish). falls back to the old
+   * whole-buffer `import_blob` call only if this node build predates
+   * `start_import` (progress-less in that case, matching prior behavior).
    */
   private async uploadViaIrohBlobs(
     path: string,
     file: File,
+    onProgress?: (loaded: number, total: number) => void,
     metadata?: UploadMetadata,
   ): Promise<TransportResponse> {
+    // ~4MB per chunk - same size CharnelTransport's tauri IPC chunking
+    // uses, though the reason differs (there it bounds IPC payload size;
+    // here it just bounds how much of the file is held at once).
+    const CHUNK_SIZE = 4 * 1024 * 1024;
     try {
-      const fileBytes = new Uint8Array(await file.arrayBuffer());
-      const hash = await this.node.import_blob!(fileBytes);
+      const hash = await (async () => {
+        if (!this.node.start_import) {
+          // old node build - no chunked import session available.
+          return this.node.import_blob!(new Uint8Array(await file.arrayBuffer()));
+        }
+        const session = this.node.start_import();
+        try {
+          for (let offset = 0; offset < file.size; offset += CHUNK_SIZE) {
+            const slice = file.slice(offset, Math.min(offset + CHUNK_SIZE, file.size));
+            const chunk = new Uint8Array(await slice.arrayBuffer());
+            await session.push(chunk);
+            onProgress?.(Math.min(offset + chunk.byteLength, file.size), file.size);
+          }
+          return await session.finish();
+        } catch (err) {
+          session.abort();
+          throw err;
+        }
+      })();
 
       try {
         const body: Record<string, unknown> = {
           blake3: hash,
           filename: file.name,
-          size: fileBytes.length,
+          size: file.size,
           ...metadata,
         };
 

package/src/codegen/routes.ts

@@ -34,13 +34,17 @@ export const routes = {
   },
   app: {
     health_check: { method: 'GET', path: '/health', req: null, resp: s.HealthResponseSchema, auth: { type: 'public' } as const },
+    radio_clear_requests: { method: 'POST', path: '/api/radio/requests/clear', req: s.RadioStationRequestsRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
     radio_info: { method: 'GET', path: '/api/radio/info', req: null, resp: s.RadioInfoResponseSchema, auth: { type: 'public' } as const },
+    radio_list_requests: { method: 'POST', path: '/api/radio/requests/list', req: s.RadioStationRequestsRequestSchema, resp: s.RadioRequestsListResponseSchema, auth: { type: 'authenticated' } as const },
     radio_public_blob: { method: 'GET', path: '/api/radio/stations/{station_id}/blobs/{blob_id}', req: null, resp: null, auth: { type: 'public' } as const },
     radio_public_blob_data: { method: 'GET', path: '/api/radio/stations/{station_id}/blobs/{blob_id}/data', req: null, resp: null, auth: { type: 'public' } as const },
     radio_public_blob_thumbnail: { method: 'GET', path: '/api/radio/stations/{station_id}/blobs/{blob_id}/thumb/{size}', req: null, resp: null, auth: { type: 'public' } as const },
     radio_public_timeline: { method: 'GET', path: '/api/radio/stations/{station_id}/timeline', req: null, resp: s.PublicTimelineManifestSchema, auth: { type: 'public' } as const },
+    radio_remove_request: { method: 'POST', path: '/api/radio/requests/remove', req: s.RemoveRadioRequestRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
     radio_stations: { method: 'GET', path: '/api/radio/stations', req: null, resp: s.RadioStationsResponseSchema, auth: { type: 'public' } as const },
     radio_stations_full: { method: 'GET', path: '/api/radio/stations/full', req: null, resp: s.RadioStationsResponseSchema, auth: { type: 'authenticated' } as const },
+    radio_submit_request: { method: 'POST', path: '/api/radio/requests/submit', req: s.SubmitRadioRequestRequestSchema, resp: s.EmptyResponseSchema, auth: { type: 'authenticated' } as const },
     server_info: { method: 'GET', path: '/api/hello', req: null, resp: s.ServerInfoResponseSchema, auth: { type: 'public' } as const },
   },
   auth: {
@@ -253,6 +257,7 @@ export const routes = {
     import_video_paths: { method: 'POST', path: '/api/upload/video-paths', req: null, resp: s.VideoImportResponseSchema, auth: { type: 'role', role: 'member' } 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_extras: { method: 'POST', path: '/api/video/videos/list-extras', req: s.ListVideoExtrasRequestSchema, resp: s.VideoSchema.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 },

package/src/codegen/schema.ts

@@ -1509,7 +1509,8 @@ export const CreateStationRequestSchema = z.object({
   codec: z.string().nullish(),
   play_mode: z.string().nullish(),
   timeline_only_mode: z.boolean().nullish(),
-  content_mode: z.string().nullish()
+  content_mode: z.string().nullish(),
+  accepts_requests: z.boolean().nullish()
 });
 export type CreateStationRequest = z.infer<typeof CreateStationRequestSchema>;
 
@@ -1546,6 +1547,7 @@ export const CreateVideoRequestSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -2395,6 +2397,8 @@ export const FavoriteItemSchema = z.union([z.intersection(z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -3702,6 +3706,8 @@ export const ListFavoritesResponseSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -3897,6 +3903,11 @@ export const ListTaxonsByKindRequestSchema = z.object({
 });
 export type ListTaxonsByKindRequest = z.infer<typeof ListTaxonsByKindRequestSchema>;
 
+export const ListVideoExtrasRequestSchema = z.object({
+  parent_video_id: z.string()
+});
+export type ListVideoExtrasRequest = z.infer<typeof ListVideoExtrasRequestSchema>;
+
 export const ListVideoSeasonsRequestSchema = z.object({
   series_id: z.string().nullish()
 });
@@ -5213,6 +5224,7 @@ export const PublicStationSchema = z.object({
   is_default: z.boolean(),
   is_public: z.boolean(),
   is_running: z.boolean(),
+  accepts_requests: z.boolean(),
   now_playing: z.object({
   kind: z.string(),
   song_id: z.string(),
@@ -5462,6 +5474,7 @@ export const RadioInfoResponseSchema = z.object({
   is_default: z.boolean(),
   is_public: z.boolean(),
   is_running: z.boolean(),
+  accepts_requests: z.boolean(),
   now_playing: z.object({
   kind: z.string(),
   song_id: z.string(),
@@ -5480,6 +5493,34 @@ export const RadioInfoResponseSchema = z.object({
 });
 export type RadioInfoResponse = z.infer<typeof RadioInfoResponseSchema>;
 
+export const RadioQueuedRequestInfoSchema = z.object({
+  id: z.string(),
+  kind: z.string(),
+  item_id: z.string(),
+  requested_by: z.string(),
+  title: z.string(),
+  artist: z.string().nullish(),
+  album: z.string().nullish(),
+  duration_ms: z.number().nullish(),
+  art_blob_id: z.string().nullish()
+});
+export type RadioQueuedRequestInfo = z.infer<typeof RadioQueuedRequestInfoSchema>;
+
+export const RadioRequestsListResponseSchema = z.object({
+  requests: z.array(z.object({
+  id: z.string(),
+  kind: z.string(),
+  item_id: z.string(),
+  requested_by: z.string(),
+  title: z.string(),
+  artist: z.string().nullish(),
+  album: z.string().nullish(),
+  duration_ms: z.number().nullish(),
+  art_blob_id: z.string().nullish()
+}))
+});
+export type RadioRequestsListResponse = z.infer<typeof RadioRequestsListResponseSchema>;
+
 export const RadioSeedSuggestRequestSchema = z.object({
   kind: z.string(),
   query: z.string(),
@@ -5507,6 +5548,7 @@ export const RadioStationSchema = z.object({
   timeline_only_mode: z.number(),
   content_mode: z.string(),
   bumper_frequency_seconds: z.number().nullish(),
+  accepts_requests: z.number(),
   created_at: z.number(),
   updated_at: z.number()
 });
@@ -5517,6 +5559,11 @@ export const RadioStationByStationIdRequestSchema = z.object({
 });
 export type RadioStationByStationIdRequest = z.infer<typeof RadioStationByStationIdRequestSchema>;
 
+export const RadioStationRequestsRequestSchema = z.object({
+  station_id: z.string()
+});
+export type RadioStationRequestsRequest = z.infer<typeof RadioStationRequestsRequestSchema>;
+
 export const RadioStationSupervisorStatusSchema = z.object({
   station_id: z.string(),
   name: z.string(),
@@ -5545,6 +5592,7 @@ export const RadioStationsResponseSchema = z.object({
   is_default: z.boolean(),
   is_public: z.boolean(),
   is_running: z.boolean(),
+  accepts_requests: z.boolean(),
   now_playing: z.object({
   kind: z.string(),
   song_id: z.string(),
@@ -5703,6 +5751,8 @@ export const RecentlyAddedVideosResponseSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -5916,6 +5966,12 @@ export const RemovePlaylistThumbnailRequestSchema = z.object({
 });
 export type RemovePlaylistThumbnailRequest = z.infer<typeof RemovePlaylistThumbnailRequestSchema>;
 
+export const RemoveRadioRequestRequestSchema = z.object({
+  station_id: z.string(),
+  request_id: z.string()
+});
+export type RemoveRadioRequestRequest = z.infer<typeof RemoveRadioRequestRequestSchema>;
+
 export const RemoveRatingRequestSchema = z.object({
   user_id: z.string().nullish(),
   target_type: z.union([z.literal("song"), z.literal("artist"), z.literal("album"), z.literal("video")]),
@@ -6177,6 +6233,8 @@ export const SeasonWithVideosSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -6236,6 +6294,8 @@ export const SeriesDetailSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -6262,6 +6322,8 @@ export const SeriesDetailSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -6825,6 +6887,13 @@ export const StationFilterSchema = z.object({
 });
 export type StationFilter = z.infer<typeof StationFilterSchema>;
 
+export const SubmitRadioRequestRequestSchema = z.object({
+  station_id: z.string(),
+  kind: z.string(),
+  item_id: z.string()
+});
+export type SubmitRadioRequestRequest = z.infer<typeof SubmitRadioRequestRequestSchema>;
+
 export const SuggestionSchema = z.object({
   value: z.string(),
   display: z.string(),
@@ -7023,6 +7092,7 @@ export const SyncVideoByBlake3RequestSchema = z.object({
   series_description: z.string().nullish(),
   season_number: z.number().nullish(),
   season_title: z.string().nullish(),
+  parent_blake3: z.string().nullish(),
   video_images: z.array(z.object({
   content_sha256: z.string(),
   data_base64: z.string().nullish(),
@@ -7319,6 +7389,8 @@ export const UnassignedVideosResponseSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -7648,7 +7720,8 @@ export const UpdateStationRequestSchema = z.object({
   codec: z.string().nullish(),
   play_mode: z.string().nullish(),
   timeline_only_mode: z.boolean().nullish(),
-  content_mode: z.string().nullish()
+  content_mode: z.string().nullish(),
+  accepts_requests: z.boolean().nullish()
 });
 export type UpdateStationRequest = z.infer<typeof UpdateStationRequestSchema>;
 
@@ -7665,12 +7738,14 @@ export const UpdateVideoRequestSchema = z.object({
   content_type: z.string().nullish(),
   title: z.string().nullish(),
   description: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
   updated_by: z.string().nullish(),
   clear_series_id: z.boolean(),
-  clear_season_id: z.boolean()
+  clear_season_id: z.boolean(),
+  clear_parent_video_id: z.boolean()
 });
 export type UpdateVideoRequest = z.infer<typeof UpdateVideoRequestSchema>;
 
@@ -7704,8 +7779,10 @@ export const UpdateVideosRequestSchema = z.object({
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
   updated_by: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   clear_series_id: z.boolean(),
-  clear_season_id: z.boolean()
+  clear_season_id: z.boolean(),
+  clear_parent_video_id: z.boolean()
 });
 export type UpdateVideosRequest = z.infer<typeof UpdateVideosRequestSchema>;
 
@@ -7781,6 +7858,8 @@ export const VideoSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -7940,6 +8019,8 @@ export const VideoWithMetadataSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -7988,6 +8069,8 @@ export const VideosByValueResponseSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),
@@ -8018,6 +8101,8 @@ export const VideosQueryResultSchema = z.object({
   title: z.string(),
   description: z.string().nullish(),
   media_blob_id: z.string(),
+  blake3: z.string().nullish(),
+  parent_video_id: z.string().nullish(),
   poster_blob_id: z.string().nullish(),
   duration_seconds: z.number().nullish(),
   release_date: z.string().nullish(),

package/src/domains/app.ts

@@ -63,6 +63,65 @@ export function createAppMethods(call: CallFn) {
       );
     },
 
+    // submit a member request to an `accepts_requests` station's queue -
+    // any authenticated caller may call this (not admin-only, unlike
+    // radio_filters_add's "add to station").
+    radioSubmitRequest: (params: {
+      station_id: string;
+      kind: "song" | "video";
+      item_id: string;
+    }) => {
+      return call(
+        "app",
+        "radio_submit_request",
+        routes.app.radio_submit_request.resp,
+        routes.app.radio_submit_request.req,
+        routes.app.radio_submit_request.method,
+        routes.app.radio_submit_request.path,
+        params,
+      );
+    },
+
+    // list every currently-queued request for a station (the "queue" tab)
+    radioListRequests: (params: { station_id: string }) => {
+      return call(
+        "app",
+        "radio_list_requests",
+        routes.app.radio_list_requests.resp,
+        routes.app.radio_list_requests.req,
+        routes.app.radio_list_requests.method,
+        routes.app.radio_list_requests.path,
+        params,
+      );
+    },
+
+    // remove one queued request - any authenticated caller may call this
+    // (member-submitted content, not admin-owned configuration).
+    radioRemoveRequest: (params: { station_id: string; request_id: string }) => {
+      return call(
+        "app",
+        "radio_remove_request",
+        routes.app.radio_remove_request.resp,
+        routes.app.radio_remove_request.req,
+        routes.app.radio_remove_request.method,
+        routes.app.radio_remove_request.path,
+        params,
+      );
+    },
+
+    // clear every queued request for a station at once
+    radioClearRequests: (params: { station_id: string }) => {
+      return call(
+        "app",
+        "radio_clear_requests",
+        routes.app.radio_clear_requests.resp,
+        routes.app.radio_clear_requests.req,
+        routes.app.radio_clear_requests.method,
+        routes.app.radio_clear_requests.path,
+        params,
+      );
+    },
+
     // get blob metadata for a station blob
     radioPublicBlob: (params: { station_id: string; blob_id: string }) => {
       return call(

package/src/domains/video.ts

@@ -107,6 +107,18 @@ export function createVideoMethods(call: CallFn) {
       );
     },
 
+    listVideoExtras: (params: s.ListVideoExtrasRequest) => {
+      return call(
+        "video",
+        "list_video_extras",
+        routes.video.list_video_extras.resp,
+        routes.video.list_video_extras.req,
+        routes.video.list_video_extras.method,
+        routes.video.list_video_extras.path,
+        params,
+      );
+    },
+
     updateVideos: (params: Partial<s.UpdateVideosRequest> & { video_ids: string[] }) => {
       return call(
         "video",

package/src/index.ts

@@ -39,6 +39,7 @@ export type {
   BlobProgressCallback,
   RadioHandleLike,
   BiStreamLike,
+  ActiveTransferLike,
 } from "./WasmTransport.js";
 export type { Transport, TransportResponse, BlobData } from "./transport.js";