@eyepop.ai/eyepop 1.14.4 → 1.15.0

package/dist/eyepop.index.js

@@ -9062,7 +9062,6 @@ 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 ${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();
@@ -9079,10 +9078,10 @@ var UploadJob = class extends AbstractJob {
           body: formData,
           signal: this._controller.signal,
           // @ts-ignore
-          duplex: "half"
+          duplex: "half",
+          eyepop: { responseStreaming: true }
         });
       } else {
-        this._requestLogger.debug(`before POST ${postUrl} with stream as body`);
         const headers = {
           ...session.authenticationHeaders(),
           Accept: "application/jsonl",
@@ -9097,7 +9096,8 @@ var UploadJob = class extends AbstractJob {
           body: this._uploadStream,
           signal: this._controller.signal,
           // @ts-ignore
-          duplex: "half"
+          duplex: "half",
+          eyepop: { responseStreaming: true }
         });
       }
       request.then(async (value) => {
@@ -9106,8 +9106,6 @@ var UploadJob = class extends AbstractJob {
         }
       }).catch((reason) => {
         this._requestLogger.debug(`error ${reason} for POST ${postUrl}`);
-      }).finally(() => {
-        this._requestLogger.debug(`after POST ${postUrl}`);
       });
     }
     return Promise.resolve();
@@ -9124,20 +9122,18 @@ var UploadJob = class extends AbstractJob {
         ...session.authenticationHeaders(),
         Accept: "application/jsonl"
       };
-      this._requestLogger.debug(`before POST ${prepareUrl} to prepare full duplex upload`);
       response = await this._client.fetch(prepareUrl, {
         headers,
         method: "POST",
         signal: this._controller.signal,
         // @ts-ignore
-        duplex: "half"
+        duplex: "half",
+        eyepop: { responseStreaming: true }
       });
-      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 ${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();
@@ -9154,11 +9150,10 @@ var UploadJob = class extends AbstractJob {
           body: formData,
           signal: this._controller.signal,
           // @ts-ignore
-          duplex: "half"
+          duplex: "half",
+          eyepop: { responseStreaming: true }
         });
-        this._requestLogger.debug(`after POST ${postUrl} with multipart body because of params)`);
       } else {
-        this._requestLogger.debug(`before POST ${postUrl} with stream as body`);
         const headers = {
           ...session.authenticationHeaders(),
           Accept: "application/jsonl",
@@ -9175,7 +9170,6 @@ var UploadJob = class extends AbstractJob {
           // @ts-ignore
           duplex: "half"
         });
-        this._requestLogger.debug(`after POST ${postUrl} with stream as body`);
       }
     }
     return response;
