@dropgate/core 2.0.0-beta.2 → 2.2.0-beta.1

package/dist/index.cjs

@@ -49,6 +49,7 @@ __export(index_exports, {
   getDefaultBase64: () => getDefaultBase64,
   getDefaultCrypto: () => getDefaultCrypto,
   getDefaultFetch: () => getDefaultFetch,
+  getServerInfo: () => getServerInfo,
   importKeyFromBase64: () => importKeyFromBase64,
   isLocalhostHostname: () => isLocalhostHostname,
   isP2PCodeLike: () => isP2PCodeLike,
@@ -57,6 +58,7 @@ __export(index_exports, {
   makeAbortSignal: () => makeAbortSignal,
   parseSemverMajorMinor: () => parseSemverMajorMinor,
   parseServerUrl: () => parseServerUrl,
+  resolvePeerConfig: () => resolvePeerConfig,
   sha256Hex: () => sha256Hex,
   sleep: () => sleep,
   startP2PReceive: () => startP2PReceive,
@@ -376,6 +378,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.
@@ -403,40 +436,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.
@@ -445,8 +444,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`,
@@ -469,10 +472,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);
@@ -482,7 +500,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) {
@@ -490,14 +510,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
     };
   }
   /**
@@ -576,206 +600,251 @@ var DropgateClient = class {
       encrypt,
       filenameOverride,
       onProgress,
+      onCancel,
       signal,
       timeouts = {},
       retry = {}
     } = opts;
-    const progress = (evt) => {
-      try {
-        if (onProgress) onProgress(evt);
-      } catch {
-      }
-    };
-    if (!this.cryptoObj?.subtle) {
-      throw new DropgateValidationError(
-        "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 });
-    if (!compat.compatible) {
-      throw new DropgateValidationError(compat.message);
-    }
-    const filename = filenameOverride ?? file.name ?? "file";
-    if (!encrypt) {
-      validatePlainFilename(filename);
-    }
-    this.validateUploadInputs({ file, lifetimeMs, encrypt, serverInfo });
-    let cryptoKey = null;
-    let keyB64 = null;
-    let transmittedFilename = filename;
-    if (encrypt) {
-      progress({ phase: "crypto", text: "Generating encryption key..." });
+    const internalController = signal ? null : new AbortController();
+    const effectiveSignal = signal || internalController?.signal;
+    let uploadState = "initializing";
+    let currentUploadId = null;
+    let currentBaseUrl = null;
+    const uploadPromise = (async () => {
       try {
-        cryptoKey = await generateAesGcmKey(this.cryptoObj);
-        keyB64 = await exportKeyBase64(this.cryptoObj, cryptoKey);
-        transmittedFilename = await encryptFilenameToBase64(
-          this.cryptoObj,
-          filename,
-          cryptoKey
+        const progress = (evt) => {
+          try {
+            if (onProgress) onProgress(evt);
+          } catch {
+          }
+        };
+        if (!this.cryptoObj?.subtle) {
+          throw new DropgateValidationError(
+            "Web Crypto API not available (crypto.subtle)."
+          );
+        }
+        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: effectiveSignal
+        });
+        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);
+        }
+        const filename = filenameOverride ?? file.name ?? "file";
+        if (!encrypt) {
+          validatePlainFilename(filename);
+        }
+        this.validateUploadInputs({ file, lifetimeMs, encrypt, serverInfo });
+        let cryptoKey = null;
+        let keyB64 = null;
+        let transmittedFilename = filename;
+        if (encrypt) {
+          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);
+            transmittedFilename = await encryptFilenameToBase64(
+              this.cryptoObj,
+              filename,
+              cryptoKey
+            );
+          } catch (err) {
+            throw new DropgateError("Failed to prepare encryption.", {
+              code: "CRYPTO_PREP_FAILED",
+              cause: err
+            });
+          }
+        }
+        const totalChunks = Math.ceil(file.size / this.chunkSize);
+        const totalUploadSize = estimateTotalUploadSizeBytes(
+          file.size,
+          totalChunks,
+          encrypt
         );
-      } catch (err) {
-        throw new DropgateError("Failed to prepare encryption.", {
-          code: "CRYPTO_PREP_FAILED",
-          cause: err
+        progress({ phase: "init", text: "Reserving server storage...", percent: 0, processedBytes: 0, totalBytes: fileSizeBytes });
+        const initPayload = {
+          filename: transmittedFilename,
+          lifetime: lifetimeMs,
+          isEncrypted: Boolean(encrypt),
+          totalSize: totalUploadSize,
+          totalChunks
+        };
+        const initRes = await fetchJson(this.fetchFn, `${baseUrl}/upload/init`, {
+          method: "POST",
+          timeoutMs: timeouts.initMs ?? 15e3,
+          signal: effectiveSignal,
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json"
+          },
+          body: JSON.stringify(initPayload)
         });
-      }
-    }
-    const totalChunks = Math.ceil(file.size / this.chunkSize);
-    const totalUploadSize = estimateTotalUploadSizeBytes(
-      file.size,
-      totalChunks,
-      encrypt
-    );
-    progress({ phase: "init", text: "Reserving server storage..." });
-    const initPayload = {
-      filename: transmittedFilename,
-      lifetime: lifetimeMs,
-      isEncrypted: Boolean(encrypt),
-      totalSize: totalUploadSize,
-      totalChunks
-    };
-    const initRes = await fetchJson(this.fetchFn, `${baseUrl}/upload/init`, {
-      method: "POST",
-      timeoutMs: timeouts.initMs ?? 15e3,
-      signal,
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      },
-      body: JSON.stringify(initPayload)
-    });
-    if (!initRes.res.ok) {
-      const errorJson = initRes.json;
-      const msg = errorJson?.error || `Server initialisation failed: ${initRes.res.status}`;
-      throw new DropgateProtocolError(msg, {
-        details: initRes.json || initRes.text
-      });
-    }
-    const initJson = initRes.json;
-    const uploadId = initJson?.uploadId;
-    if (!uploadId || typeof uploadId !== "string") {
-      throw new DropgateProtocolError(
-        "Server did not return a valid uploadId."
-      );
-    }
-    const retries = Number.isFinite(retry.retries) ? retry.retries : 5;
-    const baseBackoffMs = Number.isFinite(retry.backoffMs) ? retry.backoffMs : 1e3;
-    const maxBackoffMs = Number.isFinite(retry.maxBackoffMs) ? retry.maxBackoffMs : 3e4;
-    for (let i = 0; i < totalChunks; i++) {
-      if (signal?.aborted) {
-        throw signal.reason || new DropgateAbortError();
-      }
-      const start = i * this.chunkSize;
-      const end = Math.min(start + this.chunkSize, file.size);
-      let chunkBlob = file.slice(start, end);
-      const percentComplete = i / totalChunks * 100;
-      progress({
-        phase: "chunk",
-        text: `Uploading chunk ${i + 1} of ${totalChunks}...`,
-        percent: percentComplete,
-        chunkIndex: i,
-        totalChunks
-      });
-      const chunkBuffer = await chunkBlob.arrayBuffer();
-      let uploadBlob;
-      if (encrypt && cryptoKey) {
-        uploadBlob = await encryptToBlob(this.cryptoObj, chunkBuffer, cryptoKey);
-      } else {
-        uploadBlob = new Blob([chunkBuffer]);
-      }
-      if (uploadBlob.size > DEFAULT_CHUNK_SIZE + 1024) {
-        throw new DropgateValidationError(
-          "Chunk too large (client-side). Check chunk size settings."
+        if (!initRes.res.ok) {
+          const errorJson = initRes.json;
+          const msg = errorJson?.error || `Server initialisation failed: ${initRes.res.status}`;
+          throw new DropgateProtocolError(msg, {
+            details: initRes.json || initRes.text
+          });
+        }
+        const initJson = initRes.json;
+        const uploadId = initJson?.uploadId;
+        if (!uploadId || typeof uploadId !== "string") {
+          throw new DropgateProtocolError(
+            "Server did not return a valid uploadId."
+          );
+        }
+        currentUploadId = uploadId;
+        currentBaseUrl = baseUrl;
+        uploadState = "uploading";
+        const retries = Number.isFinite(retry.retries) ? retry.retries : 5;
+        const baseBackoffMs = Number.isFinite(retry.backoffMs) ? retry.backoffMs : 1e3;
+        const maxBackoffMs = Number.isFinite(retry.maxBackoffMs) ? retry.maxBackoffMs : 3e4;
+        for (let i = 0; i < totalChunks; i++) {
+          if (effectiveSignal?.aborted) {
+            throw effectiveSignal.reason || new DropgateAbortError();
+          }
+          const start = i * this.chunkSize;
+          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
+          });
+          const chunkBuffer = await chunkBlob.arrayBuffer();
+          let uploadBlob;
+          if (encrypt && cryptoKey) {
+            uploadBlob = await encryptToBlob(this.cryptoObj, chunkBuffer, cryptoKey);
+          } else {
+            uploadBlob = new Blob([chunkBuffer]);
+          }
+          if (uploadBlob.size > DEFAULT_CHUNK_SIZE + 1024) {
+            throw new DropgateValidationError(
+              "Chunk too large (client-side). Check chunk size settings."
+            );
+          }
+          const toHash = await uploadBlob.arrayBuffer();
+          const hashHex = await sha256Hex(this.cryptoObj, toHash);
+          const headers = {
+            "Content-Type": "application/octet-stream",
+            "X-Upload-ID": uploadId,
+            "X-Chunk-Index": String(i),
+            "X-Chunk-Hash": hashHex
+          };
+          const chunkUrl = `${baseUrl}/upload/chunk`;
+          await this.attemptChunkUpload(
+            chunkUrl,
+            {
+              method: "POST",
+              headers,
+              body: uploadBlob
+            },
+            {
+              retries,
+              backoffMs: baseBackoffMs,
+              maxBackoffMs,
+              timeoutMs: timeouts.chunkMs ?? 6e4,
+              signal: effectiveSignal,
+              progress,
+              chunkIndex: i,
+              totalChunks,
+              chunkSize: this.chunkSize,
+              fileSizeBytes
+            }
+          );
+        }
+        progress({ phase: "complete", text: "Finalising upload...", percent: 100, processedBytes: fileSizeBytes, totalBytes: fileSizeBytes });
+        uploadState = "completing";
+        const completeRes = await fetchJson(
+          this.fetchFn,
+          `${baseUrl}/upload/complete`,
+          {
+            method: "POST",
+            timeoutMs: timeouts.completeMs ?? 3e4,
+            signal: effectiveSignal,
+            headers: {
+              "Content-Type": "application/json",
+              Accept: "application/json"
+            },
+            body: JSON.stringify({ uploadId })
+          }
         );
+        if (!completeRes.res.ok) {
+          const errorJson = completeRes.json;
+          const msg = errorJson?.error || "Finalisation failed.";
+          throw new DropgateProtocolError(msg, {
+            details: completeRes.json || completeRes.text
+          });
+        }
+        const completeJson = completeRes.json;
+        const fileId = completeJson?.id;
+        if (!fileId || typeof fileId !== "string") {
+          throw new DropgateProtocolError(
+            "Server did not return a valid file id."
+          );
+        }
+        let downloadUrl = `${baseUrl}/${fileId}`;
+        if (encrypt && keyB64) {
+          downloadUrl += `#${keyB64}`;
+        }
+        progress({ phase: "done", text: "Upload successful!", percent: 100, processedBytes: fileSizeBytes, totalBytes: fileSizeBytes });
+        uploadState = "completed";
+        return {
+          downloadUrl,
+          fileId,
+          uploadId,
+          baseUrl,
+          ...encrypt && keyB64 ? { keyB64 } : {}
+        };
+      } catch (err) {
+        if (err instanceof Error && (err.name === "AbortError" || err.message?.includes("abort"))) {
+          uploadState = "cancelled";
+          onCancel?.();
+        } else {
+          uploadState = "error";
+        }
+        throw err;
       }
-      const toHash = await uploadBlob.arrayBuffer();
-      const hashHex = await sha256Hex(this.cryptoObj, toHash);
-      const headers = {
-        "Content-Type": "application/octet-stream",
-        "X-Upload-ID": uploadId,
-        "X-Chunk-Index": String(i),
-        "X-Chunk-Hash": hashHex
-      };
-      const chunkUrl = `${baseUrl}/upload/chunk`;
-      await this.attemptChunkUpload(
-        chunkUrl,
-        {
+    })();
+    const callCancelEndpoint = async (uploadId, baseUrl) => {
+      try {
+        await fetchJson(this.fetchFn, `${baseUrl}/upload/cancel`, {
           method: "POST",
-          headers,
-          body: uploadBlob
-        },
-        {
-          retries,
-          backoffMs: baseBackoffMs,
-          maxBackoffMs,
-          timeoutMs: timeouts.chunkMs ?? 6e4,
-          signal,
-          progress,
-          chunkIndex: i,
-          totalChunks
-        }
-      );
-    }
-    progress({ phase: "complete", text: "Finalising upload...", percent: 100 });
-    const completeRes = await fetchJson(
-      this.fetchFn,
-      `${baseUrl}/upload/complete`,
-      {
-        method: "POST",
-        timeoutMs: timeouts.completeMs ?? 3e4,
-        signal,
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json"
-        },
-        body: JSON.stringify({ uploadId })
+          timeoutMs: 5e3,
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json"
+          },
+          body: JSON.stringify({ uploadId })
+        });
+      } catch {
       }
