@freqhole/api-client 0.3.3 → 0.3.4

package/package.json

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

package/src/CharnelLocalTransport.ts

@@ -12,29 +12,10 @@ type InvokeFn = (cmd: string, args?: unknown) => Promise<unknown>;
 
 // tauri invoke is dynamically imported to avoid bundling in browser builds
 let invoke: InvokeFn | null = null;
-let convertFileSrc: ((path: string) => string) | null = null;
-
-// webkitgtk (linux) can't play asset:// URLs in <audio> elements.
-// detect once at module level so we can use blob: URLs as a workaround.
-//
-// historically there was a second workaround here — an embedded http
-// loopback server (`media_server_info` ipc + `server::media_server`)
-// that served blobs via plain http. it has been removed in favor of
-// the rodio backend (see `client/spume/src/music/services/audio/`),
-// which bypasses the html `<audio>` element entirely on linux. when
-// rodio is *not* enabled and we're on linux, we fall back to the
-// blob: object url path below.
-const isLinuxWebKit = typeof navigator !== "undefined" && navigator.userAgent.includes("Linux");
-
-/**
- * blobs that must never be buffered into memory as a blob: URL, even on
- * linux: a local video can easily be multi-GB, and `fetch().arrayBuffer()`
- * on one hangs the whole app. these stream from asset:// instead, which
- * also gives `<video>` real range requests for seeking.
- */
-function isStreamableMime(mime?: string | null): boolean {
-  return (mime ?? "").startsWith("video/");
-}
+let convertFileSrc: ((path: string, protocol?: string) => string) | null = null;
+// cached target_os check (android only, for now) - see mediaSrcFor() below.
+// null = not yet determined, false = determined non-android.
+let isAndroidCached: boolean | null = null;
 
 /**
  * initialize tauri invoke function
@@ -46,12 +27,45 @@ async function ensureInvoke(): Promise<InvokeFn> {
     invoke = tauri.invoke as InvokeFn;
     // also grab convertFileSrc for blob URLs
     convertFileSrc = tauri.convertFileSrc;
+    try {
+      const buildInfo = (await invoke("get_build_info")) as { target_os?: string };
+      isAndroidCached = buildInfo?.target_os === "android";
+    } catch {
+      isAndroidCached = false;
+    }
     return invoke;
   } catch {
     throw new Error("@tauri-apps/api not available - not running in Tauri");
   }
 }
 
+/**
+ * build a playable url for a local file path - tauri's built-in `asset`
+ * protocol everywhere except android, which gets the custom
+ * `freqhole-media` protocol instead (see `client/charnel/src-tauri/src/
+ * media_protocol.rs`: the built-in one caps every range response to
+ * ~1MB, which android's webview media pipeline doesn't reliably recover
+ * from for files larger than that - confirmed via a live network trace).
+ * call `ensureInvoke()` (or anything that awaits it) at least once before
+ * calling this, so `isAndroidCached` is resolved.
+ */
+function mediaSrcFor(path: string): string {
+  if (!convertFileSrc) {
+    throw new Error("convertFileSrc not available");
+  }
+  return isAndroidCached ? convertFileSrc(path, "freqhole-media") : convertFileSrc(path);
+}
+
+/**
+ * public, self-contained version of `mediaSrcFor` for callers outside this
+ * file (spume's `localAudio.ts`/`localVideo.ts`) - ensures tauri's invoke/
+ * convertFileSrc/target_os are loaded before resolving.
+ */
+export async function resolveCharnelMediaSrc(path: string): Promise<string> {
+  await ensureInvoke();
+  return mediaSrcFor(path);
+}
+
 /**
  * response shape from api_call command (matches GrimoireResponse)
  */
