@dropgate/core 2.0.0-beta.2 → 2.1.0

package/dist/index.js

@@ -309,6 +309,37 @@ function estimateTotalUploadSizeBytes(fileSizeBytes, totalChunks, isEncrypted) {
   if (!isEncrypted) return base;
   return base + (Number(totalChunks) || 0) * ENCRYPTION_OVERHEAD_PER_CHUNK;
 }
+async function getServerInfo(opts) {
+  const { host, port, secure, timeoutMs = 5e3, signal, fetchFn: customFetch } = opts;
+  const fetchFn = customFetch || getDefaultFetch();
+  if (!fetchFn) {
+    throw new DropgateValidationError("No fetch() implementation found.");
+  }
+  const baseUrl = buildBaseUrl({ host, port, secure });
+  try {
+    const { res, json } = await fetchJson(
+      fetchFn,
+      `${baseUrl}/api/info`,
+      {
+        method: "GET",
+        timeoutMs,
+        signal,
+        headers: { Accept: "application/json" }
+      }
+    );
+    if (res.ok && json && typeof json === "object" && "version" in json) {
+      return { baseUrl, serverInfo: json };
+    }
+    throw new DropgateProtocolError(
+      `Server info request failed (status ${res.status}).`
+    );
+  } catch (err) {
+    if (err instanceof DropgateError) throw err;
+    throw new DropgateNetworkError("Could not reach server /api/info.", {
+      cause: err
+    });
+  }
+}
 var DropgateClient = class {
   /**
    * Create a new DropgateClient instance.
@@ -336,40 +367,6 @@ var DropgateClient = class {
     this.base64 = opts.base64 || getDefaultBase64();
     this.logger = opts.logger || null;
   }
-  /**
-   * Fetch server information from the /api/info endpoint.
-   * @param opts - Server target and request options.
-   * @returns The server base URL and server info object.
-   * @throws {DropgateNetworkError} If the server cannot be reached.
-   * @throws {DropgateProtocolError} If the server returns an invalid response.
-   */
-  async getServerInfo(opts) {
-    const { host, port, secure, timeoutMs = 5e3, signal } = opts;
-    const baseUrl = buildBaseUrl({ host, port, secure });
-    try {
-      const { res, json } = await fetchJson(
-        this.fetchFn,
-        `${baseUrl}/api/info`,
-        {
-          method: "GET",
-          timeoutMs,
-          signal,
-          headers: { Accept: "application/json" }
-        }
-      );
-      if (res.ok && json && typeof json === "object" && "version" in json) {
-        return { baseUrl, serverInfo: json };
-      }
-      throw new DropgateProtocolError(
-        `Server info request failed (status ${res.status}).`
-      );
-    } catch (err) {
-      if (err instanceof DropgateError) throw err;
-      throw new DropgateNetworkError("Could not reach server /api/info.", {
-        cause: err
-      });
-    }
-  }
   /**
    * Resolve a user-entered sharing code or URL via the server.
    * @param value - The sharing code or URL to resolve.
@@ -378,8 +375,12 @@ var DropgateClient = class {
    * @throws {DropgateProtocolError} If the share lookup fails.
    */
   async resolveShareTarget(value, opts) {
-    const { host, port, secure, timeoutMs = 5e3, signal } = opts;
-    const baseUrl = buildBaseUrl({ host, port, secure });
+    const { timeoutMs = 5e3, signal } = opts;
+    const compat = await this.checkCompatibility(opts);
+    if (!compat.compatible) {
+      throw new DropgateValidationError(compat.message);
+    }
+    const { baseUrl } = compat;
     const { res, json } = await fetchJson(
       this.fetchFn,
       `${baseUrl}/api/resolve`,
@@ -402,10 +403,25 @@ var DropgateClient = class {
   }
   /**
    * Check version compatibility between this client and a server.
-   * @param serverInfo - Server info containing the version to check against.
-   * @returns Compatibility result with status and message.
+   * Fetches server info internally using getServerInfo.
+   * @param opts - Server target and request options.
+   * @returns Compatibility result with status, message, and server info.
+   * @throws {DropgateNetworkError} If the server cannot be reached.
+   * @throws {DropgateProtocolError} If the server returns an invalid response.
    */
-  checkCompatibility(serverInfo) {
+  async checkCompatibility(opts) {
+    let baseUrl;
+    let serverInfo;
+    try {
+      const result = await getServerInfo({ ...opts, fetchFn: this.fetchFn });
+      baseUrl = result.baseUrl;
+      serverInfo = result.serverInfo;
+    } catch (err) {
+      if (err instanceof DropgateError) throw err;
+      throw new DropgateNetworkError("Could not connect to the server.", {
+        cause: err
+      });
+    }
     const serverVersion = String(serverInfo?.version || "0.0.0");
     const clientVersion = String(this.clientVersion || "0.0.0");
     const c = parseSemverMajorMinor(clientVersion);
@@ -415,7 +431,9 @@ var DropgateClient = class {
         compatible: false,
         clientVersion,
         serverVersion,
-        message: `Incompatible versions. Client v${clientVersion}, Server v${serverVersion}${serverInfo?.name ? ` (${serverInfo.name})` : ""}.`
+        message: `Incompatible versions. Client v${clientVersion}, Server v${serverVersion}${serverInfo?.name ? ` (${serverInfo.name})` : ""}.`,
+        serverInfo,
+        baseUrl
       };
     }
     if (c.minor > s.minor) {
@@ -423,14 +441,18 @@ var DropgateClient = class {
         compatible: true,
         clientVersion,
         serverVersion,
-        message: `Client (v${clientVersion}) is newer than Server (v${serverVersion})${serverInfo?.name ? ` (${serverInfo.name})` : ""}. Some features may not work.`
+        message: `Client (v${clientVersion}) is newer than Server (v${serverVersion})${serverInfo?.name ? ` (${serverInfo.name})` : ""}. Some features may not work.`,
+        serverInfo,
+        baseUrl
       };
     }
     return {
       compatible: true,
       clientVersion,
       serverVersion,
-      message: `Server: v${serverVersion}, Client: v${clientVersion}${serverInfo?.name ? ` (${serverInfo.name})` : ""}.`
+      message: `Server: v${serverVersion}, Client: v${clientVersion}${serverInfo?.name ? ` (${serverInfo.name})` : ""}.`,
+      serverInfo,
+      baseUrl
     };
   }
   /**
@@ -524,27 +546,17 @@ var DropgateClient = class {
         "Web Crypto API not available (crypto.subtle)."
       );
     }
-    progress({ phase: "server-info", text: "Checking server..." });
-    let baseUrl;
-    let serverInfo;
-    try {
-      const res = await this.getServerInfo({
-        host,
-        port,
-        secure,
-        timeoutMs: timeouts.serverInfoMs ?? 5e3,
-        signal
-      });
-      baseUrl = res.baseUrl;
-      serverInfo = res.serverInfo;
-    } catch (err) {
-      if (err instanceof DropgateError) throw err;
-      throw new DropgateNetworkError("Could not connect to the server.", {
-        cause: err
-      });
-    }
-    const compat = this.checkCompatibility(serverInfo);
-    progress({ phase: "server-compat", text: compat.message });
+    const fileSizeBytes = file.size;
+    progress({ phase: "server-info", text: "Checking server...", percent: 0, processedBytes: 0, totalBytes: fileSizeBytes });
+    const compat = await this.checkCompatibility({
+      host,
+      port,
+      secure,
+      timeoutMs: timeouts.serverInfoMs ?? 5e3,
+      signal
+    });
+    const { baseUrl, serverInfo } = compat;
+    progress({ phase: "server-compat", text: compat.message, percent: 0, processedBytes: 0, totalBytes: fileSizeBytes });
     if (!compat.compatible) {
       throw new DropgateValidationError(compat.message);
     }
@@ -557,7 +569,7 @@ var DropgateClient = class {
     let keyB64 = null;
     let transmittedFilename = filename;
     if (encrypt) {
-      progress({ phase: "crypto", text: "Generating encryption key..." });
+      progress({ phase: "crypto", text: "Generating encryption key...", percent: 0, processedBytes: 0, totalBytes: fileSizeBytes });
       try {
         cryptoKey = await generateAesGcmKey(this.cryptoObj);
         keyB64 = await exportKeyBase64(this.cryptoObj, cryptoKey);
@@ -579,7 +591,7 @@ var DropgateClient = class {
       totalChunks,
       encrypt
     );
-    progress({ phase: "init", text: "Reserving server storage..." });
+    progress({ phase: "init", text: "Reserving server storage...", percent: 0, processedBytes: 0, totalBytes: fileSizeBytes });
     const initPayload = {
       filename: transmittedFilename,
       lifetime: lifetimeMs,
@@ -622,10 +634,13 @@ var DropgateClient = class {
       const end = Math.min(start + this.chunkSize, file.size);
       let chunkBlob = file.slice(start, end);
       const percentComplete = i / totalChunks * 100;
+      const processedBytes = i * this.chunkSize;
       progress({
         phase: "chunk",
         text: `Uploading chunk ${i + 1} of ${totalChunks}...`,
         percent: percentComplete,
+        processedBytes,
+        totalBytes: fileSizeBytes,
         chunkIndex: i,
         totalChunks
       });
@@ -665,11 +680,13 @@ var DropgateClient = class {
           signal,
           progress,
           chunkIndex: i,
-          totalChunks
+          totalChunks,
+          chunkSize: this.chunkSize,
+          fileSizeBytes
         }
       );
     }
-    progress({ phase: "complete", text: "Finalising upload...", percent: 100 });
+    progress({ phase: "complete", text: "Finalising upload...", percent: 100, processedBytes: fileSizeBytes, totalBytes: fileSizeBytes });
     const completeRes = await fetchJson(
       this.fetchFn,
       `${baseUrl}/upload/complete`,
@@ -702,7 +719,7 @@ var DropgateClient = class {
     if (encrypt && keyB64) {
       downloadUrl += `#${keyB64}`;
     }
-    progress({ phase: "done", text: "Upload successful!", percent: 100 });
+    progress({ phase: "done", text: "Upload successful!", percent: 100, processedBytes: fileSizeBytes, totalBytes: fileSizeBytes });
     return {
       downloadUrl,
       fileId,
@@ -748,8 +765,20 @@ var DropgateClient = class {
     if (!fileId || typeof fileId !== "string") {
       throw new DropgateValidationError("File ID is required.");
     }
-    const baseUrl = buildBaseUrl({ host, port, secure });
-    progress({ phase: "metadata", text: "Fetching file info...", receivedBytes: 0, totalBytes: 0, percent: 0 });
+    progress({ phase: "server-info", text: "Checking server...", processedBytes: 0, totalBytes: 0, percent: 0 });
+    const compat = await this.checkCompatibility({
+      host,
+      port,
+      secure,
+      timeoutMs,
+      signal
+    });
+    const { baseUrl } = compat;
+    progress({ phase: "server-compat", text: compat.message, processedBytes: 0, totalBytes: 0, percent: 0 });
+    if (!compat.compatible) {
+      throw new DropgateValidationError(compat.message);
+    }
+    progress({ phase: "metadata", text: "Fetching file info...", processedBytes: 0, totalBytes: 0, percent: 0 });
     const { signal: metaSignal, cleanup: metaCleanup } = makeAbortSignal(signal, timeoutMs);
     let metadata;
     try {
@@ -792,7 +821,7 @@ var DropgateClient = class {
       if (!this.cryptoObj?.subtle) {
         throw new DropgateValidationError("Web Crypto API not available for decryption.");
       }
-      progress({ phase: "decrypting", text: "Preparing decryption...", receivedBytes: 0, totalBytes: 0, percent: 0 });
+      progress({ phase: "decrypting", text: "Preparing decryption...", processedBytes: 0, totalBytes: 0, percent: 0 });
       try {
         cryptoKey = await importKeyFromBase64(this.cryptoObj, keyB64, this.base64);
         filename = await decryptFilenameFromBase64(
@@ -810,7 +839,7 @@ var DropgateClient = class {
     } else {
       filename = metadata.filename || "file";
     }
-    progress({ phase: "downloading", text: "Starting download...", percent: 0, receivedBytes: 0, totalBytes });
+    progress({ phase: "downloading", text: "Starting download...", percent: 0, processedBytes: 0, totalBytes });
     const { signal: downloadSignal, cleanup: downloadCleanup } = makeAbortSignal(signal, timeoutMs);
     let receivedBytes = 0;
     const dataChunks = [];
@@ -879,7 +908,7 @@ var DropgateClient = class {
             phase: "decrypting",
             text: `Downloading & decrypting... (${percent}%)`,
             percent,
-            receivedBytes,
+            processedBytes: receivedBytes,
             totalBytes
           });
         }
@@ -911,7 +940,7 @@ var DropgateClient = class {
             phase: "downloading",
             text: `Downloading... (${percent}%)`,
             percent,
-            receivedBytes,
+            processedBytes: receivedBytes,
             totalBytes
           });
         }
@@ -925,7 +954,7 @@ var DropgateClient = class {
     } finally {
       downloadCleanup();
     }
-    progress({ phase: "complete", text: "Download complete!", percent: 100, receivedBytes, totalBytes });
+    progress({ phase: "complete", text: "Download complete!", percent: 100, processedBytes: receivedBytes, totalBytes });
     let data;
     if (collectData && dataChunks.length > 0) {
       const totalLength = dataChunks.reduce((sum, chunk) => sum + chunk.length, 0);
@@ -952,7 +981,9 @@ var DropgateClient = class {
       signal,
       progress,
       chunkIndex,
-      totalChunks
+      totalChunks,
+      chunkSize,
+      fileSizeBytes
     } = opts;
     let attemptsLeft = retries;
     let currentBackoff = backoffMs;
@@ -985,6 +1016,8 @@ var DropgateClient = class {
           throw err instanceof DropgateError ? err : new DropgateNetworkError("Chunk upload failed.", { cause: err });
         }
         const attemptNumber = maxRetries - attemptsLeft + 1;
+        const processedBytes = chunkIndex * chunkSize;
+        const percent = chunkIndex / totalChunks * 100;
         let remaining = currentBackoff;
         const tick = 100;
         while (remaining > 0) {
@@ -992,6 +1025,9 @@ var DropgateClient = class {
           progress({
             phase: "retry-wait",
             text: `Chunk upload failed. Retrying in ${secondsLeft}s... (${attemptNumber}/${maxRetries})`,
+            percent,
+            processedBytes,
+            totalBytes: fileSizeBytes,
             chunkIndex,
             totalChunks
           });
@@ -1001,6 +1037,9 @@ var DropgateClient = class {
         progress({
           phase: "retry",
           text: `Chunk upload failed. Retrying now... (${attemptNumber}/${maxRetries})`,
+          percent,
+          processedBytes,
+          totalBytes: fileSizeBytes,
           chunkIndex,
           totalChunks
         });
@@ -1023,11 +1062,11 @@ function isSecureContextForP2P(hostname, isSecureContext) {
   return Boolean(isSecureContext) || isLocalhostHostname(hostname || "");
 }
 function generateP2PCode(cryptoObj) {
-  const crypto = cryptoObj || getDefaultCrypto();
+  const crypto2 = cryptoObj || getDefaultCrypto();
   const letters = "ABCDEFGHJKLMNPQRSTUVWXYZ";
-  if (crypto) {
+  if (crypto2) {
     const randomBytes = new Uint8Array(8);
-    crypto.getRandomValues(randomBytes);
+    crypto2.getRandomValues(randomBytes);
     let letterPart = "";
     for (let i = 0; i < 4; i++) {
       letterPart += letters[randomBytes[i] % letters.length];
@@ -1053,8 +1092,14 @@ function isP2PCodeLike(code) {
 }
 
 // src/p2p/helpers.ts
-function buildPeerOptions(opts = {}) {
-  const { host, port, peerjsPath = "/peerjs", secure = false, iceServers = [] } = opts;
+function resolvePeerConfig(userConfig, serverCaps) {
+  return {
+    path: userConfig.peerjsPath ?? serverCaps?.peerjsPath ?? "/peerjs",
+    iceServers: userConfig.iceServers ?? serverCaps?.iceServers ?? []
+  };
+}
+function buildPeerOptions(config = {}) {
+  const { host, port, peerjsPath = "/peerjs", secure = false, iceServers = [] } = config;
   const peerOpts = {
     host,
     path: peerjsPath,
@@ -1096,6 +1141,12 @@ async function createPeerWithRetries(opts) {
 }
 
 // src/p2p/send.ts
+function generateSessionId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
 async function startP2PSend(opts) {
   const {
     file,
@@ -1110,15 +1161,16 @@ async function startP2PSend(opts) {
     cryptoObj,
     maxAttempts = 4,
     chunkSize = 256 * 1024,
-    readyTimeoutMs = 8e3,
     endAckTimeoutMs = 15e3,
     bufferHighWaterMark = 8 * 1024 * 1024,
     bufferLowWaterMark = 2 * 1024 * 1024,
+    heartbeatIntervalMs = 5e3,
     onCode,
     onStatus,
     onProgress,
     onComplete,
-    onError
+    onError,
+    onDisconnect
   } = opts;
   if (!file) {
     throw new DropgateValidationError("File is missing.");
@@ -1132,8 +1184,10 @@ async function startP2PSend(opts) {
   if (serverInfo && !p2pCaps?.enabled) {
     throw new DropgateValidationError("Direct transfer is disabled on this server.");
   }
-  const finalPath = peerjsPath ?? p2pCaps?.peerjsPath ?? "/peerjs";
-  const finalIceServers = iceServers ?? p2pCaps?.iceServers ?? [];
+  const { path: finalPath, iceServers: finalIceServers } = resolvePeerConfig(
+    { peerjsPath, iceServers },
+    p2pCaps
+  );
   const peerOpts = buildPeerOptions({
     host,
     port,
@@ -1150,18 +1204,37 @@ async function startP2PSend(opts) {
     buildPeer,
     onCode
   });
-  let stopped = false;
+  const sessionId = generateSessionId();
+  let state = "listening";
   let activeConn = null;
-  let transferActive = false;
-  let transferCompleted = false;
+  let sentBytes = 0;
+  let heartbeatTimer = null;
   const reportProgress = (data) => {
     const safeTotal = Number.isFinite(data.total) && data.total > 0 ? data.total : file.size;
     const safeReceived = Math.min(Number(data.received) || 0, safeTotal || 0);
     const percent = safeTotal ? safeReceived / safeTotal * 100 : 0;
-    onProgress?.({ sent: safeReceived, total: safeTotal, percent });
+    onProgress?.({ processedBytes: safeReceived, totalBytes: safeTotal, percent });
   };
-  const stop = () => {
-    stopped = true;
+  const safeError = (err) => {
+    if (state === "closed" || state === "completed") return;
+    state = "closed";
+    onError?.(err);
+    cleanup();
+  };
+  const safeComplete = () => {
+    if (state !== "finishing") return;
+    state = "completed";
+    onComplete?.();
+    cleanup();
+  };
+  const cleanup = () => {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+    if (typeof window !== "undefined") {
+      window.removeEventListener("beforeunload", handleUnload);
+    }
     try {
       activeConn?.close();
     } catch {
@@ -1171,21 +1244,59 @@ async function startP2PSend(opts) {
     } catch {
     }
   };
+  const handleUnload = () => {
+    try {
+      activeConn?.send({ t: "error", message: "Sender closed the connection." });
+    } catch {
+    }
+    stop();
+  };
+  if (typeof window !== "undefined") {
+    window.addEventListener("beforeunload", handleUnload);
+  }
+  const stop = () => {
+    if (state === "closed") return;
+    state = "closed";
+    cleanup();
+  };
+  const isStopped = () => state === "closed";
   peer.on("connection", (conn) => {
-    if (stopped) return;
+    if (state === "closed") return;
     if (activeConn) {
-      try {
-        conn.send({ t: "error", message: "Another receiver is already connected." });
-      } catch {
-      }
-      try {
-        conn.close();
-      } catch {
+      const isOldConnOpen = activeConn.open !== false;
+      if (isOldConnOpen && state === "transferring") {
+        try {
+          conn.send({ t: "error", message: "Transfer already in progress." });
+        } catch {
+        }
+        try {
+          conn.close();
+        } catch {
+        }
+        return;
+      } else if (!isOldConnOpen) {
+        try {
+          activeConn.close();
+        } catch {
+        }
+        activeConn = null;
+        state = "listening";
+        sentBytes = 0;
+      } else {
+        try {
+          conn.send({ t: "error", message: "Another receiver is already connected." });
+        } catch {
+        }
+        try {
+          conn.close();
+        } catch {
+        }
+        return;
       }
-      return;
     }
     activeConn = conn;
-    onStatus?.({ phase: "connected", message: "Connected. Starting transfer..." });
+    state = "negotiating";
+    onStatus?.({ phase: "waiting", message: "Connected. Waiting for receiver to accept..." });
     let readyResolve = null;
     let ackResolve = null;
     const readyPromise = new Promise((resolve) => {
@@ -1201,6 +1312,7 @@ async function startP2PSend(opts) {
       const msg = data;
       if (!msg.t) return;
       if (msg.t === "ready") {
+        onStatus?.({ phase: "transferring", message: "Receiver accepted. Starting transfer..." });
         readyResolve?.();
         return;
       }
@@ -1212,22 +1324,23 @@ async function startP2PSend(opts) {
         ackResolve?.(msg);
         return;
       }
+      if (msg.t === "pong") {
+        return;
+      }
       if (msg.t === "error") {
-        onError?.(new DropgateNetworkError(msg.message || "Receiver reported an error."));
-        stop();
+        safeError(new DropgateNetworkError(msg.message || "Receiver reported an error."));
       }
     });
     conn.on("open", async () => {
       try {
-        transferActive = true;
-        if (stopped) return;
+        if (isStopped()) return;
         conn.send({
           t: "meta",
+          sessionId,
           name: file.name,
           size: file.size,
           mime: file.type || "application/octet-stream"
         });
-        let sent = 0;
         const total = file.size;
         const dc = conn._dc;
         if (dc && Number.isFinite(bufferLowWaterMark)) {
@@ -1236,13 +1349,25 @@ async function startP2PSend(opts) {
           } catch {
           }
         }
-        await Promise.race([readyPromise, sleep(readyTimeoutMs).catch(() => null)]);
+        await readyPromise;
+        if (isStopped()) return;
+        if (heartbeatIntervalMs > 0) {
+          heartbeatTimer = setInterval(() => {
+            if (state === "transferring" || state === "finishing") {
+              try {
+                conn.send({ t: "ping" });
+              } catch {
+              }
+            }
+          }, heartbeatIntervalMs);
+        }
+        state = "transferring";
         for (let offset = 0; offset < total; offset += chunkSize) {
-          if (stopped) return;
+          if (isStopped()) return;
           const slice = file.slice(offset, offset + chunkSize);
           const buf = await slice.arrayBuffer();
           conn.send(buf);
-          sent += buf.byteLength;
+          sentBytes += buf.byteLength;
           if (dc) {
             while (dc.bufferedAmount > bufferHighWaterMark) {
               await new Promise((resolve) => {
@@ -1262,13 +1387,15 @@ async function startP2PSend(opts) {
             }
           }
         }
-        if (stopped) return;
+        if (isStopped()) return;
+        state = "finishing";
         conn.send({ t: "end" });
         const ackTimeoutMs = Number.isFinite(endAckTimeoutMs) ? Math.max(endAckTimeoutMs, Math.ceil(file.size / (1024 * 1024)) * 1e3) : null;
         const ackResult = await Promise.race([
           ackPromise,
           sleep(ackTimeoutMs || 15e3).catch(() => null)
         ]);
+        if (isStopped()) return;
         if (!ackResult || typeof ackResult !== "object") {
           throw new DropgateNetworkError("Receiver did not confirm completion.");
         }
@@ -1279,29 +1406,43 @@ async function startP2PSend(opts) {
           throw new DropgateNetworkError("Receiver reported an incomplete transfer.");
         }
         reportProgress({ received: ackReceived || ackTotal, total: ackTotal });
-        transferCompleted = true;
-        transferActive = false;
-        onComplete?.();
-        stop();
+        safeComplete();
       } catch (err) {
-        onError?.(err);
-        stop();
+        safeError(err);
       }
     });
     conn.on("error", (err) => {
-      onError?.(err);
-      stop();
+      safeError(err);
     });
     conn.on("close", () => {
-      if (!transferCompleted && transferActive && !stopped) {
-        onError?.(
+      if (state === "closed" || state === "completed") {
+        cleanup();
+        return;
+      }
+      if (state === "transferring" || state === "finishing") {
+        safeError(
           new DropgateNetworkError("Receiver disconnected before transfer completed.")
         );
+      } else {
+        activeConn = null;
+        state = "listening";
+        sentBytes = 0;
+        onDisconnect?.();
       }
-      stop();
     });
   });
-  return { peer, code, stop };
+  return {
+    peer,
+    code,
+    sessionId,
+    stop,
+    getStatus: () => state,
+    getBytesSent: () => sentBytes,
+    getConnectedPeerId: () => {
+      if (!activeConn) return null;
+      return activeConn.peer || null;
+    }
+  };
 }
 
 // src/p2p/receive.ts
@@ -1315,6 +1456,8 @@ async function startP2PReceive(opts) {
     peerjsPath,
     secure = false,
     iceServers,
+    autoReady = true,
+    watchdogTimeoutMs = 15e3,
     onStatus,
     onMeta,
     onData,
@@ -1339,8 +1482,10 @@ async function startP2PReceive(opts) {
   if (!isP2PCodeLike(normalizedCode)) {
     throw new DropgateValidationError("Invalid direct transfer code.");
   }
-  const finalPath = peerjsPath ?? p2pCaps?.peerjsPath ?? "/peerjs";
-  const finalIceServers = iceServers ?? p2pCaps?.iceServers ?? [];
+  const { path: finalPath, iceServers: finalIceServers } = resolvePeerConfig(
+    { peerjsPath, iceServers },
+    p2pCaps
+  );
   const peerOpts = buildPeerOptions({
     host,
     port,
@@ -1349,44 +1494,127 @@ async function startP2PReceive(opts) {
     iceServers: finalIceServers
   });
   const peer = new Peer(void 0, peerOpts);
+  let state = "initializing";
   let total = 0;
   let received = 0;
+  let currentSessionId = null;
   let lastProgressSentAt = 0;
   const progressIntervalMs = 120;
   let writeQueue = Promise.resolve();
-  const stop = () => {
+  let watchdogTimer = null;
+  let activeConn = null;
+  const resetWatchdog = () => {
+    if (watchdogTimeoutMs <= 0) return;
+    if (watchdogTimer) {
+      clearTimeout(watchdogTimer);
+    }
+    watchdogTimer = setTimeout(() => {
+      if (state === "transferring") {
+        safeError(new DropgateNetworkError("Connection timed out (no data received)."));
+      }
+    }, watchdogTimeoutMs);
+  };
+  const clearWatchdog = () => {
+    if (watchdogTimer) {
+      clearTimeout(watchdogTimer);
+      watchdogTimer = null;
+    }
+  };
+  const safeError = (err) => {
+    if (state === "closed" || state === "completed") return;
+    state = "closed";
+    onError?.(err);
+    cleanup();
+  };
+  const safeComplete = (completeData) => {
+    if (state !== "transferring") return;
+    state = "completed";
+    onComplete?.(completeData);
+    cleanup();
+  };
+  const cleanup = () => {
+    clearWatchdog();
+    if (typeof window !== "undefined") {
+      window.removeEventListener("beforeunload", handleUnload);
+    }
     try {
       peer.destroy();
     } catch {
     }
   };
-  peer.on("error", (err) => {
-    onError?.(err);
+  const handleUnload = () => {
+    try {
+      activeConn?.send({ t: "error", message: "Receiver closed the connection." });
+    } catch {
+    }
     stop();
+  };
+  if (typeof window !== "undefined") {
+    window.addEventListener("beforeunload", handleUnload);
+  }
+  const stop = () => {
+    if (state === "closed") return;
+    state = "closed";
+    cleanup();
+  };
+  peer.on("error", (err) => {
+    safeError(err);
   });
   peer.on("open", () => {
+    state = "connecting";
     const conn = peer.connect(normalizedCode, { reliable: true });
+    activeConn = conn;
     conn.on("open", () => {
+      state = "negotiating";
       onStatus?.({ phase: "connected", message: "Waiting for file details..." });
     });
     conn.on("data", async (data) => {
       try {
+        resetWatchdog();
         if (data && typeof data === "object" && !(data instanceof ArrayBuffer) && !ArrayBuffer.isView(data)) {
           const msg = data;
           if (msg.t === "meta") {
+            if (currentSessionId && msg.sessionId && msg.sessionId !== currentSessionId) {
+              try {
+                conn.send({ t: "error", message: "Busy with another session." });
+              } catch {
+              }
+              return;
+            }
+            if (msg.sessionId) {
+              currentSessionId = msg.sessionId;
+            }
             const name = String(msg.name || "file");
             total = Number(msg.size) || 0;
             received = 0;
             writeQueue = Promise.resolve();
-            onMeta?.({ name, total });
-            onProgress?.({ received, total, percent: 0 });
+            const sendReady = () => {
+              state = "transferring";
+              resetWatchdog();
+              try {
+                conn.send({ t: "ready" });
+              } catch {
+              }
+            };
+            if (autoReady) {
+              onMeta?.({ name, total });
+              onProgress?.({ processedBytes: received, totalBytes: total, percent: 0 });
+              sendReady();
+            } else {
+              onMeta?.({ name, total, sendReady });
+              onProgress?.({ processedBytes: received, totalBytes: total, percent: 0 });
+            }
+            return;
+          }
+          if (msg.t === "ping") {
             try {
-              conn.send({ t: "ready" });
+              conn.send({ t: "pong" });
             } catch {
             }
             return;
           }
           if (msg.t === "end") {
+            clearWatchdog();
             await writeQueue;
             if (total && received < total) {
               const err = new DropgateNetworkError(
@@ -1398,11 +1626,11 @@ async function startP2PReceive(opts) {
               }
               throw err;
             }
-            onComplete?.({ received, total });
             try {
               conn.send({ t: "ack", phase: "end", received, total });
             } catch {
             }
+            safeComplete({ received, total });
             return;
           }
           if (msg.t === "error") {
@@ -1429,7 +1657,7 @@ async function startP2PReceive(opts) {
           }
           received += buf.byteLength;
           const percent = total ? Math.min(100, received / total * 100) : 0;
-          onProgress?.({ received, total, percent });
+          onProgress?.({ processedBytes: received, totalBytes: total, percent });
           const now = Date.now();
           if (received === total || now - lastProgressSentAt >= progressIntervalMs) {
             lastProgressSentAt = now;
@@ -1446,21 +1674,36 @@ async function startP2PReceive(opts) {
             });
           } catch {
           }
-          onError?.(err);
-          stop();
+          safeError(err);
         });
       } catch (err) {
-        onError?.(err);
-        stop();
+        safeError(err);
       }
     });
     conn.on("close", () => {
-      if (received > 0 && total > 0 && received < total) {
+      if (state === "closed" || state === "completed") {
+        cleanup();
+        return;
+      }
+      if (state === "transferring") {
+        safeError(new DropgateNetworkError("Sender disconnected during transfer."));
+      } else if (state === "negotiating") {
+        state = "closed";
+        cleanup();
         onDisconnect?.();
+      } else {
+        safeError(new DropgateNetworkError("Sender disconnected before file details were received."));
       }
     });
   });
-  return { peer, stop };
+  return {
+    peer,
+    stop,
+    getStatus: () => state,
+    getBytesReceived: () => received,
+    getTotalBytes: () => total,
+    getSessionId: () => currentSessionId
+  };
 }
 export {
   AES_GCM_IV_BYTES,
@@ -1492,6 +1735,7 @@ export {
   getDefaultBase64,
   getDefaultCrypto,
   getDefaultFetch,
+  getServerInfo,
   importKeyFromBase64,
   isLocalhostHostname,
   isP2PCodeLike,
@@ -1500,6 +1744,7 @@ export {
   makeAbortSignal,
   parseSemverMajorMinor,
   parseServerUrl,
+  resolvePeerConfig,
   sha256Hex,
   sleep,
   startP2PReceive,