@syra.fm/sdk 0.3.0 → 0.5.0

package/lib/typescript/module/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;GAMG;AAEH,mFAAmF;AACnF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAKhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,4CAA4C;AAC5C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,yBAAyB;AACzB,MAAM,MAAM,WAAW,GAAG,MAAM,aAAa,CAAC;AAE9C;;;GAGG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW7B,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE9D;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAa/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/package.json

@@ -1,39 +1,48 @@
 {
   "name": "@syra.fm/sdk",
-  "version": "0.3.0",
-  "description": "Headless, isomorphic client for the Syra public API — catalog reads and 30s preview clips. No React/RN/DOM dependencies; public reads only.",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/types/index.d.ts",
+  "version": "0.5.0",
+  "description": "Syra SDK — headless, isomorphic catalog client (Node/React-free, public reads + 30s previews) that also ships the Syra live-rooms engine (audio rooms over LiveKit) on React Native and web.",
   "source": "src/index.ts",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/commonjs/index.d.ts",
+  "react-native": "src/index.native.ts",
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
   "exports": {
     ".": {
+      "react-native": "./src/index.native.ts",
+      "browser": {
+        "types": "./lib/typescript/module/index.native.d.ts",
+        "import": "./lib/module/index.native.js",
+        "require": "./lib/commonjs/index.native.js"
+      },
       "import": {
-        "types": "./dist/types/index.d.ts",
-        "default": "./dist/esm/index.js"
+        "types": "./lib/typescript/module/index.d.ts",
+        "default": "./lib/module/index.js"
       },
       "require": {
-        "types": "./dist/types/index.d.ts",
-        "default": "./dist/cjs/index.js"
+        "types": "./lib/typescript/commonjs/index.d.ts",
+        "default": "./lib/commonjs/index.js"
       },
-      "default": "./dist/esm/index.js"
+      "default": "./lib/module/index.js"
     },
+    "./src/live/assets/*": "./src/live/assets/*",
     "./package.json": "./package.json"
   },
   "files": [
-    "dist",
-    "src"
+    "src",
+    "lib"
   ],
   "keywords": [
     "syra",
     "sdk",
     "music",
     "api-client",
-    "preview"
+    "preview",
+    "live-rooms"
   ],
   "author": "Syra Team",
   "license": "MIT",
@@ -41,21 +50,124 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "bun run clean && bun run build:cjs && bun run build:esm && bun run build:types && bun run build:markers",
-    "build:cjs": "tsc -p tsconfig.cjs.json",
-    "build:esm": "tsc -p tsconfig.esm.json && node scripts/fix-esm-imports.mjs",
-    "build:types": "tsc -p tsconfig.types.json",
-    "build:markers": "node scripts/write-dist-markers.mjs",
-    "clean": "rm -rf dist",
-    "typecheck": "tsc -p tsconfig.json",
+    "build": "bob build",
+    "clean": "rm -rf lib",
+    "typecheck": "tsc --noEmit -p tsconfig.build.json",
     "test": "bun test src",
     "prepublishOnly": "bun run build"
   },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "exclude": "{**/{__tests__,__mocks__}/**,**/*.{test,spec}.{ts,tsx},**/*.mp3}",
+    "targets": [
+      [
+        "commonjs",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ],
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  },
   "dependencies": {
     "zod": "^3.25.76"
   },