@@ -74,8 +88,6 @@ export class CharnelLocalTransport implements Transport {
   private blobPathCache = new Map<string, { path: string; mime?: string }>();
   // cache object URLs for db-stored blobs (no local path)
   private blobObjectUrlCache = new Map<string, string>();
-  // single audio blob URL for linux workaround (revoke-on-replace to avoid memory leak)
-  private audioBlobUrl: { blobId: string; url: string } | null = null;
 
   constructor(_baseUrl: string) {
     // baseUrl no longer needed - all requests go through IPC.
@@ -291,7 +303,7 @@ export class CharnelLocalTransport implements Transport {
     }
 
     // convert to asset URL and fetch via browser
-    const assetUrl = convertFileSrc(pathInfo.path);
+    const assetUrl = mediaSrcFor(pathInfo.path);
     const fetchResponse = await fetch(assetUrl);
     const arrayBuffer = await fetchResponse.arrayBuffer();
 
@@ -339,13 +351,7 @@ export class CharnelLocalTransport implements Transport {
   /**
    * get blob URL — preference order:
    * 1. cached object URL (db-stored blobs)
-   * 2. tauri asset:// (via `convertFileSrc`) on macos/windows
-   * 3. linux fallback: fetch via asset:// and wrap in a blob: object URL
-   *    (webkitgtk can't stream asset:// into `<audio>`)
-   *
-   * the linux fallback buffers the ENTIRE file in memory, so it is never
-   * used for video - a multi-GB local video would exhaust memory and hang
-   * the app (`<video>` also seeks, which a one-shot blob can't stream).
+   * 2. tauri asset:// (via `convertFileSrc`), for any blob with a local path
    *
    * note: when the rodio audio backend is enabled (charnel + opt-in)
    * playback bypasses html `<audio>` entirely and reads files via
@@ -359,25 +365,15 @@ export class CharnelLocalTransport implements Transport {
       return cachedObjectUrl;
     }
 
-    // on linux without rodio, we MUST go async to wrap in a blob:
-    // url (asset:// can't stream into <audio> on webkitgtk) - except for
-    // video, which streams from asset:// directly (see below).
-    const cachedPath = this.blobPathCache.get(blobId);
-    if (isLinuxWebKit && !isStreamableMime(cachedPath?.mime)) {
-      console.debug(`[CharnelLocalTransport] blob ${blobId}: linux fallback (async)`);
-      return this.getBlobUrlAsync(blobId);
-    }
-
     // check path cache (filesystem blobs) — direct asset:// url
-    const cached = cachedPath;
+    const cached = this.blobPathCache.get(blobId);
     if (cached && convertFileSrc) {
-      const url = convertFileSrc(cached.path);
+      const url = mediaSrcFor(cached.path);
       console.debug(`[CharnelLocalTransport] blob ${blobId}: asset:// (cached) -> ${url}`);
       return url;
     }
 
     // need to fetch path (or data) first
-    // console.debug(`[CharnelLocalTransport] blob ${blobId}: async path lookup`);
     return this.getBlobUrlAsync(blobId);
   }
 
@@ -400,22 +396,10 @@ export class CharnelLocalTransport implements Transport {
           throw new Error("convertFileSrc not available");
         }
 
-        // on linux without media server: fall back to blob: workaround.
-        // routes audio + image differently:
-        //   - audio: single-slot cache (revoke-on-replace) since audio
-        //     blobs are large and we only play one at a time
-        //   - other (images / waveforms / cover art): per-blob cache so
-        //     multiple `<img>` and css `background-image` urls coexist
-        //     across the playerbar, queue sidebar, etc.
-        // video is excluded - buffering it would hang the app.
-        if (isLinuxWebKit && !isStreamableMime(parsed.data.mime)) {
-          return this.createBlobObjectUrl(blobId, parsed.data.path, parsed.data.mime);
-        }
-
         console.debug(
           `[CharnelLocalTransport] blob ${blobId}: asset:// stream (mime=${parsed.data.mime ?? "?"})`,
         );
-        return convertFileSrc(parsed.data.path);
+        return mediaSrcFor(parsed.data.path);
       }
     }
 
@@ -437,54 +421,6 @@ export class CharnelLocalTransport implements Transport {
     throw new Error(`failed to get blob path: ${response.body}`);
   }
 
-  /**
-   * create a blob: object URL by fetching via asset:// protocol.
-   * used on linux where webkitgtk can't play asset:// in `<audio>`
-   * elements (and historically also where the embedded http loopback
-   * server stood in for the same workaround).
-   *
-   * mime-aware caching:
-   *   - `audio/*`: single-slot cache, revoke-on-replace. audio blobs
-   *     are large (often tens of MB) and only one ever plays at a
-   *     time, so leaking the rest is wasteful.
-   *   - everything else (images, waveforms, cover art): stored in
-   *     `blobObjectUrlCache` keyed by blob id so multiple `<img>` /
-   *     css `background-image` references coexist without one
-   *     revoking another.
-   */
-  private async createBlobObjectUrl(
-    blobId: string,
-    localPath: string,
-    mime?: string,
-  ): Promise<string> {
-    if (!convertFileSrc) {
-      throw new Error("convertFileSrc not available");
-    }
-
-    const isAudio = (mime ?? "").startsWith("audio/");
-    const effectiveMime = mime ?? (isAudio ? "audio/mpeg" : "application/octet-stream");
-
-    const assetUrl = convertFileSrc(localPath);
-    const resp = await fetch(assetUrl);
-    const arrayBuffer = await resp.arrayBuffer();
-    const blob = new Blob([arrayBuffer], { type: effectiveMime });
-    const objectUrl = URL.createObjectURL(blob);
-
-    if (isAudio) {
-      // revoke previous single-slot audio url (if any) so we don't
-      // leak large buffers as the user moves between tracks.
-      if (this.audioBlobUrl) {
-        URL.revokeObjectURL(this.audioBlobUrl.url);
-      }
-      this.audioBlobUrl = { blobId, url: objectUrl };
-    } else {
-      // per-blob cache so e.g. the playerbar's waveform and the queue
-      // sidebar's matching waveform share a single object url.
-      this.blobObjectUrlCache.set(blobId, objectUrl);
-    }
-    return objectUrl;
-  }
-
   // -----------------------------------------------------------------
   // job events (local ipc shortcut)
   //

package/src/index.ts

@@ -31,6 +31,7 @@ export {
   CharnelLocalTransport,
   createCharnelLocalTransport,
   JobEventsStreamClosed,
+  resolveCharnelMediaSrc,
 } from "./CharnelLocalTransport.js";
 export type {
   MiddenNodeLike,