@freqhole/api-client 0.3.6 → 0.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@freqhole/api-client",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "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,
         };
 
@@ -975,6 +1039,71 @@ export class WasmTransport implements Transport {
     return url;
   }
 
+  /**
+   * stream a blob's bytes straight to a caller-supplied sink, without ever
+   * assembling the whole blob in one buffer here - see the `Transport`
+   * interface doc comment for why this exists (docs/blob-transfer-opfs-
+   * and-sha256-refactor-plan.md phase 2). only the verified iroh-blobs
+   * path (blake3 required) is supported - callers without a blake3 should
+   * use `getBlobUrlWithProgress`/`fetchBlob` instead, same as before.
+   */
+  async streamBlobToSink(
+    blobId: string,
+    onChunk: (chunk: Uint8Array, offset: number) => void | Promise<void>,
+    onProgress: (received: number, total: number) => void,
+    blake3?: string,
+    totalBytes?: number,
+    mimeType?: string,
+  ): Promise<{ contentType: string; totalBytes: number }> {
+    if (!blake3) {
+      throw new TransportError(
+        `streamBlobToSink requires a blake3 hash for verified streaming (blob ${blobId})`,
+      );
+    }
+    const streamingFn =
+      this.node.download_verified_streaming_with_ensure ?? this.node.download_verified_streaming;
+    if (!streamingFn) {
+      throw new TransportError(
+        `streamBlobToSink: node has no streaming download method (blob ${blobId})`,
+      );
+    }
+
+    let totalReceived = 0;
+    // chunk delivery is fire-and-forget from the wasm side (see
+    // download_verified_streaming_with_ensure's own doc comment) - queue
+    // each onChunk call after the previous one finishes so a slow sink
+    // (e.g. an OPFS write) applies real backpressure instead of racing
+    // ahead of disk writes.
+    let writeChain: Promise<void> = Promise.resolve();
+
+    await streamingFn.call(
+      this.node,
+      this.peerAddr,
+      blake3,
+      totalBytes ?? 0,
+      (chunk: Uint8Array, offset: number) => {
+        // chunk is a wasm-owned Uint8Array view - copy to detach before
+        // it's handed off across the write chain / a later tick.
+        const owned = new Uint8Array(chunk.length);
+        owned.set(chunk);
+        totalReceived += owned.length;
+        writeChain = writeChain.then(() => onChunk(owned, offset));
+        if (!totalBytes || totalBytes <= 0) {
+          onProgress(totalReceived, totalReceived);
+        }
+      },
+      (fraction: number) => {
+        if (totalBytes && totalBytes > 0) {
+          const received = Math.min(totalBytes, Math.floor(fraction * totalBytes));
+          onProgress(received, totalBytes);
+        }
+      },
+    );
+    await writeChain;
+
+    return { contentType: mimeType ?? "application/octet-stream", totalBytes: totalReceived };
+  }
+
   /**
    * revoke a blob URL to free memory
    */

package/src/codegen/routes.ts

@@ -34,12 +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: {
@@ -252,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

@@ -1508,7 +1508,9 @@ export const CreateStationRequestSchema = z.object({
   encode_args: z.string().nullish(),
   codec: z.string().nullish(),
   play_mode: z.string().nullish(),
-  timeline_only_mode: z.boolean().nullish()
+  timeline_only_mode: z.boolean().nullish(),
+  content_mode: z.string().nullish(),
+  accepts_requests: z.boolean().nullish()
 });
 export type CreateStationRequest = z.infer<typeof CreateStationRequestSchema>;
 
@@ -1545,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(),
@@ -2394,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(),
@@ -3701,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(),
@@ -3896,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()
 });
