@freqhole/api-client 0.2.14 → 0.3.1

package/src/errors.ts

@@ -0,0 +1,142 @@
+// shared "turn a raw failed-request body into a typed, human-readable
+// error" logic, used by every transport/domain method that has to parse a
+// non-2xx response (FreqholeClient's json route caller, domains/upload.ts's
+// multipart uploads, etc). this is the ONE place that understands both
+// server-side failure shapes:
+//
+//   - the axum `ApiError` shape: `{ error, code, error_type? }` (see
+//     server/src/error.rs) - used for request-level failures (bad request,
+//     unauthorized, or a `GrimoireError` surfaced via `?`).
+//   - the `GrimoireResponse` failure shape: `{ success: false, message,
+//     errors: ErrorDetail[] }` (see grimoire/src/response.rs) - used by
+//     offal-dispatched routes that fail after starting a "success" response.
+//
+// both carry the same underlying idea: a stable snake_case `error_type`
+// code plus a human `detail`/`message`. everything downstream (isAuthError,
+// job-error checks, UI error banners) should key off `error_type`, never
+// off substring-matching a message - see docs/error-handling.md.
+
+import { z } from "zod";
+
+/** sentinel path segment marking a 401/session-expired failure. */
+export const AUTH_ERROR_PATH = "__auth_expired__";
+
+export interface ParsedApiError {
+  /** best available human-readable message - never empty. */
+  message: string;
+  /** stable error_type code, when the server provided one. */
+  errorType?: string;
+}
+
+// curated overrides for error_type codes whose server-provided detail
+// reads badly to an end user (too technical, or missing entirely for
+// codes that only ever carry a generic `detail`). this is NOT meant to
+// cover every error_type - anything absent here just falls back to the
+// server's own `detail`/`message`, which is normally fine on its own.
+// exported so callers with extra context (e.g. spume's humanizeJobError,
+// which also handles un-tagged legacy message strings) can extend this
+// same table instead of maintaining a separate, drifting copy.
+export const ERROR_TYPE_MESSAGES: Record<string, string> = {
+  unauthorized: "your session has expired - please sign in again",
+  forbidden: "you don't have permission to do that",
+  route_not_found: "that server doesn't support this feature (server may need an update)",
+  duplicate_song: "this song already exists in the library",
+  duplicate_video: "this video already exists in the library",
+  duplicate_playlist_item: "this item is already in the playlist",
+  video_previously_deleted:
+    "this video was already deleted from the library - an admin needs to run a maintenance cleanup before it can be added back",
+  fetch_not_configured: "downloading from urls isn't set up on this server",
+  fetch_forbidden: "source blocked the request (403) - it may require login/cookies",
+  fetch_not_found: "source returned 404 - the video may have been deleted, or the url is wrong",
+  fetch_video_unavailable: "video is unavailable",
+  fetch_private_video: "video is private",
+  fetch_video_removed: "video is no longer available",
+  fetch_content_unavailable: "content isn't available (may be region-locked)",
+  fetch_login_required:
+    "site requires sign-in verification - can't fetch without cookies configured",
+  message_too_large:
+    "file is too large to send over this P2P connection - large file transfers need a blob-pull upload path, not a direct embedded message",
+  upload_too_large_for_transport:
+    "file is too large to upload over this connection - large video uploads aren't fully supported over P2P yet",
+};
+
+function bodyFallbackMessage(status: number): string {
+  return status === 0 ? "connection error" : `request failed (HTTP ${status})`;
+}
+
+/** parse a raw HTTP/IPC response body into a best-effort {@link ParsedApiError}. */
+export function parseErrorResponseBody(body: string, status: number): ParsedApiError {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return { message: bodyFallbackMessage(status) };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { message: bodyFallbackMessage(status) };
+  }
+  const obj = parsed as Record<string, unknown>;
+
+  // GrimoireResponse failure shape: {success:false, message, errors:[{error_type,title,detail}]}
+  if (obj.success === false) {
+    const firstError =
+      Array.isArray(obj.errors) && obj.errors.length > 0
+        ? (obj.errors[0] as Record<string, unknown>)
+        : undefined;
+    const errorType =
+      typeof firstError?.error_type === "string" ? firstError.error_type : undefined;
+    const message =
+      (typeof firstError?.detail === "string" && firstError.detail) ||
+      (typeof obj.message === "string" && obj.message) ||
+      bodyFallbackMessage(status);
+    return { message, errorType };
+  }
+
+  // axum ApiError shape: {error, code, error_type?}
+  if (
+    typeof obj.error === "string" ||
+    typeof obj.code === "string" ||
+    typeof obj.error_type === "string"
+  ) {
+    const errorType =
+      (typeof obj.error_type === "string" && obj.error_type) ||
+      (typeof obj.code === "string" && obj.code) ||
+      undefined;
+    const message =
+      (typeof obj.error === "string" && obj.error) ||
+      (typeof obj.message === "string" && obj.message) ||
+      bodyFallbackMessage(status);
+    return { message, errorType };
+  }
+
+  return { message: bodyFallbackMessage(status) };
+}
+
+/** apply the friendly-message registry on top of a {@link ParsedApiError}. */
+export function friendlyMessage(parsed: ParsedApiError): string {
+  if (parsed.errorType && ERROR_TYPE_MESSAGES[parsed.errorType]) {
+    return ERROR_TYPE_MESSAGES[parsed.errorType];
+  }
+  return parsed.message;
+}
+
+/**
+ * build the zod issue used by every transport's error branch: `path`
+ * carries the error_type (and the auth sentinel on 401) so existing
+ * `isAuthError`/`errors?.some(e => path.includes(...))`-style checks keep
+ * working, `message` is the friendliest text available.
+ */
+export function buildErrorIssue(
+  parsed: ParsedApiError,
+  status: number,
+): { code: "custom"; path: (string | number)[]; message: string } {
+  const path: (string | number)[] = [];
+  if (status === 401 || parsed.errorType === "unauthorized") path.push(AUTH_ERROR_PATH);
+  if (parsed.errorType) path.push(parsed.errorType);
+  return { code: "custom", path, message: friendlyMessage(parsed) };
+}
+
+/** parse + wrap a failed response body straight into a `z.ZodError`. */
+export function toZodError(body: string, status: number): z.ZodError {
+  return new z.ZodError([buildErrorIssue(parseErrorResponseBody(body, status), status)]);
+}