-    );
-    if (!completeRes.res.ok) {
-      const errorJson = completeRes.json;
-      const msg = errorJson?.error || "Finalisation failed.";
-      throw new DropgateProtocolError(msg, {
-        details: completeRes.json || completeRes.text
-      });
-    }
-    const completeJson = completeRes.json;
-    const fileId = completeJson?.id;
-    if (!fileId || typeof fileId !== "string") {
-      throw new DropgateProtocolError(
-        "Server did not return a valid file id."
-      );
-    }
-    let downloadUrl = `${baseUrl}/${fileId}`;
-    if (encrypt && keyB64) {
-      downloadUrl += `#${keyB64}`;
-    }
-    progress({ phase: "done", text: "Upload successful!", percent: 100 });
+    };
     return {
-      downloadUrl,
-      fileId,
-      uploadId,
-      baseUrl,
-      ...encrypt && keyB64 ? { keyB64 } : {}
+      result: uploadPromise,
+      cancel: (reason) => {
+        if (uploadState === "completed" || uploadState === "cancelled") return;
+        uploadState = "cancelled";
+        if (currentUploadId && currentBaseUrl) {
+          callCancelEndpoint(currentUploadId, currentBaseUrl).catch(() => {
+          });
+        }
+        internalController?.abort(new DropgateAbortError(reason || "Upload cancelled by user."));
+      },
+      getStatus: () => uploadState
     };
   }
   /**
@@ -815,8 +884,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 {
@@ -859,7 +940,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(
@@ -877,7 +958,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 = [];
@@ -946,7 +1027,7 @@ var DropgateClient = class {
             phase: "decrypting",
             text: `Downloading & decrypting... (${percent}%)`,
             percent,
-            receivedBytes,
+            processedBytes: receivedBytes,
             totalBytes
           });
         }
@@ -978,7 +1059,7 @@ var DropgateClient = class {
             phase: "downloading",
             text: `Downloading... (${percent}%)`,
             percent,
-            receivedBytes,
+            processedBytes: receivedBytes,
             totalBytes
           });
         }
@@ -992,7 +1073,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);
@@ -1019,7 +1100,9 @@ var DropgateClient = class {
       signal,
       progress,
       chunkIndex,
-      totalChunks
+      totalChunks,
+      chunkSize,
+      fileSizeBytes
     } = opts;
     let attemptsLeft = retries;
     let currentBackoff = backoffMs;
@@ -1052,6 +1135,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) {
@@ -1059,6 +1144,9 @@ var DropgateClient = class {
           progress({
             phase: "retry-wait",
             text: `Chunk upload failed. Retrying in ${secondsLeft}s... (${attemptNumber}/${maxRetries})`,
+            percent,
+            processedBytes,
+            totalBytes: fileSizeBytes,
             chunkIndex,
             totalChunks
           });
@@ -1068,6 +1156,9 @@ var DropgateClient = class {
         progress({
           phase: "retry",
           text: `Chunk upload failed. Retrying now... (${attemptNumber}/${maxRetries})`,
+          percent,
+          processedBytes,
+          totalBytes: fileSizeBytes,
           chunkIndex,
           totalChunks
         });
@@ -1090,11 +1181,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];
@@ -1120,8 +1211,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,
@@ -1163,6 +1260,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,
@@ -1177,15 +1280,17 @@ 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,
+    onCancel
   } = opts;
   if (!file) {
     throw new DropgateValidationError("File is missing.");
@@ -1199,8 +1304,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,
@@ -1217,18 +1324,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" || state === "cancelled") 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 {
@@ -1238,21 +1364,69 @@ 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" || state === "cancelled") return;
+    const wasActive = state === "transferring" || state === "finishing";
+    state = "cancelled";
+    try {
+      if (activeConn && activeConn.open) {
+        activeConn.send({ t: "cancelled", message: "Sender cancelled the transfer." });
+      }
+    } catch {
+    }
+    if (wasActive && onCancel) {
+      onCancel({ cancelledBy: "sender" });
+    }
+    cleanup();
+  };
+  const isStopped = () => state === "closed" || state === "cancelled";
   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) => {
@@ -1268,6 +1442,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;
       }
@@ -1279,22 +1454,30 @@ 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."));
+        return;
+      }
+      if (msg.t === "cancelled") {
+        if (state === "cancelled" || state === "closed" || state === "completed") return;
+        state = "cancelled";
+        onCancel?.({ cancelledBy: "receiver", message: msg.message });
+        cleanup();
       }
     });
     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)) {
@@ -1303,13 +1486,26 @@ 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();
+          if (isStopped()) return;
           conn.send(buf);
-          sent += buf.byteLength;
+          sentBytes += buf.byteLength;
           if (dc) {
             while (dc.bufferedAmount > bufferHighWaterMark) {
               await new Promise((resolve) => {
@@ -1329,13 +1525,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.");
         }
@@ -1346,29 +1544,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?.(
-          new DropgateNetworkError("Receiver disconnected before transfer completed.")
-        );
+      if (state === "closed" || state === "completed" || state === "cancelled") {
+        cleanup();
+        return;
+      }
+      if (state === "transferring" || state === "finishing") {
+        state = "cancelled";
+        onCancel?.({ cancelledBy: "receiver" });
+        cleanup();
+      } 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
@@ -1382,13 +1594,16 @@ async function startP2PReceive(opts) {
     peerjsPath,
     secure = false,
     iceServers,
+    autoReady = true,
+    watchdogTimeoutMs = 15e3,
     onStatus,
     onMeta,
     onData,
     onProgress,
     onComplete,
     onError,
-    onDisconnect
+    onDisconnect,
+    onCancel
   } = opts;
   if (!code) {
     throw new DropgateValidationError("No sharing code was provided.");
@@ -1406,8 +1621,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,
@@ -1416,44 +1633,137 @@ 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" || state === "cancelled") 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" || state === "cancelled") return;
+    const wasActive = state === "transferring";
+    state = "cancelled";
+    try {
+      if (activeConn && activeConn.open) {
+        activeConn.send({ t: "cancelled", message: "Receiver cancelled the transfer." });
+      }
+    } catch {
+    }
+    if (wasActive && onCancel) {
+      onCancel({ cancelledBy: "receiver" });
+    }
+    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(
@@ -1465,16 +1775,23 @@ 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") {
             throw new DropgateNetworkError(msg.message || "Sender reported an error.");
           }
+          if (msg.t === "cancelled") {
+            if (state === "cancelled" || state === "closed" || state === "completed") return;
+            state = "cancelled";
+            onCancel?.({ cancelledBy: "sender", message: msg.message });
+            cleanup();
+            return;
+          }
           return;
         }
         let bufPromise;
@@ -1496,7 +1813,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;
@@ -1513,21 +1830,38 @@ 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" || state === "cancelled") {
+        cleanup();
+        return;
+      }
+      if (state === "transferring") {
+        state = "cancelled";
+        onCancel?.({ cancelledBy: "sender" });
+        cleanup();
+      } 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
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1560,6 +1894,7 @@ async function startP2PReceive(opts) {
   getDefaultBase64,
   getDefaultCrypto,
   getDefaultFetch,
+  getServerInfo,
   importKeyFromBase64,
   isLocalhostHostname,
   isP2PCodeLike,
@@ -1568,6 +1903,7 @@ async function startP2PReceive(opts) {
   makeAbortSignal,
   parseSemverMajorMinor,
   parseServerUrl,
+  resolvePeerConfig,
   sha256Hex,
   sleep,
   startP2PReceive,