@syra.fm/sdk 0.9.0 → 0.11.0

package/src/client.ts

@@ -2,9 +2,16 @@ import {
   trackSummarySchema,
   podcastSummarySchema,
   episodeSummarySchema,
+  episodeDraftSchema,
+  episodeStreamSchema,
+  uploadedImageSchema,
   type TrackSummary,
   type PodcastSummary,
   type EpisodeSummary,
+  type EpisodeDraft,
+  type EpisodeStream,
+  type UploadedImage,
+  type PodcastVisibility,
   type CoverArtSizes,
   type ArtworkSize,
 } from './schema';
@@ -28,9 +35,24 @@ export interface SyraClientOptions {
   /**
    * `fetch` implementation. Defaults to the global `fetch` (Node 18+, browsers,
    * React Native). Inject one (e.g. `node-fetch`) when no global is available.
-   * This is the seam where an authenticated transport can be layered in later.
    */
   fetch?: typeof fetch;
+  /**
+   * Supplies the caller's Oxy access token. Called BEFORE EVERY REQUEST, never
+   * cached here, because an access token is short-lived and the host
+   * application is the only thing that knows when it was refreshed — an SDK
+   * holding its own copy is an SDK that starts sending an expired one.
+   *
+   * Returning `null`/`undefined` means "no session right now", which is a normal
+   * state and not an error: every PUBLIC read below still works without a token,
+   * exactly as it did before this existed. Only the authenticated methods refuse,
+   * and they say so by name.
+   *
+   * The token IS sent on public reads when it is available, which is
+   * deliberate — it is what lets an owner see their own private show and their
+   * own unpublished episodes through the same methods everyone else uses.
+   */
+  getAccessToken?: () => string | null | undefined | Promise<string | null | undefined>;
 }
 
 export interface SearchTracksOptions {
@@ -94,6 +116,98 @@ export interface EpisodeArtworkSource {
   imageSourceUrl?: string | null;
 }
 
+/** The fields `createPodcast` accepts. Mirrors `POST /api/podcasts`. */
+export interface CreatePodcastInput {
+  title: string;
+  description?: string;
+  author?: string;
+  /** An image id from {@link SyraClient.uploadPodcastImage}, not a URL. */
+  image?: string;
+  language?: string;
+  categories?: string[];
+  explicit?: boolean;
+  link?: string;
+  type?: 'episodic' | 'serial';
+  visibility?: PodcastVisibility;
+  /** The Alia series this show was generated from; records `provider: 'alia'` provenance. */
+  aliaSeriesId?: string;
+  /** Disclosure. Independent of {@link CreatePodcastInput.aliaSeriesId} — neither implies the other. */
+  aiGenerated?: boolean;
+  /** Hosts & Guests as Oxy user ids. Validated server-side; free text is refused. */
+  hosts?: string[];
+  guests?: string[];
+}
+
+/** The fields `updatePodcast` accepts. Every one is optional; omitted means unchanged. */
+export interface UpdatePodcastInput {
+  title?: string;
+  description?: string;
+  author?: string;
+  image?: string;
+  language?: string;
+  categories?: string[];
+  explicit?: boolean;
+  link?: string;
+  type?: 'episodic' | 'serial';
+  visibility?: PodcastVisibility;
+  aiGenerated?: boolean;
+}
+
+/** The metadata `createEpisodeDraft` accepts — everything except the audio. */
+export interface CreateEpisodeDraftInput {
+  title: string;
+  description?: string;
+  summary?: string;
+  season?: number;
+  episodeNumber?: number;
+  episodeType?: 'full' | 'trailer' | 'bonus';
+  explicit?: boolean;
+  aiGenerated?: boolean;
+  hosts?: string[];
+  guests?: string[];
+}
+
+/**
+ * The metadata the ingest step may set.
+ *
+ * Deliberately SMALLER than {@link CreateEpisodeDraftInput}, and it is not an
+ * oversight: the ticket is redeemed by a process with no user session, so the
+ * server accepts only what such a process can know by having produced the
+ * episode. Artwork, `explicit`, `episodeType`, credits and the AI disclosure
+ * were fixed at draft time by the authenticated user and are refused here.
+ *
+ * `title` IS accepted, and it is the reason to reach for this at all: a draft is
+ * created before the content exists, so its title can only name the topic that
+ * was requested. Send the name the FINISHED episode earned and it replaces the
+ * draft's.
+ *
+ * Omitting it keeps whatever the draft said — an absent title never clears one,
+ * so a worker that has nothing better than the placeholder can still deliver
+ * the audio. A title that is empty or only whitespace is REFUSED (400) rather
+ * than stored, the same rule the authenticated endpoints apply; the ticket
+ * survives that refusal and can be redeemed again.
+ */
+export interface IngestEpisodeInput {
+  title?: string;
+  duration?: number;
+  season?: number;
+  episodeNumber?: number;
+  description?: string;
+  summary?: string;
+}
+
+/**
+ * An audio or image payload, in the shapes the three supported runtimes give you.
+ *
+ * `Blob`/`File` covers browsers and Node 18+. React Native's `FormData` accepts
+ * a `{ uri, name, type }` descriptor instead, which is not a `Blob` at all — it
+ * is named here so an RN caller does not have to cast, and so this SDK never has
+ * to import anything from React Native to support it.
+ */
+export type UploadPayload =
+  | Blob
+  | { uri: string; name?: string; type?: string };
+
 export interface SyraClient {
   /**
    * Search the public catalog for tracks. Returns one paginated page: rows are
@@ -156,6 +270,81 @@ export interface SyraClient {
    * external artwork URL. Returns `undefined` when no artwork can be derived.
    */
   episodeImageUrl(source: EpisodeArtworkSource, size?: ArtworkSize): string | undefined;
+  /**
+   * Resolve an episode's PLAYABLE audio URL, whichever kind of episode it is.
+   *
+   * An RSS-mirrored episode carries an absolute `enclosureUrl`; a Syra-hosted one
+   * carries `audioSource.url`, a path on the API. This is the one place that
+   * knows the difference, so no consumer has to.
+   *
+   * `undefined` when the episode has no audio yet — a drafted episode awaiting
+   * ingest is a real, listable episode with nothing to play, and answering with
+   * a broken URL would be worse than answering with nothing.
+   */
+  episodeAudioUrl(episode: {
+    enclosureUrl?: string | null;
+    audioSource?: { url?: string | null } | null;
+  }): string | undefined;
+
+  // ── Authenticated ──────────────────────────────────────────────────────────
+  //
+  // Every method below needs `getAccessToken` to return a token; without one they
+  // throw `SyraApiError(401)` from the CLIENT rather than making a request that
+  // was never going to be accepted.
+
+  /** `GET /api/podcasts/mine` — every show the caller owns, in every state. */
+  listMyPodcasts(): Promise<PodcastSummary[]>;
+  /** `POST /api/podcasts` — create a Syra-hosted show. */
+  createPodcast(input: CreatePodcastInput): Promise<PodcastSummary>;
+  /** `PATCH /api/podcasts/:id` — edit a Syra-hosted show you own. */
+  updatePodcast(podcastId: string, input: UpdatePodcastInput): Promise<PodcastSummary>;
+  /**
+   * Change who may see a show. A named affordance over
+   * {@link SyraClient.updatePodcast}, because it is the one field with
+   * consequences a caller should not discover by reading a diff: making a show
+   * `private` withdraws it from every listing AND stops its episodes being
+   * transcoded, and publishing it again enqueues the transcodes that were
+   * deferred.
+   */
+  setPodcastVisibility(podcastId: string, visibility: PodcastVisibility): Promise<PodcastSummary>;
+  /**
+   * `POST /api/images/upload` — store cover art and get the image id back.
+   *
+   * The id is what {@link CreatePodcastInput.image} wants; a URL is not accepted
+   * there, because the API re-hosts artwork rather than hotlinking it.
+   */
+  uploadPodcastImage(image: UploadPayload, filename?: string): Promise<UploadedImage>;
+  /**
+   * `POST /api/podcasts/:id/episodes/draft` — reserve an episode now and get a
+   * single-use ticket to attach its audio later, from a process with no session.
+   *
+   * The returned ticket is a bearer capability with a deadline: it is good for
+   * ONE redemption against THIS episode, and it stops working if the show
+   * changes hands. Treat it as a secret.
+   */
+  createEpisodeDraft(podcastId: string, input: CreateEpisodeDraftInput): Promise<EpisodeDraft>;
+  /**
+   * `POST /api/podcasts/episodes/:id/ingest` — redeem a draft's ticket by
+   * attaching the audio.
+   *
+   * Takes the whole {@link EpisodeDraft} rather than a loose id and token, so the
+   * two cannot be paired up wrongly by a caller holding several drafts.
+   *
+   * Authenticated by the TICKET, not by the session — this is the one method here
+   * that works with no `getAccessToken` at all, which is the entire point of it.
+   */
+  ingestEpisode(
+    draft: Pick<EpisodeDraft, 'episodeId' | 'ingestTicket'>,
+    audio: UploadPayload,
+    input?: IngestEpisodeInput,
+    filename?: string,
+  ): Promise<EpisodeSummary>;
+  /**
+   * `GET /api/podcasts/episodes/:id/stream` — a tokenized HLS URL for a
+   * Syra-hosted episode. Requires a session: the URL it returns embeds a stream
+   * token minted for the caller.
+   */
+  getEpisodeStream(episodeId: string): Promise<EpisodeStream>;
 }
 
 /** Order used to pick the best available artwork variant when none is named. */
@@ -232,20 +421,130 @@ export function createSyraClient(options: SyraClientOptions = {}): SyraClient {
     );
   }
 