package/src/index.ts

@@ -1,17 +1,58 @@
 // freqhole api client - main exports
 
 // instance-based client
-export { FreqholeClient, createClient, createHttpClient, isAuthError, isNetworkError } from "./FreqholeClient.js";
+export {
+  FreqholeClient,
+  createClient,
+  createHttpClient,
+  isAuthError,
+  isNetworkError,
+} from "./FreqholeClient.js";
 export type { SafeParseResult } from "./FreqholeClient.js";
 
 // transport abstraction
-export { HttpTransport, pollingJobEvents, snapshotJobEventsViaRequest, POLL_INTERVAL_FALLBACK_MS } from "./transport.js";
+export {
+  HttpTransport,
+  pollingJobEvents,
+  snapshotJobEventsViaRequest,
+  POLL_INTERVAL_FALLBACK_MS,
+} from "./transport.js";
 export { WasmTransport } from "./WasmTransport.js";
-export { CharnelTransport, createCharnelTransport, getCharnelTransport, getCharnelNodeId, isCharnelAvailable, isCharnelP2PAvailable } from "./CharnelTransport.js";
-export { CharnelLocalTransport, createCharnelLocalTransport, JobEventsStreamClosed } from "./CharnelLocalTransport.js";
-export type { MiddenNodeLike, BlobResultLike, BlobProgressCallback, RadioHandleLike } from "./WasmTransport.js";
+export { isTauriRuntime } from "./tauriRuntime.js";
+export {
+  CharnelTransport,
+  createCharnelTransport,
+  getCharnelTransport,
+  getCharnelNodeId,
+  isCharnelAvailable,
+  isCharnelP2PAvailable,
+} from "./CharnelTransport.js";
+export {
+  CharnelLocalTransport,
+  createCharnelLocalTransport,
+  JobEventsStreamClosed,
+} from "./CharnelLocalTransport.js";
+export type {
+  MiddenNodeLike,
+  BlobResultLike,
+  BlobProgressCallback,
+  RadioHandleLike,
+  BiStreamLike,
+} from "./WasmTransport.js";
 export type { Transport, TransportResponse, BlobData } from "./transport.js";
 
