@dropgate/core 2.2.1 → 3.0.1

package/dist/p2p/index.cjs

@@ -3,6 +3,7 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,15 +17,23 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/p2p/index.ts
 var p2p_exports = {};
 __export(p2p_exports, {
+  P2P_CHUNK_SIZE: () => P2P_CHUNK_SIZE,
+  P2P_END_ACK_RETRIES: () => P2P_END_ACK_RETRIES,
+  P2P_END_ACK_TIMEOUT_MS: () => P2P_END_ACK_TIMEOUT_MS,
+  P2P_MAX_UNACKED_CHUNKS: () => P2P_MAX_UNACKED_CHUNKS,
+  P2P_PROTOCOL_VERSION: () => P2P_PROTOCOL_VERSION,
   buildPeerOptions: () => buildPeerOptions,
   createPeerWithRetries: () => createPeerWithRetries,
   generateP2PCode: () => generateP2PCode,
   isLocalhostHostname: () => isLocalhostHostname,
   isP2PCodeLike: () => isP2PCodeLike,
+  isP2PMessage: () => isP2PMessage,
+  isProtocolCompatible: () => isProtocolCompatible,
   isSecureContextForP2P: () => isSecureContextForP2P,
   resolvePeerConfig: () => resolvePeerConfig,
   startP2PReceive: () => startP2PReceive,
@@ -35,18 +44,12 @@ module.exports = __toCommonJS(p2p_exports);
 // src/errors.ts
 var DropgateError = class extends Error {
   constructor(message, opts = {}) {
-    super(message);
+    super(message, opts.cause !== void 0 ? { cause: opts.cause } : void 0);
+    __publicField(this, "code");
+    __publicField(this, "details");
     this.name = this.constructor.name;
     this.code = opts.code || "DROPGATE_ERROR";
     this.details = opts.details;
-    if (opts.cause !== void 0) {
-      Object.defineProperty(this, "cause", {
-        value: opts.cause,
-        writable: false,
-        enumerable: false,
-        configurable: true
-      });
-    }
   }
 };
 var DropgateValidationError = class extends DropgateError {
@@ -178,13 +181,57 @@ async function createPeerWithRetries(opts) {
   throw lastError || new DropgateNetworkError("Could not establish PeerJS connection.");
 }
 
+// src/p2p/protocol.ts
+var P2P_PROTOCOL_VERSION = 3;
+function isP2PMessage(value) {
+  if (!value || typeof value !== "object") return false;
+  const msg = value;
+  return typeof msg.t === "string" && [
+    "hello",
+    "file_list",
+    "meta",
+    "ready",
+    "chunk",
+    "chunk_ack",
+    "file_end",
+    "file_end_ack",
+    "end",
+    "end_ack",
+    "ping",
+    "pong",
+    "error",
+    "cancelled",
+    "resume",
+    "resume_ack"
+  ].includes(msg.t);
+}
+function isProtocolCompatible(senderVersion, receiverVersion) {
+  return senderVersion === receiverVersion;
+}
+var P2P_CHUNK_SIZE = 64 * 1024;
+var P2P_MAX_UNACKED_CHUNKS = 32;
+var P2P_END_ACK_TIMEOUT_MS = 15e3;
+var P2P_END_ACK_RETRIES = 3;
+var P2P_END_ACK_RETRY_DELAY_MS = 100;
+var P2P_CLOSE_GRACE_PERIOD_MS = 2e3;
+
 // src/p2p/send.ts
+var P2P_UNACKED_CHUNK_TIMEOUT_MS = 3e4;
 function generateSessionId() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  return crypto.randomUUID();
 }
+var ALLOWED_TRANSITIONS = {
+  initializing: ["listening", "closed"],
+  listening: ["handshaking", "closed", "cancelled"],
+  handshaking: ["negotiating", "closed", "cancelled"],
+  negotiating: ["transferring", "closed", "cancelled"],
+  transferring: ["finishing", "closed", "cancelled"],
+  finishing: ["awaiting_ack", "closed", "cancelled"],
+  awaiting_ack: ["completed", "closed", "cancelled"],
+  completed: ["closed"],
+  cancelled: ["closed"],
+  closed: []
+};
 async function startP2PSend(opts) {
   const {
     file,
@@ -198,21 +245,27 @@ async function startP2PSend(opts) {
     codeGenerator,
     cryptoObj,
     maxAttempts = 4,
-    chunkSize = 256 * 1024,
-    endAckTimeoutMs = 15e3,
+    chunkSize = P2P_CHUNK_SIZE,
+    endAckTimeoutMs = P2P_END_ACK_TIMEOUT_MS,
     bufferHighWaterMark = 8 * 1024 * 1024,
     bufferLowWaterMark = 2 * 1024 * 1024,
     heartbeatIntervalMs = 5e3,
+    chunkAcknowledgments = true,
+    maxUnackedChunks = P2P_MAX_UNACKED_CHUNKS,
     onCode,
     onStatus,
     onProgress,
     onComplete,
     onError,
     onDisconnect,
-    onCancel
+    onCancel,
+    onConnectionHealth
   } = opts;
-  if (!file) {
-    throw new DropgateValidationError("File is missing.");
+  const files = Array.isArray(file) ? file : [file];
+  const isMultiFile = files.length > 1;
+  const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+  if (!files.length) {
+    throw new DropgateValidationError("At least one file is required.");
   }
   if (!Peer) {
     throw new DropgateValidationError(
@@ -248,21 +301,39 @@ async function startP2PSend(opts) {
   let activeConn = null;
   let sentBytes = 0;
   let heartbeatTimer = null;
+  let healthCheckTimer = null;
+  let lastActivityTime = Date.now();
+  const unackedChunks = /* @__PURE__ */ new Map();
+  let nextSeq = 0;
+  let ackResolvers = [];
+  let transferEverStarted = false;
+  const connectionAttempts = [];
+  const MAX_CONNECTION_ATTEMPTS = 10;
+  const CONNECTION_RATE_WINDOW_MS = 1e4;
+  const transitionTo = (newState) => {
+    if (!ALLOWED_TRANSITIONS[state].includes(newState)) {
+      console.warn(`[P2P Send] Invalid state transition: ${state} -> ${newState}`);
+      return false;
+    }
+    state = newState;
+    return true;
+  };
   const reportProgress = (data) => {
-    const safeTotal = Number.isFinite(data.total) && data.total > 0 ? data.total : file.size;
+    if (isStopped()) return;
+    const safeTotal = Number.isFinite(data.total) && data.total > 0 ? data.total : totalSize;
     const safeReceived = Math.min(Number(data.received) || 0, safeTotal || 0);
     const percent = safeTotal ? safeReceived / safeTotal * 100 : 0;
     onProgress?.({ processedBytes: safeReceived, totalBytes: safeTotal, percent });
   };
   const safeError = (err) => {
     if (state === "closed" || state === "completed" || state === "cancelled") return;
-    state = "closed";
+    transitionTo("closed");
     onError?.(err);
     cleanup();
   };
   const safeComplete = () => {
-    if (state !== "finishing") return;
-    state = "completed";
+    if (state !== "awaiting_ack" && state !== "finishing") return;
+    transitionTo("completed");
     onComplete?.();
     cleanup();
   };
@@ -271,6 +342,13 @@ async function startP2PSend(opts) {
       clearInterval(heartbeatTimer);
       heartbeatTimer = null;
     }
+    if (healthCheckTimer) {
+      clearInterval(healthCheckTimer);
+      healthCheckTimer = null;
+    }
+    ackResolvers.forEach((resolve) => resolve());
+    ackResolvers = [];
+    unackedChunks.clear();
     if (typeof window !== "undefined") {
       window.removeEventListener("beforeunload", handleUnload);
     }
@@ -295,8 +373,12 @@ async function startP2PSend(opts) {
   }
   const stop = () => {
     if (state === "closed" || state === "cancelled") return;
-    const wasActive = state === "transferring" || state === "finishing";
-    state = "cancelled";
+    if (state === "completed") {
+      cleanup();
+      return;
+    }
+    const wasActive = state === "transferring" || state === "finishing" || state === "awaiting_ack";
+    transitionTo("cancelled");
     try {
       if (activeConn && activeConn.open) {
         activeConn.send({ t: "cancelled", message: "Sender cancelled the transfer." });
@@ -309,8 +391,114 @@ async function startP2PSend(opts) {
     cleanup();
   };
   const isStopped = () => state === "closed" || state === "cancelled";
+  const startHealthMonitoring = (conn) => {
+    if (!onConnectionHealth) return;
+    healthCheckTimer = setInterval(() => {
+      if (isStopped()) return;
+      const dc = conn._dc;
+      if (!dc) return;
+      const health = {
+        iceConnectionState: dc.readyState === "open" ? "connected" : "disconnected",
+        bufferedAmount: dc.bufferedAmount,
+        lastActivityMs: Date.now() - lastActivityTime
+      };
+      onConnectionHealth(health);
+    }, 2e3);
+  };
+  const handleChunkAck = (msg) => {
+    lastActivityTime = Date.now();
+    unackedChunks.delete(msg.seq);
+    reportProgress({ received: msg.received, total: totalSize });
+    const resolver = ackResolvers.shift();
+    if (resolver) resolver();
+  };
+  const waitForAck = () => {
+    return new Promise((resolve) => {
+      ackResolvers.push(resolve);
+    });
+  };
+  const sendChunk = async (conn, data, offset, fileTotal) => {
+    if (chunkAcknowledgments) {
+      while (unackedChunks.size >= maxUnackedChunks) {
+        const now = Date.now();
+        for (const [_seq, chunk] of unackedChunks) {
+          if (now - chunk.sentAt > P2P_UNACKED_CHUNK_TIMEOUT_MS) {
+            throw new DropgateNetworkError("Receiver stopped acknowledging chunks");
+          }
+        }
+        await Promise.race([
+          waitForAck(),
+          sleep(1e3)
+          // Timeout to prevent deadlock
+        ]);
+        if (isStopped()) return;
+      }
+    }
+    const seq = nextSeq++;
+    if (chunkAcknowledgments) {
+      unackedChunks.set(seq, { offset, size: data.byteLength, sentAt: Date.now() });
+    }
+    conn.send({ t: "chunk", seq, offset, size: data.byteLength, total: fileTotal ?? totalSize });
+    conn.send(data);
+    sentBytes += data.byteLength;
+    const dc = conn._dc;
+    if (dc && bufferHighWaterMark > 0) {
+      while (dc.bufferedAmount > bufferHighWaterMark) {
+        await new Promise((resolve) => {
+          const fallback = setTimeout(resolve, 60);
+          try {
+            dc.addEventListener(
+              "bufferedamountlow",
+              () => {
+                clearTimeout(fallback);
+                resolve();
+              },
+              { once: true }
+            );
+          } catch {
+          }
+        });
+        if (isStopped()) return;
+      }
+    }
+  };
+  const waitForEndAck = async (conn, ackPromise) => {
+    const baseTimeout = endAckTimeoutMs;
+    for (let attempt = 0; attempt < P2P_END_ACK_RETRIES; attempt++) {
+      conn.send({ t: "end", attempt });
+      const timeout = baseTimeout * Math.pow(1.5, attempt);
+      const result = await Promise.race([
+        ackPromise,
+        sleep(timeout).then(() => null)
+      ]);
+      if (result && result.t === "end_ack") {
+        return result;
+      }
+      if (isStopped()) {
+        throw new DropgateNetworkError("Connection closed during completion.");
+      }
+    }
+    throw new DropgateNetworkError("Receiver did not confirm completion after retries.");
+  };
   peer.on("connection", (conn) => {
-    if (state === "closed") return;
+    if (isStopped()) return;
+    const now = Date.now();
+    while (connectionAttempts.length > 0 && connectionAttempts[0] < now - CONNECTION_RATE_WINDOW_MS) {
+      connectionAttempts.shift();
+    }
+    if (connectionAttempts.length >= MAX_CONNECTION_ATTEMPTS) {
+      console.warn("[P2P Send] Connection rate limit exceeded, rejecting connection");
+      try {
+        conn.send({ t: "error", message: "Too many connection attempts. Please wait." });
+      } catch {
+      }
+      try {
+        conn.close();
+      } catch {
+      }
+      return;
+    }
+    connectionAttempts.push(now);
     if (activeConn) {
       const isOldConnOpen = activeConn.open !== false;
       if (isOldConnOpen && state === "transferring") {
@@ -329,8 +517,21 @@ async function startP2PSend(opts) {
         } catch {
         }
         activeConn = null;
+        if (transferEverStarted) {
+          try {
+            conn.send({ t: "error", message: "Transfer already started with another receiver. Cannot reconnect." });
+          } catch {
+          }
+          try {
+            conn.close();
+          } catch {
+          }
+          return;
+        }
         state = "listening";
         sentBytes = 0;
+        nextSeq = 0;
+        unackedChunks.clear();
       } else {
         try {
           conn.send({ t: "error", message: "Another receiver is already connected." });
@@ -344,60 +545,98 @@ async function startP2PSend(opts) {
       }
     }
     activeConn = conn;
-    state = "negotiating";
-    onStatus?.({ phase: "waiting", message: "Connected. Waiting for receiver to accept..." });
+    transitionTo("handshaking");
+    if (!isStopped()) onStatus?.({ phase: "connected", message: "Receiver connected." });
+    lastActivityTime = Date.now();
+    let helloResolve = null;
     let readyResolve = null;
-    let ackResolve = null;
+    let endAckResolve = null;
+    let fileEndAckResolve = null;
+    const helloPromise = new Promise((resolve) => {
+      helloResolve = resolve;
+    });
     const readyPromise = new Promise((resolve) => {
       readyResolve = resolve;
     });
-    const ackPromise = new Promise((resolve) => {
-      ackResolve = resolve;
+    const endAckPromise = new Promise((resolve) => {
+      endAckResolve = resolve;
     });
     conn.on("data", (data) => {
-      if (!data || typeof data !== "object" || data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+      lastActivityTime = Date.now();
+      if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
         return;
       }
+      if (!isP2PMessage(data)) return;
       const msg = data;
-      if (!msg.t) return;
-      if (msg.t === "ready") {
-        onStatus?.({ phase: "transferring", message: "Receiver accepted. Starting transfer..." });
-        readyResolve?.();
-        return;
-      }
-      if (msg.t === "progress") {
-        reportProgress({ received: msg.received || 0, total: msg.total || 0 });
-        return;
-      }
-      if (msg.t === "ack" && msg.phase === "end") {
-        ackResolve?.(msg);
-        return;
-      }
-      if (msg.t === "pong") {
-        return;
-      }
-      if (msg.t === "error") {
-        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();
+      switch (msg.t) {
+        case "hello":
+          helloResolve?.(msg.protocolVersion);
+          break;
+        case "ready":
+          if (!isStopped()) onStatus?.({ phase: "transferring", message: "Receiver accepted. Starting transfer..." });
+          readyResolve?.();
+          break;
+        case "chunk_ack":
+          handleChunkAck(msg);
+          break;
+        case "file_end_ack":
+          fileEndAckResolve?.(msg);
+          break;
+        case "end_ack":
+          endAckResolve?.(msg);
+          break;
+        case "pong":
+          break;
+        case "error":
+          safeError(new DropgateNetworkError(msg.message || "Receiver reported an error."));
+          break;
+        case "cancelled":
+          if (state === "cancelled" || state === "closed" || state === "completed") return;
+          transitionTo("cancelled");
+          onCancel?.({ cancelledBy: "receiver", message: msg.reason });
+          cleanup();
+          break;
       }
     });
     conn.on("open", async () => {
       try {
         if (isStopped()) return;
+        startHealthMonitoring(conn);
+        conn.send({
+          t: "hello",
+          protocolVersion: P2P_PROTOCOL_VERSION,
+          sessionId
+        });
+        const receiverVersion = await Promise.race([
+          helloPromise,
+          sleep(1e4).then(() => null)
+        ]);
+        if (isStopped()) return;
+        if (receiverVersion === null) {
+          throw new DropgateNetworkError("Receiver did not respond to handshake.");
+        } else if (receiverVersion !== P2P_PROTOCOL_VERSION) {
+          throw new DropgateNetworkError(
+            `Protocol version mismatch: sender v${P2P_PROTOCOL_VERSION}, receiver v${receiverVersion}`
+          );
+        }
+        transitionTo("negotiating");
+        if (!isStopped()) onStatus?.({ phase: "waiting", message: "Connected. Waiting for receiver to accept..." });
+        if (isMultiFile) {
+          conn.send({
+            t: "file_list",
+            fileCount: files.length,
+            files: files.map((f) => ({ name: f.name, size: f.size, mime: f.type || "application/octet-stream" })),
+            totalSize
+          });
+        }
         conn.send({
           t: "meta",
           sessionId,
-          name: file.name,
-          size: file.size,
-          mime: file.type || "application/octet-stream"
+          name: files[0].name,
+          size: files[0].size,
+          mime: files[0].type || "application/octet-stream",
+          ...isMultiFile ? { fileIndex: 0 } : {}
         });
-        const total = file.size;
         const dc = conn._dc;
         if (dc && Number.isFinite(bufferLowWaterMark)) {
           try {
@@ -409,56 +648,61 @@ async function startP2PSend(opts) {
         if (isStopped()) return;
         if (heartbeatIntervalMs > 0) {
           heartbeatTimer = setInterval(() => {
-            if (state === "transferring" || state === "finishing") {
+            if (state === "transferring" || state === "finishing" || state === "awaiting_ack") {
               try {
-                conn.send({ t: "ping" });
+                conn.send({ t: "ping", timestamp: Date.now() });
               } catch {
               }
             }
           }, heartbeatIntervalMs);
         }
-        state = "transferring";
-        for (let offset = 0; offset < total; offset += chunkSize) {
-          if (isStopped()) return;
-          const slice = file.slice(offset, offset + chunkSize);
-          const buf = await slice.arrayBuffer();
+        transitionTo("transferring");
+        transferEverStarted = true;
+        let overallSentBytes = 0;
+        for (let fi = 0; fi < files.length; fi++) {
+          const currentFile = files[fi];
+          if (isMultiFile && fi > 0) {
+            conn.send({
+              t: "meta",
+              sessionId,
+              name: currentFile.name,
+              size: currentFile.size,
+              mime: currentFile.type || "application/octet-stream",
+              fileIndex: fi
+            });
+          }
+          for (let offset = 0; offset < currentFile.size; offset += chunkSize) {
+            if (isStopped()) return;
+            const slice = currentFile.slice(offset, offset + chunkSize);
+            const buf = await slice.arrayBuffer();
+            if (isStopped()) return;
+            await sendChunk(conn, buf, offset, currentFile.size);
+            overallSentBytes += buf.byteLength;
+            reportProgress({ received: overallSentBytes, total: totalSize });
+          }
           if (isStopped()) return;
-          conn.send(buf);
-          sentBytes += buf.byteLength;
-          if (dc) {
-            while (dc.bufferedAmount > bufferHighWaterMark) {
-              await new Promise((resolve) => {
-                const fallback = setTimeout(resolve, 60);
-                try {
-                  dc.addEventListener(
-                    "bufferedamountlow",
-                    () => {
-                      clearTimeout(fallback);
-                      resolve();
-                    },
-                    { once: true }
-                  );
-                } catch {
-                }
-              });
+          if (isMultiFile) {
+            const fileEndAckPromise = new Promise((resolve) => {
+              fileEndAckResolve = resolve;
+            });
+            conn.send({ t: "file_end", fileIndex: fi });
+            const feAck = await Promise.race([
+              fileEndAckPromise,
+              sleep(endAckTimeoutMs).then(() => null)
+            ]);
+            if (isStopped()) return;
+            if (!feAck) {
+              throw new DropgateNetworkError(`Receiver did not confirm receipt of file ${fi + 1}/${files.length}.`);
             }
           }
         }
         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)
-        ]);
+        transitionTo("finishing");
+        transitionTo("awaiting_ack");
+        const ackResult = await waitForEndAck(conn, endAckPromise);
         if (isStopped()) return;
-        if (!ackResult || typeof ackResult !== "object") {
-          throw new DropgateNetworkError("Receiver did not confirm completion.");
-        }
-        const ackData = ackResult;
-        const ackTotal = Number(ackData.total) || file.size;
-        const ackReceived = Number(ackData.received) || 0;
+        const ackTotal = Number(ackResult.total) || totalSize;
+        const ackReceived = Number(ackResult.received) || 0;
         if (ackTotal && ackReceived < ackTotal) {
           throw new DropgateNetworkError("Receiver reported an incomplete transfer.");
         }
@@ -476,14 +720,24 @@ async function startP2PSend(opts) {
         cleanup();
         return;
       }
+      if (state === "awaiting_ack") {
+        setTimeout(() => {
+          if (state === "awaiting_ack") {
+            safeError(new DropgateNetworkError("Connection closed while awaiting confirmation."));
+          }
+        }, P2P_CLOSE_GRACE_PERIOD_MS);
+        return;
+      }
       if (state === "transferring" || state === "finishing") {
-        state = "cancelled";
+        transitionTo("cancelled");
         onCancel?.({ cancelledBy: "receiver" });
         cleanup();
       } else {
         activeConn = null;
         state = "listening";
         sentBytes = 0;
+        nextSeq = 0;
+        unackedChunks.clear();
         onDisconnect?.();
       }
     });
@@ -503,6 +757,16 @@ async function startP2PSend(opts) {
 }
 
 // src/p2p/receive.ts
+var ALLOWED_TRANSITIONS2 = {
+  initializing: ["connecting", "closed"],
+  connecting: ["handshaking", "closed", "cancelled"],
+  handshaking: ["negotiating", "closed", "cancelled"],
+  negotiating: ["transferring", "closed", "cancelled"],
+  transferring: ["completed", "closed", "cancelled"],
+  completed: ["closed"],
+  cancelled: ["closed"],
+  closed: []
+};
 async function startP2PReceive(opts) {
   const {
     code,
@@ -519,6 +783,8 @@ async function startP2PReceive(opts) {
     onMeta,
     onData,
     onProgress,
+    onFileStart,
+    onFileEnd,
     onComplete,
     onError,
     onDisconnect,
@@ -556,11 +822,26 @@ async function startP2PReceive(opts) {
   let total = 0;
   let received = 0;
   let currentSessionId = null;
-  let lastProgressSentAt = 0;
-  const progressIntervalMs = 120;
   let writeQueue = Promise.resolve();
   let watchdogTimer = null;
   let activeConn = null;
+  let pendingChunk = null;
+  let fileList = null;
+  let currentFileReceived = 0;
+  let totalReceivedAllFiles = 0;
+  let expectedChunkSeq = 0;
+  let writeQueueDepth = 0;
+  const MAX_WRITE_QUEUE_DEPTH = 100;
+  const MAX_FILE_COUNT = 1e4;
+  const transitionTo = (newState) => {
+    if (!ALLOWED_TRANSITIONS2[state].includes(newState)) {
+      console.warn(`[P2P Receive] Invalid state transition: ${state} -> ${newState}`);
+      return false;
+    }
+    state = newState;
+    return true;
+  };
+  const isStopped = () => state === "closed" || state === "cancelled";
   const resetWatchdog = () => {
     if (watchdogTimeoutMs <= 0) return;
     if (watchdogTimer) {
@@ -580,15 +861,14 @@ async function startP2PReceive(opts) {
   };
   const safeError = (err) => {
     if (state === "closed" || state === "completed" || state === "cancelled") return;
-    state = "closed";
+    transitionTo("closed");
     onError?.(err);
     cleanup();
   };
   const safeComplete = (completeData) => {
     if (state !== "transferring") return;
-    state = "completed";
+    transitionTo("completed");
     onComplete?.(completeData);
-    cleanup();
   };
   const cleanup = () => {
     clearWatchdog();
@@ -612,11 +892,15 @@ async function startP2PReceive(opts) {
   }
   const stop = () => {
     if (state === "closed" || state === "cancelled") return;
+    if (state === "completed") {
+      cleanup();
+      return;
+    }
     const wasActive = state === "transferring";
-    state = "cancelled";
+    transitionTo("cancelled");
     try {
       if (activeConn && activeConn.open) {
-        activeConn.send({ t: "cancelled", message: "Receiver cancelled the transfer." });
+        activeConn.send({ t: "cancelled", reason: "Receiver cancelled the transfer." });
       }
     } catch {
     }
@@ -625,23 +909,122 @@ async function startP2PReceive(opts) {
     }
     cleanup();
   };
+  const sendChunkAck = (conn, seq) => {
+    try {
+      conn.send({ t: "chunk_ack", seq, received });
+    } catch {
+    }
+  };
   peer.on("error", (err) => {
     safeError(err);
   });
   peer.on("open", () => {
-    state = "connecting";
+    transitionTo("connecting");
     const conn = peer.connect(normalizedCode, { reliable: true });
     activeConn = conn;
     conn.on("open", () => {
-      state = "negotiating";
-      onStatus?.({ phase: "connected", message: "Waiting for file details..." });
+      transitionTo("handshaking");
+      onStatus?.({ phase: "connected", message: "Connected." });
+      conn.send({
+        t: "hello",
+        protocolVersion: P2P_PROTOCOL_VERSION,
+        sessionId: ""
+      });
     });
     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 (data instanceof ArrayBuffer || ArrayBuffer.isView(data) || typeof Blob !== "undefined" && data instanceof Blob) {
+          if (state !== "transferring") {
+            throw new DropgateValidationError(
+              "Received binary data before transfer was accepted. Possible malicious sender."
+            );
+          }
+          resetWatchdog();
+          if (writeQueueDepth >= MAX_WRITE_QUEUE_DEPTH) {
+            throw new DropgateNetworkError("Write queue overflow - receiver cannot keep up");
+          }
+          let bufPromise;
+          if (data instanceof ArrayBuffer) {
+            bufPromise = Promise.resolve(new Uint8Array(data));
+          } else if (ArrayBuffer.isView(data)) {
+            bufPromise = Promise.resolve(
+              new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
+            );
+          } else if (typeof Blob !== "undefined" && data instanceof Blob) {
+            bufPromise = data.arrayBuffer().then((buffer) => new Uint8Array(buffer));
+          } else {
+            return;
+          }
+          const chunkSeq = pendingChunk?.seq ?? -1;
+          const expectedSize = pendingChunk?.size;
+          pendingChunk = null;
+          writeQueueDepth++;
+          writeQueue = writeQueue.then(async () => {
+            const buf = await bufPromise;
+            if (expectedSize !== void 0 && buf.byteLength !== expectedSize) {
+              throw new DropgateValidationError(
+                `Chunk size mismatch: expected ${expectedSize}, got ${buf.byteLength}`
+              );
+            }
+            const newReceived = received + buf.byteLength;
+            if (total > 0 && newReceived > total) {
+              throw new DropgateValidationError(
+                `Received more data than expected: ${newReceived} > ${total}`
+              );
+            }
+            if (onData) {
+              await onData(buf);
+            }
+            received += buf.byteLength;
+            currentFileReceived += buf.byteLength;
+            const progressReceived = fileList ? totalReceivedAllFiles + currentFileReceived : received;
+            const progressTotal = fileList ? fileList.totalSize : total;
+            const percent = progressTotal ? Math.min(100, progressReceived / progressTotal * 100) : 0;
+            if (!isStopped()) onProgress?.({ processedBytes: progressReceived, totalBytes: progressTotal, percent });
+            if (chunkSeq >= 0) {
+              sendChunkAck(conn, chunkSeq);
+            }
+          }).catch((err) => {
+            try {
+              conn.send({
+                t: "error",
+                message: err?.message || "Receiver write failed."
+              });
+            } catch {
+            }
+            safeError(err);
+          }).finally(() => {
+            writeQueueDepth--;
+          });
+          return;
+        }
+        if (!isP2PMessage(data)) return;
+        const msg = data;
+        switch (msg.t) {
+          case "hello":
+            currentSessionId = msg.sessionId || null;
+            transitionTo("negotiating");
+            onStatus?.({ phase: "waiting", message: "Waiting for file details..." });
+            break;
+          case "file_list": {
+            const fileListMsg = msg;
+            if (fileListMsg.fileCount > MAX_FILE_COUNT) {
+              throw new DropgateValidationError(`Too many files: ${fileListMsg.fileCount}`);
+            }
+            const sumSize = fileListMsg.files.reduce((sum, f) => sum + f.size, 0);
+            if (sumSize !== fileListMsg.totalSize) {
+              throw new DropgateValidationError(
+                `File list size mismatch: declared ${fileListMsg.totalSize}, actual sum ${sumSize}`
+              );
+            }
+            fileList = fileListMsg;
+            total = fileListMsg.totalSize;
+            break;
+          }
+          case "meta": {
+            if (state !== "negotiating" && !(state === "transferring" && fileList)) {
+              return;
+            }
             if (currentSessionId && msg.sessionId && msg.sessionId !== currentSessionId) {
               try {
                 conn.send({ t: "error", message: "Busy with another session." });
@@ -653,40 +1036,96 @@ async function startP2PReceive(opts) {
               currentSessionId = msg.sessionId;
             }
             const name = String(msg.name || "file");
-            total = Number(msg.size) || 0;
+            const fileSize = Number(msg.size) || 0;
+            const fi = msg.fileIndex;
+            if (fileList && typeof fi === "number" && fi > 0) {
+              currentFileReceived = 0;
+              onFileStart?.({ fileIndex: fi, name, size: fileSize });
+              break;
+            }
             received = 0;
+            currentFileReceived = 0;
+            totalReceivedAllFiles = 0;
+            if (!fileList) {
+              total = fileSize;
+            }
             writeQueue = Promise.resolve();
             const sendReady = () => {
-              state = "transferring";
+              transitionTo("transferring");
               resetWatchdog();
+              if (fileList) {
+                onFileStart?.({ fileIndex: 0, name, size: fileSize });
+              }
               try {
                 conn.send({ t: "ready" });
               } catch {
               }
             };
+            const metaEvt = { name, total };
+            if (fileList) {
+              metaEvt.fileCount = fileList.fileCount;
+              metaEvt.files = fileList.files.map((f) => ({ name: f.name, size: f.size }));
+              metaEvt.totalSize = fileList.totalSize;
+            }
             if (autoReady) {
-              onMeta?.({ name, total });
-              onProgress?.({ processedBytes: received, totalBytes: total, percent: 0 });
+              if (!isStopped()) {
+                onMeta?.(metaEvt);
+                onProgress?.({ processedBytes: received, totalBytes: total, percent: 0 });
+              }
               sendReady();
             } else {
-              onMeta?.({ name, total, sendReady });
-              onProgress?.({ processedBytes: received, totalBytes: total, percent: 0 });
+              metaEvt.sendReady = sendReady;
+              if (!isStopped()) {
+                onMeta?.(metaEvt);
+                onProgress?.({ processedBytes: received, totalBytes: total, percent: 0 });
+              }
             }
-            return;
+            break;
+          }
+          case "chunk": {
+            const chunkMsg = msg;
+            if (state !== "transferring") {
+              throw new DropgateValidationError(
+                "Received chunk message before transfer was accepted."
+              );
+            }
+            if (chunkMsg.seq !== expectedChunkSeq) {
+              throw new DropgateValidationError(
+                `Chunk sequence error: expected ${expectedChunkSeq}, got ${chunkMsg.seq}`
+              );
+            }
+            expectedChunkSeq++;
+            pendingChunk = chunkMsg;
+            break;
           }
-          if (msg.t === "ping") {
+          case "ping":
             try {
-              conn.send({ t: "pong" });
+              conn.send({ t: "pong", timestamp: Date.now() });
             } catch {
             }
-            return;
+            break;
+          case "file_end": {
+            clearWatchdog();
+            await writeQueue;
+            const feIdx = msg.fileIndex;
+            onFileEnd?.({ fileIndex: feIdx, receivedBytes: currentFileReceived });
+            try {
+              conn.send({ t: "file_end_ack", fileIndex: feIdx, received: currentFileReceived, size: currentFileReceived });
+            } catch {
+            }
+            totalReceivedAllFiles += currentFileReceived;
+            currentFileReceived = 0;
+            resetWatchdog();
+            break;
           }
-          if (msg.t === "end") {
+          case "end":
             clearWatchdog();
             await writeQueue;
-            if (total && received < total) {
+            const finalReceived = fileList ? totalReceivedAllFiles + currentFileReceived : received;
+            const finalTotal = fileList ? fileList.totalSize : total;
+            if (finalTotal && finalReceived < finalTotal) {
               const err = new DropgateNetworkError(
-                "Transfer ended before the full file was received."
+                "Transfer ended before all data was received."
               );
               try {
                 conn.send({ t: "error", message: err.message });
@@ -695,62 +1134,31 @@ async function startP2PReceive(opts) {
               throw err;
             }
             try {
-              conn.send({ t: "ack", phase: "end", received, total });
+              conn.send({ t: "end_ack", received: finalReceived, total: finalTotal });
             } catch {
             }
-            safeComplete({ received, total });
-            return;
-          }
-          if (msg.t === "error") {
+            safeComplete({ received: finalReceived, total: finalTotal });
+            (async () => {
+              for (let i = 0; i < 2; i++) {
+                await sleep(P2P_END_ACK_RETRY_DELAY_MS);
+                try {
+                  conn.send({ t: "end_ack", received: finalReceived, total: finalTotal });
+                } catch {
+                  break;
+                }
+              }
+            })().catch(() => {
+            });
+            break;
+          case "error":
             throw new DropgateNetworkError(msg.message || "Sender reported an error.");
-          }
-          if (msg.t === "cancelled") {
+          case "cancelled":
             if (state === "cancelled" || state === "closed" || state === "completed") return;
-            state = "cancelled";
-            onCancel?.({ cancelledBy: "sender", message: msg.message });
+            transitionTo("cancelled");
+            onCancel?.({ cancelledBy: "sender", message: msg.reason });
             cleanup();
-            return;
-          }
-          return;
+            break;
         }
-        let bufPromise;
-        if (data instanceof ArrayBuffer) {
-          bufPromise = Promise.resolve(new Uint8Array(data));
-        } else if (ArrayBuffer.isView(data)) {
-          bufPromise = Promise.resolve(
-            new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
-          );
-        } else if (typeof Blob !== "undefined" && data instanceof Blob) {
-          bufPromise = data.arrayBuffer().then((buffer) => new Uint8Array(buffer));
-        } else {
-          return;
-        }
-        writeQueue = writeQueue.then(async () => {
-          const buf = await bufPromise;
-          if (onData) {
-            await onData(buf);
-          }
-          received += buf.byteLength;
-          const percent = total ? Math.min(100, received / total * 100) : 0;
-          onProgress?.({ processedBytes: received, totalBytes: total, percent });
-          const now = Date.now();
-          if (received === total || now - lastProgressSentAt >= progressIntervalMs) {
-            lastProgressSentAt = now;
-            try {
-              conn.send({ t: "progress", received, total });
-            } catch {
-            }
-          }
-        }).catch((err) => {
-          try {
-            conn.send({
-              t: "error",
-              message: err?.message || "Receiver write failed."
-            });
-          } catch {
-          }
-          safeError(err);
-        });
       } catch (err) {
         safeError(err);
       }
@@ -761,11 +1169,11 @@ async function startP2PReceive(opts) {
         return;
       }
       if (state === "transferring") {
-        state = "cancelled";
+        transitionTo("cancelled");
         onCancel?.({ cancelledBy: "sender" });
         cleanup();
       } else if (state === "negotiating") {
-        state = "closed";
+        transitionTo("closed");
         cleanup();
         onDisconnect?.();
       } else {
@@ -782,16 +1190,4 @@ async function startP2PReceive(opts) {
     getSessionId: () => currentSessionId
   };
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildPeerOptions,
-  createPeerWithRetries,
-  generateP2PCode,
-  isLocalhostHostname,
-  isP2PCodeLike,
-  isSecureContextForP2P,
-  resolvePeerConfig,
-  startP2PReceive,
-  startP2PSend
-});
 //# sourceMappingURL=index.cjs.map