@@ -5190,6 +5202,7 @@ export const PublicAssetRefSchema = z.object({
 export type PublicAssetRef = z.infer<typeof PublicAssetRefSchema>;
 
 export const PublicNowPlayingSchema = z.object({
+  kind: z.string(),
   song_id: z.string(),
   title: z.string(),
   artist: z.string().nullish(),
@@ -5210,7 +5223,10 @@ export const PublicStationSchema = z.object({
   listener_count: z.number(),
   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(),
   title: z.string(),
   artist: z.string().nullish(),
@@ -5391,7 +5407,8 @@ export type QueryVideosRequest = z.infer<typeof QueryVideosRequestSchema>;
 export const RadioBumperSchema = z.object({
   id: z.string(),
   station_id: z.string(),
-  song_id: z.string(),
+  song_id: z.string().nullish(),
+  video_id: z.string().nullish(),
   label: z.string(),
   weight: z.number(),
   created_at: z.number()
@@ -5400,7 +5417,8 @@ export type RadioBumper = z.infer<typeof RadioBumperSchema>;
 
 export const RadioBumpersAddRequestSchema = z.object({
   station_id: z.string(),
-  song_id: z.string(),
+  song_id: z.string().nullish(),
+  video_id: z.string().nullish(),
   label: z.string(),
   weight: z.number().nullish()
 });
@@ -5424,8 +5442,12 @@ export type RadioBumpersSetFrequencyRequest = z.infer<typeof RadioBumpersSetFreq
 
 export const RadioConfigPayloadSchema = z.object({
   enabled: z.boolean(),
-  encode_args: z.string(),
-  ffmpeg_available: z.boolean()
+  encode_args: z.string().nullish(),
+  video_encode_args: z.string().nullish(),
+  video_codec: z.string().nullish(),
+  ffmpeg_available: z.boolean(),
+  max_concurrent_audio_streams: z.number(),
+  max_concurrent_video_streams: z.number()
 });
 export type RadioConfigPayload = z.infer<typeof RadioConfigPayloadSchema>;
 
@@ -5451,7 +5473,10 @@ export const RadioInfoResponseSchema = z.object({
   listener_count: z.number(),
   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(),
   title: z.string(),
   artist: z.string().nullish(),
@@ -5468,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(),
@@ -5493,6 +5546,9 @@ export const RadioStationSchema = z.object({
   codec: z.string(),
   play_mode: z.string(),
   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()
 });
@@ -5503,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(),
@@ -5530,7 +5591,10 @@ export const RadioStationsResponseSchema = z.object({
   listener_count: z.number(),
   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(),
   title: z.string(),
   artist: z.string().nullish(),
@@ -5687,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(),
@@ -5900,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")]),
@@ -6161,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(),
@@ -6220,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(),
@@ -6246,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(),
@@ -6809,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(),
@@ -7007,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(),
@@ -7303,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(),
@@ -7631,7 +7719,9 @@ export const UpdateStationRequestSchema = z.object({
   encode_args: z.string().nullish(),
   codec: z.string().nullish(),
   play_mode: z.string().nullish(),
-  timeline_only_mode: z.boolean().nullish()
+  timeline_only_mode: z.boolean().nullish(),
+  content_mode: z.string().nullish(),
+  accepts_requests: z.boolean().nullish()
 });
 export type UpdateStationRequest = z.infer<typeof UpdateStationRequestSchema>;
 
@@ -7648,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>;
 
@@ -7687,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>;
 
@@ -7764,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(),
@@ -7923,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(),
@@ -7971,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(),
@@ -8001,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

@@ -7,7 +7,8 @@ export function createAppMethods(call: CallFn) {
   return {
     healthCheck: () => {
       return call(
-        "app", "health_check",
+        "app",
+        "health_check",
         routes.app.health_check.resp,
         routes.app.health_check.req,
         routes.app.health_check.method,
@@ -17,7 +18,8 @@ export function createAppMethods(call: CallFn) {
 
     serverInfo: () => {
       return call(
-        "app", "server_info",
+        "app",
+        "server_info",
         routes.app.server_info.resp,
         routes.app.server_info.req,
         routes.app.server_info.method,
@@ -27,7 +29,8 @@ export function createAppMethods(call: CallFn) {
 
     radioInfo: () => {
       return call(
-        "app", "radio_info",
+        "app",
+        "radio_info",
         routes.app.radio_info.resp,
         routes.app.radio_info.req,
         routes.app.radio_info.method,
@@ -37,7 +40,8 @@ export function createAppMethods(call: CallFn) {
 
     radioStations: () => {
       return call(
-        "app", "radio_stations",
+        "app",
+        "radio_stations",
         routes.app.radio_stations.resp,
         routes.app.radio_stations.req,
         routes.app.radio_stations.method,
@@ -45,10 +49,84 @@ export function createAppMethods(call: CallFn) {
       );
     },
 
+    // authenticated counterpart of radioStations() - includes non-public
+    // stations too, for a caller who actually resolved (real session or
+    // known iroh peer). see offal::music::radio's doc comment.
+    radioStationsFull: () => {
+      return call(
+        "app",
+        "radio_stations_full",
+        routes.app.radio_stations_full.resp,
+        routes.app.radio_stations_full.req,
+        routes.app.radio_stations_full.method,
+        routes.app.radio_stations_full.path,
+      );
+    },
+
+    // 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(
-        "app", "radio_public_blob",
+        "app",
+        "radio_public_blob",
         routes.app.radio_public_blob.resp,
         routes.app.radio_public_blob.req,
         routes.app.radio_public_blob.method,
@@ -60,7 +138,8 @@ export function createAppMethods(call: CallFn) {
     // stream the binary data for a station blob
     radioPublicBlobData: (params: { station_id: string; blob_id: string }) => {
       return call(
-        "app", "radio_public_blob_data",
+        "app",
+        "radio_public_blob_data",
         routes.app.radio_public_blob_data.resp,
         routes.app.radio_public_blob_data.req,
         routes.app.radio_public_blob_data.method,
@@ -72,7 +151,8 @@ export function createAppMethods(call: CallFn) {
     // get a thumbnail for a station blob at a given size
     radioPublicBlobThumbnail: (params: { station_id: string; blob_id: string; size: string }) => {
       return call(
-        "app", "radio_public_blob_thumbnail",
+        "app",
+        "radio_public_blob_thumbnail",
         routes.app.radio_public_blob_thumbnail.resp,
         routes.app.radio_public_blob_thumbnail.req,
         routes.app.radio_public_blob_thumbnail.method,
@@ -84,7 +164,8 @@ export function createAppMethods(call: CallFn) {
     // get the public timeline manifest for a station
     radioPublicTimeline: (params: { station_id: string }) => {
       return call(
-        "app", "radio_public_timeline",
+        "app",
+        "radio_public_timeline",
         routes.app.radio_public_timeline.resp,
         routes.app.radio_public_timeline.req,
         routes.app.radio_public_timeline.method,

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";
 

package/src/transport.ts

@@ -137,6 +137,34 @@ export interface Transport {
     opts?: BlobFetchOptions,
   ): Promise<string>;
 
+  /**
+   * stream a blob's bytes to a caller-supplied sink, chunk by chunk,
+   * instead of assembling the whole blob in memory first (optional).
+   * only implemented by WasmTransport - HTTP callers should stream
+   * directly from `fetch()`'s own `response.body` reader instead (see
+   * `streamVideoToOPFSWithResume`), and CharnelLocalTransport's sync-to-
+   * local path never goes through JS at all (grimoire's own disk-backed
+   * pull). intended for a caller writing straight to OPFS (or anywhere
+   * else) without ever holding the full blob in one buffer - see
+   * docs/blob-transfer-opfs-and-sha256-refactor-plan.md phase 2.
+   * @param blobId - the blob ID to fetch
+   * @param onChunk - called with each chunk as it arrives, in order
+   * @param onProgress - callback with (received, total) bytes
+   * @param blake3 - optional blake3 hash for verified streaming via iroh-blobs
+   * @param totalBytes - optional known total size in bytes
+   * @param mimeType - optional content type (midden's streaming path doesn't
+   *   surface the source mime)
+   * @returns the content type and total bytes actually streamed
+   */
+  streamBlobToSink?(
+    blobId: string,
+    onChunk: (chunk: Uint8Array, offset: number) => void | Promise<void>,
+    onProgress: (received: number, total: number) => void,
+    blake3?: string,
+    totalBytes?: number,
+    mimeType?: string,
+  ): Promise<{ contentType: string; totalBytes: number }>;
+
   /**
    * fetch server image (public, no auth required)
    * used during "add remote" flow before user is authenticated