+// shared error parsing/human-message conventions - the canonical place to
+// turn a server error_type into user-facing text (see docs/error-handling.md)
+export {
+  AUTH_ERROR_PATH,
+  ERROR_TYPE_MESSAGES,
+  parseErrorResponseBody,
+  friendlyMessage,
+  buildErrorIssue,
+  toZodError,
+} from "./errors.js";
+export type { ParsedApiError } from "./errors.js";
+
 // export utilities (url helpers, uploads, etc)
 export * as utils from "./utils.js";
 
@@ -39,10 +80,6 @@ export {
   AdminRequestValidationError,
   AdminResponseValidationError,
 } from "./AdminClient.js";
-export type {
-  AdminTransport,
-  AdminResponse,
-  AdminErrorDetail,
-} from "./AdminClient.js";
+export type { AdminTransport, AdminResponse, AdminErrorDetail } from "./AdminClient.js";
 export { adminCommands } from "./codegen/admin_commands.js";
 export type { AdminCommandName, AdminAuth, AdminAuthType } from "./codegen/admin_commands.js";

package/src/permissions.ts

@@ -7,12 +7,7 @@
 // the entity-specific route lookups below are tomb-specific.
 
 import { bindRoleHierarchy, type AccessRule } from "@freqhole/haruspex/permissions";
-import {
-  roleHierarchy,
-  routes,
-  type RouteAuth,
-  type UserRoleName,
-} from "./codegen/routes.js";
+import { roleHierarchy, routes, type RouteAuth, type UserRoleName } from "./codegen/routes.js";
 
 const roleChecks = bindRoleHierarchy(roleHierarchy);
 
@@ -28,10 +23,7 @@ const roleChecks = bindRoleHierarchy(roleHierarchy);
  * @param requiredRole - the minimum required role
  * @returns true if user has sufficient privileges
  */
