@eyepop.ai/eyepop 1.13.2 → 1.14.0

package/dist/eyepop.index.js

@@ -8668,6 +8668,7 @@ __export(index_exports, {
   EndpointState: () => EndpointState,
   ExportedBy: () => ExportedBy,
   EyePop: () => EyePop,
+  EyepopLineDecoder: () => EyepopLineDecoder,
   ForwardOperatorType: () => ForwardOperatorType,
   InferenceType: () => InferenceType,
   LoadFromJob: () => LoadFromJob,
@@ -8991,7 +8992,7 @@ var AbstractJob = class {
               reject(`upload error ${response.status}: ${await response.text()}`);
               break;
             } else if (!response.body) {
-              reject(`response body is empty`);
+              reject("response body is empty");
               break;
             } else {
               resolve(response.body);
@@ -9025,10 +9026,11 @@ var UploadJob = class extends AbstractJob {
   get [Symbol.toStringTag]() {
     return "uploadJob";
   }
-  constructor(stream, mimeType, videoMode, params, getSession, client, requestLogger) {
+  constructor(stream, mimeType, size, videoMode, params, getSession, client, requestLogger) {
     super(params, getSession, client, requestLogger);
     this._uploadStream = stream;
     this._mimeType = mimeType;
+    this._size = size;
     this._videoMode = videoMode;
     this._needsFullDuplex = !client.isFullDuplex() && mimeType.startsWith("video/") && videoMode == "stream" /* STREAM */;
   }
@@ -9045,7 +9047,7 @@ var UploadJob = class extends AbstractJob {
       const videoModeQuery = this._videoMode ? `&videoMode=${this._videoMode}` : "";
       const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=async&sourceId=${event.source_id}${videoModeQuery}`;
       if (this._params) {
-        this._requestLogger.debug("before POST %s with multipart body because of params", postUrl);
+        this._requestLogger.debug(`before POST ${postUrl} with multipart body because of params`);
         const params = JSON.stringify(this._params);
         const paramBlob = new Blob([params], { type: "application/json" });
         const formData = new FormData();
@@ -9065,12 +9067,15 @@ var UploadJob = class extends AbstractJob {
           duplex: "half"
         });
       } else {
-        this._requestLogger.debug("before POST %s with stream as body", postUrl);
+        this._requestLogger.debug(`before POST ${postUrl} with stream as body`);
         const headers = {
           ...session.authenticationHeaders(),
           Accept: "application/jsonl",
           "Content-Type": this._mimeType
         };
+        if (this._size) {
+          headers["Content-Length"] = `${this._size}`;
+        }
         request = this._client.fetch(postUrl, {
           headers,
           method: "POST",
@@ -9082,12 +9087,12 @@ var UploadJob = class extends AbstractJob {
       }
       request.then(async (value) => {
         if (value.status != 204) {
-          this._requestLogger.debug("unexpected status %d (%s) for POST %s ", value.status, await value.text(), postUrl);
+          this._requestLogger.debug(`unexpected status ${value.status} (${await value.text()}) for POST ${postUrl}`);
         }
       }).catch((reason) => {
-        this._requestLogger.debug("error %v for POST %s ", reason, postUrl);
+        this._requestLogger.debug(`error ${reason} for POST ${postUrl}`);
       }).finally(() => {
-        this._requestLogger.debug("after POST %s ", postUrl);
+        this._requestLogger.debug(`after POST ${postUrl}`);
       });
     }
     return Promise.resolve();
@@ -9095,7 +9100,7 @@ var UploadJob = class extends AbstractJob {
   async startJob() {
     const session = await this._getSession();
     if (!session.baseUrl) {
-      return Promise.reject("session.baseUrl must not ne null");
+      return Promise.reject("session.baseUrl must not be null");
     }
     let response;
     if (this._needsFullDuplex) {
@@ -9104,7 +9109,7 @@ var UploadJob = class extends AbstractJob {
         ...session.authenticationHeaders(),
         Accept: "application/jsonl"
       };
-      this._requestLogger.debug("before POST {} to prepare full duplex upload", prepareUrl);
+      this._requestLogger.debug(`before POST ${prepareUrl} to prepare full duplex upload`);
       response = await this._client.fetch(prepareUrl, {
         headers,
         method: "POST",
@@ -9112,12 +9117,12 @@ var UploadJob = class extends AbstractJob {
         // @ts-ignore
         duplex: "half"
       });
-      this._requestLogger.debug("after POST {} to prepare full duplex upload {} {}", prepareUrl, response.status, response.statusText);
+      this._requestLogger.debug(`after POST ${prepareUrl} to prepare full duplex upload ${response.status} ${response.statusText}`);
     } else {
       const videoModeQuery = this._videoMode ? `&videoMode=${this._videoMode}` : "";
       const postUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync${videoModeQuery}`;
       if (this._params) {
-        this._requestLogger.debug("before POST {} with multipart body because of params", postUrl);
+        this._requestLogger.debug(`before POST ${postUrl} with multipart body because of params`);
         const params = JSON.stringify(this._params);
         const paramBlob = new Blob([params], { type: "application/json" });
         const formData = new FormData();
@@ -9136,14 +9141,17 @@ var UploadJob = class extends AbstractJob {
           // @ts-ignore
           duplex: "half"
         });
-        this._requestLogger.debug("after POST %s with multipart body because of params", postUrl);
+        this._requestLogger.debug(`after POST ${postUrl} with multipart body because of params)`);
       } else {
-        this._requestLogger.debug("before POST %s with stream as body", postUrl);
+        this._requestLogger.debug(`before POST ${postUrl} with stream as body`);
         const headers = {
           ...session.authenticationHeaders(),
           Accept: "application/jsonl",
           "Content-Type": this._mimeType
         };
+        if (this._size) {
+          headers["Content-Length"] = `${this._size}`;
+        }
         response = await this._client.fetch(postUrl, {
           headers,
           method: "POST",
@@ -9152,7 +9160,7 @@ var UploadJob = class extends AbstractJob {
           // @ts-ignore
           duplex: "half"
         });
-        this._requestLogger.debug("after POST %s with stream as body", postUrl);
+        this._requestLogger.debug(`after POST ${postUrl} with stream as body`);
       }
     }
     return response;
@@ -9654,17 +9662,85 @@ var WebrtcWhep = class extends WebrtcBase {
 // shims/local_file.ts
 var resolvePath;
 if ("document" in globalThis && "implementation" in globalThis.document) {
-  resolvePath = async (source) => {
+  resolvePath = async (source, logger) => {
     throw new DOMException("resolving a path to a file is not supported in browser");
   };
 } else if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-  resolvePath = async (source) => {
-    const response = await fetch(`file://${source.path}`);
-    const blob = await response.blob();
-    return {
-      stream: blob,
-      mimeType: source.mimeType || "image/*"
-    };
+  let RNFSName = "react-native-fs";
+  let RNFS;
+  let RNFSLoadError;
+  try {
+    RNFS = require(RNFSName);
+  } catch (e) {
+    RNFSLoadError = e;
+  }
+  let EFSName = "expo-file-system";
+  let EFS;
+  let EFSLoadError;
+  try {
+    EFS = require(EFSName);
+  } catch (e) {
+    EFSLoadError = e;
+  }
+  resolvePath = async (source, logger) => {
+    if (RNFS?.read !== void 0) {
+      logger.debug("Using react-native-fs to read local file");
+      const bufferSize = 1024 * 1024;
+      let pos = 0;
+      let eof = false;
+      const stream = new ReadableStream({
+        async pull(controller) {
+          if (eof) {
+            return;
+          }
+          const chunkAsB64 = await RNFS.read(source.path, bufferSize, pos, "base64");
+          if (chunkAsB64.length > 0) {
+            const chunk = Buffer.from(chunkAsB64, "base64");
+            controller.enqueue(chunk);
+            pos += chunk.length;
+          } else {
+            eof = true;
+            controller.close();
+          }
+        }
+      });
+      return {
+        stream,
+        size: (await RNFS.stat(source.path)).size,
+        mimeType: source.mimeType || "image/*"
+      };
+    } else if (EFS?.readAsStringAsync !== void 0) {
+      logger.debug("Using expo-file-system to read local file");
+      const bufferSize = 1024 * 1024;
+      let pos = 0;
+      let eof = false;
+      const stream = new ReadableStream({
+        async pull(controller) {
+          if (eof) {
+            return;
+          }
+          const chunkAsB64 = await EFS.readAsStringAsync(`file://${source.path}`, {
+            length: bufferSize,
+            position: pos,
+            encoding: "base64"
+          });
+          if (chunkAsB64) {
+            const chunk = Buffer.from(chunkAsB64, "base64");
+            controller.enqueue(chunk);
+            pos += chunk.length;
+          } else {
+            eof = true;
+            controller.close();
+          }
+        }
+      });
+      return {
+        stream,
+        size: (await EFS.getInfoAsync(`file://${source.path}`)).size,
+        mimeType: source.mimeType || "image/*"
+      };
+    }
+    return Promise.reject(`Could not load '${RNFSName}' (reason" ${RNFSLoadError}) or '${EFSName}' (reason" ${EFSLoadError}), include either of those packages in your application to enable uploads via PathSource - or provide the stream itself via StreamSource.`);
   };
 } else {
   let iteratorToStream = function(iterator) {
@@ -9685,7 +9761,7 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
       yield chunk;
     }
   }
-  resolvePath = async (source) => {
+  resolvePath = async (source, logger) => {
     const mime = require_mime_types();
     const filehandle = require("fs/promises");
     const fd = await filehandle.open(source.path, "r");
@@ -9701,6 +9777,403 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
 }
 var iteratorToStream2;
 
+// shims/rn_http_header_parser.ts
+var startLine = /^[A-Z_]+(\/\d\.\d)? /;
+var requestLine = /^([A-Z_]+) (.+) [A-Z]+\/(\d)\.(\d)$/;
+var statusLine = /^[A-Z]+\/(\d)\.(\d) (\d{3}) (.*)$/;
+function parseHttpHeader(lines, onlyHeaders) {
+  var line = lines[0];
+  var match;
+  if (onlyHeaders && startLine.test(line)) {
+    return parseHeaders(lines);
+  } else if ((match = line.match(requestLine)) !== null) {
+    return {
+      method: match[1],
+      url: match[2],
+      version: { major: parseInt(match[3], 10), minor: parseInt(match[4], 10) },
+      headers: parseHeaders(lines)
+    };
+  } else if ((match = line.match(statusLine)) !== null) {
+    return {
+      version: { major: parseInt(match[1], 10), minor: parseInt(match[2], 10) },
+      statusCode: parseInt(match[3], 10),
+      statusMessage: match[4],
+      headers: parseHeaders(lines)
+    };
+  } else {
+    return parseHeaders(lines);
+  }
+}
+function parseHeaders(lines) {
+  var headers = {};
+  var i = 0;
+  var line = lines[i];
+  var index, name, value;
+  if (startLine.test(line)) {
+    line = line[++i];
+  }
+  while (line) {
+    if (line[0] === " " || line[0] === "	") {
+      value += " " + line.trim();
+      i++;
+      if (i < lines.length) {
+        line = lines[i];
+      } else {
+        line = "";
+      }
+      continue;
+    }
+    if (name && value) {
+      addHeaderLine(name, value, headers);
+    }
+    index = line.indexOf(":");
+    name = line.substr(0, index);
+    value = line.substr(index + 1).trim();
+    i++;
+    if (i < lines.length) {
+      line = lines[i];
+    } else {
+      line = "";
+    }
+  }
+  if (name && value) {
+    addHeaderLine(name, value, headers);
+  }
+  return headers;
+}
+function addHeaderLine(field, value, dest) {
+  field = field.toLowerCase();
+  switch (field) {
+    // Array headers:
+    case "set-cookie":
+      if (dest[field] !== void 0) {
+        dest[field].push(value);
+      } else {
+        dest[field] = [value];
+      }
+      break;
+    // list is taken from:
+    // https://mxr.mozilla.org/mozilla/source/netwerk/protocol/http/src/nsHttpHeaderArray.cpp
+    case "content-type":
+    case "content-length":
+    case "user-agent":
+    case "referer":
+    case "host":
+    case "authorization":
+    case "proxy-authorization":
+    case "if-modified-since":
+    case "if-unmodified-since":
+    case "from":
+    case "location":
+    case "max-forwards":
+    case "retry-after":
+    case "etag":
+    case "last-modified":
+    case "server":
+    case "age":
+    case "expires":
+      if (dest[field] === void 0) dest[field] = value;
+      break;
+    default:
+      if (typeof dest[field] === "string") {
+        dest[field] += ", " + value;
+      } else {
+        dest[field] = value;
+      }
+  }
+}
+
+// shims/rn_http_response_parser.ts
+var ResponseParser = class {
+  constructor(logger, resolve, reject) {
+    this.responseChunkRemainder = 0;
+    this.logger = logger;
+    this.resolve = resolve;
+    this.reject = reject;
+    this.error = null;
+    this.responseReadBuffer = void 0;
+    this.responseState = 0 /* RECEIVING_HEADER */;
+    this.pullController = void 0;
+    this.pullResolve = void 0;
+    this.pullReject = void 0;
+  }
+  processResponseReadBuffer(data) {
+    if (this.error) {
+      this.logger.info(`RN http streamed response, received ${data.length} bytes in error mode`);
+      return false;
+    }
+    if (this.responseReadBuffer) {
+      this.responseReadBuffer = Buffer.concat([this.responseReadBuffer, data]);
+    } else {
+      this.responseReadBuffer = Buffer.from(data.subarray());
+    }
+    if (this.responseState === 3 /* RECEIVING_COMPLETED */) {
+      if (this.pullController) {
+        this.pullController.close();
+        if (this.pullResolve) {
+          this.pullResolve();
+        }
+      }
+      return false;
+    } else if (this.responseState === 0 /* RECEIVING_HEADER */) {
+      const headerEnd = this.responseReadBuffer.indexOf("\r\n\r\n");
+      if (headerEnd >= 0) {
+        let headerChunk = this.responseReadBuffer.subarray(0, headerEnd + 4);
+        this.responseReadBuffer = Buffer.from(this.responseReadBuffer.subarray(headerEnd + 4));
+        const maxHeaderLines = 128;
+        let responseHeaderLines = [];
+        const lineDecoder = new EyepopLineDecoder();
+        for (const line of lineDecoder.decode(headerChunk)) {
+          if (line.length > 0) {
+            responseHeaderLines.push(line);
+            if (responseHeaderLines.length > maxHeaderLines) {
+              this.error = `Response header exceeds ${maxHeaderLines} lines`;
+              this.reject(this.error);
+              return false;
+            }
+          }
+        }
+        let responseHeader = parseHttpHeader(responseHeaderLines, false);
+        if (responseHeader.statusCode === void 0) {
+          this.logger.warn(`Could not find status header in HTTP response ${JSON.stringify(responseHeader)}`);
+          this.reject("missing status header in HTTP response");
+          return false;
+        }
+        const headers = new Headers(responseHeader.headers);
+        if (headers.has("transfer-encoding")) {
+          if (headers.get("transfer-encoding")?.toLowerCase() === "chunked") {
+            this.responseState = 2 /* RECEIVING_BODY_CHUNKED */;
+            this.responseChunkRemainder = 0;
+          } else {
+            this.error = `Response with unsupported transfer-encoding '${headers.get("transfer-encoding")}'`;
+            this.reject(this.error);
+            return false;
+          }
+        } else if (headers.has("content-length")) {
+          this.responseState = 1 /* RECEIVING_BODY */;
+          this.responseChunkRemainder = parseInt(headers.get("content-length") || "-1");
+        } else {
+          this.responseState = 2 /* RECEIVING_BODY_CHUNKED */;
+          this.responseChunkRemainder = 0;
+        }
+        const responseBody = new ReadableStream({
+          pull: (controller) => {
+            if (this.error || this.responseState == 3 /* RECEIVING_COMPLETED */) {
+              return;
+            }
+            if (this.pull(controller)) {
+              return;
+            }
+            return new Promise((resolve, reject) => {
+              if (this.pullController) {
+                if (this.pullReject) {
+                  this.pullReject("pull, we got a pending controller already");
+                }
+              }
+              this.pullController = controller;
+              this.pullResolve = resolve;
+              this.pullReject = reject;
+            });
+          },
+          cancel: (reason) => {
+            if (!this.error) {
+              this.error = `cancelled: ${reason}`;
+              this.reject(this.error);
+            }
+          }
+        });
+        this.resolve(new Response(responseBody, {
+          status: responseHeader.statusCode,
+          statusText: responseHeader.statusText,
+          headers
+        }));
+      }
+    } else if (this.pullController) {
+      if (this.pull(this.pullController)) {
+        this.pullController = void 0;
+        if (this.pullResolve) {
+          this.pullResolve();
+        }
+        this.pullResolve = void 0;
+        this.pullReject = void 0;
+      }
+    }
+    return true;
+  }
+  pull(controller) {
+    if (this.responseState == 3 /* RECEIVING_COMPLETED */) {
+      controller.close();
+      return false;
+    }
+    if (this.responseReadBuffer === void 0) {
+      return false;
+    }
+    if (this.responseState == 1 /* RECEIVING_BODY */) {
+      controller.enqueue(this.responseReadBuffer);
+      this.responseChunkRemainder -= this.responseReadBuffer.length;
+      this.responseReadBuffer = void 0;
+      if (this.responseChunkRemainder <= 0) {
+        this.responseState = 3 /* RECEIVING_COMPLETED */;
+        controller.close();
+      }
+      return true;
+    } else if (this.responseState == 2 /* RECEIVING_BODY_CHUNKED */) {
+      while (this.responseReadBuffer.length > 1) {
+        if (this.responseChunkRemainder == 0) {
+          let chunkHeaderEnd = 0;
+          while (this.responseReadBuffer.length >= 2 && chunkHeaderEnd == 0) {
+            chunkHeaderEnd = this.responseReadBuffer.indexOf("\r\n");
+            if (chunkHeaderEnd == 0) {
+              this.responseReadBuffer = Buffer.from(this.responseReadBuffer.subarray(2));
+            }
+          }
+          if (chunkHeaderEnd > 0) {
+            this.responseChunkRemainder = parseInt(Buffer.from(this.responseReadBuffer, 0, chunkHeaderEnd).toString("utf8"), 16);
+            this.responseReadBuffer = Buffer.from(this.responseReadBuffer.subarray(chunkHeaderEnd + 2));
+            if (this.responseChunkRemainder <= 0) {
+              this.responseState = 3 /* RECEIVING_COMPLETED */;
+              controller.close();
+              return true;
+            }
+          } else if (this.responseReadBuffer.length > 64) {
+            this.error = "Cannot find chunked encoding header within 64 bytes, given up";
+            controller.error(this.error);
+          }
+        }
+        if (this.responseChunkRemainder > 0 && this.responseReadBuffer.length > 0) {
+          const chunk = Buffer.from(this.responseReadBuffer.subarray(0, this.responseChunkRemainder));
+          this.responseReadBuffer = Buffer.from(this.responseReadBuffer.subarray(this.responseChunkRemainder));
+          controller.enqueue(chunk);
+          this.responseChunkRemainder -= chunk.length;
+          return true;
+        } else {
+          break;
+        }
+      }
+    } else {
+      this.error = `Received more data in wrong state ${this.responseState}`;
+      controller.error(this.error);
+    }
+    return false;
+  }
+};
+
+// shims/rn_streaming_fetch.ts
+async function reactNativeStreamingFetch(url, method, headers, body, contentLength, sockets, logger) {
+  const isHttps = url.protocol == "https:";
+  const port = url.port ? parseInt(url.port) : isHttps ? 443 : 80;
+  return new Promise((resolve, reject) => {
+    const connectOptions = {
+      port,
+      host: url.hostname,
+      reuseAddress: true
+    };
+    const clientSocket = new sockets.Socket();
+    const client = isHttps ? new sockets.TLSSocket(clientSocket) : clientSocket;
+    let error;
+    const responseParser = new ResponseParser(logger, resolve, (reason) => {
+      error = reason;
+      reject(error);
+      client.destroy();
+    });
+    client.on("data", function(data) {
+      responseParser.processResponseReadBuffer(data);
+    });
+    client.on("error", function(err) {
+      logger.info(`error: ${err}`);
+      if (!error) {
+        error = err;
+        reject(error);
+      }
+      client.destroy();
+    });
+    client.on("close", function() {
+      if (!error) {
+        error = "socket closed";
+        reject(error);
+      }
+    });
+    client.connect(connectOptions, async () => {
+      const headerLines = [
+        `${method} ${url.pathname}${url.search} HTTP/1.1\r
+`,
+        `Host: ${url.host}\r
+`
+      ];
+      headers.forEach((value, key) => {
+        headerLines.push(`${key}: ${value}\r
+`);
+      });
+      headerLines.push("\r\n");
+      const textEncoder = new TextEncoder();
+      const headerChunk = headerLines.join("");
+      const bodyReader = body ? body.getReader() : void 0;
+      let headerEnqueued = false;
+      let eof = false;
+      const readableHeaderChunkedBody = new ReadableStream({
+        async pull(controller) {
+          if (!headerEnqueued) {
+            controller.enqueue(headerChunk);
+            headerEnqueued = true;
+            return;
+          }
+          if (eof) {
+            controller.close();
+            return;
+          }
+          if (!bodyReader) {
+            controller.close();
+            return;
+          }
+          const chunk = await bodyReader.read();
+          if (chunk.value) {
+            let outputChunk;
+            if (contentLength) {
+              outputChunk = chunk.value;
+            } else {
+              outputChunk = Buffer.concat([
+                textEncoder.encode(`${chunk.value.length.toString(16)}\r
+`),
+                chunk.value,
+                textEncoder.encode(`\r
+`)
+              ]);
+            }
+            controller.enqueue(outputChunk);
+          } else if (chunk.done) {
+            if (!contentLength) {
+              controller.enqueue(Buffer.from(`0\r
+\r
+`, "utf8"));
+            }
+            eof = true;
+          }
+        }
+      });
+      const readableHeaderChunkedBodyReader = readableHeaderChunkedBody.getReader();
+      const pipeChunk = async () => {
+        while (true) {
+          try {
+            const chunk = await readableHeaderChunkedBodyReader.read();
+            if (chunk.value) {
+              if (!client.write(chunk.value)) {
+                break;
+              }
+            } else if (chunk.done) {
+              break;
+            }
+          } catch (e) {
+            logger.error(e);
+            break;
+          }
+        }
+      };
+      client.on("drain", pipeChunk);
+      await pipeChunk();
+    });
+  });
+}
+
 // shims/http_client.ts
 var createHttpClient;
 if ("document" in globalThis && "implementation" in globalThis.document) {
@@ -9716,15 +10189,97 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
       return false;
     }
   }
-  createHttpClient = async () => {
+  createHttpClient = async (logger) => {
+    logger.debug("Using browser fetch as http client");
     return new BrowserHttpClient();
   };
 } else if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+  let RNName = "react-native";
+  let RN;
+  let TcpSocketsName = "react-native-tcp-socket";
+  let TcpSockets;
+  let TcpSocketsError;
+  try {
+    RN = require(RNName);
+    TcpSockets = require(TcpSocketsName);
+    if (TcpSockets?.TLSSocket) {
+      if (!RN?.NativeModules?.TcpSockets) {
+        TcpSockets = void 0;
+        throw Error(`'${TcpSocketsName}' but not symbol NativeModules?.TcpSockets, native sockets not available when running 'npx expo start', use 'npx expo run:android' or 'npx expo run:ios' instead`);
+      }
+    }
+  } catch (e) {
+    TcpSocketsError = e;
+  }
   class ReactNativeHttpClient {
-    constructor() {
+    constructor(logger) {
+      this.logger = logger;
     }
     async fetch(input, init) {
       init || (init = {});
+      let streamBody;
+      if (input instanceof Request) {
+        if (input.body instanceof ReadableStream) {
+          streamBody = input.body;
+        }
+      } else if (init?.body instanceof ReadableStream) {
+        streamBody = init.body;
+      }
+      if (streamBody) {
+        if (TcpSockets?.TLSSocket !== void 0) {
+          let url;
+          let method;
+          let headers;
+          if (input instanceof Request) {
+            url = new URL(input.url);
+            method = input.method;
+            headers = input.headers;
+          } else {
+            if (input instanceof URL) {
+              url = input;
+            } else {
+              url = new URL(input);
+            }
+            method = init?.method || "POST";
+            headers = new Headers(init?.headers);
+          }
+          let contentLength = void 0;
+          if (headers.has("content-length")) {
+            contentLength = parseInt(headers.get("content-length") || "");
+          } else {
+            headers.append("Transfer-Encoding", "chunked");
+          }
+          return await reactNativeStreamingFetch(
+            url,
+            method,
+            headers,
+            streamBody,
+            contentLength,
+            TcpSockets,
+            this.logger
+          );
+        } else {
+          this.logger.warn(`[${TcpSockets}] Could not load '${TcpSocketsName}' (reason" ${TcpSocketsError}), include this package in your application to enable streamed uploads; without this package local files have to be loaded into memory uploading and this will cause Out-Of-Memory errors for large files.`);
+          try {
+            const chunks = [];
+            const reader = streamBody.getReader();
+            while (true) {
+              const { done, value } = await reader.read();
+              if (done) {
+                break;
+              }
+              chunks.push(value);
+            }
+            if (input instanceof Request) {
+              input = new Request(input, { body: Buffer.concat(chunks) });
+            } else {
+              init.body = Buffer.concat(chunks);
+            }
+          } catch (e) {
+            return Promise.reject(e);
+          }
+        }
+      }
       init.reactNative = { textStreaming: true };
       return await fetch(input, init);
     }
@@ -9734,8 +10289,9 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
       return true;
     }
   }
-  createHttpClient = async () => {
-    return new ReactNativeHttpClient();
+  createHttpClient = async (logger) => {
+    logger.debug("using React Native fetch and will attempt direct sockets communication for uploads to workaround the missing request body streaming support in React Native.");
+    return new ReactNativeHttpClient(logger);
   };
 } else {
   class NodeHttpClient {
@@ -9754,7 +10310,7 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
       return false;
     }
   }
-  createHttpClient = async () => {
+  createHttpClient = async (logger) => {
     const undici = require("undici");
     const agent = new undici.Agent({
       keepAliveTimeout: 1e4,
@@ -9762,6 +10318,7 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
       // two parallel streaming requests to the same host seem to deadlock with pipelining > 0
       pipelining: 0
     });
+    logger.debug("Using node fetch with undici agent as http client");
     return new NodeHttpClient(agent);
   };
 }
@@ -9931,7 +10488,10 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
         popId: workerOptions.popId,
         baseUrl: void 0,
         pipelineId: void 0,
-        sandboxId: void 0
+        sandboxId: void 0,
+        authenticationHeaders: () => {
+          return { Authorization: `Bearer ${accessToken}` };
+        }
       };
       session = workerSession;
     } else {
@@ -10030,7 +10590,7 @@ var Endpoint = class {
     } else {
       return Promise.reject("option secretKey or environment variable EYEPOP_SECRET_KEY is required");
     }
-    this._client = await createHttpClient();
+    this._client = await createHttpClient(this._logger);
     return await this.reconnect();
   }
   async disconnect(wait = true) {
@@ -10465,6 +11025,7 @@ var WorkerEndpoint = class extends Endpoint {
       const job = new UploadJob(
         source.file.stream(),
         source.file.type,
+        source.file.size,
         source.videoMode,
         params,
         async () => {
@@ -10496,6 +11057,7 @@ var WorkerEndpoint = class extends Endpoint {
       const job = new UploadJob(
         source.stream,
         source.mimeType,
+        source.size,
         source.videoMode,
         params,
         async () => {
@@ -10524,10 +11086,11 @@ var WorkerEndpoint = class extends Endpoint {
     await this._limit.acquire();
     try {
       this.updateState();
-      const streamSource = await resolvePath(source);
+      const streamSource = await resolvePath(source, this._logger);
       const job = new UploadJob(
         streamSource.stream,
         streamSource.mimeType,
+        streamSource.size,
         source.videoMode,
         params,
         async () => {
@@ -10730,7 +11293,8 @@ var WorkerEndpoint = class extends Endpoint {
       if (this.options().stopJobs) {
         const body = { sourceType: "NONE" };
         const headers3 = {
-          Authorization: await this.authorizationHeader()
+          Authorization: await this.authorizationHeader(),
+          "Content-Type": "application/json"
         };
         const stop_url = `${this._baseUrl}/pipelines/${this._pipeline.id}/source?mode=preempt&processing=sync`;
         let response3 = await this._client.fetch(stop_url, {
@@ -11771,6 +12335,7 @@ var index_default = EyePop;
   EndpointState,
   ExportedBy,
   EyePop,
+  EyepopLineDecoder,
   ForwardOperatorType,
   InferenceType,
   LoadFromJob,