@roboflow/inference-sdk 0.1.6 → 0.1.8

package/dist/index.es.js

@@ -1,20 +1,24 @@
-var T = Object.defineProperty;
-var O = (a, e, t) => e in a ? T(a, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : a[e] = t;
-var u = (a, e, t) => O(a, typeof e != "symbol" ? e + "" : e, t);
-class _ {
+var N = Object.defineProperty;
+var A = (r, e, t) => e in r ? N(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var d = (r, e, t) => A(r, typeof e != "symbol" ? e + "" : e, t);
+var U;
+const x = typeof process < "u" && ((U = process.env) != null && U.RF_API_BASE_URL) ? process.env.RF_API_BASE_URL : "https://api.roboflow.com", q = [
+  "https://serverless.roboflow.com"
+];
+class b {
   /**
    * @private
    * Use InferenceHTTPClient.init() instead
    */
   constructor(e, t = "https://serverless.roboflow.com") {
-    u(this, "apiKey");
-    u(this, "serverUrl");
+    d(this, "apiKey");
+    d(this, "serverUrl");
     this.apiKey = e, this.serverUrl = t;
   }
   static init({ apiKey: e, serverUrl: t }) {
     if (!e)
       throw new Error("apiKey is required");
-    return new _(e, t);
+    return new b(e, t);
   }
   /**
    * Initialize a WebRTC worker pipeline
@@ -44,59 +48,60 @@ class _ {
   async initializeWebrtcWorker({
     offer: e,
     workflowSpec: t,
-    workspaceName: n,
-    workflowId: r,
-    config: o = {}
+    workspaceName: a,
+    workflowId: o,
+    config: n = {}
   }) {
     if (!e || !e.sdp || !e.type)
       throw new Error("offer with sdp and type is required");
-    const i = !!t, s = !!(n && r);
-    if (!i && !s)
+    const i = !!t, l = !!(a && o);
+    if (!i && !l)
       throw new Error("Either workflowSpec OR (workspaceName + workflowId) is required");
-    if (i && s)
+    if (i && l)
       throw new Error("Provide either workflowSpec OR (workspaceName + workflowId), not both");
     const {
-      imageInputName: d = "image",
-      streamOutputNames: c = [],
-      dataOutputNames: l = ["string"],
-      threadPoolWorkers: p = 4,
+      imageInputName: c = "image",
+      streamOutputNames: s = [],
+      dataOutputNames: u = ["string"],
+      threadPoolWorkers: h = 4,
       workflowsParameters: y = {},
       iceServers: w,
-      processingTimeout: k,
-      requestedPlan: S,
-      requestedRegion: f
-    } = o, g = {
+      processingTimeout: R,
+      requestedPlan: g,
+      requestedRegion: v,
+      realtimeProcessing: m = !0
+    } = n, p = {
       type: "WorkflowConfiguration",
-      image_input_name: d,
+      image_input_name: c,
       workflows_parameters: y,
-      workflows_thread_pool_workers: p,
+      workflows_thread_pool_workers: h,
       cancel_thread_pool_tasks_on_exit: !0,
       video_metadata_input_name: "video_metadata"
     };
-    i ? g.workflow_specification = t : (g.workspace_name = n, g.workflow_id = r);
-    const m = {
-      workflow_configuration: g,
+    i ? p.workflow_specification = t : (p.workspace_name = a, p.workflow_id = o);
+    const S = {
+      workflow_configuration: p,
       api_key: this.apiKey,
-      webrtc_realtime_processing: !0,
+      webrtc_realtime_processing: m,
       webrtc_offer: {
         sdp: e.sdp,
         type: e.type
       },
       webrtc_config: w ? { iceServers: w } : null,
-      stream_output: c,
-      data_output: l
+      stream_output: s,
+      data_output: u
     };
-    k !== void 0 && (m.processing_timeout = k), S !== void 0 && (m.requested_plan = S), f !== void 0 && (m.requested_region = f), console.trace("payload", m);
-    const h = await fetch(`${this.serverUrl}/initialise_webrtc_worker`, {
+    R !== void 0 && (S.processing_timeout = R), g !== void 0 && (S.requested_plan = g), v !== void 0 && (S.requested_region = v);
+    const C = await fetch(`${this.serverUrl}/initialise_webrtc_worker`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(m)
+      body: JSON.stringify(S)
     });
-    if (!h.ok) {
-      const E = await h.text().catch(() => "");
-      throw new Error(`initialise_webrtc_worker failed (${h.status}): ${E}`);
+    if (!C.ok) {
+      const k = await C.text().catch(() => "");
+      throw new Error(`initialise_webrtc_worker failed (${C.status}): ${k}`);
     }
-    return await h.json();
+    return await C.json();
   }
   async terminatePipeline({ pipelineId: e }) {
     if (!e)
@@ -109,8 +114,56 @@ class _ {
       }
     );
   }
+  /**
+   * Fetch TURN server configuration from Roboflow API
+   *
+   * This automatically fetches TURN server credentials for improved WebRTC
+   * connectivity through firewalls and NAT. Only applicable when using
+   * Roboflow serverless infrastructure.
+   *
+   * @returns Promise resolving to ICE server configuration, or null if not applicable
+   *
+   * @example
+   * ```typescript
+   * const client = InferenceHTTPClient.init({ apiKey: "your-api-key" });
+   * const iceServers = await client.fetchTurnConfig();
+   * // Returns: [{ urls: ["turn:..."], username: "...", credential: "..." }]
+   * ```
+   */
+  async fetchTurnConfig() {
+    if (!q.includes(this.serverUrl))
+      return null;
+    try {
+      const e = await fetch(
+        `${x}/webrtc_turn_config?api_key=${this.apiKey}`,
+        {
+          method: "GET",
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+      if (!e.ok)
+        return console.warn(`[RFWebRTC] Failed to fetch TURN config (${e.status}), using defaults`), null;
+      const t = await e.json();
+      let a;
+      if (Array.isArray(t))
+        a = t;
+      else if (t.iceServers && Array.isArray(t.iceServers))
+        a = t.iceServers;
+      else if (t.urls)
+        a = [t];
+      else
+        return console.warn("[RFWebRTC] Invalid TURN config format, using defaults"), null;
+      return a.map((n) => ({
+        urls: Array.isArray(n.urls) ? n.urls : [n.urls],
+        username: n.username,
+        credential: n.credential
+      }));
+    } catch (e) {
+      return console.warn("[RFWebRTC] Error fetching TURN config:", e), null;
+    }
+  }
 }
-const K = {
+const ee = {
   /**
    * Create a connector that uses API key directly
    *
@@ -129,33 +182,37 @@ const K = {
    * const answer = await connector.connectWrtc(offer, wrtcParams);
    * ```
    */
-  withApiKey(a, e = {}) {
+  withApiKey(r, e = {}) {
     const { serverUrl: t } = e;
-    return typeof window < "u" && console.warn(
+    typeof window < "u" && console.warn(
       "[Security Warning] Using API key directly in browser will expose it. Use connectors.withProxyUrl() for production. See: https://docs.roboflow.com/api-reference/authentication#securing-your-api-key"
-    ), {
-      connectWrtc: async (n, r) => {
-        const o = _.init({ apiKey: a, serverUrl: t });
-        return console.log("wrtcParams", r), await o.initializeWebrtcWorker({
-          offer: n,
-          workflowSpec: r.workflowSpec,
-          workspaceName: r.workspaceName,
-          workflowId: r.workflowId,
-          config: {
-            imageInputName: r.imageInputName,
-            streamOutputNames: r.streamOutputNames,
-            dataOutputNames: r.dataOutputNames,
-            threadPoolWorkers: r.threadPoolWorkers,
-            workflowsParameters: r.workflowsParameters,
-            iceServers: r.iceServers,
-            processingTimeout: r.processingTimeout,
-            requestedPlan: r.requestedPlan,
-            requestedRegion: r.requestedRegion
-          }
-        });
-      },
+    );
+    const a = b.init({ apiKey: r, serverUrl: t });
+    return {
+      connectWrtc: async (o, n) => (console.debug("wrtcParams", n), await a.initializeWebrtcWorker({
+        offer: o,
+        workflowSpec: n.workflowSpec,
+        workspaceName: n.workspaceName,
+        workflowId: n.workflowId,
+        config: {
+          imageInputName: n.imageInputName,
+          streamOutputNames: n.streamOutputNames,
+          dataOutputNames: n.dataOutputNames,
+          threadPoolWorkers: n.threadPoolWorkers,
+          workflowsParameters: n.workflowsParameters,
+          iceServers: n.iceServers,
+          processingTimeout: n.processingTimeout,
+          requestedPlan: n.requestedPlan,
+          requestedRegion: n.requestedRegion,
+          realtimeProcessing: n.realtimeProcessing
+        }
+      })),
+      /**
+       * Fetch TURN server configuration for improved WebRTC connectivity
+       */
+      getIceServers: async () => await a.fetchTurnConfig(),
       // Store apiKey for cleanup
-      _apiKey: a,
+      _apiKey: r,
       _serverUrl: t
     };
   },
@@ -165,24 +222,41 @@ const K = {
    * Your backend receives the offer and wrtcParams, adds the secret API key,
    * and forwards to Roboflow. This keeps your API key secure.
    *
-   * @param proxyUrl - Backend proxy endpoint URL
-   * @param options - Additional options (reserved for future use)
-   * @returns Connector with connectWrtc method
+   * For improved WebRTC connectivity through firewalls, implement a separate
+   * endpoint for TURN server configuration that calls `fetchTurnConfig()`.
+   *
+   * @param proxyUrl - Backend proxy endpoint URL for WebRTC initialization
+   * @param options - Additional options
+   * @param options.turnConfigUrl - Optional URL for fetching TURN server configuration
+   * @returns Connector with connectWrtc and optional getIceServers methods
    *
    * @example
    * ```typescript
-   * const connector = connectors.withProxyUrl('/api/init-webrtc');
-   * const answer = await connector.connectWrtc(offer, wrtcParams);
+   * // Frontend: Create connector with TURN config endpoint
+   * const connector = connectors.withProxyUrl('/api/init-webrtc', {
+   *   turnConfigUrl: '/api/turn-config'
+   * });
    * ```
    *
    * @example
-   * Backend implementation (Express):
+   * Backend implementation (Express) with TURN server support:
    * ```typescript
+   * // Endpoint for TURN configuration (called first by SDK)
+   * app.get('/api/turn-config', async (req, res) => {
+   *   const client = InferenceHTTPClient.init({
+   *     apiKey: process.env.ROBOFLOW_API_KEY
+   *   });
+   *   const iceServers = await client.fetchTurnConfig();
+   *   res.json({ iceServers });
+   * });
+   *
+   * // Endpoint for WebRTC initialization
    * app.post('/api/init-webrtc', async (req, res) => {
    *   const { offer, wrtcParams } = req.body;
    *   const client = InferenceHTTPClient.init({
    *     apiKey: process.env.ROBOFLOW_API_KEY
    *   });
+   *
    *   const answer = await client.initializeWebrtcWorker({
    *     offer,
    *     workflowSpec: wrtcParams.workflowSpec,
@@ -200,72 +274,129 @@ const K = {
    *       requestedRegion: wrtcParams.requestedRegion
    *     }
    *   });
+   *
    *   res.json(answer);
    * });
    * ```
    */
-  withProxyUrl(a, e = {}) {
+  withProxyUrl(r, e = {}) {
+    const { turnConfigUrl: t } = e;
     return {
-      connectWrtc: async (t, n) => {
-        const r = await fetch(a, {
+      connectWrtc: async (a, o) => {
+        const n = await fetch(r, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({
-            offer: t,
-            wrtcParams: n
+            offer: a,
+            wrtcParams: o
           })
         });
-        if (!r.ok) {
-          const o = await r.text().catch(() => "");
-          throw new Error(`Proxy request failed (${r.status}): ${o}`);
+        if (!n.ok) {
+          const i = await n.text().catch(() => "");
+          throw new Error(`Proxy request failed (${n.status}): ${i}`);
         }
-        return await r.json();
-      }
+        return await n.json();
+      },
+      /**
+       * Fetch TURN server configuration from the proxy backend
+       * Only available if turnConfigUrl was provided
+       */
+      getIceServers: t ? async () => {
+        try {
+          const a = await fetch(t, {
+            method: "GET",
+            headers: { "Content-Type": "application/json" }
+          });
+          return a.ok ? (await a.json()).iceServers || null : (console.warn(`[RFWebRTC] Failed to fetch TURN config from proxy (${a.status})`), null);
+        } catch (a) {
+          return console.warn("[RFWebRTC] Error fetching TURN config from proxy:", a), null;
+        }
+      } : void 0
     };
   }
 };
-async function W(a = { video: !0 }) {
+async function K(r = { video: !0 }) {
   try {
-    console.log("[RFStreams] requesting with", a);
-    const e = await navigator.mediaDevices.getUserMedia(a);
+    console.log("[RFStreams] requesting with", r);
+    const e = await navigator.mediaDevices.getUserMedia(r);
     return console.log("[RFStreams] got stream", e.getVideoTracks().map((t) => ({ id: t.id, label: t.label }))), e;
   } catch (e) {
     console.warn("[RFStreams] failed, falling back", e);
     const t = await navigator.mediaDevices.getUserMedia({ video: !0, audio: !1 });
-    return console.log("[RFStreams] fallback stream", t.getVideoTracks().map((n) => ({ id: n.id, label: n.label }))), t;
+    return console.log("[RFStreams] fallback stream", t.getVideoTracks().map((a) => ({ id: a.id, label: a.label }))), t;
   }
 }
-function v(a) {
-  a && (a.getTracks().forEach((e) => e.stop()), console.log("[RFStreams] Stream stopped"));
+function W(r) {
+  r && (r.getTracks().forEach((e) => e.stop()), console.log("[RFStreams] Stream stopped"));
 }
-const j = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const te = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  stopStream: v,
-  useCamera: W
-}, Symbol.toStringTag, { value: "Module" })), F = 12;
-class b {
+  stopStream: W,
+  useCamera: K
+}, Symbol.toStringTag, { value: "Module" })), T = 49152, j = 262144, B = 10;
+function V(r) {
+  return new Promise((e) => setTimeout(e, r));
+}
+class I {
+  constructor(e, t) {
+    d(this, "file");
+    d(this, "channel");
+    d(this, "totalChunks");
+    d(this, "cancelled", !1);
+    this.file = e, this.channel = t, this.totalChunks = Math.ceil(e.size / T);
+  }
+  /**
+   * Cancel the upload
+   */
+  cancel() {
+    this.cancelled = !0;
+  }
+  /**
+   * Upload the file in chunks with backpressure handling
+   *
+   * @param onProgress - Optional callback for progress updates (bytesUploaded, totalBytes)
+   */
+  async upload(e) {
+    const t = this.file.size;
+    for (let a = 0; a < this.totalChunks; a++) {
+      if (this.cancelled)
+        throw new Error("Upload cancelled");
+      if (this.channel.readyState !== "open")
+        throw new Error("Video upload interrupted");
+      const o = a * T, n = Math.min(o + T, t), i = this.file.slice(o, n), l = new Uint8Array(await i.arrayBuffer()), c = new ArrayBuffer(8 + l.length), s = new DataView(c);
+      for (s.setUint32(0, a, !0), s.setUint32(4, this.totalChunks, !0), new Uint8Array(c, 8).set(l); this.channel.bufferedAmount > j; ) {
+        if (this.channel.readyState !== "open")
+          throw new Error("Video upload interrupted");
+        await V(B);
+      }
+      this.channel.send(c), e && e(n, t);
+    }
+  }
+}
+const $ = 12;
+class P {
   constructor() {
-    u(this, "pendingFrames", /* @__PURE__ */ new Map());
+    d(this, "pendingFrames", /* @__PURE__ */ new Map());
   }
   /**
    * Process an incoming chunk and return the complete message if all chunks received
    */
-  processChunk(e, t, n, r) {
-    if (n === 1)
-      return r;
+  processChunk(e, t, a, o) {
+    if (a === 1)
+      return o;
     this.pendingFrames.has(e) || this.pendingFrames.set(e, {
       chunks: /* @__PURE__ */ new Map(),
-      totalChunks: n
+      totalChunks: a
     });
-    const o = this.pendingFrames.get(e);
-    if (o.chunks.set(t, r), o.chunks.size === n) {
-      const i = Array.from(o.chunks.values()).reduce((c, l) => c + l.length, 0), s = new Uint8Array(i);
-      let d = 0;
-      for (let c = 0; c < n; c++) {
-        const l = o.chunks.get(c);
-        s.set(l, d), d += l.length;
+    const n = this.pendingFrames.get(e);
+    if (n.chunks.set(t, o), n.chunks.size === a) {
+      const i = Array.from(n.chunks.values()).reduce((s, u) => s + u.length, 0), l = new Uint8Array(i);
+      let c = 0;
+      for (let s = 0; s < a; s++) {
+        const u = n.chunks.get(s);
+        l.set(u, c), c += u.length;
       }
-      return this.pendingFrames.delete(e), s;
+      return this.pendingFrames.delete(e), l;
     }
     return null;
   }
@@ -276,113 +407,139 @@ class b {
     this.pendingFrames.clear();
   }
 }
-function C(a) {
-  const e = new DataView(a), t = e.getUint32(0, !0), n = e.getUint32(4, !0), r = e.getUint32(8, !0), o = new Uint8Array(a, F);
-  return { frameId: t, chunkIndex: n, totalChunks: r, payload: o };
+function L(r) {
+  const e = new DataView(r), t = e.getUint32(0, !0), a = e.getUint32(4, !0), o = e.getUint32(8, !0), n = new Uint8Array(r, $);
+  return { frameId: t, chunkIndex: a, totalChunks: o, payload: n };
 }
-async function P(a, e = 6e3) {
-  if (a.iceGatheringState === "complete") return;
+async function M(r, e = 6e3) {
+  if (r.iceGatheringState === "complete") return;
   let t = !1;
-  const n = (r) => {
-    r.candidate && r.candidate.type === "srflx" && (t = !0);
+  const a = (o) => {
+    o.candidate && o.candidate.type === "srflx" && (t = !0);
   };
-  a.addEventListener("icecandidate", n);
+  r.addEventListener("icecandidate", a);
   try {
     await Promise.race([
-      new Promise((r) => {
-        const o = () => {
-          a.iceGatheringState === "complete" && (a.removeEventListener("icegatheringstatechange", o), r());
+      new Promise((o) => {
+        const n = () => {
+          r.iceGatheringState === "complete" && (r.removeEventListener("icegatheringstatechange", n), o());
         };
-        a.addEventListener("icegatheringstatechange", o);
+        r.addEventListener("icegatheringstatechange", n);
       }),
-      new Promise((r, o) => {
+      new Promise((o, n) => {
         setTimeout(() => {
-          t ? r() : (console.error("[ICE] timeout with NO srflx candidate! Connection may fail."), o(new Error("ICE gathering timeout without srflx candidate")));
+          t ? o() : (console.error("[ICE] timeout with NO srflx candidate! Connection may fail."), n(new Error("ICE gathering timeout without srflx candidate")));
         }, e);
       })
     ]);
   } finally {
-    a.removeEventListener("icecandidate", n);
+    r.removeEventListener("icecandidate", a);
   }
 }
-function I(a) {
+function z(r) {
   return new Promise((e) => {
-    a.addEventListener("track", (t) => {
+    r.addEventListener("track", (t) => {
       t.streams && t.streams[0] && e(t.streams[0]);
     });
   });
 }
-const D = [
+const H = [
   { urls: ["stun:stun.l.google.com:19302"] }
 ];
-async function x(a, e) {
-  const t = e ?? D, n = new RTCPeerConnection({
-    iceServers: t
+async function G(r, e, t) {
+  if (!r && !e || r && e)
+    throw new Error("Either localStream or file must be provided, but not both");
+  const a = t ?? H, o = new RTCPeerConnection({
+    iceServers: a
   });
   try {
-    n.addTransceiver("video", { direction: "recvonly" });
+    o.addTransceiver("video", { direction: "recvonly" });
   } catch (s) {
     console.warn("[RFWebRTC] Could not add transceiver:", s);
   }
-  a.getVideoTracks().forEach((s) => {
+  r && r.getVideoTracks().forEach((s) => {
     try {
       s.contentHint = "detail";
     } catch {
     }
-    n.addTrack(s, a);
+    o.addTrack(s, r);
   });
-  const r = I(n), o = n.createDataChannel("roboflow-control", {
+  const n = z(o), i = o.createDataChannel("inference", {
     ordered: !0
-  }), i = await n.createOffer();
-  return await n.setLocalDescription(i), await P(n), {
-    pc: n,
-    offer: n.localDescription,
-    remoteStreamPromise: r,
-    dataChannel: o
+  });
+  let l;
+  e && (l = o.createDataChannel("video_upload"));
+  const c = await o.createOffer();
+  return await o.setLocalDescription(c), await M(o), {
+    pc: o,
+    offer: o.localDescription,
+    remoteStreamPromise: n,
+    dataChannel: i,
+    uploadChannel: l
   };
 }
-async function N(a) {
-  const e = a.getSenders().find((n) => n.track && n.track.kind === "video");
+async function J(r) {
+  const e = r.getSenders().find((a) => a.track && a.track.kind === "video");
   if (!e) return;
   const t = e.getParameters();
   t.encodings = t.encodings || [{}], t.encodings[0].scaleResolutionDownBy = 1;
   try {
     await e.setParameters(t);
-  } catch (n) {
-    console.warn("[RFWebRTC] Failed to set encoding parameters:", n);
+  } catch (a) {
+    console.warn("[RFWebRTC] Failed to set encoding parameters:", a);
   }
 }
-class R {
+function Z(r, e = 3e4) {
+  return new Promise((t, a) => {
+    if (r.readyState === "open") {
+      t();
+      return;
+    }
+    const o = () => {
+      r.removeEventListener("open", o), r.removeEventListener("error", n), clearTimeout(i), t();
+    }, n = () => {
+      r.removeEventListener("open", o), r.removeEventListener("error", n), clearTimeout(i), a(new Error("Datachannel error"));
+    }, i = setTimeout(() => {
+      r.removeEventListener("open", o), r.removeEventListener("error", n), a(new Error("Datachannel open timeout"));
+    }, e);
+    r.addEventListener("open", o), r.addEventListener("error", n);
+  });
+}
+class O {
   /** @private */
-  constructor(e, t, n, r, o, i, s) {
-    u(this, "pc");
-    u(this, "_localStream");
-    u(this, "remoteStreamPromise");
-    u(this, "pipelineId");
-    u(this, "apiKey");
-    u(this, "dataChannel");
-    u(this, "reassembler");
-    this.pc = e, this._localStream = t, this.remoteStreamPromise = n, this.pipelineId = r, this.apiKey = o, this.dataChannel = i, this.reassembler = new b(), this.dataChannel.binaryType = "arraybuffer", s && (this.dataChannel.addEventListener("open", () => {
-    }), this.dataChannel.addEventListener("message", (d) => {
+  constructor(e, t, a, o, n, i) {
+    d(this, "pc");
+    d(this, "_localStream");
+    d(this, "remoteStreamPromise");
+    d(this, "pipelineId");
+    d(this, "apiKey");
+    d(this, "dataChannel");
+    d(this, "reassembler");
+    d(this, "uploadChannel");
+    d(this, "uploader");
+    d(this, "onComplete");
+    this.pc = e, this._localStream = i == null ? void 0 : i.localStream, this.remoteStreamPromise = t, this.pipelineId = a, this.apiKey = o, this.dataChannel = n, this.reassembler = new P(), this.uploadChannel = i == null ? void 0 : i.uploadChannel, this.onComplete = i == null ? void 0 : i.onComplete, this.dataChannel.binaryType = "arraybuffer";
+    const l = i == null ? void 0 : i.onData;
+    l && (this.dataChannel.addEventListener("message", (c) => {
       try {
-        if (d.data instanceof ArrayBuffer) {
-          const { frameId: c, chunkIndex: l, totalChunks: p, payload: y } = C(d.data), w = this.reassembler.processChunk(c, l, p, y);
+        if (c.data instanceof ArrayBuffer) {
+          const { frameId: s, chunkIndex: u, totalChunks: h, payload: y } = L(c.data), w = this.reassembler.processChunk(s, u, h, y);
           if (w) {
-            const S = new TextDecoder("utf-8").decode(w), f = JSON.parse(S);
-            s(f);
+            const g = new TextDecoder("utf-8").decode(w), v = JSON.parse(g);
+            l(v);
           }
         } else {
-          const c = JSON.parse(d.data);
-          s(c);
+          const s = JSON.parse(c.data);
+          l(s);
         }
-      } catch (c) {
-        console.error("[RFWebRTC] Failed to parse data channel message:", c);
+      } catch (s) {
+        console.error("[RFWebRTC] Failed to parse data channel message:", s);
       }
-    }), this.dataChannel.addEventListener("error", (d) => {
-      console.error("[RFWebRTC] Data channel error:", d);
-    }), this.dataChannel.addEventListener("close", () => {
-      this.reassembler.clear();
-    }));
+    }), this.dataChannel.addEventListener("error", (c) => {
+      console.error("[RFWebRTC] Data channel error:", c);
+    })), this.dataChannel.addEventListener("close", () => {
+      this.reassembler.clear(), this.onComplete && this.onComplete();
+    });
   }
   /**
    * Get the remote stream (processed video from Roboflow)
@@ -402,13 +559,15 @@ class R {
   /**
    * Get the local stream (original camera)
    *
-   * @returns The local MediaStream
+   * @returns The local MediaStream, or undefined if using file upload mode
    *
    * @example
    * ```typescript
    * const conn = await useStream({ ... });
    * const localStream = conn.localStream();
-   * videoElement.srcObject = localStream;
+   * if (localStream) {
+   *   videoElement.srcObject = localStream;
+   * }
    * ```
    */
   localStream() {
@@ -418,7 +577,7 @@ class R {
    * Cleanup and close connection
    *
    * Terminates the pipeline on Roboflow, closes the peer connection,
-   * and stops the local media stream.
+   * and stops the local media stream (if applicable).
    *
    * @returns Promise that resolves when cleanup is complete
    *
@@ -430,7 +589,39 @@ class R {
    * ```
    */
   async cleanup() {
-    this.reassembler.clear(), this.pipelineId && this.apiKey && await _.init({ apiKey: this.apiKey }).terminatePipeline({ pipelineId: this.pipelineId }), this.pc && this.pc.connectionState !== "closed" && this.pc.close(), v(this._localStream);
+    if (this.uploader && this.uploader.cancel(), this.reassembler.clear(), this.pipelineId && this.apiKey)
+      try {
+        await b.init({ apiKey: this.apiKey }).terminatePipeline({ pipelineId: this.pipelineId });
+      } catch (e) {
+        console.warn("[RFWebRTC] Failed to terminate pipeline:", e);
+      }
+    this.pc && this.pc.connectionState !== "closed" && this.pc.close(), this._localStream && W(this._localStream);
+  }
+  /**
+   * Start uploading a file through the connection
+   *
+   * @param file - The file to upload
+   * @param onProgress - Optional callback for progress updates (bytesUploaded, totalBytes)
+   * @returns Promise that resolves when upload is complete
+   * @throws Error if no upload channel is available
+   *
+   * @example
+   * ```typescript
+   * await connection.startUpload(videoFile, (uploaded, total) => {
+   *   console.log(`Upload progress: ${(uploaded / total * 100).toFixed(1)}%`);
+   * });
+   * ```
+   */
+  async startUpload(e, t) {
+    if (!this.uploadChannel)
+      throw new Error("No upload channel available. This connection was not created for file uploads.");
+    await Z(this.uploadChannel), this.uploader = new I(e, this.uploadChannel), await this.uploader.upload(t);
+  }
+  /**
+   * Cancel any ongoing file upload
+   */
+  cancelUpload() {
+    this.uploader && this.uploader.cancel();
   }
   /**
    * Reconfigure pipeline outputs at runtime
@@ -485,47 +676,117 @@ class R {
     }
   }
 }
-async function U({
-  source: a,
+async function D({
+  source: r,
   connector: e,
   wrtcParams: t,
-  onData: n,
-  options: r = {}
+  onData: a,
+  onComplete: o,
+  onFileUploadProgress: n,
+  options: i = {}
 }) {
-  var f;
+  var k;
   if (!e || typeof e.connectWrtc != "function")
     throw new Error("connector must have a connectWrtc method");
-  const o = a, { pc: i, offer: s, remoteStreamPromise: d, dataChannel: c } = await x(
-    o,
-    t.iceServers
-  ), l = await e.connectWrtc(
-    { sdp: s.sdp, type: s.type },
-    t
-  ), p = { sdp: l.sdp, type: l.type };
+  const l = r instanceof File, c = l ? void 0 : r, s = l ? r : void 0;
+  let u = t.iceServers;
+  if ((!u || u.length === 0) && e.getIceServers)
+    try {
+      const f = await e.getIceServers();
+      f && f.length > 0 && (u = f, console.log("[RFWebRTC] Using TURN servers from connector"));
+    } catch (f) {
+      console.warn("[RFWebRTC] Failed to fetch TURN config, using defaults:", f);
+    }
+  const { pc: h, offer: y, remoteStreamPromise: w, dataChannel: R, uploadChannel: g } = await G(
+    c,
+    s,
+    u
+  ), v = {
+    ...t,
+    iceServers: u,
+    realtimeProcessing: t.realtimeProcessing ?? !l
+  }, m = await e.connectWrtc(
+    { sdp: y.sdp, type: y.type },
+    v
+  ), p = { sdp: m.sdp, type: m.type };
   if (!(p != null && p.sdp) || !(p != null && p.type))
-    throw console.error("[RFWebRTC] Invalid answer from server:", l), new Error("connector.connectWrtc must return answer with sdp and type");
-  const y = ((f = l == null ? void 0 : l.context) == null ? void 0 : f.pipeline_id) || null;
-  await i.setRemoteDescription(p), await new Promise((g, m) => {
-    const h = () => {
-      i.connectionState === "connected" ? (i.removeEventListener("connectionstatechange", h), g()) : i.connectionState === "failed" && (i.removeEventListener("connectionstatechange", h), m(new Error("WebRTC connection failed")));
+    throw console.error("[RFWebRTC] Invalid answer from server:", m), new Error("connector.connectWrtc must return answer with sdp and type");
+  const S = ((k = m == null ? void 0 : m.context) == null ? void 0 : k.pipeline_id) || null;
+  await h.setRemoteDescription(p), await new Promise((f, F) => {
+    const _ = () => {
+      h.connectionState === "connected" ? (h.removeEventListener("connectionstatechange", _), f()) : h.connectionState === "failed" && (h.removeEventListener("connectionstatechange", _), F(new Error("WebRTC connection failed")));
     };
-    i.addEventListener("connectionstatechange", h), h(), setTimeout(() => {
-      i.removeEventListener("connectionstatechange", h), m(new Error("WebRTC connection timeout after 30s"));
+    h.addEventListener("connectionstatechange", _), _(), setTimeout(() => {
+      h.removeEventListener("connectionstatechange", _), F(new Error("WebRTC connection timeout after 30s"));
     }, 3e4);
-  }), r.disableInputStreamDownscaling !== !1 && await N(i);
-  const k = e._apiKey || null;
-  return new R(i, o, d, y, k, c, n);
+  }), c && i.disableInputStreamDownscaling !== !1 && await J(h);
+  const C = e._apiKey || null, E = new O(
+    h,
+    w,
+    S,
+    C,
+    R,
+    {
+      localStream: c,
+      uploadChannel: g,
+      onData: a,
+      onComplete: o
+    }
+  );
+  return s && g && E.startUpload(s, n).catch((f) => {
+    console.error("[RFWebRTC] Upload error:", f);
+  }), E;
+}
+async function Q({
+  source: r,
+  connector: e,
+  wrtcParams: t,
+  onData: a,
+  options: o = {}
+}) {
+  if (r instanceof File)
+    throw new Error("useStream requires a MediaStream. Use useVideoFile for File uploads.");
+  return D({
+    source: r,
+    connector: e,
+    wrtcParams: t,
+    onData: a,
+    options: o
+  });
+}
+async function X({
+  file: r,
+  connector: e,
+  wrtcParams: t,
+  onData: a,
+  onUploadProgress: o,
+  onComplete: n
+}) {
+  return D({
+    source: r,
+    connector: e,
+    wrtcParams: {
+      ...t,
+      realtimeProcessing: t.realtimeProcessing ?? !0
+    },
+    onData: a,
+    onComplete: n,
+    onFileUploadProgress: o
+  });
 }
-const $ = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const re = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  ChunkReassembler: b,
-  RFWebRTCConnection: R,
-  parseBinaryHeader: C,
-  useStream: U
+  ChunkReassembler: P,
+  FileUploader: I,
+  RFWebRTCConnection: O,
+  parseBinaryHeader: L,
+  useStream: Q,
+  useVideoFile: X
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  _ as InferenceHTTPClient,
-  K as connectors,
-  j as streams,
-  $ as webrtc
+  b as InferenceHTTPClient,
+  ee as connectors,
+  te as streams,
+  re as webrtc
 };
+//# sourceMappingURL=index.es.js.map