-export function canAccessRole(
-  userRole: UserRoleName,
-  requiredRole: UserRoleName,
-): boolean {
+export function canAccessRole(userRole: UserRoleName, requiredRole: UserRoleName): boolean {
   return roleChecks.hasAtLeastRole(userRole, requiredRole);
 }
 
@@ -62,10 +54,7 @@ export function canAccessOwnerOr(
  * @param ownerId - the resource owner's id
  * @returns true if user is the owner
  */
-export function canAccessOwner(
-  userId: string,
-  ownerId: string | null,
-): boolean {
+export function canAccessOwner(userId: string, ownerId: string | null): boolean {
   return roleChecks.isOwner(userId, ownerId);
 }
 
@@ -92,7 +81,6 @@ export function canAccessRoute(
   });
 }
 
-
 // ============================================================================
 // entity-specific permission helpers
 // ============================================================================
@@ -163,16 +151,16 @@ export function canRemoveSongsFromPlaylist(
 }
 
 /**
- * check if user can delete a listen session.
- * listen sessions use OwnerOr(Admin) - owner or admin can delete.
+ * check if user can delete a playback session.
+ * playback sessions use OwnerOr(Admin) - owner or admin can delete.
  */
-export function canDeleteListenSession(
+export function canDeletePlaybackSession(
   userId: string,
   sessionOwnerId: string | null,
   userRole: UserRoleName,
 ): boolean {
-  // listen sessions use OwnerOr(Admin) - owner or admin can delete
-  const auth = routes.music.delete_listen_session.auth;
+  // playback sessions use OwnerOr(Admin) - owner or admin can delete
+  const auth = routes.music.delete_playback_session.auth;
   if (auth.type === "owner_or") {
     return canAccessOwnerOr(userId, sessionOwnerId, userRole, auth.role);
   }
@@ -180,13 +168,10 @@ export function canDeleteListenSession(
 }
 
 /**
- * check if user can update a listen session.
- * listen sessions use Owner - strictly owner only.
+ * check if user can update a playback session.
+ * playback sessions use Owner - strictly owner only.
  */
-export function canUpdateListenSession(
-  userId: string,
-  sessionOwnerId: string | null,
-): boolean {
+export function canUpdatePlaybackSession(userId: string, sessionOwnerId: string | null): boolean {
   return canAccessOwner(userId, sessionOwnerId);
 }
 
@@ -283,7 +268,7 @@ export function canCreatePlaylist(userRole: UserRoleName): boolean {
  * favorites require Member role.
  */
 export function canSetFavorite(userRole: UserRoleName): boolean {
-  const auth = routes.music.set_favorite.auth;
+  const auth = routes.entities.set_favorite.auth;
   if (auth.type === "role") {
     return canAccessRole(userRole, auth.role);
   }
@@ -295,7 +280,7 @@ export function canSetFavorite(userRole: UserRoleName): boolean {
  * ratings require Member role.
  */
 export function canSetRating(userRole: UserRoleName): boolean {
-  const auth = routes.music.set_rating.auth;
+  const auth = routes.entities.set_rating.auth;
   if (auth.type === "role") {
     return canAccessRole(userRole, auth.role);
   }
@@ -315,15 +300,12 @@ export function canUploadImage(userRole: UserRoleName): boolean {
 }
 
 /**
- * check if user can create listen sessions.
- * listen sessions require Member role.
+ * check if user can create playback sessions.
+ * playback sessions require Member role.
  */
-export function canCreateListenSession(userRole: UserRoleName): boolean {
-  const auth = routes.music.create_listen_session.auth;
-  if (auth.type === "role") {
-    return canAccessRole(userRole, auth.role);
-  }
-  return false;
+export function canCreatePlaybackSession(userRole: UserRoleName): boolean {
+  // route auth is "authenticated" (any logged-in role), not role-gated - use the generic check
+  return canAccessRoute(routes.music.create_playback_session.auth, userRole, null, null);
 }
 
 /**

package/src/tauriRuntime.ts

@@ -0,0 +1,22 @@
+// the one place that knows how to detect a tauri runtime.
+//
+// tauri v2 only injects `window.__TAURI__` when `app.withGlobalTauri` is
+// enabled in tauri.conf.json - freqhole does NOT enable it, so any
+// `"__TAURI__" in window` check is silently false in the real desktop app.
+// `__TAURI_INTERNALS__` is always injected, and probing its `invoke` (rather
+// than mere property existence) avoids false positives from browser
+// extensions that define the namespace without a working runtime.
+//
+// every tauri-detection site in the codebase must route through here rather
+// than sniffing globals directly, so a future tauri change is a one-line fix.
+
+declare global {
+  interface Window {
+    __TAURI_INTERNALS__?: { invoke?: unknown };
+  }
+}
+
+/** true when running inside a tauri webview with a usable ipc bridge. */
+export function isTauriRuntime(): boolean {
+  return typeof window !== "undefined" && typeof window.__TAURI_INTERNALS__?.invoke === "function";
+}

package/src/test/fixtures.ts

@@ -151,11 +151,10 @@ export const addSongsToPlaylistRequest: s.AddSongsToPlaylistRequest = {
   song_ids: [PLACEHOLDER_ID],
 };
 
-export const removeSongsFromPlaylistRequest: s.RemoveSongsFromPlaylistRequest =
-  {
-    playlist_id: PLACEHOLDER_ID,
-    song_ids: [PLACEHOLDER_ID],
-  };
+export const removeSongsFromPlaylistRequest: s.RemoveSongsFromPlaylistRequest = {
+  playlist_id: PLACEHOLDER_ID,
+  song_ids: [PLACEHOLDER_ID],
+};
 
 export const reorderPlaylistSongsRequest: s.ReorderPlaylistSongsRequest = {
   playlist_id: PLACEHOLDER_ID,
@@ -163,12 +162,11 @@ export const reorderPlaylistSongsRequest: s.ReorderPlaylistSongsRequest = {
   new_position: 0,
 };
 
-export const removePlaylistThumbnailRequest: s.RemovePlaylistThumbnailRequest =
-  {
-    playlist_id: PLACEHOLDER_ID,
-    cleanup_blob: false,
-    deleted_by: null,
-  };
+export const removePlaylistThumbnailRequest: s.RemovePlaylistThumbnailRequest = {
+  playlist_id: PLACEHOLDER_ID,
+  cleanup_blob: false,
+  deleted_by: null,
+};
 
 // Favorites
 export const listFavoritesRequest: s.ListFavoritesRequest = {
@@ -312,6 +310,7 @@ export const getJobsStatusRequest: s.GetJobsStatusRequest = {
 // Fetch
 export const fetchMediaParams: s.FetchMediaParams = {
   url: "https://example.com/video",
+  domain: "music",
   user_id: null,
 };
 
@@ -336,10 +335,7 @@ export const redeemInviteRequest: s.RedeemInviteRequest = {
 // ============================================================================
 
 // merge fixture with overrides, replacing PLACEHOLDER_ID with real IDs
-export function merge<T extends Record<string, any>>(
-  fixture: T,
-  overrides: Partial<T>,
-): T {
+export function merge<T extends Record<string, any>>(fixture: T, overrides: Partial<T>): T {
   const merged = { ...fixture, ...overrides };
 
   // recursively replace PLACEHOLDER_ID in the merged object
@@ -357,10 +353,7 @@ export function withId<T extends { id?: string }>(fixture: T, id: string): T {
 }
 
 // create a fixture with specific entity_id
-export function withEntityId<T extends { entity_id?: string }>(
-  fixture: T,
-  entityId: string,
-): T {
+export function withEntityId<T extends { entity_id?: string }>(fixture: T, entityId: string): T {
   return { ...fixture, entity_id: entityId };
 }
 
@@ -373,10 +366,7 @@ export function withPlaylistId<T extends { playlist_id?: string }>(
 }
 
 // create a fixture with specific album_id
-export function withAlbumId<T extends { album_id?: string }>(
-  fixture: T,
-  albumId: string,
-): T {
+export function withAlbumId<T extends { album_id?: string }>(fixture: T, albumId: string): T {
   return { ...fixture, album_id: albumId };
 }
 

package/src/test/integration.ts

@@ -13,11 +13,7 @@
 //
 // runs without API_KEY - uses placeholder data to trigger auth checks
 import { createHttpClient } from "../FreqholeClient.js";
-import {
-  fixtures,
-  PLACEHOLDER_ID,
-  queryParams,
-} from "./fixtures.js";
+import { fixtures, PLACEHOLDER_ID, queryParams } from "./fixtures.js";
 
 const baseUrl = process.env.API_URL || "http://localhost:8080";
 
@@ -34,9 +30,7 @@ export async function runIntegrationTests() {
       console.log(`✓ ${name}`);
       passed++;
     } catch (err) {
-      console.log(
-        `✗ ${name}: ${err instanceof Error ? err.message : "unknown error"}`,
-      );
+      console.log(`✗ ${name}: ${err instanceof Error ? err.message : "unknown error"}`);
       failed++;
     }
   }
@@ -145,13 +139,11 @@ export async function runIntegrationTests() {
     },
     {
       name: "music.removeSongsFromPlaylist",
-      fn: () =>
-        client.music.removeSongsFromPlaylist(fixtures.removeSongsFromPlaylist),
+      fn: () => client.music.removeSongsFromPlaylist(fixtures.removeSongsFromPlaylist),
     },
     {
       name: "music.reorderPlaylistSongs",
-      fn: () =>
-        client.music.reorderPlaylistSongs(fixtures.reorderPlaylistSongs),
+      fn: () => client.music.reorderPlaylistSongs(fixtures.reorderPlaylistSongs),
     },
     {
       name: "music.deleteImage",
@@ -167,22 +159,22 @@ export async function runIntegrationTests() {
       fn: () => client.music.listFavorites(fixtures.listFavorites),
     },
     {
-      name: "music.setFavorite",
-      fn: () => client.music.setFavorite(fixtures.setFavorite),
+      name: "entities.setFavorite",
+      fn: () => client.entities.setFavorite(fixtures.setFavorite),
     },
 
     // ratings
     {
-      name: "music.setRating",
-      fn: () => client.music.setRating(fixtures.setRating),
+      name: "entities.setRating",
+      fn: () => client.entities.setRating(fixtures.setRating),
     },
     {
-      name: "music.removeRating",
-      fn: () => client.music.removeRating(fixtures.removeRating),
+      name: "entities.removeRating",
+      fn: () => client.entities.removeRating(fixtures.removeRating),
     },
     {
-      name: "music.getRatingStats",
-      fn: () => client.music.getRatingStats(fixtures.getRatingStats),
+      name: "entities.getRatingStats",
+      fn: () => client.entities.getRatingStats(fixtures.getRatingStats),
     },
 
     // tags
@@ -249,8 +241,7 @@ export async function runIntegrationTests() {
     // musicbrainz
     {
       name: "music.searchMusicbrainzReleases",
-      fn: () =>
-        client.music.searchMusicbrainzReleases(fixtures.searchReleases),
+      fn: () => client.music.searchMusicbrainzReleases(fixtures.searchReleases),
     },
     {
       name: "music.getMusicbrainzRelease",
@@ -307,12 +298,8 @@ export async function runIntegrationTests() {
   }
 
   console.log("");
-  console.log(
-    "✓ auth validation complete - all routes reject without credentials\n",
-  );
-  console.log(
-    "  (authenticated workflows tested in stateful tests - see stateful.ts)\n",
-  );
+  console.log("✓ auth validation complete - all routes reject without credentials\n");
+  console.log("  (authenticated workflows tested in stateful tests - see stateful.ts)\n");
 
   console.log(`\n${passed} passed, ${failed} failed\n`);
 

package/src/test/stateful.ts

@@ -55,9 +55,7 @@ export async function runStatefulTests() {
       console.log(`✓ ${name}`);
       passed++;
     } catch (err) {
-      console.log(
-        `✗ ${name}: ${err instanceof Error ? err.message : "unknown error"}`,
-      );
+      console.log(`✗ ${name}: ${err instanceof Error ? err.message : "unknown error"}`);
       failed++;
     }
   }
@@ -119,11 +117,7 @@ export async function runStatefulTests() {
   console.log("");
 
   // abort if setup failed
-  if (
-    !testState.existingSongId ||
-    !testState.existingAlbumId ||
-    !testState.existingGenreId
-  ) {
+  if (!testState.existingSongId || !testState.existingAlbumId || !testState.existingGenreId) {
     console.log("✗ setup failed - aborting stateful tests\n");
     return { passed, failed };
   }
@@ -216,9 +210,7 @@ export async function runStatefulTests() {
       offset: 0,
     });
     if (!result.success) {
-      throw new Error(
-        `failed to query playlist songs: ${result.error.message}`,
-      );
+      throw new Error(`failed to query playlist songs: ${result.error.message}`);
     }
     if (!result.data.items || result.data.items.length === 0) {
       throw new Error("expected at least one song in playlist");
@@ -248,7 +240,7 @@ export async function runStatefulTests() {
   });
 
   await test("set favorite on song", async () => {
-    const result = await client.music.setFavorite({
+    const result = await client.entities.setFavorite({
       user_id: testState.userId!,
       target_type: "song",
       target_id: testState.existingSongId!,
@@ -272,7 +264,7 @@ export async function runStatefulTests() {
   });
 
   await test("set rating on song", async () => {
-    const result = await client.music.setRating({
+    const result = await client.entities.setRating({
       user_id: testState.userId!,
       target_type: "song",
       target_id: testState.existingSongId!,
@@ -284,7 +276,7 @@ export async function runStatefulTests() {
   });
 
   await test("get rating stats", async () => {
-    const result = await client.music.getRatingStats({
+    const result = await client.entities.getRatingStats({
       target_type: "song",
       target_id: testState.existingSongId!,
     });
@@ -375,16 +367,12 @@ export async function runStatefulTests() {
       context: null,
     });
     if (!result.success) {
-      throw new Error(
-        `failed to get song suggestions: ${result.error.message}`,
-      );
+      throw new Error(`failed to get song suggestions: ${result.error.message}`);
     }
     // verify all suggestions are songs
     for (const suggestion of result.data.suggestions) {
       if (suggestion.suggestion_type !== "song") {
-        throw new Error(
-          `expected song suggestions, got ${suggestion.suggestion_type}`,
-        );
+        throw new Error(`expected song suggestions, got ${suggestion.suggestion_type}`);
       }
     }
   });
@@ -447,9 +435,7 @@ export async function runStatefulTests() {
       },
     });
     if (!result.success) {
-      throw new Error(
-        `failed to search with tag filter: ${result.error.message}`,
-      );
+      throw new Error(`failed to search with tag filter: ${result.error.message}`);
     }
     // verify context was applied (may or may not return results depending on data)
     if (!result.data.applied_filters) {
@@ -477,9 +463,7 @@ export async function runStatefulTests() {
       },
     });
     if (!result.success) {
-      throw new Error(
-        `failed to search with exclude filter: ${result.error.message}`,
-      );
+      throw new Error(`failed to search with exclude filter: ${result.error.message}`);
     }
     // verify exclude filter was applied
     if (typeof result.data.total_count !== "number") {
@@ -507,9 +491,7 @@ export async function runStatefulTests() {
       },
     });
     if (!result.success) {
-      throw new Error(
-        `failed to search all types with tags: ${result.error.message}`,
-      );
+      throw new Error(`failed to search all types with tags: ${result.error.message}`);
     }
     // verify response structure (results depend on data with tag002)
     if (!result.data.songs) {