-  async function getJson(path: string): Promise<unknown> {
-    const doFetch = resolveFetch();
-    const response = await doFetch(`${baseURL}${path}`, {
-      headers: { Accept: 'application/json' },
-    });
-    if (!response.ok) {
+  /**
+   * The caller's token for THIS request, or `undefined`.
+   *
+   * Asked every time rather than once at construction: an access token is
+   * short-lived, and the host application is the only thing that knows when it
+   * was refreshed.
+   */
+  async function currentToken(): Promise<string | undefined> {
+    if (!options.getAccessToken) return undefined;
+    const token = await options.getAccessToken();
+    return typeof token === 'string' && token.length > 0 ? token : undefined;
+  }
+
+  /**
+   * The token, or a refusal — for the methods that cannot work without one.
+   *
+   * Thrown from the CLIENT rather than sent and rejected, so a consumer with no
+   * session gets a message naming the method instead of a bare 401 from a
+   * request that was never going to be accepted.
+   */
+  async function requireToken(method: string): Promise<string> {
+    const token = await currentToken();
+    if (!token) {
       throw new SyraApiError(
-        response.status,
-        `Syra API request failed: ${response.status} ${response.statusText} (${path})`,
+        401,
+        `@syra.fm/sdk: ${method}() needs a signed-in caller. Pass \`getAccessToken\` to ` +
+          'createSyraClient, and make sure it returns a token for the current session.',
       );
     }
+    return token;
+  }
+
+  /** Raise the API's own error, preferring the message it sent over the status text. */
+  async function raiseFor(response: Response, path: string): Promise<never> {
+    let detail = `${response.status} ${response.statusText}`;
+    try {
+      const body: unknown = await response.json();
+      if (body && typeof body === 'object' && 'error' in body && typeof body.error === 'string') {
+        detail = `${response.status} ${body.error}`;
+      }
+    } catch {
+      // A non-JSON error body is not itself an error worth reporting; the status
+      // is what the caller acts on.
+    }
+    throw new SyraApiError(response.status, `Syra API request failed: ${detail} (${path})`);
+  }
+
+  interface RequestInit_ {
+    method?: string;
+    body?: BodyInit;
+    /** Extra headers. `Authorization` is added here, never by a caller. */
+    headers?: Record<string, string>;
+    /** Refuse before sending when there is no session. The value is the method name. */
+    requires?: string;
+    /**
+     * Never attach the session token, even when one is available.
+     *
+     * For a request that carries its OWN credential — the ingest ticket. Sending
+     * both would leave the server's answer ambiguous about which one authorized
+     * the write, and would mean a worker that happens to hold a user token
+     * behaves differently from one that does not. Exactly one credential per
+     * request.
+     */
+    anonymous?: boolean;
+  }
+
+  async function request(path: string, init: RequestInit_ = {}): Promise<unknown> {
+    const doFetch = resolveFetch();
+    const headers: Record<string, string> = { Accept: 'application/json', ...init.headers };
+
+    if (init.requires) {
+      headers.Authorization = `Bearer ${await requireToken(init.requires)}`;
+    } else if (!init.anonymous) {
+      // Sent when available even on public reads — it is what lets an owner see
+      // their own private show through the same method everyone else calls.
+      const token = await currentToken();
+      if (token) headers.Authorization = `Bearer ${token}`;
+    }
+
+    const response = await doFetch(`${baseURL}${path}`, {
+      method: init.method ?? 'GET',
+      headers,
+      ...(init.body === undefined ? {} : { body: init.body }),
+    });
+    if (!response.ok) return raiseFor(response, path);
     return response.json();
   }
 
+  async function getJson(path: string): Promise<unknown> {
+    return request(path);
+  }
+
+  async function postJson(path: string, body: unknown, requires: string): Promise<unknown> {
+    return request(path, {
+      method: 'POST',
+      requires,
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+  }
+
+  /**
+   * Append an upload to a `FormData`, in whichever shape the runtime gave us.
+   *
+   * The RN `{ uri, name, type }` descriptor is not a `Blob` and the DOM
+   * `FormData.append` signature does not admit it, so it goes through one cast
+   * confined to this function — rather than every call site, or a `declare
+   * module` shim that would shadow the real DOM types in every consumer.
+   */
+  function appendUpload(form: FormData, field: string, payload: UploadPayload, filename?: string): void {
+    if (typeof Blob !== 'undefined' && payload instanceof Blob) {
+      form.append(field, payload, filename);
+      return;
+    }
+    const descriptor = payload as { uri: string; name?: string; type?: string };
+    const name = filename ?? descriptor.name ?? field;
+    form.append(field, descriptor as unknown as Blob, name);
+  }
+
+  /** Drop `undefined` fields so a partial input never sends `"key": null`. */
+  function defined(input: Record<string, unknown>): Record<string, unknown> {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+  }
+
   function resolveImageRef(ref: string | null | undefined): string | undefined {
     if (!ref) {
       return undefined;
@@ -418,7 +717,15 @@ export function createSyraClient(options: SyraClientOptions = {}): SyraClient {
 
       const items: EpisodeSummary[] = [];
       for (const raw of rawEpisodes) {
-        // A single malformed episode row must not fail the whole listing.
+        /**
+         * A single malformed episode row must not fail the whole listing — but
+         * "has no enclosure" is no longer malformed. It used to be, and that is
+         * what made every SYRA-HOSTED episode disappear from this method: their
+         * audio is `audioSource.url`, not an enclosure. The schema now validates
+         * IDENTITY and leaves playability to `episodeAudioUrl`, which is also
+         * the only honest answer for a drafted episode whose audio has not
+         * arrived yet.
+         */
         const parsed = episodeSummarySchema.safeParse(raw);
         if (parsed.success) {
           items.push(parsed.data);
@@ -469,5 +776,118 @@ export function createSyraClient(options: SyraClientOptions = {}): SyraClient {
 
       return resolveImageRef(source.imageSourceUrl);
     },
+
+    episodeAudioUrl(episode) {
+      // An RSS mirror's enclosure is already absolute and points at somebody
+      // else's host, so it is returned untouched.
+      if (episode.enclosureUrl && /^https?:\/\//i.test(episode.enclosureUrl)) {
+        return episode.enclosureUrl;
+      }
+      const sourceUrl = episode.audioSource?.url;
+      if (sourceUrl) {
+        return /^https?:\/\//i.test(sourceUrl) ? sourceUrl : `${baseURL}${sourceUrl}`;
+      }
+      // A relative enclosure is unusual but representable; resolve it the same way.
+      if (episode.enclosureUrl) return `${baseURL}${episode.enclosureUrl}`;
+      return undefined;
+    },
+
+    async listMyPodcasts() {
+      const json = (await request('/api/podcasts/mine', {
+        requires: 'listMyPodcasts',
+      })) as PodcastSearchResponseShape;
+      const rows = Array.isArray(json?.data) ? json.data : [];
+
+      const items: PodcastSummary[] = [];
+      for (const raw of rows) {
+        const parsed = podcastSummarySchema.safeParse(raw);
+        if (parsed.success) items.push(parsed.data);
+      }
+      return items;
+    },
+
+    async createPodcast(input) {
+      const json = (await postJson(
+        '/api/podcasts',
+        defined({ ...input }),
+        'createPodcast',
+      )) as { data?: unknown };
+      return podcastSummarySchema.parse(json?.data);
+    },
+
+    async updatePodcast(podcastId, input) {
+      const json = (await request(`/api/podcasts/${encodeURIComponent(podcastId)}`, {
+        method: 'PATCH',
+        requires: 'updatePodcast',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(defined({ ...input })),
+      })) as { data?: unknown };
+      return podcastSummarySchema.parse(json?.data);
+    },
+
+    async setPodcastVisibility(podcastId, visibility) {
+      return this.updatePodcast(podcastId, { visibility });
+    },
+
+    async uploadPodcastImage(image, filename) {
+      const form = new FormData();
+      // `image` is the field name `POST /api/images/upload` reads.
+      appendUpload(form, 'image', image, filename);
+
+      // No `Content-Type`: the runtime sets it, INCLUDING the multipart boundary,
+      // which cannot be written by hand. Setting it here produces a body the
+      // server cannot parse.
+      const json = (await request('/api/images/upload', {
+        method: 'POST',
+        requires: 'uploadPodcastImage',
+        body: form,
+      })) as unknown;
+      return uploadedImageSchema.parse(json);
+    },
+
+    async createEpisodeDraft(podcastId, input) {
+      const json = (await postJson(
+        `/api/podcasts/${encodeURIComponent(podcastId)}/episodes/draft`,
+        defined({ ...input }),
+        'createEpisodeDraft',
+      )) as { data?: unknown };
+      return episodeDraftSchema.parse(json?.data);
+    },
+
+    async ingestEpisode(draft, audio, input = {}, filename) {
+      const form = new FormData();
+      // `audioFile` is the field name the ingest endpoint reads.
+      appendUpload(form, 'audioFile', audio, filename ?? 'episode.mp3');
+      for (const [key, value] of Object.entries(defined({ ...input }))) {
+        form.append(key, String(value));
+      }
+
+      /**
+       * `anonymous`, and it is load-bearing rather than tidy: this request is
+       * authenticated by the TICKET alone, which is the whole reason the
+       * draft/ingest pair exists. Without it a worker that HAPPENS to hold a user
+       * token would send both credentials — behaving differently from one that
+       * does not, and leaving the server's answer ambiguous about which
+       * authorized the write. Caught by a test, not by review.
+       */
+      const json = (await request(
+        `/api/podcasts/episodes/${encodeURIComponent(draft.episodeId)}/ingest`,
+        {
+          method: 'POST',
+          anonymous: true,
+          headers: { 'X-Ingest-Ticket': draft.ingestTicket },
+          body: form,
+        },
+      )) as { data?: unknown };
+      return episodeSummarySchema.parse(json?.data);
+    },
+
+    async getEpisodeStream(episodeId) {
+      const json = await request(
+        `/api/podcasts/episodes/${encodeURIComponent(episodeId)}/stream`,
+        { requires: 'getEpisodeStream' },
+      );
+      return episodeStreamSchema.parse(json);
+    },
   };
 }

package/src/index.ts

@@ -18,18 +18,35 @@ export type {
   ArtworkSource,
   PodcastArtworkSource,
   EpisodeArtworkSource,
+  CreatePodcastInput,
+  UpdatePodcastInput,
+  CreateEpisodeDraftInput,
+  IngestEpisodeInput,
+  UploadPayload,
 } from './client';
 export {
   trackSummarySchema,
   podcastSummarySchema,
+  podcastVisibilitySchema,
   episodeSummarySchema,
+  episodeAudioSourceSchema,
+  episodeStatusSchema,
+  episodeDraftSchema,
+  episodeStreamSchema,
+  uploadedImageSchema,
   coverArtSizesSchema,
   coverArtVariantSchema,
 } from './schema';
 export type {
   TrackSummary,
   PodcastSummary,
+  PodcastVisibility,
   EpisodeSummary,
+  EpisodeAudioSource,
+  EpisodeStatus,
+  EpisodeDraft,
+  EpisodeStream,
+  UploadedImage,
   CoverArtSizes,
   CoverArtVariant,
   ArtworkSize,

package/src/live/components/CreateRoomSheet.tsx

@@ -97,7 +97,7 @@ export const CreateRoomSheet = forwardRef<CreateRoomSheetRef, CreateRoomSheetPro
     speakerPermission: isBroadcast ? 'invited' as const : speakerPermission,
     type: roomType,
     ownerType: selectedHouse ? 'house' as const : 'profile' as const,
-    houseId: selectedHouse?._id,
+    houseId: selectedHouse?.id,
     recordingEnabled,
   });
 
@@ -109,10 +109,10 @@ export const CreateRoomSheet = forwardRef<CreateRoomSheetRef, CreateRoomSheetPro
       const room = await roomsService.createRoom(buildCreatePayload());
 
       if (room) {
-        const started = await roomsService.startRoom(room._id);
+        const started = await roomsService.startRoom(room.id);
         onClose();
         if (started) {
-          joinLiveRoom(room._id);
+          joinLiveRoom(room.id);
         } else {
           toast.error('Room created but failed to start');
         }
@@ -317,10 +317,10 @@ export const CreateRoomSheet = forwardRef<CreateRoomSheetRef, CreateRoomSheetPro
               horizontal
               showsHorizontalScrollIndicator={false}
               data={[null, ...houses]}
-              keyExtractor={(item) => item?._id ?? 'personal'}
+              keyExtractor={(item) => item?.id ?? 'personal'}
               contentContainerStyle={styles.chipList}
               renderItem={({ item }) => {
-                const selected = item === null ? !selectedHouse : selectedHouse?._id === item._id;
+                const selected = item === null ? !selectedHouse : selectedHouse?.id === item.id;
                 return (
                   <TouchableOpacity
                     style={[

package/src/live/components/RecordingsPanel.tsx

@@ -49,9 +49,9 @@ export function RecordingsPanel({ roomId, isHost, theme, onClose, onPlay }: Reco
   };
 
   const handlePlay = async (recording: Recording) => {
-    setPlayingId(recording._id);
+    setPlayingId(recording.id);
     try {
-      const result = await roomsService.getRecording(recording._id);
+      const result = await roomsService.getRecording(recording.id);
       if (result?.playbackUrl) {
         onPlay?.(result.playbackUrl, recording);
       } else {
@@ -66,10 +66,10 @@ export function RecordingsPanel({ roomId, isHost, theme, onClose, onPlay }: Reco
 
   const handleToggleAccess = async (recording: Recording) => {
     const newAccess = recording.access === 'public' ? 'participants' as const : 'public' as const;
-    const success = await roomsService.updateRecordingAccess(recording._id, newAccess);
+    const success = await roomsService.updateRecordingAccess(recording.id, newAccess);
     if (success) {
       setRecordings((prev) =>
-        prev.map((r) => r._id === recording._id ? { ...r, access: newAccess } : r)
+        prev.map((r) => r.id === recording.id ? { ...r, access: newAccess } : r)
       );
       toast.success(`Recording is now ${newAccess}`);
     } else {
@@ -78,9 +78,9 @@ export function RecordingsPanel({ roomId, isHost, theme, onClose, onPlay }: Reco
   };
 
   const handleDelete = async (recording: Recording) => {
-    const success = await roomsService.deleteRecording(recording._id);
+    const success = await roomsService.deleteRecording(recording.id);
     if (success) {
-      setRecordings((prev) => prev.filter((r) => r._id !== recording._id));
+      setRecordings((prev) => prev.filter((r) => r.id !== recording.id));
       toast.success('Recording deleted');
     } else {
       toast.error('Failed to delete recording');
@@ -110,7 +110,7 @@ export function RecordingsPanel({ roomId, isHost, theme, onClose, onPlay }: Reco
         ) : (
           recordings.map((recording) => (
             <View
-              key={recording._id}
+              key={recording.id}
               style={[styles.recordingCard, { backgroundColor: `${theme.colors.card}80`, borderColor: theme.colors.border }]}
             >
               <View style={styles.recordingHeader}>
@@ -144,10 +144,10 @@ export function RecordingsPanel({ roomId, isHost, theme, onClose, onPlay }: Reco
 
                 <TouchableOpacity
                   onPress={() => handlePlay(recording)}
-                  disabled={playingId === recording._id}
+                  disabled={playingId === recording.id}
                   style={[styles.playButton, { backgroundColor: theme.colors.primary }]}
                 >
-                  {playingId === recording._id ? (
+                  {playingId === recording.id ? (
                     <ActivityIndicator size="small" color="#FFFFFF" />
                   ) : (
                     <MaterialCommunityIcons name="play" size={22} color="#FFFFFF" />

package/src/live/components/RoomCard.tsx

@@ -80,7 +80,7 @@ const ACTION_HIT_SLOP = { top: 8, bottom: 8, left: 8, right: 8 };
 
 interface RoomCardProps {
   room: {
-    _id: string;
+    id: string;
     title: string;
     status: 'scheduled' | 'live' | 'ended';
     type?: 'talk' | 'stage' | 'broadcast';