+  "peerDependencies": {
+    "react": "^19.2.3",
+    "react-native": "^0.85.3",
+    "react-native-reanimated": "^4.3.1",
+    "react-native-safe-area-context": "^5.7.0",
+    "@oxyhq/services": "^13.1.7",
+    "@oxyhq/core": "^5.2.1",
+    "livekit-client": "^2.20.0",
+    "@livekit/react-native": "^2.11.1",
+    "expo-audio": "~56.0.12",
+    "expo-image-picker": "~56.0.18",
+    "socket.io-client": "^4.8.1",
+    "@expo/vector-icons": "^15.0.2",
+    "react-native-svg": "15.15.4",
+    "sonner-native": "^0.21.1",
+    "expo-blur": "~56.0.3"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    },
+    "react-native-reanimated": {
+      "optional": true
+    },
+    "react-native-safe-area-context": {
+      "optional": true
+    },
+    "@oxyhq/services": {
+      "optional": true
+    },
+    "@oxyhq/core": {
+      "optional": true
+    },
+    "livekit-client": {
+      "optional": true
+    },
+    "@livekit/react-native": {
+      "optional": true
+    },
+    "expo-audio": {
+      "optional": true
+    },
+    "expo-image-picker": {
+      "optional": true
+    },
+    "socket.io-client": {
+      "optional": true
+    },
+    "@expo/vector-icons": {
+      "optional": true
+    },
+    "react-native-svg": {
+      "optional": true
+    },
+    "sonner-native": {
+      "optional": true
+    },
+    "expo-blur": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/node": "^20.0.0",
-    "typescript": "~5.9.2"
+    "@types/react": "~19.2.14",
+    "react-native-builder-bob": "^0.40.16",
+    "nativewind": "5.0.0-preview.3",
+    "typescript": "~5.9.3",
+    "react": "^19.2.3",
+    "react-native": "^0.85.3",
+    "react-native-reanimated": "^4.3.1",
+    "react-native-safe-area-context": "^5.7.0",
+    "@oxyhq/services": "^13.1.7",
+    "@oxyhq/core": "^5.2.1",
+    "livekit-client": "^2.20.0",
+    "@livekit/react-native": "^2.11.1",
+    "expo-audio": "~56.0.12",
+    "expo-image-picker": "~56.0.18",
+    "socket.io-client": "^4.8.1",
+    "@expo/vector-icons": "^15.0.2",
+    "react-native-svg": "15.15.4",
+    "sonner-native": "^0.21.1",
+    "expo-blur": "~56.0.3"
   }
 }

package/src/client.test.ts

@@ -45,6 +45,29 @@ function makePodcast(overrides: Record<string, unknown> = {}): Record<string, un
   };
 }
 
+function makeEpisode(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+  return {
+    id: '507f1f77bcf86cd799439031',
+    podcastId: '507f1f77bcf86cd799439021',
+    podcastTitle: 'Test Show',
+    title: 'Test Episode',
+    description: 'An episode about testing.',
+    guid: 'guid-1',
+    enclosureUrl: 'https://api.fastcast.ai/audio/guid-1.mp3',
+    enclosureType: 'audio/mpeg',
+    enclosureLength: 12_345_678,
+    duration: 1800,
+    pubDate: '2026-01-01T00:00:00.000Z',
+    episodeType: 'full',
+    image: '507f1f77bcf86cd799439032',
+    imageSourceUrl: 'https://cdn.example.com/episode.jpg',
+    status: 'ready',
+    createdAt: '2026-01-01T00:00:00.000Z',
+    updatedAt: '2026-01-01T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
 interface FetchCall {
   url: string;
 }
@@ -445,3 +468,165 @@ describe('createSyraClient.podcastArtworkUrl', () => {
     expect(client.podcastArtworkUrl({ image: 'not-an-id' })).toBeUndefined();
   });
 });