@@ -9205,15 +9199,14 @@ var LoadFromJob = class extends AbstractJob {
       "Content-Type": "application/json"
     };
     const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=queue&processing=sync`;
-    this._requestLogger.debug("before PATCH %s with url %s as source", patchUrl, this._location);
-    const response = await this._client.fetch(patchUrl, {
+    return await this._client.fetch(patchUrl, {
       headers,
       method: "PATCH",
       body: JSON.stringify(body),
-      signal: this._controller.signal
+      signal: this._controller.signal,
+      // @ts-ignore
+      eyepop: { responseStreaming: true }
     });
-    this._requestLogger.debug("after PATCH %s with url %s as source", patchUrl, this._location);
-    return response;
   }
 };
 var LoadLiveIngressJob = class extends AbstractJob {
@@ -9240,15 +9233,14 @@ var LoadLiveIngressJob = class extends AbstractJob {
       "Content-Type": "application/json"
     };
     const patchUrl = `${session.baseUrl.replace(/\/+$/, "")}/pipelines/${session.pipelineId}/source?mode=preempt&processing=sync`;
-    this._requestLogger.debug("before PATCH %s with url %s as source", patchUrl, this._ingressId);
-    const response = await this._client.fetch(patchUrl, {
+    return await this._client.fetch(patchUrl, {
       headers,
       method: "PATCH",
       body: JSON.stringify(body),
-      signal: this._controller.signal
+      signal: this._controller.signal,
+      // @ts-ignore
+      eyepop: { responseStreaming: true }
     });
-    this._requestLogger.debug("after PATCH %s with url %s as source", patchUrl, this._ingressId);
-    return response;
   }
 };
 
@@ -9306,7 +9298,6 @@ var WebrtcBase = class _WebrtcBase {
     await this._pc.setLocalDescription(offer);
     const session = await this._getSession();
     const ingressUrl = this.gresUrl(session);
-    this._requestLogger.debug(`before POST: ${ingressUrl}`);
     const headers = {
       ...session.authenticationHeaders(),
       "Content-Type": "application/sdp"
@@ -9316,7 +9307,6 @@ var WebrtcBase = class _WebrtcBase {
       method: "POST",
       body: offer.sdp
     });
-    this._requestLogger.debug(`after POST: ${ingressUrl} status: ${response.status}`);
     if (response.status != 201) {
       return Promise.reject(`unknown status code for POST '${ingressUrl}': ${response.status} (${response.statusText})`);
     }
@@ -9334,7 +9324,6 @@ var WebrtcBase = class _WebrtcBase {
     let urlPath = void 0;
     const session = await this._getSession();
     const ingressUrl = this.gresUrl(session, this._location);
-    this._requestLogger.debug("before PATCH: %s", ingressUrl);
     const headers = {
       ...session.authenticationHeaders(),
       "Content-Type": "application/trickle-ice-sdpfrag",
@@ -9516,7 +9505,6 @@ var WebrtcWhip = class extends WebrtcBase {
   async start() {
     const session = await this._getSession();
     const ingressUrl = this.gresUrl(session);
-    this._requestLogger.debug("before GET: %s", ingressUrl);
     const response = await this._client.fetch(ingressUrl, {
       headers: session.authenticationHeaders(),
       method: "GET"
@@ -9617,7 +9605,6 @@ var WebrtcWhep = class extends WebrtcBase {
   async start() {
     const session = await this._getSession();
     const egressUrl = this.gresUrl(session);
-    this._requestLogger.debug("before GET: %s", egressUrl);
     const response = await this._client.fetch(egressUrl, {
       headers: session.authenticationHeaders(),
       method: "GET"
@@ -9649,10 +9636,10 @@ var WebrtcWhep = class extends WebrtcBase {
     pc.addTransceiver("video", { direction });
     pc.onicecandidate = (evt) => this.onLocalCandidate(evt);
     this._pc = pc;
-    this._requestLogger.info("before", pc.iceConnectionState);
+    this._requestLogger.info(`onIceServers ${pc.iceConnectionState}`);
     return new Promise(async (resolve, reject) => {
       pc.ontrack = (evt) => {
-        this._requestLogger.debug("new track:", evt.track.kind);
+        this._requestLogger.debug(`new track: ${evt.track.kind}`);
         this._stream = evt.streams[0];
         resolve(this);
       };
@@ -9660,11 +9647,11 @@ var WebrtcWhep = class extends WebrtcBase {
         switch (pc.iceConnectionState) {
           case "failed":
           case "disconnected":
-            this._requestLogger.debug("disconnected");
+            this._requestLogger.debug("oniceconnectionstatechange disconnected");
             reject(`peer connection: ${pc.iceConnectionState}`);
             break;
           case "connected":
-            this._requestLogger.debug("connected");
+            this._requestLogger.debug("oniceconnectionstatechange connected");
             break;
         }
       };
@@ -9679,88 +9666,6 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
   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") {
-  let RNFAName = "react-native-file-access";
-  let RNFA;
-  let RNFALoadError;
-  try {
-    RNFA = require(RNFAName);
-  } catch (e) {
-    RNFALoadError = e;
-  }
-  let EFSName = "expo-file-system";
-  let EFS;
-  let EFSLoadError;
-  try {
-    EFS = require(EFSName);
-  } catch (e) {
-    EFSLoadError = e;
-  }
-  resolvePath = async (source, logger) => {
-    if (RNFA?.FileSystem?.readFileChunk !== void 0) {
-      logger.debug("Using react-native-file-access to read local file");
-      const bufferSize = 1024 * 1024;
-      let pos = 0;
-      const size = (await RNFA.FileSystem.stat(source.path)).size;
-      let eof = false;
-      const stream = new ReadableStream({
-        async pull(controller) {
-          if (eof) {
-            return;
-          }
-          const chunkSize = Math.min(bufferSize, size - pos);
-          const chunkAsB64 = await RNFA.FileSystem.readFileChunk(source.path, pos, chunkSize, "base64");
-          if (chunkAsB64.length > 0) {
-            const chunk = Buffer.from(chunkAsB64, "base64").subarray(0, chunkSize);
-            controller.enqueue(chunk);
-            pos += chunk.length;
-          } else {
-            eof = true;
-            controller.close();
-          }
-        }
-      });
-      return {
-        stream,
-        size,
-        mimeType: source.mimeType || "image/*"
-      };
-    }
-    if (EFS?.readAsStringAsync !== void 0) {
-      logger.debug("Using expo-file-system to read local file");
-      const bufferSize = 1024 * 1024;
-      const size = (await EFS.getInfoAsync(`file://${source.path}`)).size;
-      let pos = 0;
-      let eof = false;
-      const stream = new ReadableStream({
-        async pull(controller) {
-          if (eof) {
-            return;
-          }
-          const chunkSize = Math.min(bufferSize, size - pos);
-          const chunkAsB64 = await EFS.readAsStringAsync(`file://${source.path}`, {
-            length: chunkSize,
-            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,
-        mimeType: source.mimeType || "image/*"
-      };
-    }
-    throw new Error(`Could not load '${RNFAName}' (reason" ${RNFALoadError}) or '${EFSName}' (reason" ${EFSLoadError}). Falling back to fetch() which might cause memory issues. Include either of those packages in your application to enable uploads via PathSource - or provide the stream itself via StreamSource.We will try to load file://${source.path} via fetch()`);
-  };
 } else {
   let iteratorToStream = function(iterator) {
     return new ReadableStream({
@@ -9796,541 +9701,51 @@ 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;
+function logLineFromRequest(input, init) {
+  const url = input instanceof Request ? input.url : input;
+  const method = input instanceof Request ? input.method : init?.method || (init?.body !== void 0 ? "POST" : "GET");
+  return `${method} ${url}`;
+}
 if ("document" in globalThis && "implementation" in globalThis.document) {
   class BrowserHttpClient {
-    constructor() {
-    }
-    async fetch(input, init) {
-      return await fetch(input, init);
-    }
-    async close() {
-    }
-    isFullDuplex() {
-      return false;
-    }
-  }
-  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(logger) {
-      this.logger = 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;
-      } else if (typeof init?.body === "string") {
-        streamBody = new ReadableStream({
-          start: (controller) => {
-            controller.enqueue(Buffer.from(init?.body, "utf8"));
-            controller.close();
-          }
-        });
-      }
-      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);
+      const logLine = logLineFromRequest(input, init);
+      this._logger.debug(`Browser fetch() BEFORE ${logLine}`);
+      const response = await fetch(input, init);
+      this._logger.debug(`AFTER ${logLine} -> ${response.status}`);
+      return response;
     }
     async close() {
     }
     isFullDuplex() {
-      return true;
+      return false;
     }
   }
   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);
+    return new BrowserHttpClient(logger);
   };
 } else {
   class NodeHttpClient {
-    constructor(agent) {
-      this.agent = agent;
+    constructor(agent, logger) {
+      this._agent = agent;
+      this._logger = logger;
     }
     async fetch(input, init) {
       init || (init = {});
-      init.dispatcher = this.agent;
-      return await fetch(input, init);
+      init.dispatcher = this._agent;
+      const logLine = logLineFromRequest(input, init);
+      this._logger.debug(`Node fetch() BEFORE ${logLine}`);
+      const response = await fetch(input, init);
+      this._logger.debug(`AFTER ${logLine} -> ${response.status}`);
+      return response;
     }
     async close() {
-      return this.agent.close();
+      return this._agent.close();
     }
     isFullDuplex() {
       return false;
@@ -10345,7 +9760,7 @@ if ("document" in globalThis && "implementation" in globalThis.document) {
       pipelining: 0
     });
     logger.debug("Using node fetch with undici agent as http client");
-    return new NodeHttpClient(agent);
+    return new NodeHttpClient(agent, logger);
   };
 }
 
@@ -10616,7 +10031,11 @@ var Endpoint = class {
     } else {
       return Promise.reject("option secretKey or environment variable EYEPOP_SECRET_KEY is required");
     }
-    this._client = await createHttpClient(this._logger);
+    if (this._options.platformSupport?.createHttpClient !== void 0) {
+      this._client = await this._options.platformSupport.createHttpClient(this._requestLogger);
+    } else {
+      this._client = await createHttpClient(this._requestLogger);
+    }
     return await this.reconnect();
   }
   async disconnect(wait = true) {
@@ -10710,7 +10129,6 @@ var Endpoint = class {
           const body = { secret_key: secretKeyAuth.secretKey };
           const headers = { "Content-Type": "application/json" };
           const post_url = `${this.eyepopUrl()}/authentication/token`;
-          this._requestLogger.debug("before POST %s", post_url);
           const response = await this._client.fetch(post_url, {
             method: "POST",
             headers,
@@ -10720,7 +10138,6 @@ var Endpoint = class {
             const message = await response.text();
             return Promise.reject(`Unexpected status ${response.status}: ${message}`);
           }
-          this._requestLogger.debug("after POST %s", post_url);
           const data = await response.json();
           const token = data;
           this._token = token.access_token;
@@ -10773,12 +10190,10 @@ var WorkerEndpoint = class extends Endpoint {
       const headers = {
         Authorization: await this.authorizationHeader()
       };
-      this._requestLogger.debug("before DELETE %s", deleteUrl);
       let response = await this._client?.fetch(deleteUrl, {
         method: "DELETE",
         headers
       });
-      this._requestLogger.debug("after DELETE %s", deleteUrl);
       if (response?.status != 204) {
         const message = await response?.text();
         this._logger.info(`stoppping pipeline failed, status ${response?.status}: ${message}`);
@@ -10789,12 +10204,10 @@ var WorkerEndpoint = class extends Endpoint {
       const headers = {
         Authorization: await this.authorizationHeader()
       };
-      this._requestLogger.debug("before DELETE %s", sandboxUrl);
       let response = await this._client?.fetch(sandboxUrl, {
         method: "DELETE",
         headers
       });
-      this._requestLogger.debug("after DELETE %s", sandboxUrl);
       if (response?.status != 204) {
         const message = await response?.text();
         this._logger.info(`disconnecting sandbox failed, status ${response?.status}: ${message}`);
@@ -10840,7 +10253,7 @@ var WorkerEndpoint = class extends Endpoint {
     const client = this._client;
     const baseUrl = this._baseUrl;
     if (!baseUrl || !client) {
-      return Promise.reject("endpoint not connected, use connect() before changePopComp()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     let response = await this.fetchWithRetry(async () => {
       const session = await this.session();
@@ -10849,7 +10262,6 @@ var WorkerEndpoint = class extends Endpoint {
         ...this._authenticationHeaders(session)
       };
       const patch_url = `${session.baseUrl}/pipelines/${session.pipelineId}/pop`;
-      this._requestLogger.debug("before PATCH %s - %s", patch_url, JSON.stringify(pop));
       return await client.fetch(patch_url, {
         method: "PATCH",
         body: JSON.stringify(pop),
@@ -10860,7 +10272,6 @@ var WorkerEndpoint = class extends Endpoint {
       const message = await response.text();
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
-    this._requestLogger.debug("after PATCH pop");
     if (this._pipeline) {
       this._pipeline.pop = pop;
     }
@@ -10885,7 +10296,7 @@ var WorkerEndpoint = class extends Endpoint {
     const client = this._client;
     const baseUrl = this._baseUrl;
     if (!baseUrl || !client) {
-      return Promise.reject("endpoint not connected, use connect() before changePopComp()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     const body = {
       pipeline: popComp,
@@ -10930,7 +10341,7 @@ var WorkerEndpoint = class extends Endpoint {
     const client = this._client;
     const baseUrl = this._baseUrl;
     if (!baseUrl || !client) {
-      return Promise.reject("endpoint not connected, use connect() before changePopComp()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     const body = {
       transform: postTransform
@@ -10969,7 +10380,7 @@ var WorkerEndpoint = class extends Endpoint {
   }
   async liveIngress(stream) {
     if (!this._baseUrl || !this._client) {
-      return Promise.reject("endpoint not connected, use connect() before ingress()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     const whip = new WebrtcWhip(
       stream,
@@ -10983,7 +10394,7 @@ var WorkerEndpoint = class extends Endpoint {
   }
   async liveEgress(ingressId) {
     if (!this._baseUrl || !this._client) {
-      return Promise.reject("endpoint not connected, use connect() before ingress()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     const whep = new WebrtcWhep(
       ingressId,
@@ -11043,7 +10454,7 @@ var WorkerEndpoint = class extends Endpoint {
   }
   async uploadFile(source, params) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      return Promise.reject("endpoint not connected, use connect() before upload()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     await this._limit.acquire();
     try {
@@ -11075,7 +10486,7 @@ var WorkerEndpoint = class extends Endpoint {
   }
   async uploadStream(source, params) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      return Promise.reject("endpoint not connected, use connect() before upload()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     await this._limit.acquire();
     try {
@@ -11107,12 +10518,17 @@ var WorkerEndpoint = class extends Endpoint {
   }
   async uploadPath(source, params) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect() before process()");
+      throw new Error("endpoint not connected, use connect()");
     }
     await this._limit.acquire();
     try {
       this.updateState();
-      const streamSource = await resolvePath(source, this._logger);
+      let streamSource;
+      if (this._options.platformSupport?.resolvePath) {
+        streamSource = await this._options.platformSupport.resolvePath(source, this._logger);
+      } else {
+        streamSource = await resolvePath(source, this._logger);
+      }
       const job = new UploadJob(
         streamSource.stream,
         streamSource.mimeType,
@@ -11145,7 +10561,7 @@ var WorkerEndpoint = class extends Endpoint {
       }, params);
     }
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect() before loadFrom()");
+      throw new Error("endpoint not connected, use connect()");
     }
     await this._limit.acquire();
     try {
@@ -11174,7 +10590,7 @@ var WorkerEndpoint = class extends Endpoint {
   }
   async loadLiveIngress(source, params) {
     if (!this._baseUrl || !this._pipelineId || !this._client || !this._limit) {
-      throw new Error("endpoint not connected, use connect() before loadLiveIngress()");
+      throw new Error("endpoint not connected, use connect()");
     }
     await this._limit.acquire();
     try {
@@ -11226,10 +10642,9 @@ var WorkerEndpoint = class extends Endpoint {
       Authorization: await this.authorizationHeader()
     };
     this.updateState("FetchConfig" /* FetchConfig */);
-    this._requestLogger.debug("before GET %s", config_url);
     let response = await this._client.fetch(config_url, { headers });
     if (response.status == 401) {
-      this._requestLogger.debug("after GET %s: 401, about to retry with fresh access token", config_url);
+      this._requestLogger.debug("GET %s: 401, about to retry with fresh access token", config_url);
       this.statusHandler401(response.status);
       const headers2 = {
         Authorization: await this.authorizationHeader()
@@ -11249,7 +10664,6 @@ var WorkerEndpoint = class extends Endpoint {
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
     let config = await response.json();
-    this._requestLogger.debug("after GET %s", config_url);
     if (!config.base_url && this.options().autoStart) {
       const auto_start_config_url = `${this.eyepopUrl()}/pops/${this.options().popId}/config?auto_start=true`;
       this._requestLogger.debug("pop was not running, trying to autostart with: %s", auto_start_config_url);
@@ -11275,7 +10689,6 @@ var WorkerEndpoint = class extends Endpoint {
           Authorization: await this.authorizationHeader()
         };
         const createSandboxUrl = `${this._baseUrl}/sandboxes`;
-        this._requestLogger.debug("before POST %s", createSandboxUrl);
         const response3 = await this._client.fetch(createSandboxUrl, {
           method: "POST",
           headers: headers3
@@ -11285,7 +10698,6 @@ var WorkerEndpoint = class extends Endpoint {
           return Promise.reject(`Unexpected status ${response3.status}: ${message}`);
         }
         const responseJson = await response3.json();
-        this._requestLogger.debug("after POST %s", createSandboxUrl);
         if (responseJson) {
           this._sandboxId = responseJson;
         }
@@ -11305,7 +10717,6 @@ var WorkerEndpoint = class extends Endpoint {
       const headers2 = {
         Authorization: await this.authorizationHeader()
       };
-      this._requestLogger.debug("before GET %s", get_url);
       let response2 = await this._client.fetch(get_url, {
         method: "GET",
         headers: headers2
@@ -11314,7 +10725,6 @@ var WorkerEndpoint = class extends Endpoint {
         const message = await response2.text();
         return Promise.reject(`Unexpected status ${response2.status}: ${message}`);
       }
-      this._requestLogger.debug("after GET %s", get_url);
       this._pipeline = await response2.json();
       if (this.options().stopJobs) {
         const body = { sourceType: "NONE" };
@@ -11375,7 +10785,6 @@ var WorkerEndpoint = class extends Endpoint {
         "Content-Type": "application/json",
         Authorization: await this.authorizationHeader()
       };
-      this._requestLogger.debug("before POST %s", post_url);
       return client.fetch(post_url, {
         method: "POST",
         body: JSON.stringify(body),
@@ -11387,7 +10796,6 @@ var WorkerEndpoint = class extends Endpoint {
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
     const result = await response.json();
-    this._requestLogger.debug("after POST %s", post_url);
     return result["id"];
   }
   async manifest() {
@@ -11395,7 +10803,7 @@ var WorkerEndpoint = class extends Endpoint {
     const client = this._client;
     const baseUrl = this._baseUrl;
     if (!baseUrl || !client) {
-      return Promise.reject("endpoint not connected, use connect() before getManifest()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     let get_path;
     if (this._sandboxId === null) {
@@ -11409,23 +10817,20 @@ var WorkerEndpoint = class extends Endpoint {
         ...this._authenticationHeaders(session),
         "Content-Type": "application/json"
       };
-      this._requestLogger.debug("before GET %s", get_path);
       return client.fetch(get_path, { headers });
     });
     if (!response.ok) {
       const message = await response.text();
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
-    const result = await response.json();
-    this._requestLogger.debug("after GET %s", get_path);
-    return result;
+    return await response.json();
   }
   async models() {
     this._logger.warn("listModels for development use only");
     const client = this._client;
     const baseUrl = this._baseUrl;
     if (!baseUrl || !client) {
-      return Promise.reject("endpoint not connected, use connect() before listModels()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     let get_path;
     if (this._sandboxId === null) {
@@ -11439,7 +10844,6 @@ var WorkerEndpoint = class extends Endpoint {
         ...this._authenticationHeaders(session),
         "Content-Type": "application/json"
       };
-      this._requestLogger.debug("before GET %s", get_path);
       return client.fetch(get_path, { headers });
     });
     if (!response.ok) {
@@ -11447,7 +10851,6 @@ var WorkerEndpoint = class extends Endpoint {
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
     const result = await response.json();
-    this._requestLogger.debug("after GET %s", get_path);
     return result;
   }
   async changeManifest(manifests) {
@@ -11455,7 +10858,7 @@ var WorkerEndpoint = class extends Endpoint {
     const client = this._client;
     const baseUrl = this._baseUrl;
     if (!baseUrl || !client) {
-      return Promise.reject("endpoint not connected, use connect() before setManifest()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     let put_url;
     if (this._sandboxId === null) {
@@ -11469,7 +10872,6 @@ var WorkerEndpoint = class extends Endpoint {
         ...this._authenticationHeaders(session),
         "Content-Type": "application/json"
       };
-      this._requestLogger.debug("before PUT %s", put_url);
       return client.fetch(put_url, {
         method: "PUT",
         body: JSON.stringify(manifests),
@@ -11480,14 +10882,13 @@ var WorkerEndpoint = class extends Endpoint {
       const message = await response.text();
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
-    this._requestLogger.debug("after PUT %s", put_url);
   }
   async loadModel(model) {
     this._logger.warn("loadModel for development use only");
     const client = this._client;
     const baseUrl = this._baseUrl;
     if (!baseUrl || !client) {
-      return Promise.reject("endpoint not connected, use connect() before loadModel()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     let post_url;
     if (this._sandboxId === null) {
@@ -11501,7 +10902,6 @@ var WorkerEndpoint = class extends Endpoint {
         ...this._authenticationHeaders(session),
         "Content-Type": "application/json"
       };
-      this._requestLogger.debug("before POST %s", post_url);
       return client.fetch(post_url, {
         method: "POST",
         body: JSON.stringify(model),
@@ -11512,16 +10912,14 @@ var WorkerEndpoint = class extends Endpoint {
       const message = await response.text();
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
-    const result = await response.json();
-    this._requestLogger.debug("after POST %s", post_url);
-    return result;
+    return await response.json();
   }
   async unloadModel(modelId) {
     this._logger.warn("purgeModel for development use only");
     const client = this._client;
     const baseUrl = this._baseUrl;
     if (!baseUrl || !client) {
-      return Promise.reject("endpoint not connected, use connect() before unloadModel()");
+      return Promise.reject("endpoint not connected, use connect()");
     }
     let delete_url;
     if (this._sandboxId === null) {
@@ -11535,14 +10933,12 @@ var WorkerEndpoint = class extends Endpoint {
         ...this._authenticationHeaders(session),
         "Content-Type": "application/json"
       };
-      this._requestLogger.debug("before DELETE %s", delete_url);
       return client.fetch(delete_url, { method: "DELETE", headers });
     });
     if (!response.ok) {
       const message = await response.text();
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
-    this._requestLogger.debug("after DELETE %s", delete_url);
   }
 };
 
@@ -11760,10 +11156,9 @@ var DataEndpoint = class extends Endpoint {
       Authorization: await this.authorizationHeader()
     };
     this.updateState("FetchConfig" /* FetchConfig */);
-    this._requestLogger.debug("before GET %s", config_url);
     let response = await this._client.fetch(config_url, { headers });
     if (response.status == 401) {
-      this._requestLogger.debug("after GET %s: 401, about to retry with fresh access token", config_url);
+      this._requestLogger.debug("GET %s: 401, about to retry with fresh access token", config_url);
       this.statusHandler401(response.status);
       headers = {
         Authorization: await this.authorizationHeader()
@@ -11779,7 +11174,6 @@ var DataEndpoint = class extends Endpoint {
       return Promise.reject(`Unexpected status ${response.status}: ${message}`);
     }
     let config = await response.json();
-    this._requestLogger.debug("after GET %s", config_url);
     const baseUrl = new URL(config.base_url, this.eyepopUrl());
     this._baseUrl = baseUrl.toString();
     if (this.options().disableWs) {