@gradio/client 0.20.1 → 1.1.0

package/dist/index.js

@@ -4,6 +4,25 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _currentLine;
 var fn = new Intl.Collator(0, { numeric: 1 }).compare;
 function semiver(a, b, bool) {
   a = a.split(".");
@@ -28,6 +47,9 @@ const INVALID_URL_MSG = "Invalid URL. A full URL path is required.";
 const UNAUTHORIZED_MSG = "Not authorized to access this space. ";
 const INVALID_CREDENTIALS_MSG = "Invalid credentials. Could not login. ";
 const MISSING_CREDENTIALS_MSG = "Login credentials are required to access this space.";
+const NODEJS_FS_ERROR_MSG = "File system access is only available in Node.js environments";
+const ROOT_URL_ERROR_MSG = "Root URL not found in client config";
+const FILE_PROCESSING_ERROR_MSG = "Error uploading file";
 function resolve_root(base_url, root_path, prioritize_base) {
   if (root_path.startsWith("http://") || root_path.startsWith("https://")) {
     return prioritize_base ? base_url : root_path;
@@ -239,7 +261,7 @@ function transform_api_info(api_info, config, api_map) {
           const dependencyIndex = ((_a = config.dependencies.find(
             (dep) => dep.api_name === endpoint || dep.api_name === endpoint.replace("/", "")
           )) == null ? void 0 : _a.id) || api_map[endpoint.replace("/", "")] || -1;
-          const dependencyTypes = dependencyIndex !== -1 ? (_b = config.dependencies.find((dep) => dep.id == dependencyIndex)) == null ? void 0 : _b.types : { continuous: false, generator: false };
+          const dependencyTypes = dependencyIndex !== -1 ? (_b = config.dependencies.find((dep) => dep.id == dependencyIndex)) == null ? void 0 : _b.types : { continuous: false, generator: false, cancel: false };
           if (dependencyIndex !== -1 && ((_d = (_c = config.dependencies.find((dep) => dep.id == dependencyIndex)) == null ? void 0 : _c.inputs) == null ? void 0 : _d.length) !== parameters.length) {
             const components = config.dependencies.find((dep) => dep.id == dependencyIndex).inputs.map(
               (input) => {
@@ -532,7 +554,7 @@ async function upload_files(root_url, files, upload_id) {
       formData.append("files", file);
     });
     try {
-      const upload_url = upload_id ? `${root_url}/upload?upload_id=${upload_id}` : `${root_url}/${UPLOAD_URL}`;
+      const upload_url = upload_id ? `${root_url}/${UPLOAD_URL}?upload_id=${upload_id}` : `${root_url}/${UPLOAD_URL}`;
       response = await this.fetch(upload_url, {
         method: "POST",
         body: formData,
@@ -629,6 +651,18 @@ class FileData {
     this.alt_text = alt_text;
   }
 }
+class Command {
+  constructor(command, meta) {
+    __publicField(this, "type");
+    __publicField(this, "command");
+    __publicField(this, "meta");
+    __publicField(this, "fileData");
+    this.type = "command";
+    this.command = command;
+    this.meta = meta;
+  }
+}
+const is_node = typeof process !== "undefined" && process.versions && process.versions.node;
 function update_object(object, newValue, stack) {
   while (stack.length > 1) {
     const key2 = stack.shift();
@@ -665,11 +699,10 @@ async function walk_and_store_blobs(data, type = void 0, path = [], root = false
     );
     return blob_refs;
   } else if (globalThis.Buffer && data instanceof globalThis.Buffer || data instanceof Blob) {
-    const is_image = type === "Image";
     return [
       {
         path,
-        blob: is_image ? false : new NodeBlob([data]),
+        blob: new Blob([data]),
         type
       }
     ];
@@ -710,8 +743,80 @@ function post_message(message, origin) {
     window.parent.postMessage(message, origin, [channel.port2]);
   });
 }
+function handle_file(file_or_url) {
+  if (typeof file_or_url === "string") {
+    if (file_or_url.startsWith("http://") || file_or_url.startsWith("https://")) {
+      return {
+        path: file_or_url,
+        url: file_or_url,
+        orig_name: file_or_url.split("/").pop() ?? "unknown",
+        meta: { _type: "gradio.FileData" }
+      };
+    }
+    if (is_node) {
+      return new Command("upload_file", {
+        path: file_or_url,
+        name: file_or_url,
+        orig_path: file_or_url
+      });
+    }
+  } else if (typeof File !== "undefined" && file_or_url instanceof File) {
+    return {
+      path: file_or_url instanceof File ? file_or_url.name : "blob",
+      orig_name: file_or_url instanceof File ? file_or_url.name : "unknown",
+      // @ts-ignore
+      blob: file_or_url instanceof File ? file_or_url : new Blob([file_or_url]),
+      size: file_or_url instanceof Blob ? file_or_url.size : Buffer.byteLength(file_or_url),
+      mime_type: file_or_url instanceof File ? file_or_url.type : "application/octet-stream",
+      // Default MIME type for buffers
+      meta: { _type: "gradio.FileData" }
+    };
+  } else if (file_or_url instanceof Buffer) {
+    return new Blob([file_or_url]);
+  } else if (file_or_url instanceof Blob) {
+    return file_or_url;
+  }
+  throw new Error(
+    "Invalid input: must be a URL, File, Blob, or Buffer object."
+  );
+}
+function handle_payload(resolved_payload, dependency, components, type, with_null_state = false) {
+  if (type === "input" && !with_null_state) {
+    throw new Error("Invalid code path. Cannot skip state inputs for input.");
+  }
+  if (type === "output" && with_null_state) {
+    return resolved_payload;
+  }
+  let updated_payload = [];
+  let payload_index = 0;
+  for (let i = 0; i < dependency.inputs.length; i++) {
+    const input_id = dependency.inputs[i];
+    const component = components.find((c) => c.id === input_id);
+    if ((component == null ? void 0 : component.type) === "state") {
+      if (with_null_state) {
+        if (resolved_payload.length === dependency.inputs.length) {
+          const value = resolved_payload[payload_index];
+          updated_payload.push(value);
+          payload_index++;
+        } else {
+          updated_payload.push(null);
+        }
+      } else {
+        payload_index++;
+        continue;
+      }
+      continue;
+    } else {
+      const value = resolved_payload[payload_index];
+      updated_payload.push(value);
+      payload_index++;
+    }
+  }
+  return updated_payload;
+}
 async function handle_blob(endpoint, data, api_info) {
   const self = this;
+  await process_local_file_commands(self, data);
   const blobRefs = await walk_and_store_blobs(
     data,
     void 0,
@@ -743,6 +848,55 @@ async function handle_blob(endpoint, data, api_info) {
   });
   return data;
 }
+async function process_local_file_commands(client2, data) {
+  var _a, _b;
+  const root = ((_a = client2.config) == null ? void 0 : _a.root) || ((_b = client2.config) == null ? void 0 : _b.root_url);
+  if (!root) {
+    throw new Error(ROOT_URL_ERROR_MSG);
+  }
+  await recursively_process_commands(client2, data);
+}
+async function recursively_process_commands(client2, data, path = []) {
+  for (const key in data) {
+    if (data[key] instanceof Command) {
+      await process_single_command(client2, data, key);
+    } else if (typeof data[key] === "object" && data[key] !== null) {
+      await recursively_process_commands(client2, data[key], [...path, key]);
+    }
+  }
+}
+async function process_single_command(client2, data, key) {
+  var _a, _b;
+  let cmd_item = data[key];
+  const root = ((_a = client2.config) == null ? void 0 : _a.root) || ((_b = client2.config) == null ? void 0 : _b.root_url);
+  if (!root) {
+    throw new Error(ROOT_URL_ERROR_MSG);
+  }
+  try {
+    let fileBuffer;
+    let fullPath;
+    if (typeof process !== "undefined" && process.versions && process.versions.node) {
+      const fs = await import("fs/promises");
+      const path = await import("path");
+      fullPath = path.resolve(process.cwd(), cmd_item.meta.path);
+      fileBuffer = await fs.readFile(fullPath);
+    } else {
+      throw new Error(NODEJS_FS_ERROR_MSG);
+    }
+    const file = new Blob([fileBuffer], { type: "application/octet-stream" });
+    const response = await client2.upload_files(root, [file]);
+    const file_url = response.files && response.files[0];
+    if (file_url) {
+      const fileData = new FileData({
+        path: file_url,
+        orig_name: cmd_item.meta.name || ""
+      });
+      data[key] = fileData;
+    }
+  } catch (error) {
+    console.error(FILE_PROCESSING_ERROR_MSG, error);
+  }
+}
 async function post_data(url, body, additional_headers) {
   const headers = { "Content-Type": "application/json" };
   if (this.options.hf_token) {
@@ -790,26 +944,27 @@ async function predict(endpoint, data) {
     );
   }
   return new Promise(async (resolve, reject) => {
-    const app = this.submit(endpoint, data);
+    const app = this.submit(endpoint, data, null, null, true);
     let result;
-    app.on("data", (d) => {
-      if (status_complete) {
-        app.destroy();
-        resolve(d);
-      }
-      data_returned = true;
-      result = d;
-    }).on("status", (status) => {
-      if (status.stage === "error")
-        reject(status);
-      if (status.stage === "complete") {
-        status_complete = true;
-        if (data_returned) {
-          app.destroy();
+    for await (const message of app) {
+      if (message.type === "data") {
+        if (status_complete) {
           resolve(result);
         }
+        data_returned = true;
+        result = message;
       }
-    });
+      if (message.type === "status") {
+        if (message.stage === "error")
+          reject(message);
+        if (message.stage === "complete") {
+          status_complete = true;
+          if (data_returned) {
+            resolve(result);
+          }
+        }
+      }
+    }
   });
 }
 async function check_space_status(id, type, status_callback) {
@@ -901,7 +1056,7 @@ async function discussions_enabled(space_id) {
       }
     );
     const error = r.headers.get("x-error-message");
-    if (error && RE_DISABLED_DISCUSSION.test(error))
+    if (!r.ok || error && RE_DISABLED_DISCUSSION.test(error))
       return false;
     return true;
   } catch (e) {
@@ -1053,6 +1208,106 @@ function get_space_reference(url) {
     return match[1];
   }
 }
+class TextLineStream extends TransformStream {
+  /** Constructs a new instance. */
+  constructor(options = { allowCR: false }) {
+    super({
+      transform: (chars, controller) => {
+        chars = __privateGet(this, _currentLine) + chars;
+        while (true) {
+          const lfIndex = chars.indexOf("\n");
+          const crIndex = options.allowCR ? chars.indexOf("\r") : -1;
+          if (crIndex !== -1 && crIndex !== chars.length - 1 && (lfIndex === -1 || lfIndex - 1 > crIndex)) {
+            controller.enqueue(chars.slice(0, crIndex));
+            chars = chars.slice(crIndex + 1);
+            continue;
+          }
+          if (lfIndex === -1)
+            break;
+          const endIndex = chars[lfIndex - 1] === "\r" ? lfIndex - 1 : lfIndex;
+          controller.enqueue(chars.slice(0, endIndex));
+          chars = chars.slice(lfIndex + 1);
+        }
+        __privateSet(this, _currentLine, chars);
+      },
+      flush: (controller) => {
+        if (__privateGet(this, _currentLine) === "")
+          return;
+        const currentLine = options.allowCR && __privateGet(this, _currentLine).endsWith("\r") ? __privateGet(this, _currentLine).slice(0, -1) : __privateGet(this, _currentLine);
+        controller.enqueue(currentLine);
+      }
+    });
+    __privateAdd(this, _currentLine, "");
+  }
+}
+_currentLine = new WeakMap();
+function stream$1(input) {
+  let decoder = new TextDecoderStream();
+  let split2 = new TextLineStream({ allowCR: true });
+  return input.pipeThrough(decoder).pipeThrough(split2);
+}
+function split(input) {
+  let rgx = /[:]\s*/;
+  let match = rgx.exec(input);
+  let idx = match && match.index;
+  if (idx) {
+    return [
+      input.substring(0, idx),
+      input.substring(idx + match[0].length)
+    ];
+  }
+}
+function fallback(headers, key, value) {
+  let tmp = headers.get(key);
+  if (!tmp)
+    headers.set(key, value);
+}
+async function* events(res, signal) {
+  if (!res.body)
+    return;
+  let iter = stream$1(res.body);
+  let line, reader = iter.getReader();
+  let event;
+  for (; ; ) {
+    if (signal && signal.aborted) {
+      return reader.cancel();
+    }
+    line = await reader.read();
+    if (line.done)
+      return;
+    if (!line.value) {
+      if (event)
+        yield event;
+      event = void 0;
+      continue;
+    }
+    let [field, value] = split(line.value) || [];
+    if (!field)
+      continue;
+    if (field === "data") {
+      event || (event = {});
+      event[field] = event[field] ? event[field] + "\n" + value : value;
+    } else if (field === "event") {
+      event || (event = {});
+      event[field] = value;
+    } else if (field === "id") {
+      event || (event = {});
+      event[field] = +value || value;
+    } else if (field === "retry") {
+      event || (event = {});
+      event[field] = +value || void 0;
+    }
+  }
+}
+async function stream(input, init) {
+  let req = new Request(input, init);
+  fallback(req.headers, "Accept", "text/event-stream");
+  fallback(req.headers, "Content-Type", "application/json");
+  let r = await fetch(req);
+  if (!r.ok)
+    throw r;
+  return events(r, req.signal);
+}
 async function open_stream() {
   let {
     event_callbacks,
@@ -1062,11 +1317,12 @@ async function open_stream() {
     config,
     jwt
   } = this;
+  const that = this;
   if (!config) {
     throw new Error("Could not resolve app config");
   }
   stream_status.open = true;
-  let stream = null;
+  let stream2 = null;
   let params = new URLSearchParams({
     session_hash: this.session_hash
   }).toString();
@@ -1074,15 +1330,15 @@ async function open_stream() {
   if (jwt) {
     url.searchParams.set("__sign", jwt);
   }
-  stream = await this.stream(url);
-  if (!stream) {
+  stream2 = this.stream(url);
+  if (!stream2) {
     console.warn("Cannot connect to SSE endpoint: " + url.toString());
     return;
   }
-  stream.onmessage = async function(event) {
+  stream2.onmessage = async function(event) {
     let _data = JSON.parse(event.data);
     if (_data.msg === "close_stream") {
-      close_stream(stream_status, stream);
+      close_stream(stream_status, that.abort_controller);
       return;
     }
     const event_id = _data.event_id;
@@ -1093,17 +1349,16 @@ async function open_stream() {
         )
       );
     } else if (event_callbacks[event_id] && config) {
-      if (_data.msg === "process_completed" && ["sse", "sse_v1", "sse_v2", "sse_v2.1"].includes(config.protocol)) {
+      if (_data.msg === "process_completed" && ["sse", "sse_v1", "sse_v2", "sse_v2.1", "sse_v3"].includes(
+        config.protocol
+      )) {
         unclosed_events.delete(event_id);
-        if (unclosed_events.size === 0) {
-          close_stream(stream_status, stream);
-        }
       }
       let fn2 = event_callbacks[event_id];
-      if (typeof window !== "undefined") {
-        window.setTimeout(fn2, 0, _data);
+      if (typeof window !== "undefined" && typeof document !== "undefined") {
+        setTimeout(fn2, 0, _data);
       } else {
-        setImmediate(fn2, _data);
+        fn2(_data);
       }
     } else {
       if (!pending_stream_messages[event_id]) {
@@ -1112,7 +1367,7 @@ async function open_stream() {
       pending_stream_messages[event_id].push(_data);
     }
   };
-  stream.onerror = async function() {
+  stream2.onerror = async function() {
     await Promise.all(
       Object.keys(event_callbacks).map(
         (event_id) => event_callbacks[event_id]({
@@ -1121,13 +1376,12 @@ async function open_stream() {
         })
       )
     );
-    close_stream(stream_status, stream);
   };
 }
-function close_stream(stream_status, stream) {
-  if (stream_status && stream) {
+function close_stream(stream_status, abort_controller) {
+  if (stream_status) {
     stream_status.open = false;
-    stream == null ? void 0 : stream.close();
+    abort_controller == null ? void 0 : abort_controller.abort();
   }
 }
 function apply_diff_stream(pending_diff_streams, event_id, data) {
@@ -1191,31 +1445,81 @@ function apply_edit(target, path, action, value) {
   }
   return target;
 }
-function submit(endpoint, data, event_data, trigger_id) {
+function readable_stream(input, init = {}) {
+  const instance = {
+    close: () => {
+      throw new Error("Method not implemented.");
+    },
+    onerror: null,
+    onmessage: null,
+    onopen: null,
+    readyState: 0,
+    url: input.toString(),
+    withCredentials: false,
+    CONNECTING: 0,
+    OPEN: 1,
+    CLOSED: 2,
+    addEventListener: () => {
+      throw new Error("Method not implemented.");
+    },
+    dispatchEvent: () => {
+      throw new Error("Method not implemented.");
+    },
+    removeEventListener: () => {
+      throw new Error("Method not implemented.");
+    }
+  };
+  stream(input, init).then(async (res) => {
+    instance.readyState = instance.OPEN;
+    try {
+      for await (const chunk of res) {
+        instance.onmessage && instance.onmessage(chunk);
+      }
+      instance.readyState = instance.CLOSED;
+    } catch (e) {
+      instance.onerror && instance.onerror(e);
+      instance.readyState = instance.CLOSED;
+    }
+  }).catch((e) => {
+    console.error(e);
+    instance.onerror && instance.onerror(e);
+    instance.readyState = instance.CLOSED;
+  });
+  return instance;
+}
+function submit(endpoint, data, event_data, trigger_id, all_events) {
+  var _a;
   try {
     let fire_event = function(event) {
-      const narrowed_listener_map = listener_map;
-      const listeners = narrowed_listener_map[event.type] || [];
-      listeners == null ? void 0 : listeners.forEach((l) => l(event));
-    }, on = function(eventType, listener) {
-      const narrowed_listener_map = listener_map;
-      const listeners = narrowed_listener_map[eventType] || [];
-      narrowed_listener_map[eventType] = listeners;
-      listeners == null ? void 0 : listeners.push(listener);
-      return { on, off, cancel, destroy };
-    }, off = function(eventType, listener) {
-      const narrowed_listener_map = listener_map;
-      let listeners = narrowed_listener_map[eventType] || [];
-      listeners = listeners == null ? void 0 : listeners.filter((l) => l !== listener);
-      narrowed_listener_map[eventType] = listeners;
-      return { on, off, cancel, destroy };
-    }, destroy = function() {
-      var _a;
-      for (const event_type in listener_map) {
-        listener_map && ((_a = listener_map[event_type]) == null ? void 0 : _a.forEach((fn2) => {
-          off(event_type, fn2);
-        }));
+      if (all_events || events_to_publish[event.type]) {
+        push_event(event);
+      }
+    }, close = function() {
+      done = true;
+      while (resolvers.length > 0)
+        resolvers.shift()({
+          value: void 0,
+          done: true
+        });
+    }, push = function(data2) {
+      if (done)
+        return;
+      if (resolvers.length > 0) {
+        resolvers.shift()(data2);
+      } else {
+        values.push(data2);
       }
+    }, push_error = function(error) {
+      push(thenable_reject(error));
+      close();
+    }, push_event = function(event) {
+      push({ value: event, done: false });
+    }, next = function() {
+      if (values.length > 0)
+        return Promise.resolve(values.shift());
+      if (done)
+        return Promise.resolve({ value: void 0, done: true });
+      return new Promise((resolve) => resolvers.push(resolve));
     };
     const { hf_token } = this.options;
     const {
@@ -1230,8 +1534,10 @@ function submit(endpoint, data, event_data, trigger_id) {
       pending_diff_streams,
       event_callbacks,
       unclosed_events,
-      post_data: post_data2
+      post_data: post_data2,
+      options
     } = this;
+    const that = this;
     if (!api_info)
       throw new Error("No API found");
     if (!config)
@@ -1244,15 +1550,21 @@ function submit(endpoint, data, event_data, trigger_id) {
     );
     let resolved_data = map_data_to_params(data, api_info);
     let websocket;
-    let stream;
+    let stream2;
     let protocol = config.protocol ?? "ws";
     const _endpoint = typeof endpoint === "number" ? "/predict" : endpoint;
     let payload;
     let event_id = null;
     let complete = false;
-    const listener_map = {};
     let last_status = {};
-    let url_params = typeof window !== "undefined" ? new URLSearchParams(window.location.search).toString() : "";
+    let url_params = typeof window !== "undefined" && typeof document !== "undefined" ? new URLSearchParams(window.location.search).toString() : "";
+    const events_to_publish = ((_a = options == null ? void 0 : options.events) == null ? void 0 : _a.reduce(
+      (acc, event) => {
+        acc[event] = true;
+        return acc;
+      },
+      {}
+    )) || {};
     async function cancel() {
       const _status = {
         stage: "complete",
@@ -1266,6 +1578,7 @@ function submit(endpoint, data, event_data, trigger_id) {
         endpoint: _endpoint,
         fn_index
       });
+      let reset_request = {};
       let cancel_request = {};
       if (protocol === "ws") {
         if (websocket && websocket.readyState === 0) {
@@ -1275,19 +1588,28 @@ function submit(endpoint, data, event_data, trigger_id) {
         } else {
           websocket.close();
         }
-        cancel_request = { fn_index, session_hash };
+        reset_request = { fn_index, session_hash };
       } else {
-        stream == null ? void 0 : stream.close();
-        cancel_request = { event_id };
+        close_stream(stream_status, that.abort_controller);
+        close();
+        reset_request = { event_id };
+        cancel_request = { event_id, session_hash, fn_index };
       }
       try {
         if (!config) {
           throw new Error("Could not resolve app config");
         }
+        if ("event_id" in cancel_request) {
+          await fetch2(`${config.root}/cancel`, {
+            headers: { "Content-Type": "application/json" },
+            method: "POST",
+            body: JSON.stringify(cancel_request)
+          });
+        }
         await fetch2(`${config.root}/reset`, {
           headers: { "Content-Type": "application/json" },
           method: "POST",
-          body: JSON.stringify(cancel_request)
+          body: JSON.stringify(reset_request)
         });
       } catch (e) {
         console.warn(
@@ -1325,9 +1647,16 @@ function submit(endpoint, data, event_data, trigger_id) {
     }
     this.handle_blob(config.root, resolved_data, endpoint_info).then(
       async (_payload) => {
-        var _a;
+        var _a2;
+        let input_data = handle_payload(
+          _payload,
+          dependency,
+          config.components,
+          "input",
+          true
+        );
         payload = {
-          data: _payload || [],
+          data: input_data || [],
           event_data,
           fn_index,
           trigger_id
@@ -1354,7 +1683,13 @@ function submit(endpoint, data, event_data, trigger_id) {
                 type: "data",
                 endpoint: _endpoint,
                 fn_index,
-                data: data2,
+                data: handle_payload(
+                  data2,
+                  dependency,
+                  config.components,
+                  "output",
+                  options.with_null_state
+                ),
                 time: /* @__PURE__ */ new Date(),
                 event_data,
                 trigger_id
@@ -1478,7 +1813,13 @@ function submit(endpoint, data, event_data, trigger_id) {
               fire_event({
                 type: "data",
                 time: /* @__PURE__ */ new Date(),
-                data: data2.data,
+                data: handle_payload(
+                  data2.data,
+                  dependency,
+                  config.components,
+                  "output",
+                  options.with_null_state
+                ),
                 endpoint: _endpoint,
                 fn_index,
                 event_data,
@@ -1523,13 +1864,13 @@ function submit(endpoint, data, event_data, trigger_id) {
           if (this.jwt) {
             url.searchParams.set("__sign", this.jwt);
           }
-          stream = await this.stream(url);
-          if (!stream) {
+          stream2 = this.stream(url);
+          if (!stream2) {
             return Promise.reject(
               new Error("Cannot connect to SSE endpoint: " + url.toString())
             );
           }
-          stream.onmessage = async function(event) {
+          stream2.onmessage = async function(event) {
             const _data = JSON.parse(event.data);
             const { type, status, data: data2 } = handle_message(
               _data,
@@ -1544,7 +1885,8 @@ function submit(endpoint, data, event_data, trigger_id) {
                 ...status
               });
               if (status.stage === "error") {
-                stream == null ? void 0 : stream.close();
+                stream2 == null ? void 0 : stream2.close();
+                close();
               }
             } else if (type === "data") {
               event_id = _data.event_id;
@@ -1563,7 +1905,8 @@ function submit(endpoint, data, event_data, trigger_id) {
                   fn_index,
                   time: /* @__PURE__ */ new Date()
                 });
-                stream == null ? void 0 : stream.close();
+                stream2 == null ? void 0 : stream2.close();
+                close();
               }
             } else if (type === "complete") {
               complete = status;
@@ -1590,7 +1933,13 @@ function submit(endpoint, data, event_data, trigger_id) {
               fire_event({
                 type: "data",
                 time: /* @__PURE__ */ new Date(),
-                data: data2.data,
+                data: handle_payload(
+                  data2.data,
+                  dependency,
+                  config.components,
+                  "output",
+                  options.with_null_state
+                ),
                 endpoint: _endpoint,
                 fn_index,
                 event_data,
@@ -1606,7 +1955,8 @@ function submit(endpoint, data, event_data, trigger_id) {
                   endpoint: _endpoint,
                   fn_index
                 });
-                stream == null ? void 0 : stream.close();
+                stream2 == null ? void 0 : stream2.close();
+                close();
               }
             }
           };
@@ -1620,12 +1970,12 @@ function submit(endpoint, data, event_data, trigger_id) {
             time: /* @__PURE__ */ new Date()
           });
           let hostname = "";
-          if (typeof window !== "undefined") {
-            hostname = (_a = window == null ? void 0 : window.location) == null ? void 0 : _a.hostname;
+          if (typeof window !== "undefined" && typeof document !== "undefined") {
+            hostname = (_a2 = window == null ? void 0 : window.location) == null ? void 0 : _a2.hostname;
           }
           let hfhubdev = "dev.spaces.huggingface.tech";
           const origin = hostname.includes(".dev.") ? `https://moon-${hostname.split(".")[1]}.${hfhubdev}` : `https://huggingface.co`;
-          const is_iframe = typeof window !== "undefined" && window.parent != window;
+          const is_iframe = typeof window !== "undefined" && typeof document !== "undefined" && window.parent != window;
           const is_zerogpu_space = dependency.zerogpu && config.space_id;
           const zerogpu_auth_promise = is_iframe && is_zerogpu_space ? post_message("zerogpu-headers", origin) : Promise.resolve(null);
           const post_data_promise = zerogpu_auth_promise.then((headers) => {
@@ -1718,7 +2068,13 @@ function submit(endpoint, data, event_data, trigger_id) {
                     fire_event({
                       type: "data",
                       time: /* @__PURE__ */ new Date(),
-                      data: data2.data,
+                      data: handle_payload(
+                        data2.data,
+                        dependency,
+                        config.components,
+                        "output",
+                        options.with_null_state
+                      ),
                       endpoint: _endpoint,
                       fn_index
                     });
@@ -1756,9 +2112,10 @@ function submit(endpoint, data, event_data, trigger_id) {
                     fn_index,
                     time: /* @__PURE__ */ new Date()
                   });
-                  if (["sse_v2", "sse_v2.1"].includes(protocol)) {
-                    close_stream(stream_status, stream);
+                  if (["sse_v2", "sse_v2.1", "sse_v3"].includes(protocol)) {
+                    close_stream(stream_status, that.abort_controller);
                     stream_status.open = false;
+                    close();
                   }
                 }
               };
@@ -1778,12 +2135,33 @@ function submit(endpoint, data, event_data, trigger_id) {
         }
       }
     );
-    return { on, off, cancel, destroy };
+    let done = false;
+    const values = [];
+    const resolvers = [];
+    const iterator = {
+      [Symbol.asyncIterator]: () => iterator,
+      next,
+      throw: async (value) => {
+        push_error(value);
+        return next();
+      },
+      return: async () => {
+        close();
+        return next();
+      },
+      cancel
+    };
+    return iterator;
   } catch (error) {
     console.error("Submit function encountered an error:", error);
     throw error;
   }
 }
+function thenable_reject(error) {
+  return {
+    then: (resolve, reject) => reject(error)
+  };
+}
 function get_endpoint_info(api_info, endpoint, api_map, config) {
   let fn_index;
   let endpoint_info;
@@ -1807,13 +2185,8 @@ function get_endpoint_info(api_info, endpoint, api_map, config) {
   }
   return { fn_index, endpoint_info, dependency };
 }
-class NodeBlob extends Blob {
-  constructor(blobParts, options) {
-    super(blobParts, options);
-  }
-}
 class Client {
-  constructor(app_reference, options = {}) {
+  constructor(app_reference, options = { events: ["data"] }) {
     __publicField(this, "app_reference");
     __publicField(this, "options");
     __publicField(this, "config");
@@ -1830,6 +2203,8 @@ class Client {
     __publicField(this, "event_callbacks", {});
     __publicField(this, "unclosed_events", /* @__PURE__ */ new Set());
     __publicField(this, "heartbeat_event", null);
+    __publicField(this, "abort_controller", null);
+    __publicField(this, "stream_instance", null);
     __publicField(this, "view_api");
     __publicField(this, "upload_files");
     __publicField(this, "upload");
@@ -1841,6 +2216,9 @@ class Client {
     __publicField(this, "resolve_config");
     __publicField(this, "resolve_cookies");
     this.app_reference = app_reference;
+    if (!options.events) {
+      options.events = ["data"];
+    }
     this.options = options;
     this.view_api = view_api.bind(this);
     this.upload_files = upload_files.bind(this);
@@ -1860,24 +2238,17 @@ class Client {
     }
     return fetch(input, { ...init, headers });
   }
-  async stream(url) {
-    if (typeof window === "undefined" || typeof EventSource === "undefined") {
-      try {
-        const EventSourceModule = await import("eventsource");
-        return new EventSourceModule.default(url.toString());
-      } catch (error) {
-        console.error("Failed to load EventSource module:", error);
-        throw error;
-      }
-    } else {
-      return new EventSource(url.toString());
-    }
+  stream(url) {
+    this.abort_controller = new AbortController();
+    this.stream_instance = readable_stream(url.toString(), {
+      signal: this.abort_controller.signal
+    });
+    return this.stream_instance;
   }
   async init() {
     var _a;
     if ((typeof window === "undefined" || !("WebSocket" in window)) && !global.WebSocket) {
       const ws = await import("./wrapper-CviSselG.js");
-      NodeBlob = (await import("node:buffer")).Blob;
       global.WebSocket = ws.WebSocket;
     }
     try {
@@ -1894,7 +2265,6 @@ class Client {
     this.api_map = map_names_to_ids(((_a = this.config) == null ? void 0 : _a.dependencies) || []);
   }
   async _resolve_hearbeat(_config) {
-    var _a;
     if (_config) {
       this.config = _config;
       if (this.config && this.config.connect_heartbeat) {
@@ -1917,13 +2287,14 @@ class Client {
       if (this.jwt) {
         heartbeat_url.searchParams.set("__sign", this.jwt);
       }
-      if (!this.heartbeat_event)
-        this.heartbeat_event = await this.stream(heartbeat_url);
-    } else {
-      (_a = this.heartbeat_event) == null ? void 0 : _a.close();
+      if (!this.heartbeat_event) {
+        this.heartbeat_event = this.stream(heartbeat_url);
+      }
     }
   }
-  static async connect(app_reference, options = {}) {
+  static async connect(app_reference, options = {
+    events: ["data"]
+  }) {
     const client2 = new this(app_reference, options);
     await client2.init();
     return client2;
@@ -1932,7 +2303,9 @@ class Client {
     var _a;
     (_a = this.heartbeat_event) == null ? void 0 : _a.close();
   }
-  static async duplicate(app_reference, options = {}) {
+  static async duplicate(app_reference, options = {
+    events: ["data"]
+  }) {
     return duplicate(app_reference, options);
   }
   async _resolve_config() {
@@ -1969,7 +2342,7 @@ class Client {
   }
   async config_success(_config) {
     this.config = _config;
-    if (typeof window !== "undefined") {
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
       if (window.location.protocol === "https:") {
         this.config.root = this.config.root.replace("http://", "https://");
       }
@@ -2086,7 +2459,9 @@ class Client {
     };
   }
 }
-async function client(app_reference, options = {}) {
+async function client(app_reference, options = {
+  events: ["data"]
+}) {
   return await Client.connect(app_reference, options);
 }
 async function duplicate_space(app_reference, options) {
@@ -2097,6 +2472,7 @@ export {
   FileData,
   client,
   duplicate_space as duplicate,
+  handle_file,
   predict,
   prepare_files,
   submit,