+
+// ── getPodcastEpisodes ──────────────────────────────────────────────────────────
+
+describe('createSyraClient.getPodcastEpisodes', () => {
+  it('calls /api/podcasts/:id/episodes with page and limit and returns parsed episodes', async () => {
+    const { fetch, calls } = fakeFetch(() => ({
+      body: {
+        data: [
+          makeEpisode({ id: '507f1f77bcf86cd799439031' }),
+          makeEpisode({ id: '507f1f77bcf86cd799439033', title: 'Second Episode' }),
+        ],
+        total: 2,
+        page: 1,
+        limit: 20,
+      },
+    }));
+
+    const client = createSyraClient({ baseURL: 'https://api.example.test', fetch });
+    const page = await client.getPodcastEpisodes('507f1f77bcf86cd799439021', { limit: 20 });
+
+    expect(page.items).toHaveLength(2);
+    expect(page.items[0].id).toBe('507f1f77bcf86cd799439031');
+    expect(page.items[0].enclosureUrl).toBe('https://api.fastcast.ai/audio/guid-1.mp3');
+    expect(page.hasMore).toBe(false);
+    expect(page.limit).toBe(20);
+    expect(page.offset).toBe(0);
+
+    expect(calls).toHaveLength(1);
+    const url = new URL(calls[0].url);
+    expect(url.pathname).toBe('/api/podcasts/507f1f77bcf86cd799439021/episodes');
+    expect(url.searchParams.get('page')).toBe('1');
+    expect(url.searchParams.get('limit')).toBe('20');
+  });
+
+  it('translates a zero-based offset into a 1-based page and derives hasMore from total', async () => {
+    const { fetch, calls } = fakeFetch(() => ({
+      body: { data: [makeEpisode()], total: 45, page: 3, limit: 10 },
+    }));
+
+    const client = createSyraClient({ baseURL: 'https://api.example.test', fetch });
+    const page = await client.getPodcastEpisodes('507f1f77bcf86cd799439021', {
+      limit: 10,
+      offset: 20,
+    });
+
+    // offset 20 / limit 10 → page 3; 3 * 10 = 30 < 45 → more remain.
+    const url = new URL(calls[0].url);
+    expect(url.searchParams.get('page')).toBe('3');
+    expect(url.searchParams.get('limit')).toBe('10');
+    expect(page.offset).toBe(20);
+    expect(page.limit).toBe(10);
+    expect(page.hasMore).toBe(true);
+  });
+
+  it('reports hasMore=false when the page reaches the end of the total', async () => {
+    const { fetch } = fakeFetch(() => ({
+      body: { data: [makeEpisode()], total: 20, page: 2, limit: 10 },
+    }));
+    const client = createSyraClient({ fetch });
+    const page = await client.getPodcastEpisodes('507f1f77bcf86cd799439021', {
+      limit: 10,
+      offset: 10,
+    });
+    // page 2 * limit 10 = 20, not < total 20 → this is the last page.
+    expect(page.hasMore).toBe(false);
+  });
+
+  it('drops a row missing the required enclosureUrl without throwing', async () => {
+    const { fetch } = fakeFetch(() => ({
+      body: {
+        data: [makeEpisode({ enclosureUrl: undefined }), makeEpisode()],
+        total: 2,
+      },
+    }));
+    const client = createSyraClient({ fetch });
+    const page = await client.getPodcastEpisodes('507f1f77bcf86cd799439021', { limit: 10 });
+    expect(page.items).toHaveLength(1);
+    expect(page.items[0].enclosureUrl).toBe('https://api.fastcast.ai/audio/guid-1.mp3');
+  });
+
+  it('defaults the limit and returns an empty page when data is absent', async () => {
+    const { fetch, calls } = fakeFetch(() => ({ body: {} }));
+    const client = createSyraClient({ fetch });
+    const page = await client.getPodcastEpisodes('507f1f77bcf86cd799439021');
+    expect(page.items).toEqual([]);
+    expect(page.hasMore).toBe(false);
+    expect(page.offset).toBe(0);
+    expect(page.limit).toBe(20);
+    const url = new URL(calls[0].url);
+    expect(url.searchParams.get('page')).toBe('1');
+    expect(url.searchParams.get('limit')).toBe('20');
+  });
+});
+
+// ── getEpisode ──────────────────────────────────────────────────────────────────
+
+describe('createSyraClient.getEpisode', () => {
+  it('fetches /api/episodes/:id and validates data.episode', async () => {
+    const { fetch, calls } = fakeFetch(() => ({
+      body: { data: { episode: makeEpisode(), persons: [] } },
+    }));
+    const client = createSyraClient({ baseURL: 'https://api.example.test', fetch });
+
+    const episode = await client.getEpisode('507f1f77bcf86cd799439031');
+    expect(episode.title).toBe('Test Episode');
+    expect(episode.enclosureUrl).toBe('https://api.fastcast.ai/audio/guid-1.mp3');
+    expect(calls[0].url).toBe('https://api.example.test/api/episodes/507f1f77bcf86cd799439031');
+  });
+
+  it('throws SyraApiError on a non-2xx response', async () => {
+    const { fetch } = fakeFetch(() => ({ status: 404, body: { error: 'not found' } }));
+    const client = createSyraClient({ fetch });
+    await expect(client.getEpisode('507f1f77bcf86cd799439031')).rejects.toBeInstanceOf(SyraApiError);
+  });
+
+  it('throws when data.episode fails schema validation', async () => {
+    const { fetch } = fakeFetch(() => ({ body: { data: { episode: { id: 'x' } } } }));
+    const client = createSyraClient({ fetch });
+    await expect(client.getEpisode('x')).rejects.toThrow();
+  });
+});
+
+// ── episodeImageUrl ──────────────────────────────────────────────────────────────
+
+describe('createSyraClient.episodeImageUrl', () => {
+  const client = createSyraClient({ baseURL: 'https://api.example.test' });
+
+  it('resolves the re-hosted image id to an absolute images URL', () => {
+    expect(client.episodeImageUrl({ image: '507f1f77bcf86cd799439032' })).toBe(
+      'https://api.example.test/api/images/507f1f77bcf86cd799439032',
+    );
+  });
+
+  it('prefers a named size from imageSizes', () => {
+    const url = client.episodeImageUrl(
+      {
+        image: '507f1f77bcf86cd799439032',
+        imageSizes: {
+          large: {
+            id: '507f1f77bcf86cd799439033',
+            url: '/api/images/507f1f77bcf86cd799439033',
+            width: 640,
+            height: 640,
+          },
+        },
+      },
+      'large',
+    );
+    expect(url).toBe('https://api.example.test/api/images/507f1f77bcf86cd799439033');
+  });
+
+  it('falls back to imageSourceUrl when no Syra image is present', () => {
+    expect(client.episodeImageUrl({ imageSourceUrl: 'https://cdn.example.com/episode.jpg' })).toBe(
+      'https://cdn.example.com/episode.jpg',
+    );
+  });
+
+  it('returns undefined when nothing resolvable is present', () => {
+    expect(client.episodeImageUrl({})).toBeUndefined();
+    expect(client.episodeImageUrl({ image: 'not-an-id' })).toBeUndefined();
+  });
+});

