@reactor-models/h3-reference-to-video-turbo-realtime 0.3.0

package/dist/index.js

@@ -0,0 +1,683 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FileRef: () => import_js_sdk.FileRef,
+  H3ReferenceToVideoTurboRealtimeMainVideoView: () => H3ReferenceToVideoTurboRealtimeMainVideoView,
+  H3ReferenceToVideoTurboRealtimeModel: () => H3ReferenceToVideoTurboRealtimeModel,
+  H3ReferenceToVideoTurboRealtimeProvider: () => H3ReferenceToVideoTurboRealtimeProvider,
+  H3ReferenceToVideoTurboRealtimeTracks: () => H3ReferenceToVideoTurboRealtimeTracks,
+  MODEL_NAME: () => MODEL_NAME,
+  MODEL_VERSION: () => MODEL_VERSION,
+  useH3ReferenceToVideoTurboRealtime: () => useH3ReferenceToVideoTurboRealtime,
+  useH3ReferenceToVideoTurboRealtimeAutoplayAccepted: () => useH3ReferenceToVideoTurboRealtimeAutoplayAccepted,
+  useH3ReferenceToVideoTurboRealtimeCanvasAccepted: () => useH3ReferenceToVideoTurboRealtimeCanvasAccepted,
+  useH3ReferenceToVideoTurboRealtimeClipFailed: () => useH3ReferenceToVideoTurboRealtimeClipFailed,
+  useH3ReferenceToVideoTurboRealtimeClipFinished: () => useH3ReferenceToVideoTurboRealtimeClipFinished,
+  useH3ReferenceToVideoTurboRealtimeClipGenerated: () => useH3ReferenceToVideoTurboRealtimeClipGenerated,
+  useH3ReferenceToVideoTurboRealtimeClipLengthAccepted: () => useH3ReferenceToVideoTurboRealtimeClipLengthAccepted,
+  useH3ReferenceToVideoTurboRealtimeClipMoved: () => useH3ReferenceToVideoTurboRealtimeClipMoved,
+  useH3ReferenceToVideoTurboRealtimeClipPopped: () => useH3ReferenceToVideoTurboRealtimeClipPopped,
+  useH3ReferenceToVideoTurboRealtimeClipQueued: () => useH3ReferenceToVideoTurboRealtimeClipQueued,
+  useH3ReferenceToVideoTurboRealtimeClipStarted: () => useH3ReferenceToVideoTurboRealtimeClipStarted,
+  useH3ReferenceToVideoTurboRealtimeClipStopped: () => useH3ReferenceToVideoTurboRealtimeClipStopped,
+  useH3ReferenceToVideoTurboRealtimeCommandError: () => useH3ReferenceToVideoTurboRealtimeCommandError,
+  useH3ReferenceToVideoTurboRealtimeFlushAccepted: () => useH3ReferenceToVideoTurboRealtimeFlushAccepted,
+  useH3ReferenceToVideoTurboRealtimeMessage: () => useH3ReferenceToVideoTurboRealtimeMessage,
+  useH3ReferenceToVideoTurboRealtimeQueueUpdate: () => useH3ReferenceToVideoTurboRealtimeQueueUpdate,
+  useH3ReferenceToVideoTurboRealtimeSeedAccepted: () => useH3ReferenceToVideoTurboRealtimeSeedAccepted,
+  useH3ReferenceToVideoTurboRealtimeSessionReset: () => useH3ReferenceToVideoTurboRealtimeSessionReset,
+  useH3ReferenceToVideoTurboRealtimeStateUpdate: () => useH3ReferenceToVideoTurboRealtimeStateUpdate,
+  useH3ReferenceToVideoTurboRealtimeTrack: () => useH3ReferenceToVideoTurboRealtimeTrack
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core.ts
+var import_js_sdk = require("@reactor-team/js-sdk");
+var MODEL_NAME = "reactor/h3-reference-to-video-turbo-realtime";
+var MODEL_VERSION = "v0.3.0";
+var H3ReferenceToVideoTurboRealtimeTracks = [
+  { name: "main_video", kind: "video", direction: "recvonly" },
+  { name: "main_audio", kind: "audio", direction: "recvonly" }
+];
+function _unwrapMessage(raw) {
+  const env = raw;
+  if (env && typeof env === "object" && env.data && typeof env.data === "object") {
+    return { ...env.data, type: env.type };
+  }
+  return raw;
+}
+var H3ReferenceToVideoTurboRealtimeModel = class extends import_js_sdk.Reactor {
+  constructor(options) {
+    super({
+      ...options,
+      modelName: MODEL_NAME,
+      modelTracks: [...H3ReferenceToVideoTurboRealtimeTracks]
+    });
+  }
+  /** @deprecated The model client now extends `Reactor` directly — call methods on `this` instead. This accessor returns `this` for backwards compatibility and will be removed in a future major release. */
+  get reactor() {
+    return this;
+  }
+  /**
+   * Remove a clip from its queue; reply clip_popped and emit queue_update and state_update. A running build finishes but is discarded. Refuses with command_error for a missing/unknown id. Use stop for the playing clip.
+   * @param params - Remove a clip from its queue; reply clip_popped and emit queue_update and state_update. A running build finishes but is discarded. Refuses with command_error for a missing/unknown id. Use stop for the playing clip.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeClipPoppedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async pop(params) {
+    const reply = await this.sendCommand("pop", params);
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Reposition within the current queue, 0 = front. A running build is unaffected. Replies clip_moved and emits queue_update; refuses with command_error for a missing/unknown id or invalid position.
+   * @param params - Reposition within the current queue, 0 = front. A running build is unaffected. Replies clip_moved and emits queue_update; refuses with command_error for a missing/unknown id or invalid position.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeClipMovedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async move(params) {
+    const reply = await this.sendCommand("move", params);
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Play the front ready clip, or a named ready clip. Consumes it and emits clip_started, queue_update and state_update. Refuses with command_error if already playing or no matching ready clip exists.
+   * @param params - Play the front ready clip, or a named ready clip. Consumes it and emits clip_started, queue_update and state_update. Refuses with command_error if already playing or no matching ready clip exists.
+   * @returns Resolves once the model's handler has completed; this command declares no reply payload.
+   */
+  async play(params) {
+    await this.sendCommand("play", params);
+    return void 0;
+  }
+  /**
+   * Cut playback and emit clip_stopped and state_update; queues are untouched. Under autoplay this skips to the next clip. Refuses with command_error when nothing is playing.
+   * @returns Resolves once the model's handler has completed; this command declares no reply payload.
+   */
+  async stop() {
+    await this.sendCommand("stop", {});
+    return void 0;
+  }
+  /**
+   * Drop both queues, cut playback, restore defaults and clear tracks. Replies session_reset; emits queue_update, state_update and clip_stopped if playing. In-flight results are discarded.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeSessionResetMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async reset() {
+    const reply = await this.sendCommand("reset", {});
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Queue a clip with 1–9 reference images at position, or at the back. Each clip keeps its own prompt and ordered references: new images do not alter earlier requests. The images guide appearance, not a fixed first or last frame. Replies clip_queued and broadcasts queue_update and state_update; completion emits clip_generated. Refuses with command_error for empty text, missing/invalid reference, invalid parameters or a full generation queue.
+   * @param params - Queue a clip with 1–9 reference images at position, or at the back. Each clip keeps its own prompt and ordered references: new images do not alter earlier requests. The images guide appearance, not a fixed first or last frame. Replies clip_queued and broadcasts queue_update and state_update; completion emits clip_generated. Refuses with command_error for empty text, missing/invalid reference, invalid parameters or a full generation queue.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeClipQueuedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async enqueue(params) {
+    const reply = await this.sendCommand("enqueue", params);
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Set the advancing default seed for future enqueues. Replies seed_accepted and emits state_update; an invalid seed emits command_error. Explicit per-clip seeds do not advance it.
+   * @param params - Set the advancing default seed for future enqueues. Replies seed_accepted and emits state_update; an invalid seed emits command_error. Explicit per-clip seeds do not advance it.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeSeedAcceptedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async setSeed(params) {
+    const reply = await this.sendCommand("set_seed", params);
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Reply queue_update with both queues in full. The history field is always empty: a played clip is not listed and cannot be replayed, though a generated clip can still seed a new one through `enqueue.continue_from_clip_id`. Valid at any time.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeQueueUpdateMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async getQueue() {
+    const reply = await this.sendCommand("get_queue", {});
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Reply state_update with defaults, capacities, playback progress and valid_commands. Valid at any time.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeStateUpdateMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async getState() {
+    const reply = await this.sendCommand("get_state", {});
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Set the canvas while both queues and playback are empty. Replies canvas_accepted and emits state_update; refuses with command_error for an unsupported aspect or nonempty session.
+   * @param params - Set the canvas while both queues and playback are empty. Replies canvas_accepted and emits state_update; refuses with command_error for an unsupported aspect or nonempty session.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeCanvasAcceptedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async setCanvas(params) {
+    const reply = await this.sendCommand("set_canvas", params);
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Automatically play ready clips whenever idle. Empty queues wait; no prompts are generated automatically. Replies autoplay_accepted and emits state_update.
+   * @param params - Automatically play ready clips whenever idle. Empty queues wait; no prompts are generated automatically. Replies autoplay_accepted and emits state_update.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeAutoplayAcceptedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async setAutoplay(params) {
+    const reply = await this.sendCommand("set_autoplay", params);
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Set the duration for future enqueues, aligned to a supported frame count. Replies clip_length_accepted and emits state_update; invalid lengths emit command_error. Queued clips keep their lengths.
+   * @param params - Set the duration for future enqueues, aligned to a supported frame count. Replies clip_length_accepted and emits state_update; invalid lengths emit command_error. Queued clips keep their lengths.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeClipLengthAcceptedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async setClipSeconds(params) {
+    const reply = await this.sendCommand("set_clip_seconds", params);
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Choose black or a held last frame at boundaries. Off carries the playback clock across ready autoplay clips without flushing. Does not guarantee visual continuity; reset always clears tracks. Replies flush_accepted and emits state_update.
+   * @param params - Choose black or a held last frame at boundaries. Off carries the playback clock across ready autoplay clips without flushing. Does not guarantee visual continuity; reset always clears tracks. Replies flush_accepted and emits state_update.
+   * @returns The correlated {@link H3ReferenceToVideoTurboRealtimeFlushAcceptedMessage} reply, or `undefined` when the send fails (the SDK never rejects — see `getLastError()`).
+   */
+  async setFlushOnClipEnd(params) {
+    const reply = await this.sendCommand("set_flush_on_clip_end", params);
+    return reply === void 0 ? void 0 : _unwrapMessage(reply);
+  }
+  /**
+   * Subscribe to typed model messages.
+   * @param handler - Called with a discriminated H3ReferenceToVideoTurboRealtimeMessage
+   * @returns Unsubscribe function
+   */
+  onMessage(handler) {
+    const wrappedHandler = (raw) => {
+      handler(_unwrapMessage(raw));
+    };
+    this.on("message", wrappedHandler);
+    return () => this.off("message", wrappedHandler);
+  }
+  /**
+   * Subscribe to "clip_moved" messages only.
+   * @returns Unsubscribe function
+   */
+  onClipMoved(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "clip_moved") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "clip_failed" messages only.
+   * @returns Unsubscribe function
+   */
+  onClipFailed(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "clip_failed") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "clip_popped" messages only.
+   * @returns Unsubscribe function
+   */
+  onClipPopped(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "clip_popped") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "clip_queued" messages only.
+   * @returns Unsubscribe function
+   */
+  onClipQueued(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "clip_queued") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "clip_started" messages only.
+   * @returns Unsubscribe function
+   */
+  onClipStarted(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "clip_started") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "clip_stopped" messages only.
+   * @returns Unsubscribe function
+   */
+  onClipStopped(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "clip_stopped") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "queue_update" messages only.
+   * @returns Unsubscribe function
+   */
+  onQueueUpdate(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "queue_update") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "state_update" messages only.
+   * @returns Unsubscribe function
+   */
+  onStateUpdate(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "state_update") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "clip_finished" messages only.
+   * @returns Unsubscribe function
+   */
+  onClipFinished(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "clip_finished") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "command_error" messages only.
+   * @returns Unsubscribe function
+   */
+  onCommandError(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "command_error") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "seed_accepted" messages only.
+   * @returns Unsubscribe function
+   */
+  onSeedAccepted(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "seed_accepted") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "session_reset" messages only.
+   * @returns Unsubscribe function
+   */
+  onSessionReset(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "session_reset") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "clip_generated" messages only.
+   * @returns Unsubscribe function
+   */
+  onClipGenerated(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "clip_generated") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "flush_accepted" messages only.
+   * @returns Unsubscribe function
+   */
+  onFlushAccepted(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "flush_accepted") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "canvas_accepted" messages only.
+   * @returns Unsubscribe function
+   */
+  onCanvasAccepted(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "canvas_accepted") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "autoplay_accepted" messages only.
+   * @returns Unsubscribe function
+   */
+  onAutoplayAccepted(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "autoplay_accepted") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to "clip_length_accepted" messages only.
+   * @returns Unsubscribe function
+   */
+  onClipLengthAccepted(handler) {
+    return this.onMessage((msg) => {
+      if (msg.type === "clip_length_accepted") handler(msg);
+    });
+  }
+  /**
+   * Subscribe to the "main_video" recvonly video track the model publishes.
+   *
+   * The handler fires once the model starts publishing this track; it receives the live MediaStreamTrack and the parent MediaStream (useful for attaching to a `<video>` / `<audio>` element via `srcObject`).
+   * @param handler - Called with the received track and its stream
+   * @returns Unsubscribe function
+   */
+  onMainVideo(handler) {
+    const wrapped = (name, t, s) => {
+      if (name === "main_video") handler(t, s);
+    };
+    this.on("trackReceived", wrapped);
+    return () => this.off("trackReceived", wrapped);
+  }
+  /**
+   * Subscribe to the "main_audio" recvonly audio track the model publishes.
+   *
+   * The handler fires once the model starts publishing this track; it receives the live MediaStreamTrack and the parent MediaStream (useful for attaching to a `<video>` / `<audio>` element via `srcObject`).
+   * @param handler - Called with the received track and its stream
+   * @returns Unsubscribe function
+   */
+  onMainAudio(handler) {
+    const wrapped = (name, t, s) => {
+      if (name === "main_audio") handler(t, s);
+    };
+    this.on("trackReceived", wrapped);
+    return () => this.off("trackReceived", wrapped);
+  }
+};
+
+// src/react.tsx
+var import_js_sdk2 = require("@reactor-team/js-sdk");
+var import_jsx_runtime = require("react/jsx-runtime");
+function _unwrapMessage2(raw) {
+  const env = raw;
+  if (env && typeof env === "object" && env.data && typeof env.data === "object") {
+    return { ...env.data, type: env.type };
+  }
+  return raw;
+}
+function H3ReferenceToVideoTurboRealtimeProvider({
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_js_sdk2.ReactorProvider,
+    {
+      ...rest,
+      modelName: MODEL_NAME,
+      modelTracks: [...H3ReferenceToVideoTurboRealtimeTracks],
+      children
+    }
+  );
+}
+function useH3ReferenceToVideoTurboRealtime() {
+  const connect = (0, import_js_sdk2.useReactor)((s) => s.connect);
+  const connectOptions = (0, import_js_sdk2.useReactor)((s) => s.connectOptions);
+  const disconnect = (0, import_js_sdk2.useReactor)((s) => s.disconnect);
+  const downloadClipAsFile = (0, import_js_sdk2.useReactor)((s) => s.downloadClipAsFile);
+  const jwtToken = (0, import_js_sdk2.useReactor)((s) => s.jwtToken);
+  const lastError = (0, import_js_sdk2.useReactor)((s) => s.lastError);
+  const lastMessage = (0, import_js_sdk2.useReactor)((s) => s.lastMessage);
+  const pauseTrack = (0, import_js_sdk2.useReactor)((s) => s.pauseTrack);
+  const publish = (0, import_js_sdk2.useReactor)((s) => s.publish);
+  const reconnect = (0, import_js_sdk2.useReactor)((s) => s.reconnect);
+  const requestClip = (0, import_js_sdk2.useReactor)((s) => s.requestClip);
+  const requestRecording = (0, import_js_sdk2.useReactor)((s) => s.requestRecording);
+  const resumeTrack = (0, import_js_sdk2.useReactor)((s) => s.resumeTrack);
+  const sendCommand = (0, import_js_sdk2.useReactor)((s) => s.sendCommand);
+  const sessionId = (0, import_js_sdk2.useReactor)((s) => s.sessionId);
+  const status = (0, import_js_sdk2.useReactor)((s) => s.status);
+  const tracks = (0, import_js_sdk2.useReactor)((s) => s.tracks);
+  const unpublish = (0, import_js_sdk2.useReactor)((s) => s.unpublish);
+  const uploadFile = (0, import_js_sdk2.useReactor)((s) => s.uploadFile);
+  return {
+    connect,
+    connectOptions,
+    disconnect,
+    downloadClipAsFile,
+    jwtToken,
+    lastError,
+    lastMessage,
+    pauseTrack,
+    publish,
+    reconnect,
+    requestClip,
+    requestRecording,
+    resumeTrack,
+    sendCommand,
+    sessionId,
+    status,
+    tracks,
+    unpublish,
+    uploadFile,
+    pop: async (params) => {
+      const reply = await sendCommand("pop", params);
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    },
+    move: async (params) => {
+      const reply = await sendCommand("move", params);
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    },
+    play: async (params) => {
+      await sendCommand("play", params);
+      return void 0;
+    },
+    stop: async () => {
+      await sendCommand("stop", {});
+      return void 0;
+    },
+    reset: async () => {
+      const reply = await sendCommand("reset", {});
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    },
+    enqueue: async (params) => {
+      const reply = await sendCommand("enqueue", params);
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    },
+    setSeed: async (params) => {
+      const reply = await sendCommand("set_seed", params);
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    },
+    getQueue: async () => {
+      const reply = await sendCommand("get_queue", {});
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    },
+    getState: async () => {
+      const reply = await sendCommand("get_state", {});
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    },
+    setCanvas: async (params) => {
+      const reply = await sendCommand("set_canvas", params);
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    },
+    setAutoplay: async (params) => {
+      const reply = await sendCommand("set_autoplay", params);
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    },
+    setClipSeconds: async (params) => {
+      const reply = await sendCommand("set_clip_seconds", params);
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    },
+    setFlushOnClipEnd: async (params) => {
+      const reply = await sendCommand("set_flush_on_clip_end", params);
+      return reply === void 0 ? void 0 : _unwrapMessage2(reply);
+    }
+  };
+}
+function useH3ReferenceToVideoTurboRealtimeMessage(handler) {
+  (0, import_js_sdk2.useReactorMessage)(
+    (msg) => handler(_unwrapMessage2(msg))
+  );
+}
+function useH3ReferenceToVideoTurboRealtimeClipMoved(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_moved") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeClipFailed(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_failed") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeClipPopped(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_popped") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeClipQueued(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_queued") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeClipStarted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_started") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeClipStopped(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_stopped") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeQueueUpdate(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "queue_update") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeStateUpdate(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "state_update") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeClipFinished(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_finished") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeCommandError(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "command_error") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeSeedAccepted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "seed_accepted") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeSessionReset(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "session_reset") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeClipGenerated(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_generated") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeFlushAccepted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "flush_accepted") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeCanvasAccepted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "canvas_accepted") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeAutoplayAccepted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "autoplay_accepted") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeClipLengthAccepted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_length_accepted") {
+      handler(m);
+    }
+  });
+}
+function useH3ReferenceToVideoTurboRealtimeTrack(name) {
+  return (0, import_js_sdk2.useReactor)((s) => s.tracks[name]);
+}
+function H3ReferenceToVideoTurboRealtimeMainVideoView(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_js_sdk2.ReactorView, { ...props, track: "main_video" });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileRef,
+  H3ReferenceToVideoTurboRealtimeMainVideoView,
+  H3ReferenceToVideoTurboRealtimeModel,
+  H3ReferenceToVideoTurboRealtimeProvider,
+  H3ReferenceToVideoTurboRealtimeTracks,
+  MODEL_NAME,
+  MODEL_VERSION,
+  useH3ReferenceToVideoTurboRealtime,
+  useH3ReferenceToVideoTurboRealtimeAutoplayAccepted,
+  useH3ReferenceToVideoTurboRealtimeCanvasAccepted,
+  useH3ReferenceToVideoTurboRealtimeClipFailed,
+  useH3ReferenceToVideoTurboRealtimeClipFinished,
+  useH3ReferenceToVideoTurboRealtimeClipGenerated,
+  useH3ReferenceToVideoTurboRealtimeClipLengthAccepted,
+  useH3ReferenceToVideoTurboRealtimeClipMoved,
+  useH3ReferenceToVideoTurboRealtimeClipPopped,
+  useH3ReferenceToVideoTurboRealtimeClipQueued,
+  useH3ReferenceToVideoTurboRealtimeClipStarted,
+  useH3ReferenceToVideoTurboRealtimeClipStopped,
+  useH3ReferenceToVideoTurboRealtimeCommandError,
+  useH3ReferenceToVideoTurboRealtimeFlushAccepted,
+  useH3ReferenceToVideoTurboRealtimeMessage,
+  useH3ReferenceToVideoTurboRealtimeQueueUpdate,
+  useH3ReferenceToVideoTurboRealtimeSeedAccepted,
+  useH3ReferenceToVideoTurboRealtimeSessionReset,
+  useH3ReferenceToVideoTurboRealtimeStateUpdate,
+  useH3ReferenceToVideoTurboRealtimeTrack
+});
+//# sourceMappingURL=index.js.map