dropspace 0.0.0-stage → 0.1.1

package/dist/files/index.js

@@ -0,0 +1,751 @@
+import { WireFrameType, encodeJsonPayload, decodeJsonPayload, } from "../protocol/index.js";
+import { TypedEventEmitter, DropspaceStorageError, sanitizeFileName, InMemoryBinaryStagingAdapter, } from "../client/index.js";
+import { StreamingSha256, sha256HexSync } from "./sha256.js";
+export { StreamingSha256, sha256HexSync };
+export class FileTransferError extends Error {
+    code;
+    transferId;
+    constructor(message, code, transferId) {
+        super(message);
+        this.code = code;
+        this.transferId = transferId;
+        this.name = "FileTransferError";
+    }
+}
+export function createBlobFileSource(blob, overrideName) {
+    const name = overrideName ?? blob.name ?? "unnamed.bin";
+    const lastModified = blob.lastModified ?? 0;
+    const mimeType = blob.type || "application/octet-stream";
+    return {
+        get name() {
+            return name;
+        },
+        get size() {
+            return blob.size;
+        },
+        get mimeType() {
+            return mimeType;
+        },
+        get lastModified() {
+            return blob.lastModified ?? lastModified;
+        },
+        async readSlice(start, end) {
+            const slice = blob.slice(start, end);
+            return new Uint8Array(await slice.arrayBuffer());
+        },
+        async computeSha256() {
+            const total = blob.size;
+            if (total <= 64 * 1024 * 1024 &&
+                typeof globalThis.crypto?.subtle?.digest === "function") {
+                const buf = total === 0 ? new ArrayBuffer(0) : await blob.arrayBuffer();
+                const digest = await globalThis.crypto.subtle.digest("SHA-256", buf);
+                const bytes = new Uint8Array(digest);
+                let hex = "";
+                for (let i = 0; i < bytes.length; i++) {
+                    hex += bytes[i].toString(16).padStart(2, "0");
+                }
+                return hex;
+            }
+            const hasher = new StreamingSha256();
+            const readSize = 4 * 1024 * 1024;
+            let offset = 0;
+            let sinceYield = 0;
+            while (offset < total) {
+                const end = Math.min(total, offset + readSize);
+                const buf = new Uint8Array(await blob.slice(offset, end).arrayBuffer());
+                hasher.update(buf);
+                sinceYield += end - offset;
+                offset = end;
+                if (sinceYield >= 16 * 1024 * 1024 && offset < total) {
+                    sinceYield = 0;
+                    await new Promise((resolve) => setTimeout(resolve, 0));
+                }
+            }
+            return hasher.digestHex();
+        },
+    };
+}
+let transferSeq = 0;
+function nextTransferId() {
+    transferSeq = (transferSeq + 1) % 1_000_000_000;
+    return `xfer_${Date.now().toString(36)}_${transferSeq.toString(36)}_${Math.random().toString(36).slice(2, 7)}`;
+}
+/**
+ * Bounded-memory, chunk-tracked, pausable and resumable file transfer engine over Dropspace DataChannels.
+ */
+export class FileTransferManager {
+    options;
+    events = new TypedEventEmitter();
+    storage;
+    chunkSize;
+    policy;
+    outgoing = new Map();
+    incoming = new Map();
+    unsubscribeClient;
+    incomingFrameQueues = new Map();
+    constructor(options) {
+        this.options = options;
+        this.storage = options.storage ?? new InMemoryBinaryStagingAdapter();
+        this.chunkSize = options.chunkSize ?? 32 * 1024; // 32 KiB chunks
+        this.policy = {
+            maxFileSizeBytes: options.policy?.maxFileSizeBytes ?? 500 * 1024 * 1024,
+            allowedMimeTypes: options.policy?.allowedMimeTypes,
+            allowOverwrite: options.policy?.allowOverwrite ?? false,
+            autoAccept: options.policy?.autoAccept ?? true,
+            onIncomingOffer: options.policy?.onIncomingOffer,
+        };
+        this.unsubscribeClient = this.options.client.events.on("transferFrame", ({ peerDeviceId, frame }) => {
+            const lockKey = `${peerDeviceId}:${frame.header.transferId ?? "__control__"}`;
+            const prev = this.incomingFrameQueues.get(lockKey) ?? Promise.resolve();
+            const next = prev
+                .then(() => this.handleIncomingFrame(peerDeviceId, frame))
+                .catch(() => { });
+            this.incomingFrameQueues.set(lockKey, next);
+        });
+    }
+    /**
+     * Computes the SHA-256 hash of a `SliceableFileSource` in bounded memory (one chunk at a time).
+     */
+    async computeSourceSha256(source, chunkSize = this.chunkSize) {
+        if (source.computeSha256) {
+            return source.computeSha256();
+        }
+        const hasher = new StreamingSha256();
+        let offset = 0;
+        while (offset < source.size) {
+            const end = Math.min(source.size, offset + chunkSize);
+            const slice = await source.readSlice(offset, end);
+            hasher.update(slice);
+            offset = end;
+        }
+        return hasher.digestHex();
+    }
+    /**
+     * Verifies that the underlying file source has not mutated since the transfer started.
+     */
+    async verifySourceUnchanged(rt) {
+        if (rt.source.size !== rt.initialSize ||
+            rt.source.lastModified !== rt.initialLastModified) {
+            throw new FileTransferError(`Source file '${rt.manifest.fileName}' changed size or lastModified timestamp before resume`, "SOURCE_FILE_MODIFIED", rt.manifest.transferId);
+        }
+        const currentHash = await this.computeSourceSha256(rt.source, rt.manifest.chunkSize);
+        if (currentHash !== rt.manifest.fileSha256) {
+            throw new FileTransferError(`Source file '${rt.manifest.fileName}' content SHA-256 changed before resume`, "SOURCE_FILE_MODIFIED", rt.manifest.transferId);
+        }
+    }
+    async sendFile(peerDeviceId, sourceInput, options) {
+        const source = "readSlice" in sourceInput ? sourceInput : createBlobFileSource(sourceInput);
+        const safeFileName = sanitizeFileName(source.name);
+        const chunkSize = options?.chunkSize ?? this.chunkSize;
+        const totalBytes = source.size;
+        const totalChunks = Math.max(1, Math.ceil(totalBytes / chunkSize));
+        const transferId = options?.transferId ?? nextTransferId();
+        const fileSha256 = await this.computeSourceSha256(source, chunkSize);
+        const now = Date.now();
+        const manifest = {
+            transferId,
+            peerDeviceId,
+            direction: "send",
+            fileName: safeFileName,
+            mimeType: source.mimeType,
+            totalBytes,
+            chunkSize,
+            totalChunks,
+            fileSha256,
+            lastModified: source.lastModified,
+            state: "offered",
+            completedChunks: [],
+            transferredBytes: 0,
+            startedAt: now,
+            updatedAt: now,
+        };
+        const rt = {
+            manifest,
+            source,
+            initialSize: source.size,
+            initialLastModified: source.lastModified,
+            paused: false,
+            cancelled: false,
+            ackedChunks: new Set(),
+            sendingLoopPromise: null,
+            completionWaiters: [],
+        };
+        this.outgoing.set(transferId, rt);
+        if (options?.signal) {
+            options.signal.addEventListener("abort", () => {
+                void this.cancelTransfer(transferId, "Aborted by caller AbortSignal");
+            }, { once: true });
+        }
+        await this.sendControlFrame(peerDeviceId, transferId, {
+            action: "offer",
+            fileName: manifest.fileName,
+            mimeType: manifest.mimeType,
+            totalBytes: manifest.totalBytes,
+            chunkSize: manifest.chunkSize,
+            totalChunks: manifest.totalChunks,
+            fileSha256: manifest.fileSha256,
+            lastModified: manifest.lastModified,
+        });
+        this.events.emit("stateChange", { ...manifest });
+        if (options?.waitForCompletion ?? true) {
+            return new Promise((resolve, reject) => {
+                if (manifest.state === "completed") {
+                    resolve({ ...manifest });
+                    return;
+                }
+                if (manifest.state === "failed" || manifest.state === "cancelled") {
+                    reject(new FileTransferError(manifest.error?.message ?? "Transfer failed", manifest.error?.code ?? "CANCELLED", transferId));
+                    return;
+                }
+                rt.completionWaiters.push({ resolve, reject });
+            });
+        }
+        return { ...manifest };
+    }
+    async pauseTransfer(transferId) {
+        const out = this.outgoing.get(transferId);
+        if (out) {
+            out.paused = true;
+            out.manifest.state = "paused";
+            out.manifest.updatedAt = Date.now();
+            this.events.emit("stateChange", { ...out.manifest });
+            await this.sendControlFrame(out.manifest.peerDeviceId, transferId, {
+                action: "pause",
+            }).catch(() => { });
+            return;
+        }
+        const inc = this.incoming.get(transferId);
+        if (inc) {
+            inc.paused = true;
+            inc.manifest.state = "paused";
+            inc.manifest.updatedAt = Date.now();
+            this.events.emit("stateChange", { ...inc.manifest });
+            await this.sendControlFrame(inc.manifest.peerDeviceId, transferId, {
+                action: "pause",
+            }).catch(() => { });
+        }
+    }
+    /**
+     * Resumes a paused or interrupted transfer from the exact missing chunks without re-sending
+     * chunks that have already been persisted on the receiver.
+     * Before resuming on the sender side, verifies that the source file has not been modified!
+     */
+    async resumeTransfer(transferId) {
+        const out = this.outgoing.get(transferId);
+        if (out) {
+            try {
+                await this.verifySourceUnchanged(out);
+            }
+            catch (err) {
+                const ftErr = err instanceof FileTransferError
+                    ? err
+                    : new FileTransferError(String(err), "SOURCE_FILE_MODIFIED", transferId);
+                this.failOutgoingTransfer(out, ftErr);
+                throw ftErr;
+            }
+            out.paused = false;
+            // Query receiver for its persisted chunk bitmap so we only send missing chunks
+            await this.sendControlFrame(out.manifest.peerDeviceId, transferId, {
+                action: "offer",
+                fileName: out.manifest.fileName,
+                mimeType: out.manifest.mimeType,
+                totalBytes: out.manifest.totalBytes,
+                chunkSize: out.manifest.chunkSize,
+                totalChunks: out.manifest.totalChunks,
+                fileSha256: out.manifest.fileSha256,
+                lastModified: out.manifest.lastModified,
+                isResume: true,
+            });
+            return;
+        }
+        const inc = this.incoming.get(transferId);
+        if (inc) {
+            inc.paused = false;
+            inc.manifest.state = "transferring";
+            inc.manifest.updatedAt = Date.now();
+            const persisted = await this.storage.listWrittenChunks(transferId);
+            for (const idx of persisted) {
+                inc.receivedChunks.add(idx);
+            }
+            this.events.emit("stateChange", { ...inc.manifest });
+            await this.sendControlFrame(inc.manifest.peerDeviceId, transferId, {
+                action: "accept",
+                receivedChunks: Array.from(inc.receivedChunks),
+            });
+        }
+    }
+    async cancelTransfer(transferId, reason = "Cancelled by user") {
+        const out = this.outgoing.get(transferId);
+        if (out) {
+            out.cancelled = true;
+            out.paused = false;
+            out.manifest.state = "cancelled";
+            out.manifest.error = { code: "CANCELLED", message: reason };
+            out.manifest.updatedAt = Date.now();
+            this.events.emit("stateChange", { ...out.manifest });
+            await this.sendControlFrame(out.manifest.peerDeviceId, transferId, {
+                action: "cancel",
+                reason,
+            }).catch(() => { });
+            for (const w of out.completionWaiters.splice(0)) {
+                w.reject(new FileTransferError(reason, "CANCELLED", transferId));
+            }
+        }
+        const inc = this.incoming.get(transferId);
+        if (inc) {
+            inc.cancelled = true;
+            inc.manifest.state = "cancelled";
+            inc.manifest.error = { code: "CANCELLED", message: reason };
+            inc.manifest.updatedAt = Date.now();
+            await this.storage.deleteTransferStaging(transferId);
+            this.events.emit("stateChange", { ...inc.manifest });
+            await this.sendControlFrame(inc.manifest.peerDeviceId, transferId, {
+                action: "cancel",
+                reason,
+            }).catch(() => { });
+        }
+    }
+    syncCompletedChunks(manifest, chunks) {
+        if (manifest.completedChunks.length !== chunks.size) {
+            manifest.completedChunks = Array.from(chunks).sort((a, b) => a - b);
+        }
+        return { ...manifest };
+    }
+    getTransfer(transferId) {
+        const out = this.outgoing.get(transferId);
+        if (out)
+            return this.syncCompletedChunks(out.manifest, out.ackedChunks);
+        const inc = this.incoming.get(transferId);
+        if (inc)
+            return this.syncCompletedChunks(inc.manifest, inc.receivedChunks);
+        return undefined;
+    }
+    listTransfers() {
+        return [
+            ...Array.from(this.outgoing.values()).map((o) => this.syncCompletedChunks(o.manifest, o.ackedChunks)),
+            ...Array.from(this.incoming.values()).map((i) => this.syncCompletedChunks(i.manifest, i.receivedChunks)),
+        ];
+    }
+    async sendControlFrame(peerDeviceId, transferId, controlPayload) {
+        const sess = this.options.client.getPeerSession(peerDeviceId);
+        if (!sess || sess.getState() !== "connected") {
+            throw new FileTransferError(`Peer '${peerDeviceId}' is not connected`, "PEER_DISCONNECTED", transferId);
+        }
+        await sess.multiplexer.sendRawWireFrame(WireFrameType.TRANSFER_CONTROL, {
+            messageId: `tctrl_${transferId}_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+            channel: "files",
+            timestamp: Date.now(),
+            transferId,
+        }, encodeJsonPayload(controlPayload));
+    }
+    async handleIncomingFrame(peerDeviceId, frame) {
+        const transferId = frame.header.transferId;
+        if (!transferId)
+            return;
+        if (frame.frameType === WireFrameType.TRANSFER_CONTROL) {
+            const ctrl = decodeJsonPayload(frame.payload);
+            switch (ctrl.action) {
+                case "offer": {
+                    await this.handleIncomingOffer(peerDeviceId, transferId, ctrl);
+                    break;
+                }
+                case "accept": {
+                    const out = this.outgoing.get(transferId);
+                    if (!out || out.cancelled)
+                        break;
+                    if (Array.isArray(ctrl.receivedChunks)) {
+                        for (const idx of ctrl.receivedChunks) {
+                            out.ackedChunks.add(idx);
+                        }
+                        out.manifest.completedChunks = Array.from(out.ackedChunks).sort((a, b) => a - b);
+                    }
+                    out.paused = false;
+                    out.manifest.state = "transferring";
+                    out.manifest.updatedAt = Date.now();
+                    this.events.emit("stateChange", { ...out.manifest });
+                    void this.pumpOutgoingChunks(out);
+                    break;
+                }
+                case "chunk_ack": {
+                    const out = this.outgoing.get(transferId);
+                    if (!out || typeof ctrl.chunkIndex !== "number")
+                        break;
+                    out.ackedChunks.add(ctrl.chunkIndex);
+                    out.manifest.completedChunks = Array.from(out.ackedChunks).sort((a, b) => a - b);
+                    break;
+                }
+                case "pause": {
+                    const out = this.outgoing.get(transferId);
+                    if (out) {
+                        out.paused = true;
+                        out.manifest.state = "paused";
+                        out.manifest.updatedAt = Date.now();
+                        this.events.emit("stateChange", { ...out.manifest });
+                    }
+                    const inc = this.incoming.get(transferId);
+                    if (inc) {
+                        inc.paused = true;
+                        inc.manifest.state = "paused";
+                        inc.manifest.updatedAt = Date.now();
+                        this.events.emit("stateChange", { ...inc.manifest });
+                    }
+                    break;
+                }
+                case "complete": {
+                    const out = this.outgoing.get(transferId);
+                    if (!out)
+                        break;
+                    out.manifest.state = "completed";
+                    out.manifest.transferredBytes = out.manifest.totalBytes;
+                    out.manifest.updatedAt = Date.now();
+                    this.events.emit("stateChange", { ...out.manifest });
+                    this.events.emit("completed", { manifest: { ...out.manifest } });
+                    for (const w of out.completionWaiters.splice(0)) {
+                        w.resolve({ ...out.manifest });
+                    }
+                    break;
+                }
+                case "cancel": {
+                    const reason = ctrl.reason ?? "Cancelled by remote peer";
+                    const out = this.outgoing.get(transferId);
+                    if (out) {
+                        out.cancelled = true;
+                        out.manifest.state = "cancelled";
+                        out.manifest.error = { code: "CANCELLED", message: reason };
+                        this.events.emit("stateChange", { ...out.manifest });
+                        for (const w of out.completionWaiters.splice(0)) {
+                            w.reject(new FileTransferError(reason, "CANCELLED", transferId));
+                        }
+                    }
+                    const inc = this.incoming.get(transferId);
+                    if (inc) {
+                        inc.cancelled = true;
+                        inc.manifest.state = "cancelled";
+                        inc.manifest.error = { code: "CANCELLED", message: reason };
+                        await this.storage.deleteTransferStaging(transferId);
+                        this.events.emit("stateChange", { ...inc.manifest });
+                    }
+                    break;
+                }
+                case "error": {
+                    const code = ctrl.errorCode ?? "IO_ERROR";
+                    const msg = ctrl.reason ?? "Remote transfer error";
+                    const out = this.outgoing.get(transferId);
+                    if (out) {
+                        this.failOutgoingTransfer(out, new FileTransferError(msg, code, transferId));
+                    }
+                    break;
+                }
+            }
+            return;
+        }
+        if (frame.frameType === WireFrameType.TRANSFER_CHUNK) {
+            await this.handleIncomingChunk(peerDeviceId, transferId, frame);
+        }
+    }
+    async handleIncomingOffer(peerDeviceId, transferId, ctrl) {
+        const rawFileName = String(ctrl.fileName ?? "");
+        let safeFileName;
+        try {
+            safeFileName = sanitizeFileName(rawFileName);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Invalid filename";
+            await this.sendControlFrame(peerDeviceId, transferId, {
+                action: "error",
+                errorCode: "PATH_TRAVERSAL_BLOCKED",
+                reason: msg,
+            });
+            this.events.emit("error", {
+                transferId,
+                error: new FileTransferError(msg, "PATH_TRAVERSAL_BLOCKED", transferId),
+            });
+            return;
+        }
+        const totalBytes = Number(ctrl.totalBytes ?? 0);
+        if (this.policy.maxFileSizeBytes !== undefined &&
+            totalBytes > this.policy.maxFileSizeBytes) {
+            const msg = `File size ${totalBytes} exceeds max policy limit ${this.policy.maxFileSizeBytes}`;
+            await this.sendControlFrame(peerDeviceId, transferId, {
+                action: "error",
+                errorCode: "FILE_TOO_LARGE",
+                reason: msg,
+            });
+            return;
+        }
+        const mimeType = String(ctrl.mimeType ?? "application/octet-stream");
+        if (this.policy.allowedMimeTypes &&
+            this.policy.allowedMimeTypes.length > 0 &&
+            !this.policy.allowedMimeTypes.includes(mimeType)) {
+            const msg = `MIME type '${mimeType}' is not allowed by receiver policy`;
+            await this.sendControlFrame(peerDeviceId, transferId, {
+                action: "error",
+                errorCode: "POLICY_REJECTED",
+                reason: msg,
+            });
+            return;
+        }
+        // Check existing staging chunks for resume support!
+        const existingWrittenChunks = await this.storage.listWrittenChunks(transferId);
+        const existingRuntime = this.incoming.get(transferId);
+        const receivedSet = new Set(existingWrittenChunks);
+        if (existingRuntime) {
+            for (const idx of existingRuntime.receivedChunks) {
+                receivedSet.add(idx);
+            }
+        }
+        const chunkSize = Number(ctrl.chunkSize ?? this.chunkSize);
+        const totalChunks = Number(ctrl.totalChunks ?? Math.max(1, Math.ceil(totalBytes / chunkSize)));
+        const now = Date.now();
+        const manifest = existingRuntime?.manifest ?? {
+            transferId,
+            peerDeviceId,
+            direction: "receive",
+            fileName: safeFileName,
+            mimeType,
+            totalBytes,
+            chunkSize,
+            totalChunks,
+            fileSha256: String(ctrl.fileSha256 ?? ""),
+            lastModified: Number(ctrl.lastModified ?? 0),
+            state: "offered",
+            completedChunks: Array.from(receivedSet).sort((a, b) => a - b),
+            transferredBytes: Math.min(totalBytes, receivedSet.size * chunkSize),
+            startedAt: now,
+            updatedAt: now,
+        };
+        const inc = existingRuntime ?? {
+            manifest,
+            receivedChunks: receivedSet,
+            paused: false,
+            cancelled: false,
+        };
+        inc.paused = false;
+        this.incoming.set(transferId, inc);
+        this.events.emit("incomingOffer", { ...manifest });
+        if (this.policy.onIncomingOffer) {
+            const allowed = await this.policy.onIncomingOffer({ ...manifest });
+            if (!allowed) {
+                await this.sendControlFrame(peerDeviceId, transferId, {
+                    action: "error",
+                    errorCode: "POLICY_REJECTED",
+                    reason: "Transfer rejected by receiver policy callback",
+                });
+                return;
+            }
+        }
+        else if (!(this.policy.autoAccept ?? true)) {
+            return;
+        }
+        inc.manifest.state = "transferring";
+        inc.manifest.updatedAt = Date.now();
+        this.events.emit("stateChange", { ...inc.manifest });
+        await this.sendControlFrame(peerDeviceId, transferId, {
+            action: "accept",
+            receivedChunks: Array.from(inc.receivedChunks),
+        });
+    }
+    async pumpOutgoingChunks(rt) {
+        if (rt.sendingLoopPromise)
+            return rt.sendingLoopPromise;
+        rt.sendingLoopPromise = (async () => {
+            try {
+                const sess = this.options.client.getPeerSession(rt.manifest.peerDeviceId);
+                if (!sess || sess.getState() !== "connected") {
+                    return;
+                }
+                const totalChunks = rt.manifest.totalChunks;
+                const chunkSize = rt.manifest.chunkSize;
+                for (let i = 0; i < totalChunks; i++) {
+                    if (rt.cancelled || rt.paused)
+                        return;
+                    if (rt.ackedChunks.has(i))
+                        continue;
+                    const start = i * chunkSize;
+                    const end = Math.min(rt.manifest.totalBytes, start + chunkSize);
+                    const slice = await rt.source.readSlice(start, end);
+                    if (rt.cancelled || rt.paused)
+                        return;
+                    const chunkHash = sha256HexSync(slice);
+                    await sess.multiplexer.sendRawWireFrame(WireFrameType.TRANSFER_CHUNK, {
+                        messageId: `tchk_${rt.manifest.transferId}_${i}`,
+                        channel: "files",
+                        timestamp: Date.now(),
+                        transferId: rt.manifest.transferId,
+                        chunkIndex: i,
+                        totalChunks,
+                        byteOffset: start,
+                        chunkHash,
+                    }, slice);
+                    rt.ackedChunks.add(i);
+                    rt.manifest.transferredBytes = Math.min(rt.manifest.totalBytes, rt.ackedChunks.size * chunkSize);
+                    rt.manifest.updatedAt = Date.now();
+                    const elapsedSec = Math.max(0.001, (Date.now() - rt.manifest.startedAt) / 1000);
+                    this.events.emit("progress", {
+                        transferId: rt.manifest.transferId,
+                        peerDeviceId: rt.manifest.peerDeviceId,
+                        direction: "send",
+                        fileName: rt.manifest.fileName,
+                        state: rt.manifest.state,
+                        transferredBytes: rt.manifest.transferredBytes,
+                        totalBytes: rt.manifest.totalBytes,
+                        completedChunks: rt.ackedChunks.size,
+                        totalChunks,
+                        progressRatio: rt.manifest.totalBytes > 0
+                            ? rt.manifest.transferredBytes / rt.manifest.totalBytes
+                            : 1,
+                        bytesPerSecond: Math.round(rt.manifest.transferredBytes / elapsedSec),
+                    });
+                }
+            }
+            catch (err) {
+                const ftErr = err instanceof FileTransferError
+                    ? err
+                    : new FileTransferError(err instanceof Error ? err.message : String(err), "IO_ERROR", rt.manifest.transferId);
+                this.failOutgoingTransfer(rt, ftErr);
+            }
+            finally {
+                rt.sendingLoopPromise = null;
+            }
+        })();
+        return rt.sendingLoopPromise;
+    }
+    async handleIncomingChunk(peerDeviceId, transferId, frame) {
+        const inc = this.incoming.get(transferId);
+        if (!inc || inc.cancelled)
+            return;
+        const chunkIndex = frame.header.chunkIndex ?? 0;
+        const expectedChunkHash = frame.header.chunkHash;
+        if (expectedChunkHash) {
+            const actualChunkHash = sha256HexSync(frame.payload);
+            if (actualChunkHash !== expectedChunkHash) {
+                const err = new FileTransferError(`Chunk ${chunkIndex} SHA-256 mismatch`, "HASH_MISMATCH", transferId);
+                await this.failIncomingTransfer(inc, peerDeviceId, err);
+                return;
+            }
+        }
+        // Write chunk to persistent staging BEFORE acknowledging
+        try {
+            await this.storage.writeChunk(transferId, chunkIndex, frame.payload);
+        }
+        catch (storageErr) {
+            const code = storageErr instanceof DropspaceStorageError
+                ? storageErr.code
+                : "IO_ERROR";
+            const err = new FileTransferError(storageErr instanceof Error ? storageErr.message : String(storageErr), code, transferId);
+            await this.failIncomingTransfer(inc, peerDeviceId, err);
+            return;
+        }
+        inc.receivedChunks.add(chunkIndex);
+        inc.manifest.transferredBytes = Math.min(inc.manifest.totalBytes, inc.receivedChunks.size * inc.manifest.chunkSize);
+        inc.manifest.updatedAt = Date.now();
+        // Send persistent chunk_ack only AFTER writeChunk succeeded
+        await this.sendControlFrame(peerDeviceId, transferId, {
+            action: "chunk_ack",
+            chunkIndex,
+        }).catch(() => { });
+        const elapsedSec = Math.max(0.001, (Date.now() - inc.manifest.startedAt) / 1000);
+        this.events.emit("progress", {
+            transferId,
+            peerDeviceId,
+            direction: "receive",
+            fileName: inc.manifest.fileName,
+            state: inc.manifest.state,
+            transferredBytes: inc.manifest.transferredBytes,
+            totalBytes: inc.manifest.totalBytes,
+            completedChunks: inc.receivedChunks.size,
+            totalChunks: inc.manifest.totalChunks,
+            progressRatio: inc.manifest.totalBytes > 0
+                ? inc.manifest.transferredBytes / inc.manifest.totalBytes
+                : 1,
+            bytesPerSecond: Math.round(inc.manifest.transferredBytes / elapsedSec),
+        });
+        if (inc.receivedChunks.size === inc.manifest.totalChunks) {
+            this.syncCompletedChunks(inc.manifest, inc.receivedChunks);
+            await this.verifyAndFinalizeIncoming(inc, peerDeviceId);
+        }
+    }
+    async verifyAndFinalizeIncoming(inc, peerDeviceId) {
+        const transferId = inc.manifest.transferId;
+        inc.manifest.state = "verifying";
+        this.events.emit("stateChange", { ...inc.manifest });
+        // Bounded-memory streaming SHA-256 verification across staged chunks
+        const hasher = new StreamingSha256();
+        let sinceYield = 0;
+        for (let i = 0; i < inc.manifest.totalChunks; i++) {
+            const chunk = await this.storage.readChunk(transferId, i);
+            if (!chunk) {
+                const err = new FileTransferError(`Missing staged chunk ${i} during final verification`, "IO_ERROR", transferId);
+                await this.failIncomingTransfer(inc, peerDeviceId, err);
+                return;
+            }
+            hasher.update(chunk);
+            sinceYield += chunk.byteLength;
+            if (sinceYield >= 16 * 1024 * 1024 && i + 1 < inc.manifest.totalChunks) {
+                sinceYield = 0;
+                await new Promise((resolve) => setTimeout(resolve, 0));
+            }
+        }
+        const computedSha256 = hasher.digestHex();
+        if (computedSha256 !== inc.manifest.fileSha256) {
+            const err = new FileTransferError(`Full file SHA-256 integrity mismatch (expected ${inc.manifest.fileSha256}, got ${computedSha256})`, "HASH_MISMATCH", transferId);
+            await this.failIncomingTransfer(inc, peerDeviceId, err);
+            return;
+        }
+        try {
+            const { finalKey } = await this.storage.finalizeTransfer(transferId, inc.manifest.fileName, inc.manifest.totalChunks, { allowOverwrite: this.policy.allowOverwrite });
+            inc.manifest.state = "completed";
+            inc.manifest.finalStorageKey = finalKey;
+            inc.manifest.transferredBytes = inc.manifest.totalBytes;
+            inc.manifest.updatedAt = Date.now();
+            await this.sendControlFrame(peerDeviceId, transferId, {
+                action: "complete",
+            }).catch(() => { });
+            this.events.emit("stateChange", { ...inc.manifest });
+            this.events.emit("completed", {
+                manifest: { ...inc.manifest },
+                finalStorageKey: finalKey,
+            });
+        }
+        catch (storageErr) {
+            const code = storageErr instanceof DropspaceStorageError
+                ? storageErr.code
+                : "IO_ERROR";
+            const err = new FileTransferError(storageErr instanceof Error ? storageErr.message : String(storageErr), code, transferId);
+            await this.failIncomingTransfer(inc, peerDeviceId, err);
+        }
+    }
+    failOutgoingTransfer(rt, err) {
+        rt.cancelled = true;
+        rt.manifest.state = "failed";
+        rt.manifest.error = { code: err.code, message: err.message };
+        rt.manifest.updatedAt = Date.now();
+        this.events.emit("stateChange", { ...rt.manifest });
+        this.events.emit("error", { transferId: rt.manifest.transferId, error: err });
+        void this.sendControlFrame(rt.manifest.peerDeviceId, rt.manifest.transferId, {
+            action: "error",
+            errorCode: err.code,
+            reason: err.message,
+        }).catch(() => { });
+        for (const w of rt.completionWaiters.splice(0)) {
+            w.reject(err);
+        }
+    }
+    async failIncomingTransfer(inc, peerDeviceId, err) {
+        inc.manifest.state = "failed";
+        inc.manifest.error = { code: err.code, message: err.message };
+        inc.manifest.updatedAt = Date.now();
+        this.events.emit("stateChange", { ...inc.manifest });
+        this.events.emit("error", { transferId: inc.manifest.transferId, error: err });
+        await this.sendControlFrame(peerDeviceId, inc.manifest.transferId, {
+            action: "error",
+            errorCode: err.code,
+            reason: err.message,
+        }).catch(() => { });
+    }
+    close() {
+        this.unsubscribeClient();
+        this.events.removeAllListeners();
+    }
+}
+//# sourceMappingURL=index.js.map