package/src/client.ts

@@ -1,8 +1,10 @@
 import {
   trackSummarySchema,
   podcastSummarySchema,
+  episodeSummarySchema,
   type TrackSummary,
   type PodcastSummary,
+  type EpisodeSummary,
   type CoverArtSizes,
   type ArtworkSize,
 } from './schema';
@@ -45,6 +47,13 @@ export interface SearchPodcastsOptions {
   offset?: number;
 }
 
+export interface PodcastEpisodesOptions {
+  /** Maximum number of episodes to request from the API (the page size). */
+  limit?: number;
+  /** Zero-based offset of the first episode to return (for infinite scroll). */
+  offset?: number;
+}
+
 /**
  * One page of paginated catalog search results.
  *
@@ -78,6 +87,13 @@ export interface PodcastArtworkSource {
   imageSourceUrl?: string | null;
 }
 
+/** Minimal shape from which podcast-episode artwork URLs can be derived. */
+export interface EpisodeArtworkSource {
+  image?: string | null;
+  imageSizes?: CoverArtSizes | null;
+  imageSourceUrl?: string | null;
+}
+
 export interface SyraClient {
   /**
    * Search the public catalog for tracks. Returns one paginated page: rows are
@@ -115,6 +131,31 @@ export interface SyraClient {
    * external artwork URL. Returns `undefined` when no artwork can be derived.
    */
   podcastArtworkUrl(source: PodcastArtworkSource, size?: ArtworkSize): string | undefined;
+  /**
+   * List a podcast show's EPISODES (newest first, as the backend orders them).
+   * Returns one paginated page: rows are validated against the episode-summary
+   * schema and malformed rows are dropped — including any without a playable
+   * `enclosureUrl`, which the schema requires. The backend paginates by 1-based
+   * `page`, but this keeps the uniform offset-based {@link SearchPage} for parity
+   * with {@link SyraClient.searchPodcasts}; paginate by advancing `offset` by
+   * `limit` (the page size), never by `items.length`.
+   */
+  getPodcastEpisodes(
+    podcastId: string,
+    options?: PodcastEpisodesOptions,
+  ): Promise<SearchPage<EpisodeSummary>>;
+  /**
+   * Fetch a single episode by id, validated against the episode-summary schema.
+   * The by-id endpoint nests the episode under `data.episode` alongside resolved
+   * persons; this returns just the episode summary needed to stream its audio.
+   */
+  getEpisode(episodeId: string): Promise<EpisodeSummary>;
+  /**
+   * Resolve an absolute artwork URL from a podcast episode reference. Prefers the
+   * re-hosted Syra image, then the requested/fallback variant, then the original
+   * external artwork URL. Returns `undefined` when no artwork can be derived.
+   */
+  episodeImageUrl(source: EpisodeArtworkSource, size?: ArtworkSize): string | undefined;
 }
 
 /** Order used to pick the best available artwork variant when none is named. */
