@reactor-team/js-sdk 1.0.1

package/dist/index.js

@@ -0,0 +1,1000 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Reactor: () => Reactor,
+  ReactorProvider: () => ReactorProvider,
+  ReactorView: () => ReactorView,
+  useReactor: () => useReactor,
+  useReactorMessage: () => useReactorMessage,
+  useReactorStore: () => useReactorStore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/types.ts
+var import_zod = require("zod");
+var ApplicationMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("application"),
+  data: import_zod.z.any()
+  // Can be any JSON-serializable data
+});
+var FPSMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("fps"),
+  data: import_zod.z.number()
+});
+var GPUMachineReceiveMessageSchema = import_zod.z.discriminatedUnion("type", [
+  ApplicationMessageSchema,
+  FPSMessageSchema
+]);
+var WelcomeMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("welcome"),
+  data: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
+});
+var GPUMachineAssignmentDataSchema = import_zod.z.object({
+  livekitWsUrl: import_zod.z.string(),
+  livekitJwtToken: import_zod.z.string()
+});
+var GPUMachineAssignmentMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("gpu-machine-assigned"),
+  data: GPUMachineAssignmentDataSchema
+});
+var EchoMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("echo"),
+  data: import_zod.z.record(import_zod.z.string(), import_zod.z.any())
+});
+var WaitingInfoDataSchema = import_zod.z.object({
+  position: import_zod.z.number().optional(),
+  estimatedWaitTime: import_zod.z.number().optional(),
+  averageWaitTime: import_zod.z.number().optional()
+});
+var WaitingInfoMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("waiting-info"),
+  data: WaitingInfoDataSchema
+});
+var CoordinatorMessageSchema = import_zod.z.discriminatedUnion("type", [
+  WelcomeMessageSchema,
+  GPUMachineAssignmentMessageSchema,
+  EchoMessageSchema,
+  WaitingInfoMessageSchema
+]);
+var GPUMachineSendMessageSchema = import_zod.z.discriminatedUnion("type", [
+  ApplicationMessageSchema
+]);
+var SessionSetupMessageSchema = import_zod.z.object({
+  type: import_zod.z.literal("sessionSetup"),
+  data: import_zod.z.object({
+    modelName: import_zod.z.string(),
+    modelVersion: import_zod.z.string().default("latest")
+  })
+});
+
+// src/core/CoordinatorClient.ts
+var import_zod2 = require("zod");
+var OptionsSchema = import_zod2.z.object({
+  wsUrl: import_zod2.z.string().nonempty(),
+  jwtToken: import_zod2.z.string().optional(),
+  insecureApiKey: import_zod2.z.string().optional(),
+  modelName: import_zod2.z.string(),
+  modelVersion: import_zod2.z.string().default("latest")
+}).refine((data) => data.jwtToken || data.insecureApiKey, {
+  message: "At least one of jwtToken or insecureApiKey must be provided."
+});
+var CoordinatorClient = class {
+  constructor(options) {
+    this.eventListeners = /* @__PURE__ */ new Map();
+    const validatedOptions = OptionsSchema.parse(options);
+    this.wsUrl = validatedOptions.wsUrl;
+    this.protocols = validatedOptions.jwtToken ? [`jwt-token.${validatedOptions.jwtToken}`] : [`insecure-api-key.${validatedOptions.insecureApiKey}`];
+    this.modelName = validatedOptions.modelName;
+    this.modelVersion = validatedOptions.modelVersion;
+  }
+  // Event Emitter API
+  on(event, handler) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(handler);
+  }
+  off(event, handler) {
+    var _a;
+    (_a = this.eventListeners.get(event)) == null ? void 0 : _a.delete(handler);
+  }
+  emit(event, ...args) {
+    var _a;
+    (_a = this.eventListeners.get(event)) == null ? void 0 : _a.forEach((handler) => handler(...args));
+  }
+  sendMessage(message) {
+    var _a;
+    try {
+      const messageStr = typeof message === "string" ? message : JSON.stringify(message);
+      (_a = this.websocket) == null ? void 0 : _a.send(messageStr);
+    } catch (error) {
+      console.error("[CoordinatorClient] Failed to send message:", error);
+      this.emit("statusChanged", "error");
+    }
+  }
+  connect() {
+    return __async(this, null, function* () {
+      console.debug("[CoordinatorClient] Connecting to", this.wsUrl);
+      this.websocket = new WebSocket(this.wsUrl, this.protocols);
+      this.websocket.onopen = () => {
+        console.debug("[CoordinatorClient] WebSocket opened");
+        this.emit("statusChanged", "connected");
+      };
+      this.websocket.onmessage = (event) => {
+        try {
+          let parsedData;
+          if (typeof event.data === "string") {
+            parsedData = JSON.parse(event.data);
+          } else {
+            parsedData = event.data;
+          }
+          console.debug(
+            "[CoordinatorClient] Received message from coordinator:",
+            parsedData
+          );
+          const validatedData = CoordinatorMessageSchema.parse(parsedData);
+          this.emit(validatedData.type, validatedData.data);
+        } catch (error) {
+          console.error(
+            "[CoordinatorClient] Failed to parse WebSocket message from coordinator:",
+            error,
+            "message",
+            event.data
+          );
+          this.emit("statusChanged", "error");
+        }
+      };
+      this.websocket.onclose = (event) => {
+        console.debug("[CoordinatorClient] WebSocket closed", event);
+        this.websocket = void 0;
+        this.emit("statusChanged", "disconnected");
+      };
+      this.websocket.onerror = (error) => {
+        console.error("[CoordinatorClient] WebSocket error:", error);
+        this.websocket = void 0;
+        this.emit("statusChanged", "error");
+      };
+      yield new Promise((resolve, reject) => {
+        var _a, _b;
+        const onOpen = () => {
+          var _a2;
+          (_a2 = this.websocket) == null ? void 0 : _a2.removeEventListener("error", onError);
+          resolve();
+        };
+        const onError = (error) => {
+          var _a2;
+          (_a2 = this.websocket) == null ? void 0 : _a2.removeEventListener("open", onOpen);
+          reject(error);
+        };
+        (_a = this.websocket) == null ? void 0 : _a.addEventListener("open", onOpen);
+        (_b = this.websocket) == null ? void 0 : _b.addEventListener("error", onError);
+      });
+      console.log("[CoordinatorClient] WebSocket connected");
+      this.sendMessage({
+        type: "sessionSetup",
+        data: {
+          modelName: this.modelName,
+          modelVersion: this.modelVersion
+        }
+      });
+      console.debug("[CoordinatorClient] Setup session message sent");
+    });
+  }
+  /**
+   * Closes the WebSocket connection if it exists.
+   * This will trigger the onclose event handler.
+   */
+  disconnect() {
+    if (this.websocket) {
+      console.debug("[CoordinatorClient] Closing WebSocket connection");
+      this.websocket.close();
+      this.websocket = void 0;
+    }
+  }
+};
+
+// src/core/GPUMachineClient.ts
+var import_livekit_client = require("livekit-client");
+var GPUMachineClient = class {
+  constructor(token, liveKitUrl) {
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.token = token;
+    this.liveKitUrl = liveKitUrl;
+  }
+  // Event Emitter API
+  on(event, handler) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(handler);
+  }
+  off(event, handler) {
+    var _a;
+    (_a = this.eventListeners.get(event)) == null ? void 0 : _a.delete(handler);
+  }
+  emit(event, ...args) {
+    var _a;
+    (_a = this.eventListeners.get(event)) == null ? void 0 : _a.forEach((handler) => handler(...args));
+  }
+  sendMessage(message) {
+    try {
+      if (this.roomInstance) {
+        const messageStr = JSON.stringify(message);
+        this.roomInstance.localParticipant.sendText(messageStr, {
+          topic: "application"
+        });
+      } else {
+        console.warn(
+          "[GPUMachineClient] Cannot send message - not connected to room"
+        );
+      }
+    } catch (error) {
+      console.error("[GPUMachineClient] Failed to send message:", error);
+      this.emit("statusChanged", "error");
+    }
+  }
+  connect() {
+    return __async(this, null, function* () {
+      this.roomInstance = new import_livekit_client.Room({
+        adaptiveStream: true,
+        dynacast: true
+      });
+      this.roomInstance.on(import_livekit_client.RoomEvent.Connected, () => {
+        console.debug("[GPUMachineClient] Connected to room");
+        this.emit("statusChanged", "connected");
+      });
+      this.roomInstance.on(import_livekit_client.RoomEvent.Disconnected, () => {
+        console.debug("[GPUMachineClient] Disconnected from room");
+        this.emit("statusChanged", "disconnected");
+      });
+      this.roomInstance.on(
+        import_livekit_client.RoomEvent.TrackSubscribed,
+        (track, _publication, participant) => {
+          console.debug(
+            "[GPUMachineClient] Track subscribed:",
+            track.kind,
+            participant.identity
+          );
+          if (track.kind === import_livekit_client.Track.Kind.Video) {
+            const videoTrack = track;
+            this.emit("streamChanged", videoTrack);
+          }
+        }
+      );
+      this.roomInstance.on(
+        import_livekit_client.RoomEvent.TrackUnsubscribed,
+        (track, _publication, participant) => {
+          console.debug(
+            "[GPUMachineClient] Track unsubscribed:",
+            track.kind,
+            participant.identity
+          );
+          if (track.kind === import_livekit_client.Track.Kind.Video) {
+            this.emit("streamChanged", null);
+          }
+        }
+      );
+      this.roomInstance.registerTextStreamHandler(
+        "application",
+        (reader, participant) => __async(this, null, function* () {
+          const text = yield reader.readAll();
+          console.log("[GPUMachineClient] Received message:", text);
+          try {
+            const parsedData = JSON.parse(text);
+            const validatedMessage = GPUMachineReceiveMessageSchema.parse(parsedData);
+            if (validatedMessage.type === "fps") {
+              this.machineFPS = validatedMessage.data;
+            }
+            this.emit(validatedMessage.type, validatedMessage.data);
+          } catch (error) {
+            console.error(
+              "[GPUMachineClient] Failed to parse/validate message:",
+              error
+            );
+            this.emit("statusChanged", "error");
+          }
+        })
+      );
+      yield this.roomInstance.connect(this.liveKitUrl, this.token);
+      console.log("[GPUMachineClient] Room connected");
+    });
+  }
+  /**
+   * Closes the LiveKit connection if it exists.
+   * This will trigger the onclose event handler.
+   */
+  disconnect() {
+    return __async(this, null, function* () {
+      if (this.roomInstance) {
+        console.debug("[GPUMachineClient] Closing LiveKit connection");
+        yield this.roomInstance.disconnect();
+        this.roomInstance = void 0;
+      }
+      this.machineFPS = void 0;
+    });
+  }
+  /**
+   * Returns the current fps rate of the machine.
+   * @returns The current fps rate of the machine.
+   */
+  getFPS() {
+    return this.machineFPS;
+  }
+  /**
+   * Returns the current video stream from the GPU machine.
+   * @returns The current video stream or undefined if not available.
+   */
+  getVideoStream() {
+    return this.videoStream;
+  }
+};
+
+// src/core/Reactor.ts
+var import_zod3 = require("zod");
+var OptionsSchema2 = import_zod3.z.object({
+  directConnection: import_zod3.z.object({
+    livekitJwtToken: import_zod3.z.string(),
+    livekitWsUrl: import_zod3.z.string()
+  }).optional(),
+  insecureApiKey: import_zod3.z.string().optional(),
+  jwtToken: import_zod3.z.string().optional(),
+  coordinatorUrl: import_zod3.z.string().optional(),
+  modelName: import_zod3.z.string()
+}).refine(
+  (data) => data.directConnection || data.insecureApiKey || data.jwtToken,
+  {
+    message: "At least one of directConnection, insecureApiKey, or jwtToken must be provided."
+  }
+);
+var Reactor = class {
+  constructor(options) {
+    //client for the machine instance
+    this.status = "disconnected";
+    // Generic event map
+    this.eventListeners = /* @__PURE__ */ new Map();
+    const validatedOptions = OptionsSchema2.parse(options);
+    this.coordinatorUrl = validatedOptions.coordinatorUrl || "ws://localhost:8080/ws";
+    this.jwtToken = validatedOptions.jwtToken;
+    this.insecureApiKey = validatedOptions.insecureApiKey;
+    this.directConnection = validatedOptions.directConnection;
+    this.modelName = validatedOptions.modelName;
+    this.modelVersion = "1.0.0";
+  }
+  // Event Emitter API
+  on(event, handler) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(event).add(handler);
+  }
+  off(event, handler) {
+    var _a;
+    (_a = this.eventListeners.get(event)) == null ? void 0 : _a.delete(handler);
+  }
+  emit(event, ...args) {
+    var _a;
+    (_a = this.eventListeners.get(event)) == null ? void 0 : _a.forEach((handler) => handler(...args));
+  }
+  /**
+   * Public method to send a message to the machine.
+   * Automatically wraps the message in an application message.
+   * @param message The message to send to the machine.
+   * @throws Error if not in ready state
+   */
+  sendMessage(message) {
+    var _a;
+    if (process.env.NODE_ENV !== "development" && this.status !== "ready") {
+      const errorMessage = `Cannot send message, status is ${this.status}`;
+      console.error("[Reactor] Not ready, cannot send message");
+      throw new Error(errorMessage);
+    }
+    try {
+      const applicationMessage = {
+        type: "application",
+        data: message
+      };
+      (_a = this.machineClient) == null ? void 0 : _a.sendMessage(applicationMessage);
+    } catch (error) {
+      console.error("[Reactor] Failed to send message:", error);
+      this.createError(
+        "MESSAGE_SEND_FAILED",
+        `Failed to send message: ${error}`,
+        "gpu",
+        true
+      );
+    }
+  }
+  /**
+   * Connects to the machine via LiveKit and waits for the gpu machine to be ready.
+   * Once the machine is ready, the Reactor will establish the LiveKit connection.
+   * @param livekitJwtToken The JWT token for LiveKit authentication
+   * @param livekitWsUrl The WebSocket URL for LiveKit connection
+   */
+  connectToGPUMachine(livekitJwtToken, livekitWsUrl) {
+    return __async(this, null, function* () {
+      console.debug("[Reactor] Connecting to machine room...");
+      try {
+        this.machineClient = new GPUMachineClient(livekitJwtToken, livekitWsUrl);
+        this.machineClient.on("application", (message) => {
+          this.emit("newMessage", message);
+        });
+        this.machineClient.on(
+          "statusChanged",
+          (status) => {
+            switch (status) {
+              case "connected":
+                this.setStatus("ready");
+                break;
+              case "disconnected":
+                this.disconnect();
+                break;
+              case "error":
+                this.createError(
+                  "GPU_CONNECTION_ERROR",
+                  "GPU machine connection failed",
+                  "gpu",
+                  true
+                );
+                this.disconnect();
+                break;
+            }
+          }
+        );
+        this.machineClient.on("fps", (fps) => {
+          this.emit("fps", fps);
+        });
+        this.machineClient.on("streamChanged", (videoTrack) => {
+          this.emit("streamChanged", videoTrack);
+        });
+        console.debug("[Reactor] About to connect to machine");
+        yield this.machineClient.connect();
+      } catch (error) {
+        throw error;
+      }
+    });
+  }
+  /**
+   * Connects to the coordinator and waits for a GPU to be assigned.
+   * Once a GPU is assigned, the Reactor will connect to the gpu machine via LiveKit.
+   */
+  connect() {
+    return __async(this, null, function* () {
+      console.debug("[Reactor] Connecting, status:", this.status);
+      if (this.status !== "disconnected")
+        throw new Error("Already connected or connecting");
+      if (this.directConnection) {
+        return this.connectToGPUMachine(
+          this.directConnection.livekitJwtToken,
+          this.directConnection.livekitWsUrl
+        );
+      }
+      this.setStatus("connecting");
+      try {
+        console.debug(
+          "[Reactor] Connecting to coordinator with authenticated URL"
+        );
+        this.coordinatorClient = new CoordinatorClient({
+          wsUrl: this.coordinatorUrl,
+          jwtToken: this.jwtToken,
+          insecureApiKey: this.insecureApiKey,
+          modelName: this.modelName,
+          modelVersion: this.modelVersion
+        });
+        this.coordinatorClient.on(
+          "gpu-machine-assigned",
+          (assignmentData) => __async(this, null, function* () {
+            console.debug(
+              "[Reactor] GPU machine assigned by coordinator:",
+              assignmentData
+            );
+            try {
+              yield this.connectToGPUMachine(
+                assignmentData.livekitJwtToken,
+                assignmentData.livekitWsUrl
+              );
+            } catch (error) {
+              console.error("[Reactor] Failed to connect to GPU machine:", error);
+              this.createError(
+                "GPU_CONNECTION_FAILED",
+                `Failed to connect to GPU machine: ${error}`,
+                "gpu",
+                true
+              );
+              this.disconnect();
+            }
+          })
+        );
+        this.coordinatorClient.on(
+          "waiting-info",
+          (waitingData) => {
+            console.debug("[Reactor] Waiting info update received:", waitingData);
+            this.setWaitingInfo(__spreadValues(__spreadValues({}, this.waitingInfo), waitingData));
+          }
+        );
+        this.coordinatorClient.on(
+          "statusChanged",
+          (newStatus) => {
+            switch (newStatus) {
+              case "connected":
+                this.setStatus("waiting");
+                this.setWaitingInfo({
+                  position: void 0,
+                  estimatedWaitTime: void 0,
+                  averageWaitTime: void 0
+                });
+                break;
+              case "disconnected":
+                this.disconnect();
+                break;
+              case "error":
+                this.createError(
+                  "COORDINATOR_CONNECTION_ERROR",
+                  "Coordinator connection failed",
+                  "coordinator",
+                  true
+                );
+                this.disconnect();
+                break;
+            }
+          }
+        );
+        yield this.coordinatorClient.connect();
+      } catch (error) {
+        console.error("[Reactor] Authentication failed:", error);
+        this.createError(
+          "AUTHENTICATION_FAILED",
+          `Authentication failed: ${error}`,
+          "coordinator",
+          true
+        );
+        this.setStatus("disconnected");
+        throw error;
+      }
+    });
+  }
+  /**
+   * Disconnects from the coordinator and the gpu machine.
+   * Ensures cleanup completes even if individual disconnections fail.
+   */
+  disconnect() {
+    return __async(this, null, function* () {
+      if (this.status === "disconnected") return;
+      if (this.coordinatorClient) {
+        try {
+          this.coordinatorClient.disconnect();
+        } catch (error) {
+          console.error("[Reactor] Error disconnecting from coordinator:", error);
+        }
+        this.coordinatorClient = void 0;
+      }
+      if (this.machineClient) {
+        try {
+          yield this.machineClient.disconnect();
+        } catch (error) {
+          console.error("[Reactor] Error disconnecting from GPU machine:", error);
+        }
+        this.machineClient = void 0;
+      }
+      this.setStatus("disconnected");
+      this.waitingInfo = void 0;
+    });
+  }
+  setStatus(newStatus) {
+    console.debug("[Reactor] Setting status:", newStatus, "from", this.status);
+    if (this.status !== newStatus) {
+      this.status = newStatus;
+      this.emit("statusChanged", newStatus);
+    }
+  }
+  setWaitingInfo(newWaitingInfo) {
+    console.debug(
+      "[Reactor] Setting waiting info:",
+      newWaitingInfo,
+      "from",
+      this.waitingInfo
+    );
+    if (this.waitingInfo !== newWaitingInfo) {
+      this.waitingInfo = newWaitingInfo;
+      this.emit("waitingInfoChanged", newWaitingInfo);
+    }
+  }
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Get the current state including status, error, and waiting info
+   */
+  getState() {
+    return {
+      status: this.status,
+      waitingInfo: this.waitingInfo,
+      lastError: this.lastError
+    };
+  }
+  /**
+   * Get waiting information when status is 'waiting'
+   */
+  getWaitingInfo() {
+    return this.waitingInfo;
+  }
+  /**
+   * Get the last error that occurred
+   */
+  getLastError() {
+    return this.lastError;
+  }
+  /**
+   * Create and store an error
+   */
+  createError(code, message, component, recoverable, retryAfter) {
+    this.lastError = {
+      code,
+      message,
+      timestamp: Date.now(),
+      recoverable,
+      component,
+      retryAfter
+    };
+    this.emit("error", this.lastError);
+  }
+};
+
+// src/react/ReactorProvider.tsx
+var import_react3 = require("react");
+
+// src/core/store.ts
+var import_react = require("zustand/react");
+var import_react2 = require("react");
+var ReactorContext = (0, import_react2.createContext)(
+  void 0
+);
+var defaultInitState = {
+  status: "disconnected",
+  videoTrack: null,
+  fps: void 0,
+  waitingInfo: void 0,
+  lastError: void 0
+};
+var initReactorStore = (props) => {
+  return __spreadValues(__spreadValues({}, defaultInitState), props);
+};
+var createReactorStore = (initProps, publicState = defaultInitState) => {
+  console.debug("[ReactorStore] Creating store", {
+    coordinatorUrl: initProps.coordinatorUrl,
+    initialState: publicState
+  });
+  return (0, import_react.create)()((set, get) => {
+    const reactor = new Reactor(initProps);
+    console.debug("[ReactorStore] Setting up event listeners");
+    reactor.on("statusChanged", (newStatus) => {
+      console.debug("[ReactorStore] Status changed", {
+        oldStatus: get().status,
+        newStatus
+      });
+      set({ status: newStatus });
+    });
+    reactor.on("waitingInfoChanged", (newWaitingInfo) => {
+      console.debug("[ReactorStore] Waiting info changed", {
+        oldWaitingInfo: get().waitingInfo,
+        newWaitingInfo
+      });
+      set({ waitingInfo: newWaitingInfo });
+    });
+    reactor.on("streamChanged", (videoTrack) => {
+      console.debug("[ReactorStore] Stream changed", {
+        hasVideoTrack: !!videoTrack,
+        videoTrackKind: videoTrack == null ? void 0 : videoTrack.kind,
+        videoTrackSid: videoTrack == null ? void 0 : videoTrack.sid
+      });
+      set({ videoTrack });
+    });
+    reactor.on("fps", (fps) => {
+      console.debug("[ReactorStore] FPS updated", { fps });
+      set({ fps });
+    });
+    reactor.on("error", (error) => {
+      console.debug("[ReactorStore] Error occurred", error);
+      set({ lastError: error });
+    });
+    return __spreadProps(__spreadValues({}, publicState), {
+      internal: { reactor },
+      // actions
+      onMessage: (handler) => {
+        console.debug("[ReactorStore] Registering message handler");
+        get().internal.reactor.on("newMessage", handler);
+        return () => {
+          console.debug("[ReactorStore] Cleaning up message handler");
+          get().internal.reactor.off("newMessage", handler);
+        };
+      },
+      sendMessage: (mess) => {
+        console.debug("[ReactorStore] Sending message", { message: mess });
+        try {
+          get().internal.reactor.sendMessage(mess);
+          console.debug("[ReactorStore] Message sent successfully");
+        } catch (error) {
+          console.error("[ReactorStore] Failed to send message:", error);
+          throw error;
+        }
+      },
+      connect: () => __async(null, null, function* () {
+        console.debug("[ReactorStore] Connect called");
+        try {
+          yield get().internal.reactor.connect();
+          console.debug("[ReactorStore] Connect completed successfully");
+        } catch (error) {
+          console.error("[ReactorStore] Connect failed:", error);
+          throw error;
+        }
+      }),
+      disconnect: () => __async(null, null, function* () {
+        console.debug("[ReactorStore] Disconnect called", {
+          currentStatus: get().status
+        });
+        try {
+          yield get().internal.reactor.disconnect();
+          console.debug("[ReactorStore] Disconnect completed successfully");
+        } catch (error) {
+          console.error("[ReactorStore] Disconnect failed:", error);
+          throw error;
+        }
+      })
+    });
+  });
+};
+
+// src/react/ReactorProvider.tsx
+var import_zustand = require("zustand");
+var import_jsx_runtime = require("react/jsx-runtime");
+function ReactorProvider(_a) {
+  var _b = _a, {
+    children,
+    autoConnect = true
+  } = _b, props = __objRest(_b, [
+    "children",
+    "autoConnect"
+  ]);
+  const storeRef = (0, import_react3.useRef)(void 0);
+  const firstRender = (0, import_react3.useRef)(true);
+  function attemptAutoConnect() {
+    var _a2, _b2;
+    const status = (_a2 = storeRef.current) == null ? void 0 : _a2.getState().status;
+    if (autoConnect && status === "disconnected") {
+      console.debug("[ReactorProvider] Starting autoconnect...");
+      (_b2 = storeRef.current) == null ? void 0 : _b2.getState().connect().then(() => {
+        console.debug("[ReactorProvider] Autoconnect successful");
+      }).catch((error) => {
+        console.error("[ReactorProvider] Failed to autoconnect:", error);
+      });
+    }
+  }
+  if (storeRef.current === void 0) {
+    console.debug("[ReactorProvider] Creating new reactor store");
+    storeRef.current = createReactorStore(initReactorStore(props));
+    console.debug("[ReactorProvider] Reactor store created successfully");
+    attemptAutoConnect();
+  }
+  (0, import_react3.useEffect)(() => {
+    if (firstRender.current) {
+      firstRender.current = false;
+      return;
+    }
+    console.debug("[ReactorProvider] Updating reactor store");
+    storeRef.current = createReactorStore(initReactorStore(props));
+    console.debug("[ReactorProvider] Reactor store updated successfully");
+    attemptAutoConnect();
+  }, [props, autoConnect]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ReactorContext.Provider, { value: storeRef.current, children });
+}
+function useReactorStore(selector) {
+  const ctx = (0, import_react3.useContext)(ReactorContext);
+  if (!ctx) {
+    throw new Error("useReactor must be used within a ReactorProvider");
+  }
+  return (0, import_zustand.useStore)(ctx, selector);
+}
+
+// src/react/hooks.ts
+var import_shallow = require("zustand/shallow");
+var import_react4 = require("react");
+function useReactor(selector) {
+  return useReactorStore((0, import_shallow.useShallow)(selector));
+}
+function useReactorMessage(handler) {
+  const reactor = useReactor((state) => state.internal.reactor);
+  const handlerRef = (0, import_react4.useRef)(handler);
+  (0, import_react4.useEffect)(() => {
+    handlerRef.current = handler;
+  }, [handler]);
+  (0, import_react4.useEffect)(() => {
+    console.debug("[useReactorMessage] Setting up message subscription");
+    const stableHandler = (message) => {
+      console.debug("[useReactorMessage] Message received", { message });
+      handlerRef.current(message);
+    };
+    reactor.on("newMessage", stableHandler);
+    console.debug("[useReactorMessage] Message handler registered");
+    return () => {
+      console.debug("[useReactorMessage] Cleaning up message subscription");
+      reactor.off("newMessage", stableHandler);
+    };
+  }, [reactor]);
+}
+
+// src/react/ReactorView.tsx
+var import_react5 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function ReactorView({
+  width,
+  height,
+  className,
+  style
+}) {
+  const { videoTrack, status } = useReactor((state) => ({
+    videoTrack: state.videoTrack,
+    status: state.status
+  }));
+  const videoRef = (0, import_react5.useRef)(null);
+  console.debug("[ReactorView] Render", {
+    hasVideoTrack: !!videoTrack,
+    status,
+    hasVideoElement: !!videoRef.current
+  });
+  (0, import_react5.useEffect)(() => {
+    console.debug("[ReactorView] Video track effect triggered", {
+      hasVideoElement: !!videoRef.current,
+      hasVideoTrack: !!videoTrack,
+      videoTrackKind: videoTrack == null ? void 0 : videoTrack.kind
+    });
+    if (videoRef.current && videoTrack) {
+      console.debug("[ReactorView] Attaching video track to element");
+      try {
+        videoTrack.attach(videoRef.current);
+        console.debug("[ReactorView] Video track attached successfully");
+      } catch (error) {
+        console.error("[ReactorView] Failed to attach video track:", error);
+      }
+      return () => {
+        console.debug("[ReactorView] Detaching video track from element");
+        if (videoRef.current) {
+          try {
+            videoTrack.detach(videoRef.current);
+            console.debug("[ReactorView] Video track detached successfully");
+          } catch (error) {
+            console.error("[ReactorView] Failed to detach video track:", error);
+          }
+        }
+      };
+    } else {
+      console.debug("[ReactorView] No video track or element to attach");
+    }
+  }, [videoTrack]);
+  const showPlaceholder = !videoTrack;
+  console.debug("[ReactorView] Placeholder state", { showPlaceholder, status });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+    "div",
+    {
+      style: __spreadValues(__spreadValues(__spreadValues({
+        position: "relative",
+        background: "#000"
+      }, width && { width }), height && { height }), style),
+      className,
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "video",
+          {
+            ref: videoRef,
+            style: {
+              width: "100%",
+              height: "100%",
+              objectFit: "contain",
+              display: showPlaceholder ? "none" : "block"
+            },
+            muted: true,
+            playsInline: true
+          }
+        ),
+        showPlaceholder && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: "100%",
+              height: "100%",
+              color: "#fff",
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              fontSize: "16px",
+              fontFamily: "monospace",
+              textAlign: "center",
+              padding: "20px",
+              boxSizing: "border-box"
+            },
+            children: status
+          }
+        )
+      ]
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Reactor,
+  ReactorProvider,
+  ReactorView,
+  useReactor,
+  useReactorMessage,
+  useReactorStore
+});
+//# sourceMappingURL=index.js.map