@reactor-models/fast-h3 1.0.2

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, {
+  FastH3MainVideoView: () => FastH3MainVideoView,
+  FastH3Model: () => FastH3Model,
+  FastH3Provider: () => FastH3Provider,
+  FastH3Tracks: () => FastH3Tracks,
+  FileRef: () => import_js_sdk.FileRef,
+  MODEL_NAME: () => MODEL_NAME,
+  MODEL_VERSION: () => MODEL_VERSION,
+  useFastH3: () => useFastH3,
+  useFastH3AutoplayAccepted: () => useFastH3AutoplayAccepted,
+  useFastH3CanvasAccepted: () => useFastH3CanvasAccepted,
+  useFastH3ClipFailed: () => useFastH3ClipFailed,
+  useFastH3ClipFinished: () => useFastH3ClipFinished,
+  useFastH3ClipGenerated: () => useFastH3ClipGenerated,
+  useFastH3ClipLengthAccepted: () => useFastH3ClipLengthAccepted,
+  useFastH3ClipMoved: () => useFastH3ClipMoved,
+  useFastH3ClipPopped: () => useFastH3ClipPopped,
+  useFastH3ClipQueued: () => useFastH3ClipQueued,
+  useFastH3ClipStarted: () => useFastH3ClipStarted,
+  useFastH3ClipStopped: () => useFastH3ClipStopped,
+  useFastH3CommandError: () => useFastH3CommandError,
+  useFastH3FlushAccepted: () => useFastH3FlushAccepted,
+  useFastH3Message: () => useFastH3Message,
+  useFastH3QueueUpdate: () => useFastH3QueueUpdate,
+  useFastH3SeedAccepted: () => useFastH3SeedAccepted,
+  useFastH3SessionReset: () => useFastH3SessionReset,
+  useFastH3StateUpdate: () => useFastH3StateUpdate,
+  useFastH3Track: () => useFastH3Track
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core.ts
+var import_js_sdk = require("@reactor-team/js-sdk");
+var MODEL_NAME = "reactor/fast-h3";
+var MODEL_VERSION = "v1.0.2";
+var FastH3Tracks = [
+  { 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 FastH3Model = class extends import_js_sdk.Reactor {
+  constructor(options) {
+    super({
+      ...options,
+      modelName: MODEL_NAME,
+      modelTracks: [...FastH3Tracks]
+    });
+  }
+  /** @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 one clip by its UUID from whichever queue holds it, freeing its slot. Works on generating and built clips alike; a build already running for it is discarded when it completes. The clip that is playing is in neither queue — `stop` is the command that cuts it. A built clip stays in `queue_update.history` after popping, so clips continued from it are unaffected; an unbuilt clip that queued clips continue from is refused, since popping it would leave them nothing to open from — pop those first. Emits `clip_popped`, `queue_update` and `state_update`, or `command_error` when no queued clip has that id or queued clips still continue from it.
+   * @param params - Remove one clip by its UUID from whichever queue holds it, freeing its slot. Works on generating and built clips alike; a build already running for it is discarded when it completes. The clip that is playing is in neither queue — `stop` is the command that cuts it. A built clip stays in `queue_update.history` after popping, so clips continued from it are unaffected; an unbuilt clip that queued clips continue from is refused, since popping it would leave them nothing to open from — pop those first. Emits `clip_popped`, `queue_update` and `state_update`, or `command_error` when no queued clip has that id or queued clips still continue from it.
+   * @returns The correlated {@link FastH3ClipPoppedMessage} 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 one clip within the queue that holds it — the generation queue for a clip still to build, the playout queue for a built one; clips never move between queues except by building. `position` 0 is the front: the next build, or what bare `play` and autoplay take next. Values past the end mean the back. Replies `clip_moved` with the queue and the resulting position, and emits `queue_update`; `command_error` when no queued clip has that id.
+   * @param params - Reposition one clip within the queue that holds it — the generation queue for a clip still to build, the playout queue for a built one; clips never move between queues except by building. `position` 0 is the front: the next build, or what bare `play` and autoplay take next. Values past the end mean the back. Replies `clip_moved` with the queue and the resulting position, and emits `queue_update`; `command_error` when no queued clip has that id.
+   * @returns The correlated {@link FastH3ClipMovedMessage} 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 one clip from the playout queue. Blank `clip_id` plays the front clip; a UUID plays that specific one. Playing consumes the entry: it leaves the queue, `clip_started` marks its first frames, and when it ends the stream holds on black until the next `play`. Emits `queue_update` and `state_update`, or `command_error` when a clip is already playing, the id is unknown, or the clip is still generating.
+   * @param params - Play one clip from the playout queue. Blank `clip_id` plays the front clip; a UUID plays that specific one. Playing consumes the entry: it leaves the queue, `clip_started` marks its first frames, and when it ends the stream holds on black until the next `play`. Emits `queue_update` and `state_update`, or `command_error` when a clip is already playing, the id is unknown, or the clip is still generating.
+   * @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 the clip that is playing. Whatever is queued on the output tracks is dropped and the picture goes to black within a fraction of a second (with `set_flush_on_clip_end` off, the transport drains what it holds and freezes on the last frame instead), and the session is back where a finished clip leaves it — the queue is untouched and the next `play` starts clean. With autoplay on this acts as a skip: the next ready clip starts on its own, so send `set_autoplay` off first to hold the stream. Emits `clip_stopped` and `state_update`, or `command_error` when no clip 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;
+  }
+  /**
+   * Return every condition to its default, drop both queues' clips and the retained history, and clear the output tracks. A clip that is playing is cut, with a `clip_stopped` to mark it. Valid at any time. Replies `session_reset` and emits `queue_update` and `state_update`.
+   * @returns The correlated {@link FastH3SessionResetMessage} 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 one clip generation. The clip enters the generation queue (at `position`, or the back), builds when its turn comes, and then joins the back of the playout queue, announced by `clip_generated`. The prompt is what the clip will show; the metadata is an opaque string echoed back on every message that references the clip, for frontends to carry their own tracking data. The clip opens from text alone, from an uploaded still (`starting_frame` — the image animates forward), or from an existing clip's last frame (`continue_from_clip_id` — any clip in the queues or in `queue_update.history`); a continued clip simply waits its turn until its source is built, wherever the two sit in the queue. The clip's canvas is the session's; its length is the `seconds` passed here (snapped to what the model can produce) or the session default, and its seed is the one passed here or the session's advancing default. Builds run through the queue in order; watch `queue_update` for the clip turning ready. Replies `clip_queued` with the clip's UUID and emits `queue_update` and `state_update`, or `command_error` when the queue is full, the prompt is empty, both a starting frame and a source clip are given, the source clip is unknown or no longer retained, or the upload is not a decodable image.
+   * @param params - Queue one clip generation. The clip enters the generation queue (at `position`, or the back), builds when its turn comes, and then joins the back of the playout queue, announced by `clip_generated`. The prompt is what the clip will show; the metadata is an opaque string echoed back on every message that references the clip, for frontends to carry their own tracking data. The clip opens from text alone, from an uploaded still (`starting_frame` — the image animates forward), or from an existing clip's last frame (`continue_from_clip_id` — any clip in the queues or in `queue_update.history`); a continued clip simply waits its turn until its source is built, wherever the two sit in the queue. The clip's canvas is the session's; its length is the `seconds` passed here (snapped to what the model can produce) or the session default, and its seed is the one passed here or the session's advancing default. Builds run through the queue in order; watch `queue_update` for the clip turning ready. Replies `clip_queued` with the clip's UUID and emits `queue_update` and `state_update`, or `command_error` when the queue is full, the prompt is empty, both a starting frame and a source clip are given, the source clip is unknown or no longer retained, or the upload is not a decodable image.
+   * @returns The correlated {@link FastH3ClipQueuedMessage} 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 default seed — the one an `enqueue` without a seed of its own uses, advancing it by one, so re-enqueuing the same prompts in the same order reproduces the same clips. Clips already in the queue keep the seed they were enqueued with. Valid at any time. Emits `seed_accepted` and `state_update`.
+   * @param params - Set the default seed — the one an `enqueue` without a seed of its own uses, advancing it by one, so re-enqueuing the same prompts in the same order reproduces the same clips. Clips already in the queue keep the seed they were enqueued with. Valid at any time. Emits `seed_accepted` and `state_update`.
+   * @returns The correlated {@link FastH3SeedAcceptedMessage} 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);
+  }
+  /**
+   * Return both queues' contents — `generation` (waiting to build) and `playout` (built, playable) — plus `history`, the built clips no longer queued that `continue_from_clip_id` can still name, every clip as its full structure. The same payload the model broadcasts as `queue_update`. Valid at any time.
+   * @returns The correlated {@link FastH3QueueUpdateMessage} 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);
+  }
+  /**
+   * Return a snapshot of everything the session exposes except the queue's contents (`get_queue` carries those): the conditions in force, what is playing, progress counters, and the commands that are valid right now. The same payload the model broadcasts as `state_update`. Valid at any time.
+   * @returns The correlated {@link FastH3StateUpdateMessage} 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);
+  }
+  /**
+   * Choose the aspect ratio of `main_video`. The video track keeps one size and queued clips are built at it, so this is only valid while the queue is empty and nothing is playing. Emits `canvas_accepted`, carrying the exact pixel size, and `state_update`, or `command_error` while clips are queued or playing, or when the ratio is not one this model offers.
+   * @param params - Choose the aspect ratio of `main_video`. The video track keeps one size and queued clips are built at it, so this is only valid while the queue is empty and nothing is playing. Emits `canvas_accepted`, carrying the exact pixel size, and `state_update`, or `command_error` while clips are queued or playing, or when the ratio is not one this model offers.
+   * @returns The correlated {@link FastH3CanvasAcceptedMessage} 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);
+  }
+  /**
+   * Turn autoplay on or off. On, the playout queue's front clip starts on its own whenever nothing is playing — right after a clip finishes, or the moment a build completes while the stream is idle — so a steadily fed queue plays through without a `play` per clip. Off (the default), the stream holds on black until an explicit `play`. Takes effect immediately and lasts for the session. Emits `autoplay_accepted` and `state_update`.
+   * @param params - Turn autoplay on or off. On, the playout queue's front clip starts on its own whenever nothing is playing — right after a clip finishes, or the moment a build completes while the stream is idle — so a steadily fed queue plays through without a `play` per clip. Off (the default), the stream holds on black until an explicit `play`. Takes effect immediately and lasts for the session. Emits `autoplay_accepted` and `state_update`.
+   * @returns The correlated {@link FastH3AutoplayAcceptedMessage} 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 default length for enqueues that carry no `seconds` of their own. The value is snapped to the nearest length the model can produce, so read the effective one back from `clip_length_accepted`. Clips already in the queue keep the length they were enqueued with. Longer clips carry a scene further; shorter ones build faster. Valid at any time. Emits `clip_length_accepted` and `state_update`.
+   * @param params - Set the default length for enqueues that carry no `seconds` of their own. The value is snapped to the nearest length the model can produce, so read the effective one back from `clip_length_accepted`. Clips already in the queue keep the length they were enqueued with. Longer clips carry a scene further; shorter ones build faster. Valid at any time. Emits `clip_length_accepted` and `state_update`.
+   * @returns The correlated {@link FastH3ClipLengthAcceptedMessage} 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);
+  }
+  /**
+   * Set whether the stream cuts to black when a clip ends, is stopped, or a non-continuing clip follows it. On (the default) those boundaries flush to black at once. Off, the stream holds the last frame instead — `stop` then drains what the transport already holds (up to a couple of seconds) before the picture freezes, rather than snapping to black. Either way, autoplay chains a clip whose `continue_from_clip_id` names the clip just finished with no cut at all, and `reset` always clears the tracks. Takes effect at the next boundary and lasts for the session. Emits `flush_accepted` and `state_update`.
+   * @param params - Set whether the stream cuts to black when a clip ends, is stopped, or a non-continuing clip follows it. On (the default) those boundaries flush to black at once. Off, the stream holds the last frame instead — `stop` then drains what the transport already holds (up to a couple of seconds) before the picture freezes, rather than snapping to black. Either way, autoplay chains a clip whose `continue_from_clip_id` names the clip just finished with no cut at all, and `reset` always clears the tracks. Takes effect at the next boundary and lasts for the session. Emits `flush_accepted` and `state_update`.
+   * @returns The correlated {@link FastH3FlushAcceptedMessage} 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 FastH3Message
+   * @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 FastH3Provider({
+  children,
+  ...rest
+}) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_js_sdk2.ReactorProvider,
+    {
+      ...rest,
+      modelName: MODEL_NAME,
+      modelTracks: [...FastH3Tracks],
+      children
+    }
+  );
+}
+function useFastH3() {
+  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 useFastH3Message(handler) {
+  (0, import_js_sdk2.useReactorMessage)(
+    (msg) => handler(_unwrapMessage2(msg))
+  );
+}
+function useFastH3ClipMoved(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_moved") {
+      handler(m);
+    }
+  });
+}
+function useFastH3ClipFailed(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_failed") {
+      handler(m);
+    }
+  });
+}
+function useFastH3ClipPopped(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_popped") {
+      handler(m);
+    }
+  });
+}
+function useFastH3ClipQueued(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_queued") {
+      handler(m);
+    }
+  });
+}
+function useFastH3ClipStarted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_started") {
+      handler(m);
+    }
+  });
+}
+function useFastH3ClipStopped(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_stopped") {
+      handler(m);
+    }
+  });
+}
+function useFastH3QueueUpdate(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "queue_update") {
+      handler(m);
+    }
+  });
+}
+function useFastH3StateUpdate(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "state_update") {
+      handler(m);
+    }
+  });
+}
+function useFastH3ClipFinished(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_finished") {
+      handler(m);
+    }
+  });
+}
+function useFastH3CommandError(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "command_error") {
+      handler(m);
+    }
+  });
+}
+function useFastH3SeedAccepted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "seed_accepted") {
+      handler(m);
+    }
+  });
+}
+function useFastH3SessionReset(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "session_reset") {
+      handler(m);
+    }
+  });
+}
+function useFastH3ClipGenerated(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_generated") {
+      handler(m);
+    }
+  });
+}
+function useFastH3FlushAccepted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "flush_accepted") {
+      handler(m);
+    }
+  });
+}
+function useFastH3CanvasAccepted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "canvas_accepted") {
+      handler(m);
+    }
+  });
+}
+function useFastH3AutoplayAccepted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "autoplay_accepted") {
+      handler(m);
+    }
+  });
+}
+function useFastH3ClipLengthAccepted(handler) {
+  (0, import_js_sdk2.useReactorMessage)((msg) => {
+    const m = _unwrapMessage2(msg);
+    if (m.type === "clip_length_accepted") {
+      handler(m);
+    }
+  });
+}
+function useFastH3Track(name) {
+  return (0, import_js_sdk2.useReactor)((s) => s.tracks[name]);
+}
+function FastH3MainVideoView(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 = {
+  FastH3MainVideoView,
+  FastH3Model,
+  FastH3Provider,
+  FastH3Tracks,
+  FileRef,
+  MODEL_NAME,
+  MODEL_VERSION,
+  useFastH3,
+  useFastH3AutoplayAccepted,
+  useFastH3CanvasAccepted,
+  useFastH3ClipFailed,
+  useFastH3ClipFinished,
+  useFastH3ClipGenerated,
+  useFastH3ClipLengthAccepted,
+  useFastH3ClipMoved,
+  useFastH3ClipPopped,
+  useFastH3ClipQueued,
+  useFastH3ClipStarted,
+  useFastH3ClipStopped,
+  useFastH3CommandError,
+  useFastH3FlushAccepted,
+  useFastH3Message,
+  useFastH3QueueUpdate,
+  useFastH3SeedAccepted,
+  useFastH3SessionReset,
+  useFastH3StateUpdate,
+  useFastH3Track
+});
+//# sourceMappingURL=index.js.map