@@ -129,6 +170,12 @@ const ARTWORK_FALLBACK_ORDER: ArtworkSize[] = [
 
 const OBJECT_ID_PATTERN = /^[a-f\d]{24}$/i;
 
+/**
+ * Default episode page size, matching the backend's own default so the SDK's
+ * offset→page translation lines up with the server's pagination window.
+ */
+const DEFAULT_EPISODES_PAGE_SIZE = 20;
+
 /** Read a finite number from an unknown response field, else a fallback. */
 function numberOr(value: unknown, fallback: number): number {
   return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
@@ -152,6 +199,17 @@ interface PodcastDetailResponseShape {
   data?: { podcast?: unknown };
 }
 
+interface PodcastEpisodesResponseShape {
+  data?: unknown[];
+  total?: unknown;
+  page?: unknown;
+  limit?: unknown;
+}
+
+interface EpisodeDetailResponseShape {
+  data?: { episode?: unknown };
+}
+
 /**
  * Create a headless client for the public Syra API. Public reads only — there
  * is no authentication in this version.
@@ -344,5 +402,72 @@ export function createSyraClient(options: SyraClientOptions = {}): SyraClient {
 
       return resolveImageRef(source.imageSourceUrl);
     },
+
+    async getPodcastEpisodes(podcastId, listOptions = {}) {
+      // The endpoint paginates by 1-based `page`; translate the SDK's uniform
+      // offset-based paging into it. `limit` must be concrete (unlike search,
+      // which can omit it) because the page number is derived from it.
+      const limit = listOptions.limit ?? DEFAULT_EPISODES_PAGE_SIZE;
+      const offset = listOptions.offset ?? 0;
+      const page = Math.floor(offset / limit) + 1;
+
+      const json = (await getJson(
+        `/api/podcasts/${encodeURIComponent(podcastId)}/episodes?page=${page}&limit=${limit}`,
+      )) as PodcastEpisodesResponseShape;
+      const rawEpisodes = Array.isArray(json?.data) ? json.data : [];
+
+      const items: EpisodeSummary[] = [];
+      for (const raw of rawEpisodes) {
+        // A single malformed episode row must not fail the whole listing.
+        const parsed = episodeSummarySchema.safeParse(raw);
+        if (parsed.success) {
+          items.push(parsed.data);
+        }
+      }
+
+      // `total` is the backend's full count over the show; derive `hasMore` from
+      // it rather than `items.length`, which the schema/enclosure filter above may
+      // shrink below `limit` on a page that is NOT the last one. Absent a count,
+      // fall back to what we have (this page ends the listing).
+      const total = numberOr(json?.total, offset + items.length);
+      return {
+        items,
+        hasMore: page * limit < total,
+        limit,
+        offset,
+      };
+    },
+
+    async getEpisode(episodeId) {
+      const json = (await getJson(
+        `/api/episodes/${encodeURIComponent(episodeId)}`,
+      )) as EpisodeDetailResponseShape;
+      return episodeSummarySchema.parse(json?.data?.episode);
+    },
+
+    episodeImageUrl(source, size) {
+      if (size && source.imageSizes) {
+        const resolved = resolveImageRef(source.imageSizes[size]?.url);
+        if (resolved) {
+          return resolved;
+        }
+      }
+
+      const fromImage = resolveImageRef(source.image);
+      if (fromImage) {
+        return fromImage;
+      }
+
+      if (source.imageSizes) {
+        for (const key of ARTWORK_FALLBACK_ORDER) {
+          const resolved = resolveImageRef(source.imageSizes[key]?.url);
+          if (resolved) {
+            return resolved;
+          }
+        }
+      }
+
+      return resolveImageRef(source.imageSourceUrl);
+    },
   };
 }

package/src/index.native.ts

@@ -0,0 +1,2 @@
+export * from './index';
+export * from './live';

package/src/index.ts

@@ -8,19 +8,23 @@ export type {
   SyraClientOptions,
   SearchTracksOptions,
   SearchPodcastsOptions,
+  PodcastEpisodesOptions,
   SearchPage,
   ArtworkSource,
   PodcastArtworkSource,
+  EpisodeArtworkSource,
 } from './client';
 export {
   trackSummarySchema,
   podcastSummarySchema,
+  episodeSummarySchema,
   coverArtSizesSchema,
   coverArtVariantSchema,
 } from './schema';
 export type {
   TrackSummary,
   PodcastSummary,
+  EpisodeSummary,
   CoverArtSizes,
   CoverArtVariant,
   ArtworkSize,

package/src/live/assets/icons/spaces-icon.tsx

@@ -0,0 +1,15 @@
+import React from 'react';
+import Svg, { Path } from 'react-native-svg';
+import { ViewStyle, type ColorValue } from 'react-native';
+
+export const LiveRoomsIcon = ({ color = 'currentColor', size = 26, style }: { color?: ColorValue; size?: number; style?: ViewStyle }) => (
+  <Svg viewBox="0 0 24 24" width={size} height={size} style={style}>
+    <Path d="M12 22.25c-4.99 0-9.18-3.393-10.39-7.994l1.93-.512c.99 3.746 4.4 6.506 8.46 6.506s7.47-2.76 8.46-6.506l1.93.512c-1.21 4.601-5.4 7.994-10.39 7.994zM5 11.5c0 3.866 3.13 7 7 7s7-3.134 7-7V8.75c0-3.866-3.13-7-7-7s-7 3.134-7 7v2.75zm12-2.75v2.75c0 2.761-2.24 5-5 5s-5-2.239-5-5V8.75c0-2.761 2.24-5 5-5s5 2.239 5 5zM11.25 8v4.25c0 .414.34.75.75.75s.75-.336.75-.75V8c0-.414-.34-.75-.75-.75s-.75.336-.75.75zm-3 1v2.25c0 .414.34.75.75.75s.75-.336.75-.75V9c0-.414-.34-.75-.75-.75s-.75.336-.75.75zm7.5 0c0-.414-.34-.75-.75-.75s-.75.336-.75.75v2.25c0 .414.34.75.75.75s.75-.336.75-.75V9z" fill={color} />
+  </Svg>
+);
+
+export const LiveRoomsIconActive = ({ color = 'currentColor', size = 26, style }: { color?: ColorValue; size?: number; style?: ViewStyle }) => (
+  <Svg viewBox="0 0 24 24" width={size} height={size} style={style}>
+    <Path d="M12 22.25c-4.99 0-9.18-3.393-10.39-7.994l1.93-.512c.99 3.746 4.4 6.506 8.46 6.506s7.47-2.76 8.46-6.506l1.93.512c-1.21 4.601-5.4 7.994-10.39 7.994zm0-20.5c-3.87 0-7 3.134-7 7v2.75c0 3.866 3.13 7 7 7s7-3.134 7-7V8.75c0-3.866-3.13-7-7-7zm-2.25 9.5c0 .414-.34.75-.75.75s-.75-.336-.75-.75V9c0-.414.34-.75.75-.75s.75.336.75.75v2.25zm3 1c0 .414-.34.75-.75.75s-.75-.336-.75-.75V8c0-.414.34-.75.75-.75s.75.336.75.75v4.25zm3-1c0 .414-.34.75-.75.75s-.75-.336-.75-.75V9c0-.414.34-.75.75-.75s.75.336.75.75v2.25z" fill={color} />
+  </Svg>
+);

package/src/live/assets/icons/syra-icon.tsx

@@ -0,0 +1,13 @@
+import React from 'react';
+import Svg, { Rect } from 'react-native-svg';
+import { ViewStyle, type ColorValue } from 'react-native';
+
+export const SyraIcon = ({ color = 'currentColor', size = 26, style }: { color?: ColorValue; size?: number; style?: ViewStyle }) => (
+  <Svg viewBox="0 0 500 500" width={size} height={size} style={style}>
+    <Rect x="303.35" y="46.22" width="128.77" height="407.56" fill={color} />
+    <Rect x="153.71" y="88.97" width="106.76" height="322.05" fill={color} />
+    <Rect x="25" y="131.94" width="86.2" height="236.13" fill={color} />
+  </Svg>
+);
+
+export const SyraIconActive = SyraIcon;

package/src/live/components/AnimatedPulse.tsx

@@ -0,0 +1,52 @@
+import React, { useEffect } from 'react';
+import { StyleSheet } from 'react-native';
+import Animated, {
+  useSharedValue,
+  useAnimatedStyle,
+  withRepeat,
+  withTiming,
+  Easing,
+} from 'react-native-reanimated';
+
+interface AnimatedPulseProps {
+  size?: number;
+  color?: string;
+}
+
+export const AnimatedPulse = React.memo(function AnimatedPulse({
+  size = 8,
+  color = '#FFFFFF',
+}: AnimatedPulseProps) {
+  const opacity = useSharedValue(1);
+
+  useEffect(() => {
+    opacity.value = withRepeat(
+      withTiming(0.3, { duration: 500, easing: Easing.inOut(Easing.ease) }),
+      -1,
+      true,
+    );
+  }, [opacity]);
+
+  const animatedStyle = useAnimatedStyle(() => ({
+    opacity: opacity.value,
+  }));
+
+  return (
+    <Animated.View
+      style={[
+        styles.dot,
+        {
+          width: size,
+          height: size,
+          borderRadius: size / 2,
+          backgroundColor: color,
+        },
+        animatedStyle,
+      ]}
+    />
+  );
+});
+
+const styles = StyleSheet.create({
+  dot: {},
+});