@vivix-ai/ivi-frontend-sdk 0.2.2

package/dist/index.js

@@ -0,0 +1,3505 @@
+import { ReceiveConversationItemAddedEvent, ReceiveConversationItemDoneEvent, ReceiveResponseCreatedEvent, IviClient, SessionCreatedEvent, ReceiveSessionEndedEvent, ReceiveSessionStageGetResponseEvent, ReceiveSessionStageUpdatedEvent, ReceiveSessionTrackCreatedEvent, ReceiveSessionTrackDeletedEvent, ReceiveSessionTrackTookEvent, ReceiveSessionTrackCuedEvent, ReceiveSessionTrackNextSetEvent, ReceiveSessionTracksListResponseEvent, ReceiveSessionSourceCreatedEvent, ReceiveSessionSourceReadyEvent, ReceiveSessionSourceFailedEvent, ReceiveSessionSourceDeletedEvent, ReceiveSessionSourcePreloadEvent, ReceiveSessionSourceClearPreloadEvent, ReceiveSessionSourcesListResponseEvent, ReceiveSessionSourcePlaybackCompletedEvent, SessionStreamCreatedEvent, ReceiveSessionStreamStartedEvent, ReceiveSessionStreamEndedEvent, ReceiveSessionStreamFailedEvent, ReceiveSessionStreamDeletedEvent, ReceiveSessionStreamsListResponseEvent, ReceiveConversationListResponseEvent, ReceiveResponseOutputTextDeltaEvent, ReceiveResponseOutputTextDoneEvent, ReceiveResponseOutputAudioTranscriptDeltaEvent, ReceiveResponseOutputAudioTranscriptDoneEvent, ReceiveResponseDoneEvent } from '@vivix/ivi-sdk-ts';
+import { createContext, useState, useEffect, useMemo, useContext, useRef, useCallback } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/runtime/runtime-coordinator.ts
+
+// src/runtime/logger.ts
+var EVENT_LOG_PREFIX = "[IVI-EVT]";
+var STATE_LOG_PREFIX = "[IVI-STATE]";
+var activeLogCallback;
+function runWithIviRuntimeLogCallback(onLog, fn) {
+  const previous = activeLogCallback;
+  activeLogCallback = onLog;
+  try {
+    return fn();
+  } finally {
+    activeLogCallback = previous;
+  }
+}
+function logIviEventReceived(event) {
+  const message = `${EVENT_LOG_PREFIX} ${event.type}`;
+  activeLogCallback?.({
+    level: "info",
+    tag: EVENT_LOG_PREFIX,
+    message,
+    args: [message, event.raw],
+    data: event.raw
+  });
+  console.log(message, event.raw);
+}
+function logIviStateChange(entity, key, eventType, before, after) {
+  if (!didChange(before, after)) {
+    return;
+  }
+  const label = key === null ? entity : `${entity}[${key}]`;
+  const message = `${STATE_LOG_PREFIX} ${label} <- ${eventType}`;
+  const data = {
+    before,
+    after
+  };
+  activeLogCallback?.({
+    level: "info",
+    tag: STATE_LOG_PREFIX,
+    message,
+    args: [message, data],
+    data
+  });
+  console.log(message, data);
+}
+function didChange(before, after) {
+  if (before === after) return false;
+  if (before === void 0 || after === void 0) return true;
+  try {
+    return JSON.stringify(before) !== JSON.stringify(after);
+  } catch {
+    return true;
+  }
+}
+
+// src/runtime/runtime-dispatcher.ts
+var IviRuntimeDispatcher = class {
+  constructor(client, callbacks) {
+    this.unsubscribeEvent = null;
+    this.unsubscribeConnection = null;
+    this.client = client;
+    this.callbacks = callbacks;
+  }
+  start() {
+    if (this.unsubscribeEvent || this.unsubscribeConnection) {
+      return;
+    }
+    this.unsubscribeEvent = this.client.onEvent((event) => {
+      this.dispatchEvent(event);
+    });
+    this.unsubscribeConnection = this.client.onConnectionChange((connected) => {
+      this.callbacks.onConnectionChange(connected);
+    });
+  }
+  stop() {
+    this.unsubscribeEvent?.();
+    this.unsubscribeEvent = null;
+    this.unsubscribeConnection?.();
+    this.unsubscribeConnection = null;
+  }
+  dispatchEvent(event) {
+    runWithIviRuntimeLogCallback(this.callbacks.onLog, () => {
+      logIviEventReceived(event);
+      if (event.type === "session.created" || event.type === "session.ended") {
+        this.callbacks.sessionHandler.handle(event);
+      } else if (event.type.startsWith("session.stage.")) {
+        this.callbacks.stageHandler.handle(event);
+      } else if (event.type.startsWith("session.track.") || event.type.startsWith("session.tracks.")) {
+        this.callbacks.trackHandler.handle(event);
+      } else if (event.type.startsWith("session.source.") || event.type.startsWith("session.sources.")) {
+        this.callbacks.sourceHandler.handle(event);
+      } else if (event.type.startsWith("session.stream.") || event.type.startsWith("session.streams.")) {
+        this.callbacks.streamHandler.handle(event);
+      } else if (event.type.startsWith("conversation.") || event.type.startsWith("response.")) {
+        this.callbacks.conversationHandler.handle(event);
+      }
+    });
+    this.callbacks.onEvent?.(event);
+  }
+};
+var SessionEventHandler = class {
+  constructor(sessionManager, callbacks) {
+    this.sessionManager = sessionManager;
+    this.callbacks = callbacks;
+  }
+  handle(event) {
+    if (event instanceof SessionCreatedEvent) {
+      const before = this.sessionManager.getSession();
+      this.sessionManager.setSession(event.session);
+      logIviStateChange("session", null, event.type, before, this.sessionManager.getSession());
+      this.callbacks.onSessionCreated(event);
+      return;
+    }
+    if (event instanceof ReceiveSessionEndedEvent) {
+      this.callbacks.onSessionEnded(event);
+    }
+  }
+};
+var StageEventHandler = class {
+  constructor(stageManager, callbacks) {
+    this.stageManager = stageManager;
+    this.callbacks = callbacks;
+  }
+  handle(event) {
+    if (!(event instanceof ReceiveSessionStageGetResponseEvent) && !(event instanceof ReceiveSessionStageUpdatedEvent)) {
+      return {
+        handled: false,
+        fromStageGetResponse: false
+      };
+    }
+    const before = this.stageManager.getStage();
+    this.stageManager.setStage(event.stage);
+    logIviStateChange("stage", null, event.type, before, this.stageManager.getStage());
+    const result = {
+      handled: true,
+      fromStageGetResponse: event instanceof ReceiveSessionStageGetResponseEvent
+    };
+    this.callbacks.onStageChanged({
+      fromStageGetResponse: result.fromStageGetResponse
+    });
+    return result;
+  }
+};
+var TrackEventHandler = class {
+  constructor(trackManager, callbacks) {
+    this.trackManager = trackManager;
+    this.callbacks = callbacks;
+  }
+  handle(event) {
+    if (event instanceof ReceiveSessionTrackCreatedEvent) {
+      const trackId = event.track.track_id;
+      const before = this.trackManager.getAll().get(trackId);
+      this.trackManager.upsert(event.track);
+      logIviStateChange("track", trackId, event.type, before, this.trackManager.getAll().get(trackId));
+      this.callbacks.onTracksChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionTrackDeletedEvent) {
+      const before = this.trackManager.getAll().get(event.trackId);
+      this.trackManager.remove(event.trackId);
+      logIviStateChange("track", event.trackId, event.type, before, void 0);
+      this.callbacks.onTracksChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionTrackTookEvent) {
+      const before = this.trackManager.getAll().get(event.trackId);
+      if (before?.active_source_id === event.sourceId) {
+        return { handled: true, listRefreshed: false };
+      }
+      this.trackManager.applyTrackTook(event.trackId, event.sourceId);
+      logIviStateChange("track", event.trackId, event.type, before, this.trackManager.getAll().get(event.trackId));
+      this.callbacks.onTracksChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionTrackCuedEvent) {
+      const before = this.trackManager.getAll().get(event.trackId);
+      this.trackManager.applyTrackCued(event.trackId, event.sourceId);
+      logIviStateChange("track", event.trackId, event.type, before, this.trackManager.getAll().get(event.trackId));
+      this.callbacks.onTracksChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionTrackNextSetEvent) {
+      const before = this.trackManager.getAll().get(event.trackId);
+      this.trackManager.applyTrackNextSet(event.trackId, event.sourceId);
+      logIviStateChange("track", event.trackId, event.type, before, this.trackManager.getAll().get(event.trackId));
+      this.callbacks.onTracksChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionTracksListResponseEvent) {
+      const beforeSnapshot = snapshotMap(this.trackManager.getAll());
+      this.trackManager.replaceAll(event.tracks);
+      logIviStateChange("tracks(list)", null, event.type, beforeSnapshot, snapshotMap(this.trackManager.getAll()));
+      this.callbacks.onTracksChanged({ listRefreshed: true });
+      return { handled: true, listRefreshed: true };
+    }
+    return { handled: false, listRefreshed: false };
+  }
+};
+function snapshotMap(map) {
+  const snap = {};
+  map.forEach((value, key) => {
+    snap[key] = value;
+  });
+  return snap;
+}
+var SourceEventHandler = class {
+  constructor(sourceManager, callbacks) {
+    this.sourceManager = sourceManager;
+    this.callbacks = callbacks;
+  }
+  handle(event) {
+    if (event instanceof ReceiveSessionSourceCreatedEvent) {
+      const sourceId = event.source.source_id;
+      const before = this.sourceManager.get(sourceId);
+      this.sourceManager.upsertCreated(event.source);
+      logIviStateChange("source", sourceId, event.type, before, this.sourceManager.get(sourceId));
+      this.callbacks.onSourcesChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionSourceReadyEvent) {
+      const before = this.sourceManager.get(event.sourceId);
+      this.sourceManager.markReady({
+        sourceId: event.sourceId,
+        kind: event.kind,
+        assetType: event.assetType,
+        playback: event.playback,
+        width: event.width,
+        height: event.height,
+        durationMs: event.durationMs,
+        hasAudio: event.hasAudio
+      });
+      logIviStateChange("source", event.sourceId, event.type, before, this.sourceManager.get(event.sourceId));
+      this.callbacks.onSourcesChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionSourceFailedEvent) {
+      const before = this.sourceManager.get(event.sourceId);
+      this.sourceManager.markFailed(event.sourceId, event.error);
+      logIviStateChange("source", event.sourceId, event.type, before, this.sourceManager.get(event.sourceId));
+      this.callbacks.onSourcesChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionSourceDeletedEvent) {
+      const before = this.sourceManager.get(event.sourceId);
+      this.sourceManager.remove(event.sourceId);
+      logIviStateChange("source", event.sourceId, event.type, before, void 0);
+      this.callbacks.onSourcesChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionSourcePreloadEvent) {
+      for (const source of event.sources) {
+        const sourceId = source.source_id;
+        const before = this.sourceManager.get(sourceId);
+        this.sourceManager.upsertCreated(source);
+        this.sourceManager.applyPreload(sourceId, {
+          autoclearAfterPlay: event.autoclearAfterPlay
+        });
+        logIviStateChange("source", sourceId, event.type, before, this.sourceManager.get(sourceId));
+      }
+      this.callbacks.onSourcesChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionSourceClearPreloadEvent) {
+      for (const sourceId of event.sourceIds ?? []) {
+        const before = this.sourceManager.get(sourceId);
+        this.sourceManager.clearPreload(sourceId);
+        logIviStateChange("source", sourceId, event.type, before, this.sourceManager.get(sourceId));
+      }
+      this.callbacks.onSourcesChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionSourcesListResponseEvent) {
+      const beforeSnapshot = snapshotMap2(this.sourceManager.getAll());
+      this.sourceManager.replaceAll(event.sources);
+      logIviStateChange("sources(list)", null, event.type, beforeSnapshot, snapshotMap2(this.sourceManager.getAll()));
+      this.callbacks.onSourcesChanged({ listRefreshed: true });
+      return { handled: true, listRefreshed: true };
+    }
+    if (event instanceof ReceiveSessionSourcePlaybackCompletedEvent) {
+      return { handled: true, listRefreshed: false };
+    }
+    return { handled: false, listRefreshed: false };
+  }
+};
+function snapshotMap2(map) {
+  const snap = {};
+  map.forEach((value, key) => {
+    snap[key] = value;
+  });
+  return snap;
+}
+var StreamEventHandler = class {
+  constructor(streamManager, callbacks) {
+    this.streamManager = streamManager;
+    this.callbacks = callbacks;
+  }
+  handle(event) {
+    if (event instanceof SessionStreamCreatedEvent) {
+      const streamId = event.stream.stream_id;
+      const before = this.streamManager.getAll().get(streamId);
+      this.streamManager.upsertCreated(event.stream);
+      logIviStateChange("stream", streamId, event.type, before, this.streamManager.getAll().get(streamId));
+      this.callbacks.onStreamsChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionStreamStartedEvent) {
+      const before = this.streamManager.getAll().get(event.streamId);
+      this.streamManager.markStarted(event.streamId, event.trackId);
+      logIviStateChange("stream", event.streamId, event.type, before, this.streamManager.getAll().get(event.streamId));
+      this.callbacks.onStreamsChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionStreamEndedEvent) {
+      const before = this.streamManager.getAll().get(event.streamId);
+      this.streamManager.markEnded(event.streamId);
+      logIviStateChange("stream", event.streamId, event.type, before, this.streamManager.getAll().get(event.streamId));
+      this.callbacks.onStreamsChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionStreamFailedEvent) {
+      const before = this.streamManager.getAll().get(event.streamId);
+      this.streamManager.markFailed(event.streamId, event.error);
+      logIviStateChange("stream", event.streamId, event.type, before, this.streamManager.getAll().get(event.streamId));
+      this.callbacks.onStreamsChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionStreamDeletedEvent) {
+      const before = this.streamManager.getAll().get(event.streamId);
+      this.streamManager.remove(event.streamId);
+      logIviStateChange("stream", event.streamId, event.type, before, void 0);
+      this.callbacks.onStreamsChanged({ listRefreshed: false });
+      return { handled: true, listRefreshed: false };
+    }
+    if (event instanceof ReceiveSessionStreamsListResponseEvent) {
+      const beforeSnapshot = snapshotMap3(this.streamManager.getAll());
+      this.streamManager.replaceAll(event.streams);
+      logIviStateChange("streams(list)", null, event.type, beforeSnapshot, snapshotMap3(this.streamManager.getAll()));
+      this.callbacks.onStreamsChanged({ listRefreshed: true });
+      return { handled: true, listRefreshed: true };
+    }
+    return { handled: false, listRefreshed: false };
+  }
+};
+function snapshotMap3(map) {
+  const snap = {};
+  map.forEach((value, key) => {
+    snap[key] = value;
+  });
+  return snap;
+}
+var ConversationEventHandler = class {
+  constructor(conversationManager, callbacks) {
+    this.conversationManager = conversationManager;
+    this.callbacks = callbacks;
+  }
+  handle(event) {
+    if (event instanceof ReceiveConversationListResponseEvent) {
+      const before = snapshotMap4(this.conversationManager.getAllMap());
+      this.conversationManager.replaceAll(event.items);
+      logIviStateChange(
+        "conversations(list)",
+        null,
+        event.type,
+        before,
+        snapshotMap4(this.conversationManager.getAllMap())
+      );
+      this.callbacks.onConversationsChanged();
+      return { handled: true };
+    }
+    if (event instanceof ReceiveConversationItemAddedEvent) {
+      const before = this.conversationManager.getAllMap().get(event.item.id);
+      this.conversationManager.upsertAdded(event.item);
+      logIviStateChange(
+        "conversationItem",
+        event.item.id,
+        event.type,
+        before,
+        this.conversationManager.getAllMap().get(event.item.id)
+      );
+      this.callbacks.onConversationsChanged();
+      return { handled: true };
+    }
+    if (event instanceof ReceiveConversationItemDoneEvent) {
+      const before = this.conversationManager.getAllMap().get(event.item.id);
+      this.conversationManager.markDone(event.item);
+      logIviStateChange(
+        "conversationItem",
+        event.item.id,
+        event.type,
+        before,
+        this.conversationManager.getAllMap().get(event.item.id)
+      );
+      this.callbacks.onConversationsChanged();
+      return { handled: true };
+    }
+    if (event instanceof ReceiveResponseOutputTextDeltaEvent) {
+      const before = this.conversationManager.getAllMap().get(event.itemId);
+      this.conversationManager.applyTextDelta(event.itemId, event.delta);
+      logIviStateChange(
+        "conversationItem",
+        event.itemId,
+        event.type,
+        before,
+        this.conversationManager.getAllMap().get(event.itemId)
+      );
+      this.callbacks.onConversationsChanged();
+      return { handled: true };
+    }
+    if (event instanceof ReceiveResponseOutputTextDoneEvent) {
+      const before = this.conversationManager.getAllMap().get(event.itemId);
+      this.conversationManager.applyTextDone(event.itemId, event.text);
+      logIviStateChange(
+        "conversationItem",
+        event.itemId,
+        event.type,
+        before,
+        this.conversationManager.getAllMap().get(event.itemId)
+      );
+      this.callbacks.onConversationsChanged();
+      return { handled: true };
+    }
+    if (event instanceof ReceiveResponseOutputAudioTranscriptDeltaEvent) {
+      const before = this.conversationManager.getAllMap().get(event.itemId);
+      this.conversationManager.applyTranscriptDelta(event.itemId, event.delta);
+      logIviStateChange(
+        "conversationItem",
+        event.itemId,
+        event.type,
+        before,
+        this.conversationManager.getAllMap().get(event.itemId)
+      );
+      this.callbacks.onConversationsChanged();
+      return { handled: true };
+    }
+    if (event instanceof ReceiveResponseOutputAudioTranscriptDoneEvent) {
+      const before = this.conversationManager.getAllMap().get(event.itemId);
+      this.conversationManager.applyTranscriptDone(event.itemId, event.transcript);
+      logIviStateChange(
+        "conversationItem",
+        event.itemId,
+        event.type,
+        before,
+        this.conversationManager.getAllMap().get(event.itemId)
+      );
+      this.callbacks.onConversationsChanged();
+      return { handled: true };
+    }
+    if (event instanceof ReceiveResponseDoneEvent) {
+      if (event.response.id) {
+        const itemId = `item_${event.response.id}`;
+        const before = this.conversationManager.getAllMap().get(itemId);
+        this.conversationManager.markModelItemStatusFromResponse(event.response.id, event.response.status);
+        logIviStateChange(
+          "conversationItem",
+          itemId,
+          event.type,
+          before,
+          this.conversationManager.getAllMap().get(itemId)
+        );
+        this.callbacks.onConversationsChanged();
+      }
+      return { handled: true };
+    }
+    if (event instanceof ReceiveResponseCreatedEvent) {
+      return { handled: true };
+    }
+    return { handled: false };
+  }
+};
+function snapshotMap4(map) {
+  const snap = {};
+  map.forEach((value, key) => {
+    snap[key] = value;
+  });
+  return snap;
+}
+
+// src/runtime/managers/session-manager.ts
+var SessionManager = class {
+  constructor() {
+    this.session = null;
+  }
+  setSession(session) {
+    this.session = session;
+  }
+  getSession() {
+    return this.session;
+  }
+  reset() {
+    this.session = null;
+  }
+};
+
+// src/runtime/managers/stage-manager.ts
+var StageManager = class {
+  constructor() {
+    this.stage = null;
+  }
+  setStage(stage) {
+    this.stage = stage;
+  }
+  getStage() {
+    return this.stage;
+  }
+  reset() {
+    this.stage = null;
+  }
+};
+
+// src/runtime/managers/track-manager.ts
+var TrackManager = class {
+  constructor() {
+    this.tracks = /* @__PURE__ */ new Map();
+  }
+  patchTrack(trackId, patch) {
+    const next = new Map(this.tracks);
+    const current = next.get(trackId) ?? { track_id: trackId };
+    next.set(trackId, {
+      ...current,
+      ...patch
+    });
+    this.tracks = next;
+  }
+  upsert(track) {
+    const next = new Map(this.tracks);
+    next.set(track.track_id, track);
+    this.tracks = next;
+  }
+  remove(trackId) {
+    const next = new Map(this.tracks);
+    next.delete(trackId);
+    this.tracks = next;
+  }
+  replaceAll(tracks) {
+    const next = /* @__PURE__ */ new Map();
+    tracks.forEach((track) => next.set(track.track_id, track));
+    this.tracks = next;
+  }
+  applyTrackTook(trackId, sourceId) {
+    const current = this.tracks.get(trackId);
+    const resolvedSourceId = sourceId ?? current?.next_source_id ?? null;
+    if (!resolvedSourceId) {
+      return;
+    }
+    this.patchTrack(trackId, {
+      active_source_id: resolvedSourceId,
+      next_source_id: null
+    });
+  }
+  applyTrackCued(trackId, sourceId) {
+    this.patchTrack(trackId, {
+      active_source_id: sourceId,
+      next_source_id: null
+    });
+  }
+  applyTrackNextSet(trackId, sourceId) {
+    this.patchTrack(trackId, {
+      next_source_id: sourceId
+    });
+  }
+  findTrackIdByActiveSource(sourceId) {
+    for (const [trackId, track] of this.tracks) {
+      if (track.active_source_id === sourceId) return trackId;
+    }
+    return null;
+  }
+  has(trackId) {
+    return this.tracks.has(trackId);
+  }
+  getAll() {
+    return this.tracks;
+  }
+  reset() {
+    this.tracks = /* @__PURE__ */ new Map();
+  }
+};
+
+// src/runtime/managers/source-manager.ts
+var SourceManager = class {
+  constructor() {
+    this.sources = /* @__PURE__ */ new Map();
+    /**
+     * 记录本次运行期间曾经被某个 track 的 active/next 槽引用过的 source id 集合。
+     * 用于 autoclearAfterPlay 判定：只有曾经"上过 track"的 source，在其离开 track 时才需要清理预加载。
+     */
+    this.sourcesEverReferencedByTrack = /* @__PURE__ */ new Set();
+  }
+  upsertCreated(source) {
+    const previous = this.sources.get(source.source_id);
+    const next = new Map(this.sources);
+    next.set(source.source_id, {
+      source,
+      status: previous?.status === "ready" ? "ready" : "created",
+      playback: previous?.playback,
+      width: previous?.width,
+      height: previous?.height,
+      durationMs: previous?.durationMs,
+      hasAudio: previous?.hasAudio,
+      error: previous?.status === "failed" ? previous.error : void 0,
+      preload: previous?.preload
+    });
+    this.sources = next;
+  }
+  markReady(payload) {
+    const previous = this.sources.get(payload.sourceId);
+    const next = new Map(this.sources);
+    next.set(payload.sourceId, {
+      source: previous?.source ?? this.buildReadyFallbackSource(payload.sourceId, payload.kind, payload.assetType),
+      status: "ready",
+      playback: payload.playback,
+      width: payload.width,
+      height: payload.height,
+      durationMs: payload.durationMs,
+      hasAudio: payload.hasAudio,
+      preload: previous?.preload
+    });
+    this.sources = next;
+  }
+  markFailed(sourceId, error) {
+    const previous = this.sources.get(sourceId);
+    const next = new Map(this.sources);
+    next.set(sourceId, {
+      source: previous?.source ?? {
+        source_id: sourceId,
+        kind: "stream",
+        url: ""
+      },
+      status: "failed",
+      playback: previous?.playback,
+      width: previous?.width,
+      height: previous?.height,
+      durationMs: previous?.durationMs,
+      hasAudio: previous?.hasAudio,
+      error,
+      preload: previous?.preload
+    });
+    this.sources = next;
+  }
+  remove(sourceId) {
+    const next = new Map(this.sources);
+    next.delete(sourceId);
+    this.sources = next;
+    this.sourcesEverReferencedByTrack.delete(sourceId);
+  }
+  replaceAll(sources) {
+    const next = /* @__PURE__ */ new Map();
+    sources.forEach((source) => {
+      const previous = this.sources.get(source.source_id);
+      next.set(source.source_id, {
+        source,
+        status: source.playback ? "ready" : "created",
+        playback: source.playback,
+        preload: previous?.preload
+      });
+    });
+    this.sources = next;
+  }
+  /**
+   * 应用一次显式预加载。若 source 目前尚未注册，会建立一个占位实例，
+   * 待后续 `session.source.created` / `ready` 事件补齐字段。
+   */
+  applyPreload(sourceId, state) {
+    const previous = this.sources.get(sourceId);
+    const next = new Map(this.sources);
+    if (previous) {
+      next.set(sourceId, {
+        ...previous,
+        preload: state
+      });
+    } else {
+      next.set(sourceId, {
+        source: {
+          source_id: sourceId,
+          kind: "stream",
+          url: ""
+        },
+        status: "created",
+        preload: state
+      });
+    }
+    this.sources = next;
+  }
+  /**
+   * 清除指定 source 的预加载标记。
+   */
+  clearPreload(sourceId) {
+    const previous = this.sources.get(sourceId);
+    if (!previous || !previous.preload) return;
+    const next = new Map(this.sources);
+    next.set(sourceId, {
+      ...previous,
+      preload: void 0
+    });
+    this.sources = next;
+  }
+  /**
+   * 根据当前 tracks 状态同步 source 运行态：
+   * 1) 将 track 的 active/next 引用的 source 由 `created` 提升为 `ready`（保留既有行为）。
+   * 2) 对当前不再被任何 track 引用、且 `preload.autoclearAfterPlay === true`、
+   *    且历史上曾经被 track 引用过的 source，自动清除其预加载标记。
+   */
+  syncWithTracks(tracks) {
+    const currentlyReferencedIds = /* @__PURE__ */ new Set();
+    tracks.forEach((track) => {
+      if (track.active_source_id) {
+        currentlyReferencedIds.add(track.active_source_id);
+      }
+      if (track.next_source_id) {
+        currentlyReferencedIds.add(track.next_source_id);
+      }
+    });
+    const next = new Map(this.sources);
+    let changed = false;
+    currentlyReferencedIds.forEach((sourceId) => {
+      if (!this.sourcesEverReferencedByTrack.has(sourceId)) {
+        this.sourcesEverReferencedByTrack.add(sourceId);
+      }
+      const existing = next.get(sourceId);
+      if (!existing) return;
+      if (existing.status === "created") {
+        next.set(sourceId, {
+          ...existing,
+          status: "ready"
+        });
+        changed = true;
+      }
+    });
+    next.forEach((source, sourceId) => {
+      if (!source.preload || !source.preload.autoclearAfterPlay) return;
+      if (currentlyReferencedIds.has(sourceId)) return;
+      if (!this.sourcesEverReferencedByTrack.has(sourceId)) return;
+      next.set(sourceId, {
+        ...source,
+        preload: void 0
+      });
+      changed = true;
+    });
+    if (changed) {
+      this.sources = next;
+    }
+  }
+  has(sourceId) {
+    return this.sources.has(sourceId);
+  }
+  get(sourceId) {
+    return this.sources.get(sourceId);
+  }
+  getAll() {
+    return this.sources;
+  }
+  reset() {
+    this.sources = /* @__PURE__ */ new Map();
+    this.sourcesEverReferencedByTrack = /* @__PURE__ */ new Set();
+  }
+  buildReadyFallbackSource(sourceId, kind, assetType) {
+    return {
+      source_id: sourceId,
+      kind,
+      asset_type: assetType
+    };
+  }
+};
+
+// src/runtime/managers/stream-manager.ts
+var StreamManager = class {
+  constructor() {
+    this.streams = /* @__PURE__ */ new Map();
+  }
+  upsertCreated(stream) {
+    const next = new Map(this.streams);
+    next.set(stream.stream_id, {
+      stream,
+      status: stream.status
+    });
+    this.streams = next;
+  }
+  markStarted(streamId, trackId) {
+    const previous = this.streams.get(streamId);
+    if (!previous) return;
+    const next = new Map(this.streams);
+    next.set(streamId, {
+      ...previous,
+      status: "active",
+      stream: { ...previous.stream, status: "active" },
+      trackId
+    });
+    this.streams = next;
+  }
+  markEnded(streamId) {
+    const previous = this.streams.get(streamId);
+    if (!previous) return;
+    const next = new Map(this.streams);
+    next.set(streamId, {
+      ...previous,
+      status: "ended",
+      stream: { ...previous.stream, status: "ended" }
+    });
+    this.streams = next;
+  }
+  markFailed(streamId, error) {
+    const previous = this.streams.get(streamId);
+    if (!previous) return;
+    const next = new Map(this.streams);
+    next.set(streamId, {
+      ...previous,
+      status: "failed",
+      stream: { ...previous.stream, status: "failed" },
+      error
+    });
+    this.streams = next;
+  }
+  remove(streamId) {
+    const next = new Map(this.streams);
+    next.delete(streamId);
+    this.streams = next;
+  }
+  replaceAll(streams) {
+    const next = /* @__PURE__ */ new Map();
+    streams.forEach((stream) => {
+      const previous = this.streams.get(stream.stream_id);
+      next.set(stream.stream_id, {
+        stream,
+        status: stream.status,
+        trackId: previous?.trackId
+      });
+    });
+    this.streams = next;
+  }
+  has(streamId) {
+    return this.streams.has(streamId);
+  }
+  getAll() {
+    return this.streams;
+  }
+  reset() {
+    this.streams = /* @__PURE__ */ new Map();
+  }
+};
+
+// src/runtime/managers/conversation-manager.ts
+var ConversationManager = class {
+  constructor() {
+    this.items = /* @__PURE__ */ new Map();
+    this.order = [];
+  }
+  replaceAll(items) {
+    const nextItems = /* @__PURE__ */ new Map();
+    const nextOrder = [];
+    items.forEach((item) => {
+      const runtimeItem = this.buildRuntimeItem(item, item.status === "in_progress" ? "added" : "done");
+      nextItems.set(runtimeItem.id, runtimeItem);
+      nextOrder.push(runtimeItem.id);
+    });
+    this.items = nextItems;
+    this.order = nextOrder;
+  }
+  upsertAdded(item) {
+    const previous = this.items.get(item.id);
+    const next = new Map(this.items);
+    const mergedItem = this.mergeConversationItem(previous?.item, item);
+    const mergedText = this.extractText(mergedItem.content);
+    const mergedTranscript = this.extractTranscript(mergedItem.content);
+    const runtimeItem = this.buildRuntimeItem(
+      mergedItem,
+      "added",
+      mergedText || previous?.text || "",
+      mergedTranscript || previous?.transcript || ""
+    );
+    next.set(item.id, runtimeItem);
+    this.items = next;
+    this.ensureOrder(item.id);
+  }
+  markDone(item) {
+    const previous = this.items.get(item.id);
+    const next = new Map(this.items);
+    const mergedItem = this.mergeConversationItem(previous?.item, item);
+    const mergedText = this.extractText(mergedItem.content);
+    const mergedTranscript = this.extractTranscript(mergedItem.content);
+    const runtimeItem = this.buildRuntimeItem(
+      mergedItem,
+      "done",
+      mergedText || previous?.text || "",
+      mergedTranscript || previous?.transcript || ""
+    );
+    if (runtimeItem.role === "model" && previous && previous.status !== "in_progress") {
+      runtimeItem.status = previous.status;
+      runtimeItem.item = {
+        ...runtimeItem.item,
+        status: previous.status
+      };
+    }
+    next.set(item.id, runtimeItem);
+    this.items = next;
+    this.ensureOrder(item.id);
+  }
+  applyTextDelta(itemId, delta) {
+    const existing = this.items.get(itemId);
+    if (!existing) {
+      return;
+    }
+    this.applyContentUpdate(itemId, {
+      text: `${existing.text}${delta}`,
+      transcript: existing.transcript,
+      content: this.upsertContentText(existing.content, `${existing.text}${delta}`)
+    });
+  }
+  applyTextDone(itemId, text) {
+    const existing = this.items.get(itemId);
+    if (!existing) {
+      return;
+    }
+    this.applyContentUpdate(itemId, {
+      text,
+      transcript: existing.transcript,
+      content: this.upsertContentText(existing.content, text)
+    });
+  }
+  applyTranscriptDelta(itemId, delta) {
+    const existing = this.items.get(itemId);
+    if (!existing) {
+      return;
+    }
+    this.applyContentUpdate(itemId, {
+      text: existing.text,
+      transcript: `${existing.transcript}${delta}`,
+      content: this.upsertContentTranscript(existing.content, `${existing.transcript}${delta}`)
+    });
+  }
+  applyTranscriptDone(itemId, transcript) {
+    const existing = this.items.get(itemId);
+    if (!existing) {
+      return;
+    }
+    this.applyContentUpdate(itemId, {
+      text: existing.text,
+      transcript,
+      content: this.upsertContentTranscript(existing.content, transcript)
+    });
+  }
+  markModelItemStatusFromResponse(responseId, status) {
+    const itemId = `item_${responseId}`;
+    const existing = this.items.get(itemId);
+    if (!existing || existing.role !== "model") {
+      return;
+    }
+    const nextStatus = this.mapResponseStatusToConversationStatus(status);
+    const next = new Map(this.items);
+    next.set(itemId, {
+      ...existing,
+      lifecycle: "done",
+      status: nextStatus,
+      item: {
+        ...existing.item,
+        status: nextStatus
+      }
+    });
+    this.items = next;
+  }
+  getAllMap() {
+    return this.items;
+  }
+  getOrderedList() {
+    return this.order.map((id) => this.items.get(id)).filter((item) => !!item);
+  }
+  reset() {
+    this.items = /* @__PURE__ */ new Map();
+    this.order = [];
+  }
+  applyContentUpdate(itemId, update) {
+    const existing = this.items.get(itemId);
+    if (!existing) {
+      return;
+    }
+    const next = new Map(this.items);
+    next.set(itemId, {
+      ...existing,
+      text: update.text,
+      transcript: update.transcript,
+      content: update.content,
+      item: {
+        ...existing.item,
+        content: update.content
+      }
+    });
+    this.items = next;
+  }
+  ensureOrder(itemId) {
+    if (this.order.includes(itemId)) {
+      return;
+    }
+    this.order = [...this.order, itemId];
+  }
+  buildRuntimeItem(item, lifecycle, text = this.extractText(item.content), transcript = this.extractTranscript(item.content)) {
+    const role = item.role ?? "user";
+    return {
+      id: item.id,
+      role,
+      lifecycle,
+      status: this.normalizeConversationStatus(role, item.status),
+      item,
+      text,
+      transcript,
+      content: item.content ?? []
+    };
+  }
+  normalizeConversationStatus(role, status) {
+    if (role === "model") {
+      if (status === "completed") {
+        return "completed";
+      }
+      if (status === "incomplete") {
+        return "incomplete";
+      }
+      return "in_progress";
+    }
+    if (status === void 0) {
+      return "completed";
+    }
+    return status === "in_progress" ? "in_progress" : "completed";
+  }
+  mapResponseStatusToConversationStatus(status) {
+    if (status === "completed") {
+      return "completed";
+    }
+    if (status === "in_progress") {
+      return "in_progress";
+    }
+    return "incomplete";
+  }
+  mergeConversationItem(previous, next) {
+    return {
+      ...previous,
+      ...next,
+      content: next.content ?? previous?.content ?? []
+    };
+  }
+  extractText(content) {
+    return content?.find((item) => item.type === "text")?.text ?? "";
+  }
+  extractTranscript(content) {
+    return content?.find((item) => item.type === "audio")?.transcript ?? "";
+  }
+  upsertContentText(content, text) {
+    const next = [...content];
+    const textIndex = next.findIndex((item) => item.type === "text");
+    if (textIndex >= 0) {
+      next[textIndex] = {
+        ...next[textIndex],
+        type: "text",
+        text
+      };
+      return next;
+    }
+    return [
+      ...next,
+      {
+        type: "text",
+        text
+      }
+    ];
+  }
+  upsertContentTranscript(content, transcript) {
+    const next = [...content];
+    const audioIndex = next.findIndex((item) => item.type === "audio");
+    if (audioIndex >= 0) {
+      next[audioIndex] = {
+        ...next[audioIndex],
+        type: "audio",
+        transcript
+      };
+      return next;
+    }
+    return [
+      ...next,
+      {
+        type: "audio",
+        transcript
+      }
+    ];
+  }
+};
+
+// src/runtime/managers/trtc-source-manager.ts
+var TAG = "[IVI-TRTC]";
+var TrtcSourceManager = class {
+  constructor(onLog) {
+    this.onLog = onLog;
+    this.sessions = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 将 runtime 当前 sources 与 TRTC 会话池对齐：
+   * - 对 ready + trtc 的 source 进行 upsert（必要时建立连接）
+   * - 清理已不在 runtime 中的会话（释放资源）
+   */
+  syncRuntimeSources(sources) {
+    const existingIds = new Set(sources.keys());
+    sources.forEach((source, sourceId) => {
+      if (!isRuntimeTrtcSource(source)) {
+        return;
+      }
+      this.upsertSource(sourceId, source.playback.trtc);
+    });
+    this.sessions.forEach((_session, sourceId) => {
+      if (!existingIds.has(sourceId)) {
+        this.removeSource(sourceId);
+      }
+    });
+  }
+  /**
+   * 按 sourceId 注册/更新 TRTC 配置。
+   * 若配置发生变化，会先销毁旧会话再按新参数重建连接。
+   */
+  upsertSource(sourceId, trtc) {
+    const existing = this.sessions.get(sourceId);
+    if (!existing) {
+      this.log("info", `\u65B0\u5EFA\u4F1A\u8BDD source=${sourceId} room=${trtc.room_id} user=${trtc.user_id}`);
+      const session2 = this.createSession(sourceId, trtc);
+      this.sessions.set(sourceId, session2);
+      void this.ensureConnected(session2);
+      return;
+    }
+    if (isSameTrtcConfig(existing.trtc, trtc)) {
+      return;
+    }
+    this.log("info", `\u914D\u7F6E\u53D8\u66F4\uFF0C\u91CD\u5EFA\u4F1A\u8BDD source=${sourceId} room=${trtc.room_id}`);
+    void this.disposeSession(existing);
+    const session = this.createSession(sourceId, trtc);
+    this.sessions.set(sourceId, session);
+    void this.ensureConnected(session);
+  }
+  /**
+   * 删除指定 source 的 TRTC 会话并释放连接资源。
+   * 该操作通常由 source.deleted 或会话重置触发。
+   */
+  removeSource(sourceId) {
+    const session = this.sessions.get(sourceId);
+    if (!session) {
+      return;
+    }
+    this.log("info", `\u79FB\u9664\u4F1A\u8BDD source=${sourceId}`);
+    this.sessions.delete(sourceId);
+    void this.disposeSession(session);
+    this.emitSnapshot(sourceId, {
+      status: "idle"
+    });
+    this.listeners.delete(sourceId);
+  }
+  reset() {
+    this.log("info", `\u91CD\u7F6E\u5168\u90E8\u4F1A\u8BDD count=${this.sessions.size}`);
+    const sessions = Array.from(this.sessions.values());
+    this.sessions.clear();
+    sessions.forEach((session) => {
+      void this.disposeSession(session);
+    });
+    this.listeners.clear();
+  }
+  subscribe(sourceId, listener) {
+    const set = this.listeners.get(sourceId) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.listeners.set(sourceId, set);
+    listener(this.getSnapshot(sourceId));
+    return () => {
+      const target = this.listeners.get(sourceId);
+      if (!target) {
+        return;
+      }
+      target.delete(listener);
+      if (target.size === 0) {
+        this.listeners.delete(sourceId);
+      }
+    };
+  }
+  getSnapshot(sourceId) {
+    const session = this.sessions.get(sourceId);
+    if (!session) {
+      return {
+        status: "idle"
+      };
+    }
+    return {
+      status: session.status,
+      error: session.error
+    };
+  }
+  /**
+   * 检查指定 source 的 TRTC 会话是否曾收到过 REMOTE_VIDEO_AVAILABLE 事件。
+   */
+  hasRemoteVideoAvailable(sourceId) {
+    const session = this.sessions.get(sourceId);
+    return session?.hasEverReceivedRemoteVideo ?? false;
+  }
+  /**
+   * 等待指定 source 的 TRTC 会话首次收到 REMOTE_VIDEO_AVAILABLE。
+   * - 若已收到过，立即返回 true。
+   * - 若会话被销毁或超时，返回 false。
+   */
+  waitForRemoteVideoAvailable(sourceId, timeoutMs = 3e4) {
+    const session = this.sessions.get(sourceId);
+    if (!session) return Promise.resolve(false);
+    if (session.hasEverReceivedRemoteVideo) return Promise.resolve(true);
+    return new Promise((resolve) => {
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const idx = session.remoteVideoWaiters.indexOf(waiter);
+        if (idx >= 0) session.remoteVideoWaiters.splice(idx, 1);
+        resolve(false);
+      }, timeoutMs);
+      const waiter = (available) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve(available);
+      };
+      session.remoteVideoWaiters.push(waiter);
+    });
+  }
+  /**
+   * 将一个渲染容器绑定到 source 会话：
+   * - 确保连接已建立
+   * - 回放历史已知远端视频轨道到该容器
+   * - 应用全局音频策略（根据所有 view 的 muted 汇总）
+   */
+  async attachView(sourceId, viewId, container, muted) {
+    const session = this.sessions.get(sourceId);
+    if (!session) {
+      throw new Error(`TRTC source session not found: ${sourceId}`);
+    }
+    session.views.set(viewId, {
+      container,
+      muted,
+      startedVideoKeys: /* @__PURE__ */ new Set(),
+      startingVideoKeys: /* @__PURE__ */ new Set()
+    });
+    await this.ensureConnected(session);
+    const binding = session.views.get(viewId);
+    if (!binding) {
+      return;
+    }
+    await this.renderKnownRemoteVideosToView(session, binding);
+    await this.applyAudioPolicy(session);
+  }
+  detachView(sourceId, viewId) {
+    const session = this.sessions.get(sourceId);
+    if (!session) {
+      return;
+    }
+    session.views.delete(viewId);
+    void this.applyAudioPolicy(session);
+  }
+  updateViewMuted(sourceId, viewId, muted) {
+    const session = this.sessions.get(sourceId);
+    if (!session) {
+      return;
+    }
+    const binding = session.views.get(viewId);
+    if (!binding) {
+      return;
+    }
+    binding.muted = muted;
+    void this.applyAudioPolicy(session);
+  }
+  createSession(sourceId, trtc) {
+    return {
+      sourceId,
+      trtc,
+      TRTC: null,
+      client: null,
+      connectPromise: null,
+      views: /* @__PURE__ */ new Map(),
+      remoteVideoStreams: /* @__PURE__ */ new Set(),
+      remoteAudioUsers: /* @__PURE__ */ new Set(),
+      status: "idle",
+      hasEverReceivedRemoteVideo: false,
+      remoteVideoWaiters: []
+    };
+  }
+  /**
+   * 懒连接入口：同一会话只允许一次并发 connectPromise。
+   * 建连后统一注册远端音视频事件，并持续向所有已绑定 view 分发渲染。
+   */
+  async ensureConnected(session) {
+    if (session.client && session.TRTC) {
+      return;
+    }
+    if (session.connectPromise) {
+      await session.connectPromise;
+      return;
+    }
+    session.status = "connecting";
+    session.error = void 0;
+    this.emitSnapshot(session.sourceId, {
+      status: session.status
+    });
+    session.connectPromise = (async () => {
+      const m = await import('trtc-sdk-v5');
+      const TRTC = m.default ?? m;
+      const sdkAppId = Number(session.trtc.app_id);
+      if (!Number.isFinite(sdkAppId)) {
+        throw new Error("TRTC app_id \u5FC5\u987B\u662F\u6570\u5B57\u5B57\u7B26\u4E32\u3002");
+      }
+      const isStringRoomId = shouldUseStringRoomId(session.trtc.room_id);
+      const client = TRTC.create();
+      const onRemoteVideoAvailable = (event) => {
+        this.log("info", `\u8FDC\u7AEF\u89C6\u9891\u53EF\u7528 source=${session.sourceId} userId=${event.userId} streamType=${event.streamType}`);
+        const remoteVideoKey = buildRemoteVideoKey(event.userId, String(event.streamType));
+        session.remoteVideoStreams.add(remoteVideoKey);
+        if (!session.hasEverReceivedRemoteVideo) {
+          session.hasEverReceivedRemoteVideo = true;
+          for (const waiter of session.remoteVideoWaiters) {
+            waiter(true);
+          }
+          session.remoteVideoWaiters.length = 0;
+        }
+        session.views.forEach((binding) => {
+          void this.startRemoteVideoForBinding(client, event.userId, event.streamType, binding, remoteVideoKey);
+        });
+      };
+      const onRemoteVideoUnavailable = (event) => {
+        this.log("info", `\u8FDC\u7AEF\u89C6\u9891\u4E0D\u53EF\u7528 source=${session.sourceId} userId=${event.userId} streamType=${event.streamType}`);
+        const remoteVideoKey = buildRemoteVideoKey(event.userId, String(event.streamType));
+        session.remoteVideoStreams.delete(remoteVideoKey);
+        session.views.forEach((binding) => {
+          binding.startedVideoKeys.delete(remoteVideoKey);
+          binding.startingVideoKeys.delete(remoteVideoKey);
+        });
+        void client.stopRemoteVideo({
+          userId: event.userId,
+          streamType: event.streamType
+        }).catch(() => void 0);
+      };
+      const onRemoteAudioAvailable = (event) => {
+        this.log("info", `\u8FDC\u7AEF\u97F3\u9891\u53EF\u7528 source=${session.sourceId} userId=${event.userId}`);
+        session.remoteAudioUsers.add(event.userId);
+        void this.applyAudioPolicy(session);
+      };
+      const onRemoteAudioUnavailable = (event) => {
+        this.log("info", `\u8FDC\u7AEF\u97F3\u9891\u4E0D\u53EF\u7528 source=${session.sourceId} userId=${event.userId}`);
+        session.remoteAudioUsers.delete(event.userId);
+        void this.applyAudioPolicy(session);
+      };
+      session.onRemoteVideoAvailable = onRemoteVideoAvailable;
+      session.onRemoteVideoUnavailable = onRemoteVideoUnavailable;
+      session.onRemoteAudioAvailable = onRemoteAudioAvailable;
+      session.onRemoteAudioUnavailable = onRemoteAudioUnavailable;
+      client.on(TRTC.EVENT.REMOTE_VIDEO_AVAILABLE, onRemoteVideoAvailable);
+      client.on(TRTC.EVENT.REMOTE_VIDEO_UNAVAILABLE, onRemoteVideoUnavailable);
+      client.on(TRTC.EVENT.REMOTE_AUDIO_AVAILABLE, onRemoteAudioAvailable);
+      client.on(TRTC.EVENT.REMOTE_AUDIO_UNAVAILABLE, onRemoteAudioUnavailable);
+      this.log("info", `\u6B63\u5728\u8FDB\u623F source=${session.sourceId} room=${session.trtc.room_id} sdkAppId=${sdkAppId} userId=${session.trtc.user_id}`);
+      await client.enterRoom({
+        sdkAppId,
+        userId: session.trtc.user_id,
+        userSig: session.trtc.user_sig,
+        scene: TRTC.TYPE.SCENE_LIVE,
+        role: TRTC.TYPE.ROLE_AUDIENCE,
+        autoReceiveAudio: true,
+        ...isStringRoomId ? { strRoomId: session.trtc.room_id } : { roomId: Number(session.trtc.room_id) }
+      });
+      session.TRTC = TRTC;
+      session.client = client;
+      session.status = "connected";
+      session.error = void 0;
+      this.log("info", `\u8FDB\u623F\u6210\u529F source=${session.sourceId} room=${session.trtc.room_id}`);
+      this.emitSnapshot(session.sourceId, {
+        status: session.status
+      });
+      await this.applyAudioPolicy(session);
+    })().catch((error) => {
+      session.status = "error";
+      session.error = error instanceof Error ? error.message : String(error);
+      this.log("error", `\u8FDE\u63A5\u5931\u8D25 source=${session.sourceId} error=${session.error}`);
+      this.emitSnapshot(session.sourceId, {
+        status: session.status,
+        error: session.error
+      });
+      throw error;
+    }).finally(() => {
+      session.connectPromise = null;
+    });
+    await session.connectPromise;
+  }
+  async renderKnownRemoteVideosToView(session, binding) {
+    const client = session.client;
+    if (!client) {
+      return;
+    }
+    for (const key of session.remoteVideoStreams) {
+      const parsed = parseRemoteVideoKey(key);
+      if (!parsed) {
+        continue;
+      }
+      await this.startRemoteVideoForBinding(
+        client,
+        parsed.userId,
+        parsed.streamType,
+        binding,
+        key
+      );
+    }
+  }
+  async startRemoteVideoForBinding(client, userId, streamType, binding, remoteVideoKey) {
+    if (binding.startedVideoKeys.has(remoteVideoKey) || binding.startingVideoKeys.has(remoteVideoKey)) {
+      return;
+    }
+    binding.startingVideoKeys.add(remoteVideoKey);
+    try {
+      await client.startRemoteVideo({
+        userId,
+        streamType,
+        view: binding.container,
+        option: { fillMode: "contain" }
+      });
+      binding.startedVideoKeys.add(remoteVideoKey);
+      enforceContainMedia(binding.container);
+    } catch (error) {
+      if (error instanceof Error && /already started|OPERATION_ABORT/i.test(error.message)) {
+        binding.startedVideoKeys.add(remoteVideoKey);
+        return;
+      }
+      this.log("warn", `\u8FDC\u7AEF\u89C6\u9891\u6E32\u67D3\u5931\u8D25 userId=${userId} streamType=${streamType}`, error);
+    } finally {
+      binding.startingVideoKeys.delete(remoteVideoKey);
+    }
+  }
+  /**
+   * 统一音频策略：
+   * - 所有 view 都 muted -> 全局静音
+   * - 至少一个 view 需出声 -> 对可用远端用户解除静音
+   */
+  async applyAudioPolicy(session) {
+    const client = session.client;
+    if (!client) {
+      return;
+    }
+    const hasUnmutedView = Array.from(session.views.values()).some((view) => !view.muted);
+    if (!hasUnmutedView) {
+      await client.muteRemoteAudio("*", true);
+      return;
+    }
+    const activeUsers = Array.from(session.remoteAudioUsers);
+    if (activeUsers.length === 0) {
+      await client.muteRemoteAudio("*", false);
+      return;
+    }
+    for (const userId of activeUsers) {
+      await client.muteRemoteAudio(userId, false);
+    }
+  }
+  /**
+   * 销毁单个 source 会话：
+   * 解绑事件、停止远端视频、退出房间并销毁客户端。
+   */
+  async disposeSession(session) {
+    const TRTC = session.TRTC;
+    const client = session.client;
+    session.connectPromise = null;
+    session.views.clear();
+    session.remoteAudioUsers.clear();
+    session.remoteVideoStreams.clear();
+    session.status = "idle";
+    session.error = void 0;
+    for (const waiter of session.remoteVideoWaiters) {
+      waiter(false);
+    }
+    session.remoteVideoWaiters.length = 0;
+    session.hasEverReceivedRemoteVideo = false;
+    if (!client) {
+      return;
+    }
+    this.log("info", `\u9500\u6BC1\u4F1A\u8BDD source=${session.sourceId}`);
+    try {
+      if (TRTC && session.onRemoteVideoAvailable && session.onRemoteVideoUnavailable) {
+        client.off(TRTC.EVENT.REMOTE_VIDEO_AVAILABLE, session.onRemoteVideoAvailable);
+        client.off(TRTC.EVENT.REMOTE_VIDEO_UNAVAILABLE, session.onRemoteVideoUnavailable);
+      }
+      if (TRTC && session.onRemoteAudioAvailable && session.onRemoteAudioUnavailable) {
+        client.off(TRTC.EVENT.REMOTE_AUDIO_AVAILABLE, session.onRemoteAudioAvailable);
+        client.off(TRTC.EVENT.REMOTE_AUDIO_UNAVAILABLE, session.onRemoteAudioUnavailable);
+      }
+      await client.stopRemoteVideo({ userId: "*" });
+      await client.exitRoom();
+      this.log("info", `\u9000\u623F\u5B8C\u6210 source=${session.sourceId}`);
+      client.destroy();
+    } catch (err) {
+      this.log("warn", `\u9000\u623F/\u9500\u6BC1\u5F02\u5E38 source=${session.sourceId}`, err);
+      try {
+        client.destroy();
+      } catch {
+      }
+    } finally {
+      session.TRTC = null;
+      session.client = null;
+    }
+  }
+  emitSnapshot(sourceId, snapshot) {
+    const targetListeners = this.listeners.get(sourceId);
+    if (!targetListeners) {
+      return;
+    }
+    targetListeners.forEach((listener) => listener(snapshot));
+  }
+  log(level, message, ...extra) {
+    const args = [TAG, message, ...extra];
+    this.onLog?.({
+      level,
+      tag: TAG,
+      message: `${TAG} ${message}`,
+      args,
+      data: extra.length > 0 ? { message, extra } : { message }
+    });
+    if (level === "error") {
+      console.error(...args);
+      return;
+    }
+    if (level === "warn") {
+      console.warn(...args);
+      return;
+    }
+    console.log(...args);
+  }
+};
+function isRuntimeTrtcSource(source) {
+  return source.status === "ready" && source.playback?.type === "trtc" && Boolean(source.playback.trtc);
+}
+function isSameTrtcConfig(a, b) {
+  return a.app_id === b.app_id && a.user_id === b.user_id && a.user_sig === b.user_sig && a.room_id === b.room_id;
+}
+function shouldUseStringRoomId(roomId) {
+  if (!/^\d+$/.test(roomId)) {
+    return true;
+  }
+  const roomNumber = Number(roomId);
+  return !Number.isInteger(roomNumber) || roomNumber < 1 || roomNumber > 4294967294;
+}
+function buildRemoteVideoKey(userId, streamType) {
+  return `${userId}::${streamType}`;
+}
+function parseRemoteVideoKey(key) {
+  const separatorIndex = key.indexOf("::");
+  if (separatorIndex < 0) {
+    return null;
+  }
+  return {
+    userId: key.slice(0, separatorIndex),
+    streamType: key.slice(separatorIndex + 2)
+  };
+}
+function enforceContainMedia(container) {
+  const playerNodes = container.querySelectorAll("[id^='player_'], [id^='video_'], [id^='audio_']");
+  playerNodes.forEach((node) => {
+    if (!(node instanceof HTMLElement)) {
+      return;
+    }
+    node.style.setProperty("width", "100%", "important");
+    node.style.setProperty("height", "100%", "important");
+    node.style.setProperty("max-width", "100%", "important");
+    node.style.setProperty("max-height", "100%", "important");
+  });
+  const mediaElements = container.querySelectorAll("video, canvas");
+  mediaElements.forEach((element) => {
+    if (!(element instanceof HTMLElement)) {
+      return;
+    }
+    element.style.setProperty("width", "100%", "important");
+    element.style.setProperty("height", "100%", "important");
+    element.style.setProperty("max-width", "100%", "important");
+    element.style.setProperty("max-height", "100%", "important");
+    element.style.setProperty("object-fit", "contain", "important");
+    element.style.setProperty("display", "block", "important");
+  });
+}
+
+// src/runtime/runtime-coordinator.ts
+var IviRuntimeCoordinator = class {
+  /**
+   * @param client 底层实时客户端，负责实际事件收发。
+   * @param config 协调行为配置（例如会话建立后的同步策略）。
+   */
+  constructor(client, config) {
+    this.sessionManager = new SessionManager();
+    this.stageManager = new StageManager();
+    this.trackManager = new TrackManager();
+    this.sourceManager = new SourceManager();
+    this.streamManager = new StreamManager();
+    this.conversationManager = new ConversationManager();
+    this.stateListeners = /* @__PURE__ */ new Set();
+    this.eventListeners = /* @__PURE__ */ new Set();
+    this.pendingUserTextToResponseFlows = /* @__PURE__ */ new Map();
+    this.userTextFlowCounter = 0;
+    this.waitingTracksListValidation = false;
+    this.waitingSourcesListValidation = false;
+    this.state = {
+      status: "idle",
+      session: null,
+      stage: null,
+      tracks: /* @__PURE__ */ new Map(),
+      sources: /* @__PURE__ */ new Map(),
+      streams: /* @__PURE__ */ new Map(),
+      conversationItems: /* @__PURE__ */ new Map(),
+      conversations: []
+    };
+    this.client = client;
+    this.config = {
+      syncStageOnSessionCreated: true,
+      ...config
+    };
+    this.trtcSourceManager = new TrtcSourceManager(this.config.onLog);
+    this.sessionHandler = new SessionEventHandler(this.sessionManager, {
+      onSessionCreated: (event) => this.onSessionCreated(event),
+      onSessionEnded: (event) => this.onSessionEnded(event)
+    });
+    this.stageHandler = new StageEventHandler(this.stageManager, {
+      onStageChanged: ({ fromStageGetResponse }) => this.onStageChanged(fromStageGetResponse)
+    });
+    this.trackHandler = new TrackEventHandler(this.trackManager, {
+      onTracksChanged: ({ listRefreshed }) => this.onTracksChanged(listRefreshed)
+    });
+    this.sourceHandler = new SourceEventHandler(this.sourceManager, {
+      onSourcesChanged: ({ listRefreshed }) => this.onSourcesChanged(listRefreshed)
+    });
+    this.streamHandler = new StreamEventHandler(this.streamManager, {
+      onStreamsChanged: () => this.onStreamsChanged()
+    });
+    this.conversationHandler = new ConversationEventHandler(this.conversationManager, {
+      onConversationsChanged: () => this.onConversationsChanged()
+    });
+    this.dispatcher = new IviRuntimeDispatcher(client, {
+      sessionHandler: this.sessionHandler,
+      stageHandler: this.stageHandler,
+      trackHandler: this.trackHandler,
+      sourceHandler: this.sourceHandler,
+      streamHandler: this.streamHandler,
+      conversationHandler: this.conversationHandler,
+      onConnectionChange: (connected) => this.onConnectionChange(connected),
+      onEvent: (event) => this.emitEvent(event),
+      onLog: this.config.onLog
+    });
+  }
+  /**
+   * 启动协调器并建立实时连接。
+   * 启动后状态会从 idle/stopped 进入 connecting，连接成功后由事件驱动进入后续状态。
+   */
+  async start() {
+    this.setState({
+      ...this.state,
+      status: "connecting"
+    });
+    this.dispatcher.start();
+    try {
+      await this.client.connect();
+    } catch (error) {
+      this.stop();
+      throw error;
+    }
+  }
+  /**
+   * 停止协调器并断开实时连接，同时重置运行态数据为 stopped。
+   */
+  stop() {
+    this.dispatcher.stop();
+    this.client.disconnect();
+    this.resetStoppedState();
+  }
+  getState() {
+    return this.state;
+  }
+  onStateChange(listener) {
+    this.stateListeners.add(listener);
+    return () => {
+      this.stateListeners.delete(listener);
+    };
+  }
+  onEvent(listener) {
+    this.eventListeners.add(listener);
+    return () => {
+      this.eventListeners.delete(listener);
+    };
+  }
+  /**
+   * 编排一次"用户文本输入 -> 触发模型回复"链路。
+   *
+   * 流程：
+   * 1) 发送 conversation.item.create（可指定 itemId）；
+   * 2) 等待 conversation.item.added + conversation.item.done；
+   * 3) 发送 response.create（携带 item_reference，可选绑定 stream）；
+   * 4) 等待 response.created 并结束。
+   */
+  sendUserTextAndTriggerResponse(options) {
+    const normalizedStreamId = options.streamId?.trim() || void 0;
+    const normalizedText = options.text.trim();
+    if (!normalizedText) {
+      throw new Error("text must be a non-empty string.");
+    }
+    const normalizedItemId = typeof options.itemId === "string" && options.itemId.trim().length > 0 ? options.itemId.trim() : void 0;
+    if (normalizedItemId && this.pendingUserTextToResponseFlows.has(normalizedItemId)) {
+      throw new Error(`Conversation item flow already exists for itemId: ${normalizedItemId}`);
+    }
+    if (normalizedStreamId && this.hasPendingResponseFlow(normalizedStreamId)) {
+      throw new Error(`Response flow already pending for streamId: ${normalizedStreamId}`);
+    }
+    const itemId = normalizedItemId ?? this.buildUserTextItemId();
+    return new Promise((resolve, reject) => {
+      this.pendingUserTextToResponseFlows.set(itemId, {
+        itemId,
+        streamId: normalizedStreamId,
+        response: options.response,
+        callbacks: options.callbacks,
+        responseRequested: false,
+        resolve,
+        reject
+      });
+      this.client.sendConversationUserText(normalizedText, itemId).catch((error) => {
+        this.pendingUserTextToResponseFlows.delete(itemId);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      });
+    });
+  }
+  /**
+   * 上报某个 source 在指定 track 上播放完成。
+   *
+   * - 若 next 槽位为空，只发送 complete。
+   * - 若 next 槽位已有 source，立即将 next 提升为 active，并发送 complete 与 take。
+   * - 当前为普通视频/m3u8 且 next 为 TRTC source 时，等待 TRTC 远端视频可用后再切换并发送 complete/take。
+   */
+  sendSessionSourcePlaybackCompleted(sourceId, trackId) {
+    const resolvedTrackId = trackId ?? this.trackManager.findTrackIdByActiveSource(sourceId);
+    if (!resolvedTrackId) {
+      this.client.sendSessionSourcePlaybackCompleted(sourceId, trackId);
+      return;
+    }
+    const track = this.trackManager.getAll().get(resolvedTrackId);
+    if (!track) {
+      this.client.sendSessionSourcePlaybackCompleted(sourceId, trackId);
+      return;
+    }
+    if (track.next_source_id) {
+      const currentSource = this.sourceManager.get(sourceId);
+      const nextSource = this.sourceManager.get(track.next_source_id);
+      if (isVideoPlaybackSource(currentSource) && isTrtcPlaybackSource(nextSource)) {
+        void this.deferredTrtcTakeCompleteAndTake(resolvedTrackId, track.next_source_id, sourceId, trackId);
+        return;
+      }
+      this.applyLocalTrackTake(resolvedTrackId);
+      this.client.sendSessionSourcePlaybackCompleted(sourceId, trackId);
+      this.sendSessionTrackTake(resolvedTrackId);
+      return;
+    }
+    this.client.sendSessionSourcePlaybackCompleted(sourceId, trackId);
+  }
+  getTrtcSourceManager() {
+    return this.trtcSourceManager;
+  }
+  onConnectionChange(connected) {
+    if (connected || this.state.status === "idle") {
+      return;
+    }
+    if (this.state.status === "stopped") {
+      return;
+    }
+    this.resetStoppedState();
+  }
+  validateStageTracks(stage, hasTrack) {
+    const missingTrackIds = this.getMissingTrackIds(stage, hasTrack);
+    if (missingTrackIds.length === 0) {
+      return false;
+    }
+    this.waitingTracksListValidation = true;
+    return true;
+  }
+  validateTracksListRefreshed(stage, hasTrack) {
+    if (!this.waitingTracksListValidation) {
+      return;
+    }
+    this.waitingTracksListValidation = false;
+    const missingTrackIds = this.getMissingTrackIds(stage, hasTrack);
+    if (missingTrackIds.length > 0) {
+      throw new Error(
+        `Runtime track sync failed: missing tracks after session.tracks.list.response: ${missingTrackIds.join(", ")}`
+      );
+    }
+  }
+  reset() {
+    this.waitingTracksListValidation = false;
+    this.waitingSourcesListValidation = false;
+  }
+  onSessionCreated(event) {
+    this.stageManager.reset();
+    this.trackManager.reset();
+    this.sourceManager.reset();
+    this.streamManager.reset();
+    this.trtcSourceManager.reset();
+    this.conversationManager.reset();
+    this.reset();
+    const nextStatus = this.config.syncStageOnSessionCreated !== false ? "syncing" : "running";
+    this.setState({
+      status: nextStatus,
+      session: event.session,
+      stage: this.stageManager.getStage(),
+      tracks: this.trackManager.getAll(),
+      sources: this.sourceManager.getAll(),
+      streams: this.streamManager.getAll(),
+      conversationItems: this.conversationManager.getAllMap(),
+      conversations: this.conversationManager.getOrderedList()
+    });
+    if (this.config.syncStageOnSessionCreated !== false) {
+      this.client.sendSessionStageGet();
+    }
+  }
+  onSessionEnded(event) {
+    this.resetStoppedState();
+    this.config.onSessionEnded?.(event);
+  }
+  onStageChanged(fromStageGetResponse) {
+    const nextStatus = fromStageGetResponse && this.state.status === "syncing" ? "running" : this.state.status;
+    const nextStage = this.stageManager.getStage();
+    this.setState({
+      ...this.state,
+      status: nextStatus,
+      stage: nextStage
+    });
+    const shouldFetchTracks = this.validateStageTracks(nextStage, (trackId) => this.trackManager.has(trackId));
+    if (shouldFetchTracks) {
+      this.client.sendSessionTracksList();
+      return;
+    }
+    this.ensureSourcesSyncedForTracks();
+  }
+  onTracksChanged(listRefreshed) {
+    const nextStage = this.stageManager.getStage();
+    this.sourceManager.syncWithTracks(this.trackManager.getAll());
+    this.trtcSourceManager.syncRuntimeSources(this.sourceManager.getAll());
+    this.setState({
+      ...this.state,
+      tracks: this.trackManager.getAll(),
+      sources: this.sourceManager.getAll()
+    });
+    if (listRefreshed) {
+      this.validateTracksListRefreshed(nextStage, (trackId) => this.trackManager.has(trackId));
+    }
+    this.ensureSourcesSyncedForTracks();
+  }
+  applyLocalTrackTake(trackId) {
+    this.trackManager.applyTrackTook(trackId);
+    this.sourceManager.syncWithTracks(this.trackManager.getAll());
+    this.trtcSourceManager.syncRuntimeSources(this.sourceManager.getAll());
+    this.setState({
+      ...this.state,
+      tracks: this.trackManager.getAll(),
+      sources: this.sourceManager.getAll()
+    });
+  }
+  async deferredTrtcTakeCompleteAndTake(trackId, nextSourceId, completedSourceId, completedTrackIdArg) {
+    const remoteVideoAvailable = await this.trtcSourceManager.waitForRemoteVideoAvailable(nextSourceId);
+    if (!remoteVideoAvailable) return;
+    if (this.state.status !== "running") return;
+    const currentTrack = this.trackManager.getAll().get(trackId);
+    if (!currentTrack || currentTrack.next_source_id !== nextSourceId) {
+      return;
+    }
+    this.applyLocalTrackTake(trackId);
+    this.client.sendSessionSourcePlaybackCompleted(completedSourceId, completedTrackIdArg);
+    this.sendSessionTrackTake(trackId);
+  }
+  sendSessionTrackTake(trackId) {
+    const message = {
+      type: "session.track.take",
+      track_id: trackId
+    };
+    void this.client.send(message);
+  }
+  onSourcesChanged(listRefreshed) {
+    this.sourceManager.syncWithTracks(this.trackManager.getAll());
+    this.trtcSourceManager.syncRuntimeSources(this.sourceManager.getAll());
+    this.setState({
+      ...this.state,
+      sources: this.sourceManager.getAll()
+    });
+    if (listRefreshed) {
+      this.validateSourcesListRefreshed((sourceId) => this.sourceManager.has(sourceId));
+    }
+  }
+  onStreamsChanged() {
+    this.setState({
+      ...this.state,
+      streams: this.streamManager.getAll()
+    });
+  }
+  onConversationsChanged() {
+    this.setState({
+      ...this.state,
+      conversationItems: this.conversationManager.getAllMap(),
+      conversations: this.conversationManager.getOrderedList()
+    });
+  }
+  setState(nextState) {
+    if (this.state.status === nextState.status && this.state.session === nextState.session && this.state.stage === nextState.stage && this.state.tracks === nextState.tracks && this.state.sources === nextState.sources && this.state.streams === nextState.streams && this.state.conversationItems === nextState.conversationItems && this.state.conversations === nextState.conversations) {
+      return;
+    }
+    this.state = nextState;
+    this.stateListeners.forEach((listener) => listener(this.state));
+  }
+  emitEvent(event) {
+    this.progressUserTextToResponseFlows(event);
+    this.eventListeners.forEach((listener) => listener(event, this.state));
+  }
+  resetStoppedState() {
+    this.rejectPendingUserTextToResponseFlows(
+      new Error("Runtime stopped before user text to response flow completed.")
+    );
+    this.sessionManager.reset();
+    this.stageManager.reset();
+    this.trackManager.reset();
+    this.sourceManager.reset();
+    this.streamManager.reset();
+    this.trtcSourceManager.reset();
+    this.conversationManager.reset();
+    this.reset();
+    this.setState({
+      status: "stopped",
+      session: null,
+      stage: null,
+      tracks: /* @__PURE__ */ new Map(),
+      sources: /* @__PURE__ */ new Map(),
+      streams: /* @__PURE__ */ new Map(),
+      conversationItems: /* @__PURE__ */ new Map(),
+      conversations: []
+    });
+  }
+  ensureSourcesSyncedForTracks() {
+    const missingSourceIds = this.getMissingSourceIds((sourceId) => this.sourceManager.has(sourceId));
+    if (missingSourceIds.length === 0) {
+      return;
+    }
+    this.waitingSourcesListValidation = true;
+    this.client.sendSessionSourcesList();
+  }
+  validateSourcesListRefreshed(hasSource) {
+    if (!this.waitingSourcesListValidation) {
+      return;
+    }
+    this.waitingSourcesListValidation = false;
+    const missingSourceIds = this.getMissingSourceIds(hasSource);
+    if (missingSourceIds.length > 0) {
+      throw new Error(
+        `Runtime source sync failed: missing sources after session.sources.list.response: ${missingSourceIds.join(", ")}`
+      );
+    }
+  }
+  getMissingTrackIds(stage, hasTrack) {
+    if (!stage) {
+      return [];
+    }
+    const missing = /* @__PURE__ */ new Set();
+    stage.composition.forEach((item) => {
+      if (!hasTrack(item.track_id)) {
+        missing.add(item.track_id);
+      }
+    });
+    return Array.from(missing);
+  }
+  getMissingSourceIds(hasSource) {
+    const missing = /* @__PURE__ */ new Set();
+    this.trackManager.getAll().forEach((track) => {
+      if (track.active_source_id && !hasSource(track.active_source_id)) {
+        missing.add(track.active_source_id);
+      }
+      if (track.next_source_id && !hasSource(track.next_source_id)) {
+        missing.add(track.next_source_id);
+      }
+    });
+    return Array.from(missing);
+  }
+  hasPendingResponseFlow(streamId) {
+    for (const flow of this.pendingUserTextToResponseFlows.values()) {
+      if (flow.streamId === streamId) {
+        return true;
+      }
+    }
+    return false;
+  }
+  rejectPendingUserTextToResponseFlows(error) {
+    this.pendingUserTextToResponseFlows.forEach((flow) => {
+      flow.reject(error);
+    });
+    this.pendingUserTextToResponseFlows.clear();
+  }
+  progressUserTextToResponseFlows(event) {
+    if (event instanceof ReceiveConversationItemAddedEvent) {
+      const flow = this.pendingUserTextToResponseFlows.get(event.item.id);
+      if (!flow) {
+        return;
+      }
+      flow.addedEvent = event;
+      flow.callbacks?.onConversationItemAdded?.(event);
+      this.tryTriggerResponseCreate(flow);
+      return;
+    }
+    if (event instanceof ReceiveConversationItemDoneEvent) {
+      const flow = this.pendingUserTextToResponseFlows.get(event.item.id);
+      if (!flow) {
+        return;
+      }
+      flow.doneEvent = event;
+      flow.callbacks?.onConversationItemDone?.(event);
+      this.tryTriggerResponseCreate(flow);
+      return;
+    }
+    if (!(event instanceof ReceiveResponseCreatedEvent)) {
+      return;
+    }
+    const matchedFlow = Array.from(this.pendingUserTextToResponseFlows.values()).find(
+      (flow) => flow.responseRequested && flow.streamId === event.streamId
+    );
+    if (!matchedFlow) {
+      return;
+    }
+    matchedFlow.callbacks?.onResponseCreated?.(event);
+    matchedFlow.resolve({
+      itemId: matchedFlow.itemId,
+      streamId: matchedFlow.streamId,
+      responseCreatedEvent: event
+    });
+    this.pendingUserTextToResponseFlows.delete(matchedFlow.itemId);
+  }
+  tryTriggerResponseCreate(flow) {
+    if (flow.responseRequested || !flow.addedEvent || !flow.doneEvent) {
+      return;
+    }
+    flow.callbacks?.onConversationItemReady?.({
+      itemId: flow.itemId,
+      addedEvent: flow.addedEvent,
+      doneEvent: flow.doneEvent
+    });
+    this.client.sendResponseCreateByItemId(flow.itemId, flow.streamId, flow.response);
+    flow.responseRequested = true;
+  }
+  buildUserTextItemId() {
+    this.userTextFlowCounter += 1;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.TZ]/g, "");
+    const randomSuffix = Math.random().toString(36).slice(2, 8);
+    return `client.conversation.item.user.text.${timestamp}.${this.userTextFlowCounter}.${randomSuffix}`;
+  }
+};
+function isVideoPlaybackSource(source) {
+  if (!source || source.status !== "ready" || !source.playback) return false;
+  if (source.playback.type === "trtc") return false;
+  if (source.source.asset_type === "image") return false;
+  return Boolean(source.playback.url);
+}
+function isTrtcPlaybackSource(source) {
+  if (!source || !source.playback) return false;
+  return source.playback.type === "trtc" && Boolean(source.playback.trtc);
+}
+var IviFrontendSdk = class {
+  createClient(config) {
+    return new IviClient(config);
+  }
+  createRuntimeCoordinator(clientConfig, runtimeConfig) {
+    const client = this.createClient(clientConfig);
+    return new IviRuntimeCoordinator(client, runtimeConfig);
+  }
+};
+var IviStageViewContext = createContext(null);
+var EMPTY_RUNTIME_STATE = {
+  status: "idle",
+  session: null,
+  stage: null,
+  tracks: /* @__PURE__ */ new Map(),
+  sources: /* @__PURE__ */ new Map(),
+  streams: /* @__PURE__ */ new Map(),
+  conversationItems: /* @__PURE__ */ new Map(),
+  conversations: []
+};
+function useRuntimeState(runtime) {
+  const [state, setState] = useState(() => runtime?.getState() ?? EMPTY_RUNTIME_STATE);
+  useEffect(() => {
+    if (!runtime) {
+      setState(EMPTY_RUNTIME_STATE);
+      return;
+    }
+    setState(runtime.getState());
+    return runtime.onStateChange((next) => {
+      setState(next);
+    });
+  }, [runtime]);
+  return state;
+}
+function IVIStageView(props) {
+  const {
+    children,
+    className,
+    style,
+    runtime,
+    onBindingsChange,
+    onRuntimeEvent
+  } = props;
+  const state = useRuntimeState(runtime);
+  const slotTrackMap = useMemo(() => {
+    return buildSlotTrackMapFromState(state);
+  }, [state.stage]);
+  const slotBindings = useMemo(() => {
+    return buildSlotBindingsFromState(state);
+  }, [state.stage, state.tracks, state.sources]);
+  useEffect(() => {
+    onBindingsChange?.(slotBindings);
+  }, [slotBindings, onBindingsChange]);
+  useEffect(() => {
+    if (!runtime || !onRuntimeEvent) {
+      return;
+    }
+    return runtime.onEvent((event) => {
+      onRuntimeEvent(event);
+    });
+  }, [runtime, onRuntimeEvent]);
+  const contextValue = useMemo(
+    () => ({
+      runtime,
+      state,
+      slotTrackMap,
+      slotBindings
+    }),
+    [runtime, state, slotTrackMap, slotBindings]
+  );
+  const resolvedChildren = typeof children === "function" ? children({
+    runtime,
+    slotTrackMap,
+    slotBindings
+  }) : children;
+  const rootStyle = {
+    width: "100%",
+    height: "100%",
+    minWidth: 0,
+    minHeight: 0,
+    ...style ?? {}
+  };
+  return /* @__PURE__ */ jsx("div", { className, style: rootStyle, children: /* @__PURE__ */ jsx(IviStageViewContext.Provider, { value: contextValue, children: resolvedChildren }) });
+}
+function buildSlotTrackMapFromState(state) {
+  const map = /* @__PURE__ */ new Map();
+  state.stage?.composition.forEach((item) => {
+    map.set(item.slot, item.track_id);
+  });
+  return map;
+}
+function buildSlotBindingsFromState(state) {
+  const bindings = [];
+  state.stage?.composition.forEach((item) => {
+    const track = state.tracks.get(item.track_id);
+    const sourceId = track?.active_source_id ?? null;
+    const source = sourceId ? state.sources.get(sourceId) : void 0;
+    bindings.push({
+      slot: item.slot,
+      trackId: item.track_id,
+      track,
+      sourceId,
+      source
+    });
+  });
+  return bindings;
+}
+var VOLUME_STORAGE_KEY = "ivi-volume-preferences";
+var DEFAULT_VOLUME = 80;
+function clampVolume(v) {
+  return Math.max(0, Math.min(100, Math.round(v)));
+}
+function loadVolumePreferences() {
+  try {
+    const raw = localStorage.getItem(VOLUME_STORAGE_KEY);
+    if (raw) {
+      const parsed = JSON.parse(raw);
+      return {
+        trtc: clampVolume(parsed.trtc ?? DEFAULT_VOLUME),
+        video: clampVolume(parsed.video ?? DEFAULT_VOLUME),
+        hls: clampVolume(parsed.hls ?? DEFAULT_VOLUME)
+      };
+    }
+  } catch {
+  }
+  return { trtc: DEFAULT_VOLUME, video: DEFAULT_VOLUME, hls: DEFAULT_VOLUME };
+}
+function saveVolumePreferences(prefs) {
+  try {
+    localStorage.setItem(VOLUME_STORAGE_KEY, JSON.stringify(prefs));
+  } catch {
+  }
+}
+function useVolumeMemory(mediaType) {
+  const [prefs, setPrefs] = useState(loadVolumePreferences);
+  const setVolume = useCallback(
+    (v) => {
+      if (!mediaType) return;
+      setPrefs((prev) => {
+        const next = { ...prev, [mediaType]: clampVolume(v) };
+        saveVolumePreferences(next);
+        return next;
+      });
+    },
+    [mediaType]
+  );
+  return [mediaType ? prefs[mediaType] : DEFAULT_VOLUME, setVolume];
+}
+function DefaultSpeakerIcon({ volume, color }) {
+  if (volume === 0) {
+    return /* @__PURE__ */ jsxs("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+      /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M11 5L6 9H2v6h4l5 4V5z",
+          fill: color,
+          stroke: color,
+          strokeWidth: "1.5",
+          strokeLinejoin: "round"
+        }
+      ),
+      /* @__PURE__ */ jsx("path", { d: "M22 9l-6 6M16 9l6 6", stroke: color, strokeWidth: "2", strokeLinecap: "round" })
+    ] });
+  }
+  if (volume < 50) {
+    return /* @__PURE__ */ jsxs("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+      /* @__PURE__ */ jsx(
+        "path",
+        {
+          d: "M11 5L6 9H2v6h4l5 4V5z",
+          fill: color,
+          stroke: color,
+          strokeWidth: "1.5",
+          strokeLinejoin: "round"
+        }
+      ),
+      /* @__PURE__ */ jsx("path", { d: "M15.54 8.46a5 5 0 010 7.07", stroke: color, strokeWidth: "2", strokeLinecap: "round" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M11 5L6 9H2v6h4l5 4V5z",
+        fill: color,
+        stroke: color,
+        strokeWidth: "1.5",
+        strokeLinejoin: "round"
+      }
+    ),
+    /* @__PURE__ */ jsx("path", { d: "M15.54 8.46a5 5 0 010 7.07", stroke: color, strokeWidth: "2", strokeLinecap: "round" }),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M19.07 4.93a10 10 0 010 14.14",
+        stroke: color,
+        strokeWidth: "2",
+        strokeLinecap: "round"
+      }
+    )
+  ] });
+}
+function VolumeSlider({
+  value,
+  onChange,
+  trackBg,
+  fillColor,
+  thumbColor
+}) {
+  const trackRef = useRef(null);
+  const calcValue = useCallback(
+    (clientX) => {
+      const el = trackRef.current;
+      if (!el) return;
+      const rect = el.getBoundingClientRect();
+      const ratio = Math.max(0, Math.min(1, (clientX - rect.left) / rect.width));
+      onChange(Math.round(ratio * 100));
+    },
+    [onChange]
+  );
+  const onPointerDown = useCallback(
+    (e) => {
+      e.preventDefault();
+      e.target.setPointerCapture(e.pointerId);
+      calcValue(e.clientX);
+    },
+    [calcValue]
+  );
+  const onPointerMove = useCallback(
+    (e) => {
+      if (e.buttons === 0) return;
+      calcValue(e.clientX);
+    },
+    [calcValue]
+  );
+  const pct = `${value}%`;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: trackRef,
+      onPointerDown,
+      onPointerMove,
+      style: {
+        position: "relative",
+        flex: 1,
+        height: 4,
+        minWidth: 60,
+        borderRadius: 2,
+        backgroundColor: trackBg,
+        cursor: "pointer",
+        touchAction: "none"
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              left: 0,
+              top: 0,
+              height: "100%",
+              width: pct,
+              borderRadius: 2,
+              backgroundColor: fillColor,
+              pointerEvents: "none"
+            }
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              left: pct,
+              top: "50%",
+              width: 10,
+              height: 10,
+              borderRadius: "50%",
+              backgroundColor: thumbColor,
+              transform: "translate(-50%, -50%)",
+              boxShadow: "0 1px 3px rgba(0,0,0,0.3)",
+              pointerEvents: "none"
+            }
+          }
+        )
+      ]
+    }
+  );
+}
+function IVIVolumeControl(props) {
+  const { volume, onVolumeChange, renderSpeakerIcon, colors, className, style } = props;
+  const bg = colors?.background ?? "rgba(0, 0, 0, 0.55)";
+  const fg = colors?.foreground ?? "#fff";
+  const trackBg = colors?.trackBackground ?? "rgba(255, 255, 255, 0.25)";
+  const trackFill = colors?.trackFill ?? fg;
+  const prevVolumeRef = useRef(volume > 0 ? volume : DEFAULT_VOLUME);
+  if (volume > 0) {
+    prevVolumeRef.current = volume;
+  }
+  const toggleMute = useCallback(() => {
+    onVolumeChange(volume > 0 ? 0 : prevVolumeRef.current);
+  }, [volume, onVolumeChange]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className,
+      style: {
+        display: "inline-flex",
+        alignItems: "center",
+        gap: 6,
+        padding: "5px 10px",
+        borderRadius: 999,
+        backgroundColor: bg,
+        color: fg,
+        userSelect: "none",
+        fontSize: 12,
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        lineHeight: 1,
+        ...style
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            onClick: toggleMute,
+            role: "button",
+            tabIndex: 0,
+            onKeyDown: (e) => {
+              if (e.key === "Enter" || e.key === " ") toggleMute();
+            },
+            style: { cursor: "pointer", display: "flex", alignItems: "center", flexShrink: 0 },
+            children: renderSpeakerIcon ? renderSpeakerIcon(volume) : /* @__PURE__ */ jsx(DefaultSpeakerIcon, { volume, color: fg })
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          VolumeSlider,
+          {
+            value: volume,
+            onChange: onVolumeChange,
+            trackBg,
+            fillColor: trackFill,
+            thumbColor: fg
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          "span",
+          {
+            style: {
+              minWidth: 28,
+              textAlign: "right",
+              fontSize: 11,
+              opacity: 0.9,
+              flexShrink: 0,
+              fontVariantNumeric: "tabular-nums"
+            },
+            children: [
+              volume,
+              "%"
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function useApplyVolumeToSlot(containerRef, volume, enabled, activeSourceId) {
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container || !enabled) return;
+    const normalizedVolume = clampVolume(volume) / 100;
+    const apply = () => {
+      const activeSlot = container.querySelector('[data-ivi-slot-role="active"]');
+      if (!activeSlot) return;
+      activeSlot.querySelectorAll("video, audio").forEach((el) => {
+        el.volume = normalizedVolume;
+      });
+    };
+    apply();
+    const observer = new MutationObserver(apply);
+    observer.observe(container, { childList: true, subtree: true });
+    return () => observer.disconnect();
+  }, [containerRef, volume, enabled, activeSourceId]);
+}
+function useSubtitleEntries(conversations, maxVisible, dismissAfterMs) {
+  const [visibleIds, setVisibleIds] = useState([]);
+  const timersRef = useRef(/* @__PURE__ */ new Map());
+  const seenRef = useRef(/* @__PURE__ */ new Set());
+  const dismissedRef = useRef(/* @__PURE__ */ new Set());
+  const initializedRef = useRef(false);
+  useEffect(() => {
+    const seen = seenRef.current;
+    const dismissed = dismissedRef.current;
+    const timers = timersRef.current;
+    if (!initializedRef.current) {
+      initializedRef.current = true;
+      for (const item of conversations) {
+        if (item.lifecycle === "done" || !(item.text || item.transcript)) {
+          seen.add(item.id);
+          dismissed.add(item.id);
+        }
+      }
+    }
+    const newIds = [];
+    for (const item of conversations) {
+      const displayText = item.text || item.transcript;
+      if (!displayText) continue;
+      if (!seen.has(item.id)) {
+        seen.add(item.id);
+        newIds.push(item.id);
+      }
+      if (item.lifecycle === "done" && !dismissed.has(item.id)) {
+        dismissed.add(item.id);
+        const timer = setTimeout(() => {
+          timers.delete(item.id);
+          setVisibleIds((prev) => prev.filter((id) => id !== item.id));
+        }, dismissAfterMs);
+        timers.set(item.id, timer);
+      }
+    }
+    if (newIds.length > 0) {
+      setVisibleIds((prev) => {
+        const next = [...prev, ...newIds];
+        while (next.length > maxVisible) {
+          const removedId = next.shift();
+          if (timers.has(removedId)) {
+            clearTimeout(timers.get(removedId));
+            timers.delete(removedId);
+          }
+          dismissed.add(removedId);
+        }
+        return next;
+      });
+    }
+  }, [conversations, maxVisible, dismissAfterMs]);
+  useEffect(() => {
+    const timers = timersRef.current;
+    return () => {
+      timers.forEach((t) => clearTimeout(t));
+      timers.clear();
+    };
+  }, []);
+  const conversationMap = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const item of conversations) {
+      map.set(item.id, item);
+    }
+    return map;
+  }, [conversations]);
+  return useMemo(() => {
+    return visibleIds.map((id) => {
+      const item = conversationMap.get(id);
+      if (!item) return null;
+      const text = item.text || item.transcript;
+      if (!text) return null;
+      return { id: item.id, role: item.role, text, lifecycle: item.lifecycle };
+    }).filter((entry) => entry !== null);
+  }, [visibleIds, conversationMap]);
+}
+var BREATHE_KEYFRAMES = `@keyframes ivi-subtitle-breathe{0%,100%{opacity:1}50%{opacity:.55}}`;
+function IVISubtitleOverlay(props) {
+  const {
+    conversations,
+    roles = "user",
+    maxVisible = 2,
+    dismissAfterMs = 5e3,
+    subtitleStyle,
+    className,
+    style
+  } = props;
+  const roleSet = useMemo(
+    () => new Set(Array.isArray(roles) ? roles : [roles]),
+    [roles]
+  );
+  const filtered = useMemo(
+    () => conversations.filter((c) => roleSet.has(c.role)),
+    [conversations, roleSet]
+  );
+  const entries = useSubtitleEntries(filtered, maxVisible, dismissAfterMs);
+  if (entries.length === 0) return null;
+  const fontFamily = subtitleStyle?.fontFamily ?? "system-ui, -apple-system, sans-serif";
+  const fontSize = subtitleStyle?.fontSize ?? 14;
+  const color = subtitleStyle?.color ?? "#fff";
+  const bg = subtitleStyle?.background ?? "rgba(0, 0, 0, 0.6)";
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className,
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        gap: 6,
+        pointerEvents: "none",
+        ...style
+      },
+      children: [
+        /* @__PURE__ */ jsx("style", { children: BREATHE_KEYFRAMES }),
+        entries.map((entry) => /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              display: "inline-block",
+              padding: "5px 16px",
+              borderRadius: 999,
+              backgroundColor: bg,
+              color,
+              fontSize,
+              fontFamily,
+              lineHeight: 1.5,
+              maxWidth: "100%",
+              overflow: "hidden",
+              textOverflow: "ellipsis",
+              whiteSpace: "nowrap",
+              animation: entry.lifecycle === "added" ? "ivi-subtitle-breathe 1.5s ease-in-out infinite" : void 0
+            },
+            children: entry.text
+          },
+          entry.id
+        ))
+      ]
+    }
+  );
+}
+function useIviStageView() {
+  const context = useContext(IviStageViewContext);
+  if (!context) {
+    throw new Error("useIviStageView must be used inside IVIStageView.");
+  }
+  return context;
+}
+var standaloneTrtcSourceManager = new TrtcSourceManager();
+function IVITrtcPlayer(props) {
+  const {
+    trtc,
+    sourceId,
+    runtime,
+    className,
+    style,
+    loadingFallback = null,
+    errorFallback = null,
+    muted = false
+  } = props;
+  const containerRef = useRef(null);
+  const viewIdRef = useRef(`trtc-view-${Math.random().toString(36).slice(2, 10)}`);
+  const manager = runtime?.getTrtcSourceManager() ?? standaloneTrtcSourceManager;
+  const resolvedSourceId = useMemo(
+    () => sourceId ?? `adhoc:${trtc.app_id}:${trtc.user_id}:${trtc.room_id}`,
+    [sourceId, trtc.app_id, trtc.room_id, trtc.user_id]
+  );
+  const shouldManageSourceLifecycle = !runtime || !sourceId;
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const mutedRef = useRef(muted);
+  mutedRef.current = muted;
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) {
+      return;
+    }
+    let disposed = false;
+    if (shouldManageSourceLifecycle) {
+      manager.upsertSource(resolvedSourceId, trtc);
+    }
+    const unsubscribe = manager.subscribe(resolvedSourceId, (snapshot) => {
+      if (disposed) {
+        return;
+      }
+      setLoading(snapshot.status === "idle" || snapshot.status === "connecting");
+      setError(snapshot.status === "error" ? snapshot.error ?? "TRTC \u62C9\u6D41\u5931\u8D25" : null);
+    });
+    void manager.attachView(resolvedSourceId, viewIdRef.current, container, mutedRef.current).catch((caughtError) => {
+      if (disposed) {
+        return;
+      }
+      setError(caughtError instanceof Error ? caughtError.message : "TRTC \u62C9\u6D41\u5931\u8D25");
+      setLoading(false);
+    });
+    return () => {
+      disposed = true;
+      unsubscribe();
+      manager.detachView(resolvedSourceId, viewIdRef.current);
+      if (shouldManageSourceLifecycle) {
+        manager.removeSource(resolvedSourceId);
+      }
+    };
+  }, [
+    manager,
+    resolvedSourceId,
+    shouldManageSourceLifecycle,
+    trtc.app_id,
+    trtc.room_id,
+    trtc.user_id,
+    trtc.user_sig
+  ]);
+  useEffect(() => {
+    manager.updateViewMuted(resolvedSourceId, viewIdRef.current, muted);
+  }, [manager, muted, resolvedSourceId]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className,
+      style: {
+        width: "100%",
+        height: "100%",
+        minWidth: 0,
+        minHeight: 0,
+        backgroundColor: "#000",
+        position: "relative",
+        ...style
+      },
+      children: [
+        /* @__PURE__ */ jsx("div", { ref: containerRef, style: { width: "100%", height: "100%" } }),
+        loading ? loadingFallback : null,
+        error ? errorFallback ?? /* @__PURE__ */ jsx("div", { children: error }) : null
+      ]
+    }
+  );
+}
+var RETRY_DELAY_MS = 500;
+var UNLIMITED_RETRIES = Number.MAX_SAFE_INTEGER;
+function makeRetryConfig(label, kind) {
+  return {
+    maxNumRetry: UNLIMITED_RETRIES,
+    retryDelayMs: RETRY_DELAY_MS,
+    maxRetryDelayMs: RETRY_DELAY_MS,
+    backoff: "linear",
+    shouldRetry: (_config, retryCount, isTimeout) => {
+      const reason = kind === "timeout" || isTimeout ? "\u52A0\u8F7D\u8D85\u65F6" : "\u52A0\u8F7D\u5931\u8D25";
+      console.warn(
+        `[IVIHlsVideo] ${label} ${reason}\uFF0C${RETRY_DELAY_MS}ms \u540E\u8FDB\u884C\u7B2C ${retryCount + 1} \u6B21\u91CD\u8BD5\uFF08\u65E0\u4E0A\u9650\uFF09`
+      );
+      return true;
+    }
+  };
+}
+function makeLoadPolicy(label) {
+  return {
+    default: {
+      maxTimeToFirstByteMs: 1e4,
+      maxLoadTimeMs: 2e4,
+      timeoutRetry: makeRetryConfig(label, "timeout"),
+      errorRetry: makeRetryConfig(label, "error")
+    }
+  };
+}
+function IVIHlsVideo(props) {
+  const { url, videoProps, style, aggressivePreload = false, paused = false } = props;
+  const videoRef = useRef(null);
+  const pausedRef = useRef(paused);
+  useEffect(() => {
+    pausedRef.current = paused;
+    const video = videoRef.current;
+    if (!video) return;
+    if (paused) {
+      video.pause();
+    } else {
+      video.play().catch((err) => {
+        console.warn(
+          "[IVIHlsVideo] paused\u2192active \u5207\u6362\u65F6 play() \u88AB\u6D4F\u89C8\u5668\u62D2\u7EDD\uFF08\u591A\u534A\u53D7\u81EA\u52A8\u64AD\u653E\u7B56\u7565\u9650\u5236\uFF09",
+          err
+        );
+      });
+    }
+  }, [paused]);
+  useEffect(() => {
+    const video = videoRef.current;
+    if (!video) {
+      return;
+    }
+    let disposed = false;
+    let hlsInstance = null;
+    let fullReloadTimer = null;
+    const clearFullReloadTimer = () => {
+      if (fullReloadTimer) {
+        clearTimeout(fullReloadTimer);
+        fullReloadTimer = null;
+      }
+    };
+    const onVideoError = () => {
+      const el = videoRef.current;
+      const mediaErr = el?.error;
+      console.warn("[IVIHlsVideo] <video> \u5143\u7D20\u62A5\u9519", {
+        code: mediaErr?.code,
+        message: mediaErr?.message,
+        currentSrc: el?.currentSrc,
+        networkState: el?.networkState,
+        readyState: el?.readyState
+      });
+    };
+    const onVideoStalled = () => {
+      console.warn("[IVIHlsVideo] <video> stalled\uFF08\u7F13\u51B2\u505C\u6EDE\uFF09", {
+        currentTime: videoRef.current?.currentTime,
+        readyState: videoRef.current?.readyState
+      });
+    };
+    video.addEventListener("error", onVideoError);
+    video.addEventListener("stalled", onVideoStalled);
+    const resumePlayback = () => {
+      if (disposed) return;
+      if (pausedRef.current) return;
+      const el = videoRef.current;
+      if (!el) return;
+      el.play().catch((err) => {
+        console.warn(
+          "[IVIHlsVideo] \u6062\u590D\u540E play() \u88AB\u6D4F\u89C8\u5668\u62D2\u7EDD\uFF08\u53EF\u80FD\u53D7\u81EA\u52A8\u64AD\u653E\u7B56\u7565\u9650\u5236\uFF09",
+          err
+        );
+      });
+    };
+    const scheduleFullReload = (reason) => {
+      if (disposed || fullReloadTimer) return;
+      console.warn(
+        `[IVIHlsVideo] ${reason}\uFF0C${RETRY_DELAY_MS}ms \u540E\u91CD\u65B0\u62C9\u53D6\u6E90\uFF08\u65E0\u9650\u91CD\u8BD5\uFF09`
+      );
+      fullReloadTimer = setTimeout(() => {
+        fullReloadTimer = null;
+        if (disposed || !hlsInstance || !videoRef.current) return;
+        try {
+          hlsInstance.loadSource(url);
+          hlsInstance.attachMedia(videoRef.current);
+          hlsInstance.startLoad();
+          resumePlayback();
+        } catch (err) {
+          console.warn("[IVIHlsVideo] \u91CD\u65B0\u62C9\u53D6\u6E90\u629B\u51FA\u5F02\u5E38\uFF0C\u7EE7\u7EED\u91CD\u8BD5", err);
+          scheduleFullReload("\u91CD\u65B0\u62C9\u53D6\u6E90\u5F02\u5E38");
+        }
+      }, RETRY_DELAY_MS);
+    };
+    const setup = async () => {
+      try {
+        const module = await import('hls.js');
+        if (disposed || !videoRef.current) {
+          return;
+        }
+        const hlsModule = module;
+        const Hls = hlsModule.default ?? module;
+        const events = hlsModule.Events ?? Hls.Events ?? {};
+        const errorTypes = hlsModule.ErrorTypes ?? Hls.ErrorTypes ?? {};
+        if (!Hls.isSupported()) {
+          console.warn(
+            "[IVIHlsVideo] \u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 hls.js\uFF0C\u964D\u7EA7\u5230\u539F\u751F HLS\uFF08\u5931\u8D25\u5C06\u7531 <video> error \u4E8B\u4EF6\u6253\u5370\uFF09",
+            { url }
+          );
+          videoRef.current.src = url;
+          return;
+        }
+        const bufferPreset = aggressivePreload ? {
+          maxBufferLength: 180,
+          maxMaxBufferLength: 240,
+          backBufferLength: 120
+        } : {
+          maxBufferLength: 30,
+          maxMaxBufferLength: 60,
+          backBufferLength: 30
+        };
+        const instance = new Hls({
+          enableWorker: true,
+          lowLatencyMode: false,
+          ...bufferPreset,
+          capLevelToPlayerSize: true,
+          // 以下三项是核心：列表与分片的拉取全部使用 hls.js 内置重试，
+          // 无上限次数、间隔上限 0.5s、每次重试通过 shouldRetry 打印警告。
+          manifestLoadPolicy: makeLoadPolicy("manifest \u4E3B\u5217\u8868"),
+          playlistLoadPolicy: makeLoadPolicy("level \u5B50\u7801\u7387\u5217\u8868"),
+          fragLoadPolicy: makeLoadPolicy("fragment \u5A92\u4F53\u5206\u7247")
+        });
+        hlsInstance = instance;
+        const errorEvent = events.ERROR ?? "hlsError";
+        const networkErrorType = errorTypes.NETWORK_ERROR ?? "networkError";
+        const mediaErrorType = errorTypes.MEDIA_ERROR ?? "mediaError";
+        instance.on(errorEvent, (_eventName, data) => {
+          if (!data) {
+            console.warn("[IVIHlsVideo] HLS ERROR \u4E8B\u4EF6 data \u4E3A\u7A7A");
+            return;
+          }
+          if (!data.fatal) {
+            if (data.type !== networkErrorType) {
+              console.warn(
+                "[IVIHlsVideo] HLS \u975E\u81F4\u547D\u9519\u8BEF\uFF08\u4E0D\u8D70\u5185\u7F6E\u91CD\u8BD5\uFF09",
+                data.type,
+                data.details
+              );
+            }
+            return;
+          }
+          switch (data.type) {
+            case networkErrorType:
+              console.warn(
+                "[IVIHlsVideo] HLS \u81F4\u547D\u7F51\u7EDC\u9519\u8BEF\uFF0C\u8C03\u7528 startLoad() \u91CD\u542F\u62C9\u6D41",
+                data.details
+              );
+              try {
+                hlsInstance?.startLoad();
+                resumePlayback();
+              } catch (err) {
+                console.warn("[IVIHlsVideo] startLoad() \u5F02\u5E38\uFF0C\u8D70\u515C\u5E95\u91CD\u8F7D", err);
+                scheduleFullReload("startLoad \u5F02\u5E38");
+              }
+              break;
+            case mediaErrorType:
+              console.warn(
+                "[IVIHlsVideo] HLS \u81F4\u547D\u5A92\u4F53\u9519\u8BEF\uFF0C\u8C03\u7528 recoverMediaError() \u6062\u590D",
+                data.details
+              );
+              try {
+                hlsInstance?.recoverMediaError();
+                resumePlayback();
+              } catch (err) {
+                console.warn("[IVIHlsVideo] recoverMediaError() \u5F02\u5E38\uFF0C\u8D70\u515C\u5E95\u91CD\u8F7D", err);
+                scheduleFullReload("recoverMediaError \u5F02\u5E38");
+              }
+              break;
+            default:
+              console.warn(
+                "[IVIHlsVideo] HLS \u5176\u4ED6\u81F4\u547D\u9519\u8BEF\uFF0C\u51C6\u5907\u91CD\u65B0\u62C9\u53D6\u6E90",
+                data.type,
+                data.details
+              );
+              scheduleFullReload("\u5176\u4ED6\u81F4\u547D\u9519\u8BEF");
+              break;
+          }
+        });
+        instance.loadSource(url);
+        instance.attachMedia(videoRef.current);
+      } catch (err) {
+        console.warn(
+          "[IVIHlsVideo] \u52A8\u6001\u52A0\u8F7D hls.js \u5931\u8D25\uFF0C\u964D\u7EA7\u5230\u539F\u751F HLS\uFF08\u5931\u8D25\u5C06\u7531 <video> error \u4E8B\u4EF6\u6253\u5370\uFF09",
+          err
+        );
+        if (disposed || !videoRef.current) return;
+        videoRef.current.src = url;
+      }
+    };
+    void setup();
+    return () => {
+      disposed = true;
+      clearFullReloadTimer();
+      video.removeEventListener("error", onVideoError);
+      video.removeEventListener("stalled", onVideoStalled);
+      hlsInstance?.destroy();
+      hlsInstance = null;
+    };
+  }, [url, aggressivePreload]);
+  return /* @__PURE__ */ jsx(
+    "video",
+    {
+      ref: videoRef,
+      ...videoProps,
+      autoPlay: paused ? false : videoProps?.autoPlay ?? true,
+      playsInline: videoProps?.playsInline ?? true,
+      controls: videoProps?.controls ?? true,
+      style
+    }
+  );
+}
+function isM3u8Url(url) {
+  return /\.m3u8(?:$|[?#])/i.test(url);
+}
+function resolveBlurMode(bg) {
+  if (bg === "blur") return "live";
+  if (typeof bg === "object" && "blur" in bg) return bg.blur;
+  return false;
+}
+function TrackSlotBlurLayer(props) {
+  const { source, mode, children } = props;
+  return /* @__PURE__ */ jsxs("div", { style: CONTAINER_STYLE, children: [
+    /* @__PURE__ */ jsx("div", { style: BG_LAYER_STYLE, children: /* @__PURE__ */ jsx(BlurBackgroundLayer, { source, mode }) }),
+    /* @__PURE__ */ jsx("div", { style: MAIN_LAYER_STYLE, children })
+  ] });
+}
+function BlurBackgroundLayer({
+  source,
+  mode
+}) {
+  const { playback } = source;
+  if (source.source.asset_type === "image" && playback.url) {
+    return /* @__PURE__ */ jsx("img", { src: playback.url, alt: "", style: BLUR_MEDIA_STYLE });
+  }
+  if (playback.type === "trtc") {
+    return /* @__PURE__ */ jsx(SlotVideoBlurCanvas, { staticOnly: mode === "static" });
+  }
+  const url = playback.url;
+  if (!url) return null;
+  if (mode === "static") {
+    return isM3u8Url(url) ? /* @__PURE__ */ jsx(HlsStaticBlurFrame, { url }) : /* @__PURE__ */ jsx(StaticBlurFrame, { url });
+  }
+  if (isM3u8Url(url)) {
+    return /* @__PURE__ */ jsx(
+      IVIHlsVideo,
+      {
+        url,
+        videoProps: { muted: true, autoPlay: true, playsInline: true },
+        style: BLUR_MEDIA_STYLE,
+        paused: false
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    "video",
+    {
+      src: url,
+      muted: true,
+      autoPlay: true,
+      playsInline: true,
+      style: BLUR_MEDIA_STYLE
+    }
+  );
+}
+function SlotVideoBlurCanvas({ staticOnly }) {
+  const canvasRef = useRef(null);
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    const container = canvas.closest("[data-ivi-source-id]");
+    if (!container) return;
+    let animId;
+    let lastDrawTime = 0;
+    let captured = false;
+    const intervalMs = 1e3 / 5;
+    const draw = (time) => {
+      if (staticOnly && captured) return;
+      animId = requestAnimationFrame(draw);
+      if (time - lastDrawTime < intervalMs) return;
+      lastDrawTime = time;
+      const video = container.querySelector("video");
+      if (!video || video.readyState < 2) return;
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return;
+      if (canvas.width !== video.videoWidth || canvas.height !== video.videoHeight) {
+        canvas.width = video.videoWidth || 640;
+        canvas.height = video.videoHeight || 360;
+      }
+      ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+      captured = true;
+    };
+    animId = requestAnimationFrame(draw);
+    return () => cancelAnimationFrame(animId);
+  }, [staticOnly]);
+  return /* @__PURE__ */ jsx("canvas", { ref: canvasRef, style: BLUR_MEDIA_STYLE });
+}
+function StaticBlurFrame({ url }) {
+  const canvasRef = useRef(null);
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    if (!canvas) return;
+    const video = document.createElement("video");
+    video.muted = true;
+    video.playsInline = true;
+    video.preload = "auto";
+    video.crossOrigin = "anonymous";
+    video.src = url;
+    const onReady = () => {
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return;
+      canvas.width = video.videoWidth || 640;
+      canvas.height = video.videoHeight || 360;
+      ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+      cleanup();
+    };
+    const cleanup = () => {
+      video.removeEventListener("loadeddata", onReady);
+      video.pause();
+      video.removeAttribute("src");
+      video.load();
+    };
+    video.addEventListener("loadeddata", onReady);
+    video.load();
+    return cleanup;
+  }, [url]);
+  return /* @__PURE__ */ jsx("canvas", { ref: canvasRef, style: BLUR_MEDIA_STYLE });
+}
+function HlsStaticBlurFrame({ url }) {
+  return /* @__PURE__ */ jsx(
+    IVIHlsVideo,
+    {
+      url,
+      videoProps: { muted: true, autoPlay: true, playsInline: true },
+      style: BLUR_MEDIA_STYLE,
+      paused: true
+    }
+  );
+}
+var CONTAINER_STYLE = {
+  width: "100%",
+  height: "100%",
+  position: "relative",
+  overflow: "hidden"
+};
+var BG_LAYER_STYLE = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  width: "100%",
+  height: "100%",
+  zIndex: 0,
+  overflow: "hidden"
+};
+var MAIN_LAYER_STYLE = {
+  position: "relative",
+  zIndex: 1,
+  width: "100%",
+  height: "100%"
+};
+var BLUR_MEDIA_STYLE = {
+  width: "100%",
+  height: "100%",
+  objectFit: "cover",
+  filter: "blur(20px)",
+  transform: "scale(1.15)",
+  display: "block"
+};
+function toReadyRuntimeSource(source) {
+  if (!source || source.status !== "ready" || !source.playback) {
+    return null;
+  }
+  return source;
+}
+function supportsSubtitleOverlay(source) {
+  if (!source) return false;
+  if (source.source.asset_type === "image") return false;
+  return source.source.kind === "stream" || source.source.kind === "generation_stream" || source.source.kind === "generated_clip" || source.source.kind === "static";
+}
+function detectMediaVolumeType(source) {
+  if (!source) return null;
+  if (source.playback.type === "trtc") return "trtc";
+  if (source.source.asset_type === "image") return null;
+  const url = source.playback.url;
+  if (!url) return null;
+  return isM3u8Url(url) ? "hls" : "video";
+}
+function TrackSlotMediaContent(props) {
+  const {
+    slot,
+    track,
+    source,
+    slotSourceId,
+    isActive,
+    runtime,
+    renderTrtc,
+    renderMedia,
+    imageProps,
+    videoProps,
+    trtcPlayerProps,
+    adaptToSourceSize,
+    fitStrategy,
+    background
+  } = props;
+  const renderContext = {
+    slot: slot ?? "",
+    track,
+    source,
+    isPreloading: !isActive
+  };
+  const mediaStyle = buildAdaptiveMediaStyle(source, adaptToSourceSize, fitStrategy, background);
+  const shouldMute = !isActive;
+  if (renderMedia) return renderMedia(renderContext);
+  if (source.playback.type === "trtc") {
+    if (!source.playback.trtc) return null;
+    if (renderTrtc) return renderTrtc(renderContext);
+    const trtcMuted = shouldMute || Boolean(trtcPlayerProps?.muted);
+    return /* @__PURE__ */ jsx(
+      IVITrtcPlayer,
+      {
+        trtc: source.playback.trtc,
+        sourceId: source.source.source_id,
+        runtime,
+        ...trtcPlayerProps,
+        muted: trtcMuted,
+        loadingFallback: isActive ? trtcPlayerProps?.loadingFallback : null,
+        errorFallback: isActive ? trtcPlayerProps?.errorFallback : null,
+        style: { ...mediaStyle, ...trtcPlayerProps?.style ?? {} }
+      }
+    );
+  }
+  if (source.source.asset_type === "image") {
+    return /* @__PURE__ */ jsx(
+      "img",
+      {
+        src: source.playback.url,
+        alt: "",
+        ...imageProps,
+        style: { ...mediaStyle, ...imageProps?.style ?? {} }
+      }
+    );
+  }
+  const playbackUrl = source.playback.url;
+  if (!playbackUrl) return null;
+  const videoStyle = { ...mediaStyle, ...videoProps?.style ?? {} };
+  const mergedVideoProps = {
+    ...videoProps,
+    muted: shouldMute || Boolean(videoProps?.muted),
+    onEnded: isActive ? createAutoTakeOnEndedHandler(
+      runtime,
+      slotSourceId,
+      track.track_id,
+      videoProps?.onEnded
+    ) : void 0
+  };
+  const shouldPause = !isActive;
+  return isM3u8Url(playbackUrl) ? /* @__PURE__ */ jsx(
+    IVIHlsVideo,
+    {
+      url: playbackUrl,
+      videoProps: mergedVideoProps,
+      style: videoStyle,
+      paused: shouldPause
+    }
+  ) : /* @__PURE__ */ jsx(
+    SlotVideo,
+    {
+      src: playbackUrl,
+      paused: shouldPause,
+      videoProps: {
+        ...mergedVideoProps,
+        autoPlay: videoProps?.autoPlay ?? true,
+        playsInline: videoProps?.playsInline ?? true,
+        controls: isActive ? videoProps?.controls ?? true : false
+      },
+      style: videoStyle
+    }
+  );
+}
+function buildAdaptiveMediaStyle(source, adaptToSourceSize, fitStrategy, background) {
+  const objectFitStyle = fitStrategy === "auto" ? {} : {
+    objectFit: fitStrategy ?? "contain"
+  };
+  if (!adaptToSourceSize) {
+    return objectFitStyle;
+  }
+  return {
+    width: "100%",
+    height: "100%",
+    display: "block",
+    ...objectFitStyle,
+    backgroundColor: resolveBackgroundColor(background)
+  };
+}
+function resolveBackgroundColor(bg) {
+  if (!bg || bg === "black") return "#000";
+  if (bg === "white") return "#fff";
+  if (bg === "transparent") return "transparent";
+  if (bg === "blur") return "transparent";
+  if (typeof bg === "object") {
+    if ("color" in bg) return bg.color;
+    if ("blur" in bg) return "transparent";
+  }
+  return "#000";
+}
+function createAutoTakeOnEndedHandler(runtime, sourceId, trackId, userOnEnded) {
+  return (event) => {
+    runtime?.sendSessionSourcePlaybackCompleted(sourceId, trackId);
+    userOnEnded?.(event);
+  };
+}
+function SlotVideo(props) {
+  const videoRef = useRef(null);
+  useEffect(() => {
+    const video = videoRef.current;
+    if (!video) return;
+    if (props.paused) {
+      video.pause();
+    } else {
+      video.play().catch(() => void 0);
+    }
+  }, [props.paused]);
+  return /* @__PURE__ */ jsx(
+    "video",
+    {
+      ref: videoRef,
+      src: props.src,
+      ...props.videoProps,
+      autoPlay: props.paused ? false : props.videoProps.autoPlay ?? true,
+      style: props.style
+    }
+  );
+}
+
+// src/react/internal/use-multi-preload-sources.ts
+function useMultiPreloadSources(sources, activeSourceId) {
+  return useMemo(() => {
+    const entries = [];
+    for (const [id, runtimeSource] of sources) {
+      const isActive = id === activeSourceId;
+      const shouldMount = Boolean(runtimeSource.preload) || isActive;
+      if (!shouldMount) {
+        continue;
+      }
+      const ready = toReadyRuntimeSource(runtimeSource);
+      if (!ready) {
+        continue;
+      }
+      entries.push({
+        sourceId: id,
+        source: ready,
+        isActive
+      });
+    }
+    return entries;
+  }, [sources, activeSourceId]);
+}
+function IVITrackSlot(props) {
+  const {
+    slot,
+    trackId,
+    className,
+    style,
+    emptyFallback = null,
+    renderTrtc,
+    renderMedia,
+    videoProps,
+    imageProps,
+    adaptToSourceSize = true,
+    fitStrategy = "contain",
+    trtcPlayerProps,
+    showVolumeControl,
+    volumeControlProps,
+    showSubtitle,
+    subtitleProps,
+    background = "black"
+  } = props;
+  const context = useIviStageView();
+  const containerRef = useRef(null);
+  const resolvedTrackId = trackId ?? (slot ? context.slotTrackMap.get(slot) : void 0);
+  const track = resolvedTrackId ? context.state.tracks.get(resolvedTrackId) : void 0;
+  const activeSourceId = track?.active_source_id ?? null;
+  const preloadEntries = useMultiPreloadSources(context.state.sources, activeSourceId);
+  const activeEntry = preloadEntries.find((e) => e.isActive) ?? null;
+  const activeSource = activeEntry?.source ?? null;
+  const mediaType = detectMediaVolumeType(activeSource);
+  const [volume, setVolume] = useVolumeMemory(showVolumeControl ? mediaType : null);
+  useApplyVolumeToSlot(containerRef, volume, !!showVolumeControl && mediaType !== null, activeSourceId);
+  if (!resolvedTrackId || !track) {
+    return /* @__PURE__ */ jsx("div", { className, style, children: emptyFallback });
+  }
+  const slotContainerStyle = {
+    position: "relative",
+    width: "100%",
+    height: "100%",
+    minWidth: 0,
+    minHeight: 0,
+    ...style ?? {}
+  };
+  const blurMode = resolveBlurMode(background);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      style: slotContainerStyle,
+      "data-ivi-slot": slot,
+      "data-ivi-track-id": track.track_id,
+      children: [
+        !activeSource && emptyFallback,
+        preloadEntries.map((entry) => {
+          const isActive = entry.isActive;
+          const showBlur = blurMode !== false && isActive;
+          const content = /* @__PURE__ */ jsx(
+            TrackSlotMediaContent,
+            {
+              slot,
+              track,
+              source: entry.source,
+              slotSourceId: entry.sourceId,
+              isActive,
+              runtime: context.runtime,
+              renderTrtc,
+              renderMedia,
+              imageProps,
+              videoProps,
+              trtcPlayerProps,
+              adaptToSourceSize,
+              fitStrategy,
+              background
+            }
+          );
+          return /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: isActive ? ACTIVE_SLOT_STYLE : STANDBY_SLOT_STYLE,
+              "data-ivi-source-id": entry.sourceId,
+              "data-ivi-slot-role": isActive ? "active" : "standby",
+              children: /* @__PURE__ */ jsx("div", { style: SLOT_CONTENT_STYLE, children: showBlur ? /* @__PURE__ */ jsx(TrackSlotBlurLayer, { source: entry.source, mode: blurMode, children: content }) : content })
+            },
+            entry.sourceId
+          );
+        }),
+        showSubtitle && activeSource && supportsSubtitleOverlay(activeSource) && /* @__PURE__ */ jsx("div", { style: SUBTITLE_OVERLAY_STYLE, children: /* @__PURE__ */ jsx(
+          IVISubtitleOverlay,
+          {
+            conversations: context.state.conversations,
+            ...subtitleProps
+          }
+        ) }),
+        showVolumeControl && mediaType !== null && /* @__PURE__ */ jsx("div", { style: VOLUME_OVERLAY_STYLE, children: /* @__PURE__ */ jsx(
+          IVIVolumeControl,
+          {
+            volume,
+            onVolumeChange: setVolume,
+            ...volumeControlProps
+          }
+        ) })
+      ]
+    }
+  );
+}
+var PHYSICAL_SLOT_BASE = {
+  position: "absolute",
+  top: 0,
+  left: 0,
+  width: "100%",
+  height: "100%"
+};
+var ACTIVE_SLOT_STYLE = {
+  ...PHYSICAL_SLOT_BASE,
+  visibility: "visible",
+  zIndex: 1
+};
+var STANDBY_SLOT_STYLE = {
+  ...PHYSICAL_SLOT_BASE,
+  visibility: "hidden",
+  zIndex: 0,
+  pointerEvents: "none"
+};
+var SLOT_CONTENT_STYLE = {
+  width: "100%",
+  height: "100%"
+};
+var SUBTITLE_OVERLAY_STYLE = {
+  position: "absolute",
+  bottom: 48,
+  left: "50%",
+  transform: "translateX(-50%)",
+  zIndex: 10,
+  maxWidth: "90%",
+  pointerEvents: "none"
+};
+var VOLUME_OVERLAY_STYLE = {
+  position: "absolute",
+  bottom: 12,
+  right: 12,
+  zIndex: 10,
+  pointerEvents: "auto"
+};
+function useManagedIviRuntime(config) {
+  const {
+    clientConfig,
+    autoStart = true,
+    runtimeConfig,
+    onRuntimeInitError,
+    onLog
+  } = config;
+  const { url, sessionId } = clientConfig;
+  const runtime = useMemo(() => {
+    if (typeof window === "undefined" || !sessionId) {
+      return null;
+    }
+    if (!url) {
+      throw new Error("useManagedIviRuntime: `url` is required when `sessionId` is provided.");
+    }
+    const mergedClientConfig = {
+      ...clientConfig,
+      url: normalizeUrlToWsUrl(url),
+      onLog: (entry) => {
+        onLog?.(normalizeClientLogEntry(entry));
+        clientConfig.onLog?.(entry);
+      }
+    };
+    const client = new IviClient(mergedClientConfig);
+    const mergedRuntimeConfig = {
+      ...runtimeConfig,
+      onLog: (entry) => {
+        onLog?.(normalizeRuntimeLogEntry(entry));
+        runtimeConfig?.onLog?.(entry);
+      }
+    };
+    return new IviRuntimeCoordinator(client, mergedRuntimeConfig);
+  }, [url, sessionId, clientConfig, runtimeConfig, onLog]);
+  useEffect(() => {
+    if (!autoStart || !runtime) {
+      return;
+    }
+    let disposed = false;
+    runtime.start().catch((error) => {
+      if (disposed) {
+        return;
+      }
+      if (onRuntimeInitError) {
+        onRuntimeInitError(error);
+        return;
+      }
+      throw error;
+    });
+    return () => {
+      disposed = true;
+      runtime.stop();
+    };
+  }, [autoStart, runtime, onRuntimeInitError]);
+  return runtime;
+}
+function normalizeUrlToWsUrl(url) {
+  if (/^wss?:\/\//.test(url)) {
+    return url;
+  }
+  if (/^https?:\/\//.test(url)) {
+    const normalized = new URL(url);
+    normalized.protocol = normalized.protocol === "https:" ? "wss:" : "ws:";
+    return normalized.toString();
+  }
+  throw new Error(
+    `useManagedIviRuntime: invalid url "${url}". Expected a ws://, wss://, http://, or https:// URL.`
+  );
+}
+function normalizeClientLogEntry(entry) {
+  const tag = getClientLogTag(entry.category);
+  return {
+    level: entry.level === "warn" || entry.level === "error" ? entry.level : "info",
+    source: "client",
+    tag,
+    message: `${tag} ${entry.message}`,
+    args: entry.data === void 0 ? [`${tag} ${entry.message}`] : [`${tag} ${entry.message}`, entry.data],
+    data: entry.data,
+    clientLog: entry
+  };
+}
+function normalizeRuntimeLogEntry(entry) {
+  return {
+    level: entry.level,
+    source: "runtime",
+    tag: entry.tag,
+    message: entry.message,
+    args: entry.args,
+    data: entry.data,
+    runtimeLog: entry
+  };
+}
+function getClientLogTag(category) {
+  if (category === "send") return "[IVI-SEND]";
+  if (category === "ws") return "[IVI-WS]";
+  if (category === "reconnect") return "[IVI-RECONNECT]";
+  return "[IVI-CLIENT]";
+}
+
+export { EMPTY_RUNTIME_STATE, IVIStageView, IVITrackSlot, IviFrontendSdk, IviRuntimeCoordinator, IviRuntimeDispatcher, useIviStageView, useManagedIviRuntime, useRuntimeState };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map