@useragent-kit/sdk 0.0.0 → 0.0.1

package/dist/experimental/file-transfer.js

@@ -0,0 +1,1377 @@
+import { createWindowHostFileTransferTransport } from "./transport.js";
+// ---------------------------------------------------------------------------
+// Experimental file transfer — P2P data transport via host data API.
+// ---------------------------------------------------------------------------
+// Layered protocol on top of the raw data channel:
+//   1. JSON control messages for metadata and signaling
+//   2. Binary chunk frames for file payloads
+//
+// Message types:
+//   { type: "file-offer",      id, name, size, mime, chunkSize, totalChunks,
+//                               protocolVersion, capabilities[] }
+//   { type: "file-accept",     id, windowSize, protocolVersion, capabilities[] }
+//   { type: "file-reject",     id, reason? }
+//   binary frame: file chunk payloads
+//   { type: "file-window-ack", id, ackedThrough, received, missing[], windowSize,
+//                               protocolVersion, capabilities[] }
+//   { type: "file-window-probe", id }
+//   { type: "file-ack",        id }                      (receiver confirms receipt)
+// ---------------------------------------------------------------------------
+// Keep per-message payloads conservative while the transport is still being
+// tuned. Binary chunks remove the base64 overhead, but smaller frames still
+// reduce burst pressure and retransmit cost on weaker links.
+const CHUNK_SIZE = 8 * 1024;
+const DEFAULT_WINDOW_SIZE = 8;
+const MIN_WINDOW_SIZE = 4;
+const MAX_WINDOW_SIZE = 48;
+const ACK_STRIDE = 2;
+const CHUNK_SEND_BURST = 8;
+const CHUNK_SEND_PAUSE_MS = 4;
+const WINDOW_GROW_STEP = 4;
+const WINDOW_GROW_INTERVAL_MS = 1500;
+const WINDOW_SHRINK_COOLDOWN_MS = 1000;
+const SLOW_NETWORK_RECOVERY_WINDOW_MS = 15000;
+const SLOW_NETWORK_RECOVERY_THRESHOLD = 3;
+const SLOW_NETWORK_HEALTHY_CLEAR_MS = 12000;
+const SLOW_NETWORK_WINDOW_CAP = 12;
+const MAX_MISSING_HINTS = 16;
+const ACK_HEARTBEAT_MS = 1000;
+const WINDOW_STALL_PROBE_MS = 3000;
+const DUPLICATE_ACK_MIN_INTERVAL_MS = 3000;
+const EARLY_REPAIR_UI_SUPPRESS_BYTES = 512 * 1024;
+const MAX_FILE_SIZE = 100 * 1024 * 1024; // 100 MB cap on incoming offers
+const MAX_CONCURRENT_INCOMING = 3; // limit simultaneous incoming transfers
+const FILE_PROTOCOL_VERSION = 2;
+const FILE_CAPABILITIES = ["binary-chunks-v1", "window-ack-v1", "window-probe-v1"];
+const REQUIRED_FILE_CAPABILITIES = ["binary-chunks-v1"];
+const BINARY_CHUNK_MAGIC = [0xff, 0x56, 0x4f, 0x58, 0x46];
+const BINARY_FRAME_KIND_CHUNK = 1;
+const HASH_ALGO = "SHA-256";
+const STALL_RETRY_RANGE = 4;
+const STALL_RETRY_ESCALATION = [4, 8, 16];
+const SLOW_NETWORK_CHUNK_SEND_BURST = 4;
+const SLOW_NETWORK_CHUNK_SEND_PAUSE_MS = 12;
+let connId = null;
+let onEvent = null;
+let transportOverride = null;
+let initializedTransport = null;
+let transportUnsubscribers = [];
+// Resolver waiting for the dataConnected event after connect() is called.
+let pendingConnectResolve = null;
+let pendingConnectReject = null;
+let pendingConnectTimer = null;
+let pendingConnectConnId = null;
+// Tracks in-flight connectData promise so callers can await it instead of starting a second one.
+let pendingConnectPromise = null;
+const pendingIncomingOffers = new Map();
+const incoming = new Map();
+const pendingOutgoingOffers = new Map();
+const pendingOutgoingAcks = new Map();
+const activeOutgoingTransfers = new Map();
+const sentCancels = new Set();
+export function onDataEvent(cb) {
+    onEvent = cb;
+}
+export function setFileTransferTransport(transport) {
+    if (initializedTransport && initializedTransport !== transport) {
+        teardownTransportListeners();
+    }
+    transportOverride = transport;
+}
+export function getFileTransferTransport() {
+    return resolveTransport();
+}
+function emit(event) {
+    onEvent?.(event);
+}
+function logTransfer(level, id, message, details) {
+    const suffix = details ? ` ${JSON.stringify(details)}` : "";
+    const line = `[vox-file] id=${id} ${message}${suffix}`;
+    if (level === "warn") {
+        console.warn(line);
+    }
+    else {
+        console.info(line);
+    }
+}
+function randomId() {
+    return Math.random().toString(36).slice(2, 10);
+}
+function rejectPendingTransfers(reason) {
+    const rejected = new Set();
+    for (const [id, transfer] of pendingOutgoingOffers) {
+        if (transfer.timer !== null)
+            clearTimeout(transfer.timer);
+        emit({ type: "sendRejected", id, name: transfer.offer.name, reason });
+        transfer.reject(new Error(reason));
+        pendingOutgoingOffers.delete(id);
+        rejected.add(id);
+    }
+    for (const [id, ack] of pendingOutgoingAcks) {
+        if (ack.timer !== null)
+            clearTimeout(ack.timer);
+        if (!rejected.has(id)) {
+            emit({ type: "sendRejected", id, name: ack.name, reason });
+            rejected.add(id);
+        }
+        ack.reject(new Error(reason));
+        pendingOutgoingAcks.delete(id);
+    }
+    for (const [id, transfer] of activeOutgoingTransfers) {
+        transfer.closed = true;
+        stopProbeTimer(transfer);
+        logOutgoingSummary(transfer, "rejected", reason);
+        if (!rejected.has(id)) {
+            emit({ type: "sendRejected", id, name: transfer.offer.name, reason });
+            rejected.add(id);
+        }
+    }
+    activeOutgoingTransfers.clear();
+}
+async function sendCancel(id, reason) {
+    if (sentCancels.has(id))
+        return;
+    sentCancels.add(id);
+    await sendJson({ type: "file-cancel", id, reason });
+}
+// ---------------------------------------------------------------------------
+// Lifecycle
+// ---------------------------------------------------------------------------
+/** Open a data connection to a peer. Resolves only when the dataConnected event fires.
+ *  If a connect attempt is already in flight, returns the existing promise. */
+export function connectData(peerAddress) {
+    const ep = resolveTransport();
+    if (!ep)
+        return Promise.resolve();
+    if (pendingConnectPromise)
+        return pendingConnectPromise;
+    const p = new Promise((resolve, reject) => {
+        pendingConnectResolve = resolve;
+        pendingConnectReject = reject;
+        pendingConnectConnId = null;
+        pendingConnectTimer = setTimeout(() => {
+            pendingConnectTimer = null;
+            if (pendingConnectReject) {
+                const rej = pendingConnectReject;
+                pendingConnectResolve = null;
+                pendingConnectReject = null;
+                pendingConnectConnId = null;
+                rej(new Error("Data connect timed out"));
+            }
+        }, 60000);
+        ep.connect(peerAddress)
+            .then((nextConnId) => {
+            pendingConnectConnId = nextConnId;
+        })
+            .catch((e) => {
+            if (pendingConnectTimer !== null) {
+                clearTimeout(pendingConnectTimer);
+                pendingConnectTimer = null;
+            }
+            if (pendingConnectReject) {
+                const rej = pendingConnectReject;
+                pendingConnectResolve = null;
+                pendingConnectReject = null;
+                pendingConnectConnId = null;
+                const msg = e instanceof Error ? e.message : String(e);
+                rej(new Error("Data connect failed: " + msg));
+            }
+        });
+    });
+    pendingConnectPromise = p.finally(() => {
+        pendingConnectPromise = null;
+    });
+    return pendingConnectPromise;
+}
+/** Start listening for incoming data connections at the given address. */
+export async function startDataListening(address) {
+    const ep = resolveTransport();
+    if (!ep)
+        return;
+    await ep.startListening(address);
+}
+/** Wire up host data events. Call once on boot. */
+export function initDataEvents() {
+    const ep = resolveTransport();
+    if (!ep)
+        return;
+    if (initializedTransport === ep && transportUnsubscribers.length > 0)
+        return;
+    teardownTransportListeners();
+    initializedTransport = ep;
+    transportUnsubscribers.push(ep.onConnected((data) => {
+        connId = data.connId;
+        if (pendingConnectTimer !== null) {
+            clearTimeout(pendingConnectTimer);
+            pendingConnectTimer = null;
+        }
+        if (pendingConnectResolve) {
+            const res = pendingConnectResolve;
+            pendingConnectResolve = null;
+            pendingConnectReject = null;
+            pendingConnectConnId = null;
+            res();
+        }
+        emit({ type: "connected", connId: data.connId, peer: data.peer });
+    }));
+    transportUnsubscribers.push(ep.onMessage((data) => {
+        handleMessage(data.connId, data.data);
+    }));
+    transportUnsubscribers.push(ep.onBinary((data) => {
+        handleBinaryMessage(data.connId, data.dataBase64);
+    }));
+    transportUnsubscribers.push(ep.onClosed((data) => {
+        const isActiveConnClose = connId != null && data.connId === connId;
+        if (pendingConnectConnId === data.connId) {
+            pendingConnectConnId = null;
+        }
+        if (data.connId === connId)
+            connId = null;
+        clearIncomingTransfers();
+        pendingIncomingOffers.clear();
+        if (isActiveConnClose) {
+            rejectPendingTransfers("Connection closed");
+            emit({ type: "closed", reason: data.reason });
+        }
+    }));
+    transportUnsubscribers.push(ep.onError((data) => {
+        const isPendingConnectError = pendingConnectConnId != null && data.connId === pendingConnectConnId;
+        const isActiveConnError = connId != null && data.connId === connId;
+        if (isPendingConnectError) {
+            if (pendingConnectTimer !== null) {
+                clearTimeout(pendingConnectTimer);
+                pendingConnectTimer = null;
+            }
+            if (pendingConnectReject) {
+                const rej = pendingConnectReject;
+                pendingConnectResolve = null;
+                pendingConnectReject = null;
+                pendingConnectConnId = null;
+                rej(new Error("Data connect failed: " + data.error));
+            }
+            return;
+        }
+        if (!isActiveConnError) {
+            return;
+        }
+        rejectPendingTransfers(data.error);
+        emit({ type: "error", message: data.error });
+    }));
+}
+/** Close the data connection. */
+export async function closeData() {
+    if (pendingConnectTimer !== null) {
+        clearTimeout(pendingConnectTimer);
+        pendingConnectTimer = null;
+    }
+    if (pendingConnectReject) {
+        const rej = pendingConnectReject;
+        pendingConnectResolve = null;
+        pendingConnectReject = null;
+        pendingConnectConnId = null;
+        rej(new Error("Connection closed"));
+    }
+    if (connId == null)
+        return;
+    try {
+        await resolveTransport()?.close(connId);
+    }
+    catch (_) { }
+    connId = null;
+    clearIncomingTransfers();
+    pendingIncomingOffers.clear();
+    rejectPendingTransfers("Connection closed");
+}
+export function isConnected() {
+    return connId != null;
+}
+// ---------------------------------------------------------------------------
+// Send a file
+// ---------------------------------------------------------------------------
+export async function sendFile(file) {
+    if (connId == null) {
+        emit({ type: "error", message: "No data connection" });
+        return;
+    }
+    const id = randomId();
+    const totalChunks = Math.ceil(file.size / CHUNK_SIZE);
+    const offer = {
+        id,
+        name: file.name,
+        size: file.size,
+        mime: file.type || "application/octet-stream",
+        hashAlgo: HASH_ALGO,
+        hashHex: await digestFile(file),
+    };
+    let failureReported = false;
+    emit({ type: "sendPending", id, name: file.name, size: file.size });
+    try {
+        await sendJson({
+            type: "file-offer",
+            ...offer,
+            chunkSize: CHUNK_SIZE,
+            totalChunks,
+            protocolVersion: FILE_PROTOCOL_VERSION,
+            capabilities: FILE_CAPABILITIES,
+        });
+        const acceptance = await waitForFileAcceptance(offer);
+        emit({ type: "sendAccepted", id, name: file.name });
+        const transfer = {
+            offer,
+            file,
+            totalChunks,
+            nextSeqToSend: 0,
+            ackedThrough: -1,
+            remoteWindow: acceptance.windowSize,
+            pendingResends: [],
+            pendingResendSet: new Set(),
+            pumpPromise: null,
+            awaitingAckEmitted: false,
+            closed: false,
+            lastAckAt: Date.now(),
+            probeTimer: null,
+            protocolVersion: acceptance.protocolVersion,
+            capabilities: acceptance.capabilities,
+            stalledAckCount: 0,
+            lastAckedSnapshot: null,
+            lastProgressAt: Date.now(),
+            highestRetriedSeq: -1,
+            recoveryLevel: 0,
+            speedBps: 0,
+            lastSpeedSampleAt: Date.now(),
+            lastSpeedSampleBytes: 0,
+            slowNetworkMode: false,
+        };
+        logTransfer("info", id, "outgoing transfer started", {
+            size: file.size,
+            totalChunks,
+            remoteWindow: acceptance.windowSize,
+            protocolVersion: acceptance.protocolVersion,
+            capabilities: acceptance.capabilities,
+        });
+        activeOutgoingTransfers.set(id, transfer);
+        startProbeTimer(transfer);
+        await pumpOutgoingTransfer(transfer);
+        await waitForFileAck(id, file.name);
+        logOutgoingSummary(transfer, "completed");
+        emit({ type: "sendComplete", id, name: file.name });
+    }
+    catch (e) {
+        if (!failureReported) {
+            const reason = e instanceof Error ? e.message : String(e);
+            sendCancel(id, reason).catch(() => { });
+            emit({ type: "sendRejected", id, name: file.name, reason });
+            failureReported = true;
+        }
+        throw e;
+    }
+    finally {
+        const transfer = activeOutgoingTransfers.get(id);
+        if (transfer) {
+            if (failureReported) {
+                logOutgoingSummary(transfer, "failed");
+            }
+            transfer.closed = true;
+            activeOutgoingTransfers.delete(id);
+            stopProbeTimer(transfer);
+        }
+        sentCancels.delete(id);
+    }
+}
+// ---------------------------------------------------------------------------
+// Receive messages
+// ---------------------------------------------------------------------------
+function handleMessage(_cid, raw) {
+    let msg;
+    try {
+        msg = JSON.parse(raw);
+    }
+    catch {
+        return;
+    }
+    switch (msg.type) {
+        case "file-offer":
+            handleFileOffer(msg);
+            break;
+        case "file-accept":
+            handleFileAccept(msg);
+            break;
+        case "file-reject":
+            handleFileReject(msg);
+            break;
+        case "file-cancel":
+            handleFileCancel(msg);
+            break;
+        case "file-window-ack":
+            handleFileWindowAck(msg);
+            break;
+        case "file-window-probe":
+            handleFileWindowProbe(msg);
+            break;
+        case "file-ack":
+            handleFileAck(msg);
+            break;
+    }
+}
+function handleBinaryMessage(_cid, dataBase64) {
+    const frame = decodeBinaryChunkFrame(base64ToUint8(dataBase64));
+    if (!frame)
+        return;
+    handleFileChunk(frame);
+}
+function handleFileOffer(msg) {
+    const id = String(msg.id ?? "");
+    if (!id)
+        return;
+    const size = Number(msg.size);
+    const chunkSize = Number(msg.chunkSize);
+    const totalChunks = Number(msg.totalChunks);
+    const protocolVersion = Number(msg.protocolVersion);
+    const capabilities = normalizeCapabilities(msg.capabilities);
+    if (!Number.isFinite(size) ||
+        size <= 0 ||
+        size > MAX_FILE_SIZE ||
+        !Number.isInteger(chunkSize) ||
+        chunkSize <= 0 ||
+        !Number.isInteger(totalChunks) ||
+        totalChunks <= 0) {
+        sendJson({ type: "file-reject", id, reason: "invalid offer metadata" }).catch(() => { });
+        emit({ type: "error", message: "Rejected file offer: invalid metadata" });
+        return;
+    }
+    if (!isCompatibleOffer(protocolVersion, capabilities)) {
+        sendJson({ type: "file-reject", id, reason: "incompatible file transfer version" }).catch(() => { });
+        emit({ type: "error", message: "Rejected file offer: incompatible file transfer version" });
+        return;
+    }
+    if (incoming.size + pendingIncomingOffers.size >= MAX_CONCURRENT_INCOMING) {
+        sendJson({ type: "file-reject", id, reason: "too many concurrent transfers" }).catch(() => { });
+        emit({ type: "error", message: "Rejected file offer: too many concurrent transfers" });
+        return;
+    }
+    const rawName = String(msg.name ?? "");
+    const safeName = rawName.replace(/[/\\]/g, "").slice(0, 255) || "file";
+    const offer = {
+        id,
+        name: safeName,
+        size,
+        mime: msg.mime,
+        hashAlgo: typeof msg.hashAlgo === "string" ? msg.hashAlgo : undefined,
+        hashHex: typeof msg.hashHex === "string" ? msg.hashHex : undefined,
+    };
+    pendingIncomingOffers.set(id, {
+        offer,
+        chunkSize,
+        totalChunks,
+        protocolVersion,
+        capabilities,
+    });
+    emit({ type: "fileOffer", offer, connId: connId });
+}
+function handleFileAccept(msg) {
+    const id = String(msg.id ?? "");
+    const acceptance = resolveAcceptance(msg);
+    if (!acceptance) {
+        const transfer = pendingOutgoingOffers.get(id);
+        if (transfer) {
+            if (transfer.timer !== null)
+                clearTimeout(transfer.timer);
+            pendingOutgoingOffers.delete(id);
+            emit({
+                type: "sendRejected",
+                id,
+                name: transfer.offer.name,
+                reason: "receiver does not support this file transfer version",
+            });
+            transfer.reject(new Error("Receiver does not support this file transfer version"));
+        }
+        return;
+    }
+    resolvePendingOutgoingOffer(id, acceptance);
+}
+function handleFileReject(msg) {
+    const id = String(msg.id ?? "");
+    sentCancels.delete(id);
+    if (pendingIncomingOffers.has(id)) {
+        const pending = pendingIncomingOffers.get(id);
+        pendingIncomingOffers.delete(id);
+        if (pending) {
+            emit({
+                type: "fileCanceled",
+                id,
+                name: pending.offer.name,
+                reason: normalizeReason(msg.reason, "sender canceled"),
+            });
+        }
+        return;
+    }
+    const incomingFile = incoming.get(id);
+    if (incomingFile) {
+        clearIncomingTransfer(id);
+        emit({
+            type: "fileCanceled",
+            id,
+            name: incomingFile.offer.name,
+            reason: normalizeReason(msg.reason, "sender canceled"),
+        });
+        return;
+    }
+    const reason = normalizeReason(msg.reason, "rejected");
+    const transfer = pendingOutgoingOffers.get(id);
+    if (transfer) {
+        if (transfer.timer !== null) {
+            clearTimeout(transfer.timer);
+            transfer.timer = null;
+        }
+        pendingOutgoingOffers.delete(id);
+        emit({ type: "sendRejected", id, name: transfer.offer.name, reason });
+        transfer.reject(new Error(`File rejected: ${reason}`));
+    }
+    const ack = pendingOutgoingAcks.get(id);
+    if (ack) {
+        if (ack.timer !== null) {
+            clearTimeout(ack.timer);
+            ack.timer = null;
+        }
+        pendingOutgoingAcks.delete(id);
+        ack.reject(new Error(`File rejected: ${reason}`));
+    }
+    const active = activeOutgoingTransfers.get(id);
+    if (active) {
+        active.closed = true;
+        stopProbeTimer(active);
+        activeOutgoingTransfers.delete(id);
+        logOutgoingSummary(active, "rejected", reason);
+        emit({ type: "sendRejected", id, name: active.offer.name, reason });
+    }
+}
+function handleFileCancel(msg) {
+    const id = String(msg.id ?? "");
+    const reason = normalizeReason(msg.reason, "transfer canceled");
+    sentCancels.delete(id);
+    if (pendingIncomingOffers.has(id)) {
+        const pending = pendingIncomingOffers.get(id);
+        pendingIncomingOffers.delete(id);
+        if (pending) {
+            emit({ type: "fileCanceled", id, name: pending.offer.name, reason });
+        }
+        return;
+    }
+    const incomingFile = incoming.get(id);
+    if (incomingFile) {
+        clearIncomingTransfer(id);
+        emit({ type: "fileCanceled", id, name: incomingFile.offer.name, reason });
+        return;
+    }
+    const pending = pendingOutgoingOffers.get(id);
+    if (pending) {
+        if (pending.timer !== null)
+            clearTimeout(pending.timer);
+        pendingOutgoingOffers.delete(id);
+        emit({ type: "sendRejected", id, name: pending.offer.name, reason });
+        pending.reject(new Error(reason));
+    }
+    const ack = pendingOutgoingAcks.get(id);
+    if (ack) {
+        if (ack.timer !== null)
+            clearTimeout(ack.timer);
+        pendingOutgoingAcks.delete(id);
+        emit({ type: "sendRejected", id, name: ack.name, reason });
+        ack.reject(new Error(reason));
+    }
+    const active = activeOutgoingTransfers.get(id);
+    if (active) {
+        active.closed = true;
+        stopProbeTimer(active);
+        activeOutgoingTransfers.delete(id);
+        logOutgoingSummary(active, "canceled", reason);
+        emit({ type: "sendRejected", id, name: active.offer.name, reason });
+    }
+}
+function handleFileWindowAck(msg) {
+    const id = String(msg.id ?? "");
+    if (pendingOutgoingOffers.has(id)) {
+        const acceptance = resolveAcceptance(msg);
+        if (acceptance) {
+            resolvePendingOutgoingOffer(id, acceptance);
+        }
+    }
+    const transfer = activeOutgoingTransfers.get(id);
+    if (!transfer || transfer.closed)
+        return;
+    const ackedThrough = Number(msg.ackedThrough);
+    const received = Number(msg.received);
+    const nextSnapshot = {
+        ackedThrough: Number.isInteger(ackedThrough) ? ackedThrough : transfer.ackedThrough,
+        received: Number.isFinite(received) && received >= 0
+            ? received
+            : (transfer.lastAckedSnapshot?.received ?? 0),
+    };
+    if (transfer.lastAckedSnapshot &&
+        transfer.lastAckedSnapshot.ackedThrough === nextSnapshot.ackedThrough &&
+        transfer.lastAckedSnapshot.received === nextSnapshot.received) {
+        transfer.stalledAckCount += 1;
+    }
+    else {
+        transfer.stalledAckCount = 0;
+        transfer.lastAckedSnapshot = nextSnapshot;
+        transfer.lastProgressAt = Date.now();
+        transfer.recoveryLevel = 0;
+    }
+    if (Number.isInteger(ackedThrough)) {
+        transfer.ackedThrough = Math.max(transfer.ackedThrough, Math.min(ackedThrough, transfer.totalChunks - 1));
+    }
+    transfer.lastAckAt = Date.now();
+    refreshOutgoingAckTimeout(id);
+    transfer.remoteWindow = normalizeWindowSize(msg.windowSize, transfer.remoteWindow);
+    transfer.slowNetworkMode = Boolean(msg.slowNetworkMode);
+    if (Number.isFinite(received) && received >= 0) {
+        const sent = Math.min(received, transfer.offer.size);
+        transfer.speedBps = updateTransferSpeed(transfer, sent);
+        emit({
+            type: "sendProgress",
+            id,
+            name: transfer.offer.name,
+            sent,
+            total: transfer.offer.size,
+            bytesPerSecond: transfer.speedBps,
+            slowNetwork: transfer.slowNetworkMode,
+        });
+    }
+    queueResends(transfer, normalizeMissingSeqs(msg.missing, transfer.nextSeqToSend));
+    if (transfer.stalledAckCount >= 2) {
+        const retryCount = retryRangeForStallCount(transfer.stalledAckCount);
+        queueRetryRange(transfer, transfer.ackedThrough + 1, retryCount);
+        logTransfer("warn", id, "stalled ack frontier; retrying range", {
+            ackedThrough: transfer.ackedThrough,
+            retryStart: transfer.ackedThrough + 1,
+            retryCount,
+            highestSent: transfer.nextSeqToSend - 1,
+            missing: normalizeMissingSeqs(msg.missing, transfer.nextSeqToSend),
+            recoveryLevel: transfer.recoveryLevel,
+        });
+    }
+    void pumpOutgoingTransfer(transfer);
+}
+function handleFileWindowProbe(msg) {
+    const id = String(msg.id ?? "");
+    const file = incoming.get(id);
+    if (!file || file.completed)
+        return;
+    void sendWindowAck(id, file, findMissingAhead(file).length > 0);
+}
+function handleFileAck(msg) {
+    const id = String(msg.id ?? "");
+    sentCancels.delete(id);
+    const ack = pendingOutgoingAcks.get(id);
+    if (!ack)
+        return;
+    if (ack.timer !== null) {
+        clearTimeout(ack.timer);
+        ack.timer = null;
+    }
+    pendingOutgoingAcks.delete(id);
+    ack.resolve();
+}
+function handleFileChunk(msg) {
+    const id = msg.id;
+    const file = incoming.get(id);
+    if (!file || file.completed)
+        return;
+    const seq = msg.seq;
+    if (!Number.isInteger(seq) || seq < 0 || seq >= file.expectedChunks)
+        return;
+    if (!(msg.data instanceof Uint8Array) || msg.data.length === 0)
+        return;
+    if (file.chunks[seq])
+        return;
+    file.chunks[seq] = msg.data;
+    file.maxSeenSeq = Math.max(file.maxSeenSeq, seq);
+    file.received += msg.data.length;
+    advanceContiguous(file);
+    file.stalledAckCount = 0;
+    file.lastAckSnapshot = null;
+    file.speedBps = updateTransferSpeed(file, Math.min(file.received, file.offer.size));
+    emit({
+        type: "fileProgress",
+        id,
+        received: Math.min(file.received, file.offer.size),
+        total: file.offer.size,
+        bytesPerSecond: file.speedBps,
+        slowNetwork: file.slowNetworkMode,
+    });
+    if (file.highestContiguous >= file.expectedChunks - 1) {
+        file.completed = true;
+        void finalizeIncomingFile(id, file);
+        return;
+    }
+    const contiguousAdvanced = file.highestContiguous - file.lastAckedThrough;
+    const hasGap = findMissingAhead(file).length > 0;
+    if (hasGap || contiguousAdvanced >= ACK_STRIDE) {
+        void sendWindowAck(id, file, hasGap);
+    }
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function waitForFileAcceptance(offer) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pendingOutgoingOffers.delete(offer.id);
+            sendCancel(offer.id, "timed out waiting for receiver approval").catch(() => { });
+            emit({
+                type: "sendRejected",
+                id: offer.id,
+                name: offer.name,
+                reason: "timed out waiting for receiver approval",
+            });
+            reject(new Error("Timed out waiting for receiver approval"));
+        }, 60000);
+        pendingOutgoingOffers.set(offer.id, { offer, resolve, reject, timer });
+    });
+}
+function resolvePendingOutgoingOffer(id, acceptance) {
+    const transfer = pendingOutgoingOffers.get(id);
+    if (!transfer)
+        return;
+    if (transfer.timer !== null) {
+        clearTimeout(transfer.timer);
+        transfer.timer = null;
+    }
+    pendingOutgoingOffers.delete(id);
+    transfer.resolve(acceptance);
+}
+function waitForFileAck(id, name) {
+    return new Promise((resolve, reject) => {
+        const timer = scheduleOutgoingAckTimeout(id, reject);
+        pendingOutgoingAcks.set(id, { name, resolve, reject, timer });
+    });
+}
+async function sendJson(obj) {
+    const transport = resolveTransport();
+    if (connId == null || !transport)
+        return;
+    const json = JSON.stringify(obj);
+    await transport.send(connId, json);
+}
+async function sendBinary(bytes) {
+    const transport = resolveTransport();
+    if (connId == null || !transport)
+        return;
+    await transport.sendBytes(connId, bytes);
+}
+export async function acceptFileOffer(id) {
+    const pending = pendingIncomingOffers.get(id);
+    if (!pending)
+        return;
+    const windowSize = DEFAULT_WINDOW_SIZE;
+    await sendJson({
+        type: "file-accept",
+        id,
+        windowSize,
+        protocolVersion: FILE_PROTOCOL_VERSION,
+        capabilities: FILE_CAPABILITIES,
+    });
+    pendingIncomingOffers.delete(id);
+    incoming.set(id, {
+        offer: pending.offer,
+        chunkSize: pending.chunkSize,
+        expectedChunks: pending.totalChunks,
+        chunks: new Array(pending.totalChunks),
+        received: 0,
+        highestContiguous: -1,
+        maxSeenSeq: -1,
+        lastAckedThrough: -1,
+        windowSize,
+        completed: false,
+        ackTimer: null,
+        protocolVersion: pending.protocolVersion,
+        capabilities: pending.capabilities,
+        stalledAckCount: 0,
+        lastAckSnapshot: null,
+        lastAckSignature: null,
+        lastAckSentAt: 0,
+        lastWindowTuneAt: Date.now(),
+        lastWindowTuneReceived: 0,
+        speedBps: 0,
+        lastSpeedSampleAt: Date.now(),
+        lastSpeedSampleBytes: 0,
+        slowNetworkMode: false,
+        lastRecoveryAt: 0,
+        recoveryCountWindowStart: 0,
+        recoveryCountInWindow: 0,
+    });
+    const file = incoming.get(id);
+    if (file) {
+        logTransfer("info", id, "incoming transfer accepted", {
+            size: pending.offer.size,
+            totalChunks: pending.totalChunks,
+            windowSize,
+            protocolVersion: pending.protocolVersion,
+            capabilities: pending.capabilities,
+        });
+        startAckHeartbeat(id, file);
+        await sendWindowAck(id, file, false);
+    }
+}
+export async function rejectFileOffer(id, reason = "rejected") {
+    await sendJson({ type: "file-reject", id, reason });
+    pendingIncomingOffers.delete(id);
+    clearIncomingTransfer(id);
+}
+export async function cancelFileTransfer(id, reason = "transfer canceled") {
+    if (pendingIncomingOffers.has(id)) {
+        await rejectFileOffer(id, reason);
+        return;
+    }
+    const incomingFile = incoming.get(id);
+    if (incomingFile) {
+        await sendCancel(id, reason);
+        clearIncomingTransfer(id);
+        emit({ type: "fileCanceled", id, name: incomingFile.offer.name, reason });
+        return;
+    }
+    const pending = pendingOutgoingOffers.get(id);
+    if (pending) {
+        if (pending.timer !== null)
+            clearTimeout(pending.timer);
+        pendingOutgoingOffers.delete(id);
+        await sendCancel(id, reason);
+        emit({ type: "sendRejected", id, name: pending.offer.name, reason });
+        pending.reject(new Error(reason));
+        return;
+    }
+    const ack = pendingOutgoingAcks.get(id);
+    if (ack) {
+        if (ack.timer !== null)
+            clearTimeout(ack.timer);
+        pendingOutgoingAcks.delete(id);
+        await sendCancel(id, reason);
+        emit({ type: "sendRejected", id, name: ack.name, reason });
+        ack.reject(new Error(reason));
+        return;
+    }
+    const active = activeOutgoingTransfers.get(id);
+    if (active) {
+        active.closed = true;
+        activeOutgoingTransfers.delete(id);
+        stopProbeTimer(active);
+        await sendCancel(id, reason);
+        emit({ type: "sendRejected", id, name: active.offer.name, reason });
+    }
+}
+async function pumpOutgoingTransfer(transfer) {
+    if (transfer.pumpPromise)
+        return transfer.pumpPromise;
+    transfer.pumpPromise = (async () => {
+        const burst = transfer.slowNetworkMode ? SLOW_NETWORK_CHUNK_SEND_BURST : CHUNK_SEND_BURST;
+        const pauseMs = transfer.slowNetworkMode
+            ? SLOW_NETWORK_CHUNK_SEND_PAUSE_MS
+            : CHUNK_SEND_PAUSE_MS;
+        let writes = 0;
+        while (!transfer.closed) {
+            const resendSeq = transfer.pendingResends.shift();
+            if (resendSeq != null) {
+                transfer.pendingResendSet.delete(resendSeq);
+                await sendChunk(transfer, resendSeq);
+                writes += 1;
+            }
+            else {
+                const inFlight = transfer.nextSeqToSend - (transfer.ackedThrough + 1);
+                if (inFlight >= transfer.remoteWindow || transfer.nextSeqToSend >= transfer.totalChunks) {
+                    break;
+                }
+                const seq = transfer.nextSeqToSend;
+                transfer.nextSeqToSend += 1;
+                await sendChunk(transfer, seq);
+                writes += 1;
+            }
+            if (writes % burst === 0) {
+                await sleep(pauseMs);
+            }
+        }
+        if (!transfer.awaitingAckEmitted && transfer.nextSeqToSend >= transfer.totalChunks) {
+            transfer.awaitingAckEmitted = true;
+            emit({ type: "sendAwaitingAck", id: transfer.offer.id, name: transfer.offer.name });
+        }
+    })().finally(() => {
+        transfer.pumpPromise = null;
+        if (!transfer.closed && hasPendingOutgoingWork(transfer)) {
+            void pumpOutgoingTransfer(transfer);
+        }
+    });
+    return transfer.pumpPromise;
+}
+function hasPendingOutgoingWork(transfer) {
+    if (transfer.pendingResends.length > 0)
+        return true;
+    const inFlight = transfer.nextSeqToSend - (transfer.ackedThrough + 1);
+    return inFlight < transfer.remoteWindow && transfer.nextSeqToSend < transfer.totalChunks;
+}
+async function sendChunk(transfer, seq) {
+    const data = await readChunkBytes(transfer.file, seq);
+    await sendBinary(encodeBinaryChunkFrame(transfer.offer.id, seq, data));
+}
+async function readChunkBytes(file, seq) {
+    const start = seq * CHUNK_SIZE;
+    const end = Math.min(start + CHUNK_SIZE, file.size);
+    const slice = file.slice(start, end);
+    const buffer = await slice.arrayBuffer();
+    return new Uint8Array(buffer);
+}
+function queueResends(transfer, seqs) {
+    for (const seq of seqs) {
+        if (seq <= transfer.ackedThrough)
+            continue;
+        if (seq >= transfer.nextSeqToSend)
+            continue;
+        if (transfer.pendingResendSet.has(seq))
+            continue;
+        transfer.pendingResendSet.add(seq);
+        transfer.pendingResends.push(seq);
+        transfer.highestRetriedSeq = Math.max(transfer.highestRetriedSeq, seq);
+    }
+}
+function advanceContiguous(file) {
+    while (file.highestContiguous + 1 < file.expectedChunks &&
+        file.chunks[file.highestContiguous + 1]) {
+        file.highestContiguous += 1;
+    }
+}
+function findMissingAhead(file) {
+    const missing = [];
+    for (let seq = file.highestContiguous + 1; seq <= file.maxSeenSeq && missing.length < MAX_MISSING_HINTS; seq++) {
+        if (!file.chunks[seq])
+            missing.push(seq);
+    }
+    return missing;
+}
+function hintedMissing(file) {
+    const missing = findMissingAhead(file);
+    if (missing.length > 0)
+        return missing;
+    // Do not invent a "missing chunk 0" hint before any payload has arrived.
+    // Early startup delay is normal while the sender fills its first window.
+    if (file.maxSeenSeq < 0 || file.received <= 0)
+        return [];
+    if (file.stalledAckCount >= 2) {
+        const frontier = file.highestContiguous + 1;
+        if (frontier >= 0 && frontier < file.expectedChunks) {
+            return [frontier];
+        }
+    }
+    return [];
+}
+function tuneIncomingWindow(id, file, recoveryActive) {
+    const now = Date.now();
+    if (recoveryActive) {
+        // Avoid shrinking during initial channel startup before any chunk arrives.
+        if (file.maxSeenSeq < 0 || file.received <= 0)
+            return;
+        noteRecovery(file, now);
+        if (now - file.lastWindowTuneAt < WINDOW_SHRINK_COOLDOWN_MS)
+            return;
+        const nextWindow = Math.max(MIN_WINDOW_SIZE, Math.floor(file.windowSize / 2));
+        if (nextWindow !== file.windowSize) {
+            logTransfer("warn", id, "shrinking receive window", {
+                from: file.windowSize,
+                to: nextWindow,
+                received: file.received,
+                highestContiguous: file.highestContiguous,
+            });
+            file.windowSize = nextWindow;
+        }
+        file.lastWindowTuneAt = now;
+        file.lastWindowTuneReceived = file.received;
+        return;
+    }
+    maybeClearSlowNetworkMode(file, now);
+    if (now - file.lastWindowTuneAt < WINDOW_GROW_INTERVAL_MS)
+        return;
+    const bytesSinceTune = file.received - file.lastWindowTuneReceived;
+    const bytesNeeded = Math.max(file.chunkSize * file.windowSize, file.chunkSize * 4);
+    if (bytesSinceTune < bytesNeeded)
+        return;
+    const maxWindow = file.slowNetworkMode ? SLOW_NETWORK_WINDOW_CAP : MAX_WINDOW_SIZE;
+    const nextWindow = Math.min(maxWindow, file.windowSize + WINDOW_GROW_STEP);
+    if (nextWindow !== file.windowSize) {
+        logTransfer("info", id, "growing receive window", {
+            from: file.windowSize,
+            to: nextWindow,
+            bytesSinceTune,
+            highestContiguous: file.highestContiguous,
+        });
+        file.windowSize = nextWindow;
+    }
+    file.lastWindowTuneAt = now;
+    file.lastWindowTuneReceived = file.received;
+}
+async function sendWindowAck(id, file, hasGap) {
+    const ackedThrough = file.highestContiguous;
+    const received = Math.min(file.received, file.offer.size);
+    const snapshot = { ackedThrough, received };
+    if (file.lastAckSnapshot &&
+        file.lastAckSnapshot.ackedThrough === snapshot.ackedThrough &&
+        file.lastAckSnapshot.received === snapshot.received) {
+        file.stalledAckCount += 1;
+    }
+    else {
+        file.stalledAckCount = 0;
+        file.lastAckSnapshot = snapshot;
+    }
+    const missing = hintedMissing(file);
+    tuneIncomingWindow(id, file, hasGap || missing.length > 0);
+    const ackSignature = JSON.stringify([ackedThrough, received, missing, file.windowSize]);
+    const now = Date.now();
+    if (file.lastAckSignature === ackSignature &&
+        now - file.lastAckSentAt < DUPLICATE_ACK_MIN_INTERVAL_MS) {
+        return;
+    }
+    file.lastAckSignature = ackSignature;
+    file.lastAckSentAt = now;
+    const shouldSurfaceRepairUi = hasGap || file.received >= EARLY_REPAIR_UI_SUPPRESS_BYTES || file.stalledAckCount >= 2;
+    if ((hasGap || missing.length > 0) && shouldSurfaceRepairUi) {
+        emit({
+            type: "fileRepairing",
+            id,
+            name: file.offer.name,
+            missing: missing.length || 1,
+            slowNetwork: file.slowNetworkMode,
+        });
+        logTransfer("warn", id, "receiver requesting recovery", {
+            ackedThrough,
+            received,
+            missing,
+            stalledAckCount: file.stalledAckCount,
+        });
+    }
+    await sendJson({
+        type: "file-window-ack",
+        id,
+        ackedThrough,
+        received,
+        missing,
+        windowSize: file.windowSize,
+        slowNetworkMode: file.slowNetworkMode,
+        protocolVersion: FILE_PROTOCOL_VERSION,
+        capabilities: FILE_CAPABILITIES,
+    });
+    file.lastAckedThrough = file.highestContiguous;
+}
+async function finalizeIncomingFile(id, file) {
+    const parts = [];
+    for (const chunk of file.chunks) {
+        if (!chunk) {
+            emit({ type: "error", message: `File "${file.offer.name}" incomplete during reassembly` });
+            incoming.delete(id);
+            return;
+        }
+        parts.push(chunk.slice().buffer);
+    }
+    const blob = new Blob(parts, { type: file.offer.mime });
+    if (file.offer.hashAlgo === HASH_ALGO && file.offer.hashHex) {
+        const actualHash = await digestBlob(blob);
+        if (actualHash !== file.offer.hashHex) {
+            stopAckHeartbeat(file);
+            incoming.delete(id);
+            await sendCancel(id, "integrity check failed");
+            emit({
+                type: "error",
+                message: `File "${file.offer.name}" failed integrity verification`,
+            });
+            emit({
+                type: "fileCanceled",
+                id,
+                name: file.offer.name,
+                reason: "integrity check failed",
+            });
+            return;
+        }
+    }
+    stopAckHeartbeat(file);
+    incoming.delete(id);
+    logTransfer("info", id, "incoming transfer completed", {
+        size: file.offer.size,
+        expectedChunks: file.expectedChunks,
+        received: file.received,
+        protocolVersion: file.protocolVersion,
+        capabilities: file.capabilities,
+    });
+    await sendJson({ type: "file-ack", id });
+    emit({ type: "fileComplete", id, name: file.offer.name, blob });
+}
+function normalizeWindowSize(raw, fallback = DEFAULT_WINDOW_SIZE) {
+    const value = Number(raw);
+    if (!Number.isInteger(value))
+        return fallback;
+    return Math.max(MIN_WINDOW_SIZE, Math.min(MAX_WINDOW_SIZE, value));
+}
+function normalizeCapabilities(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const caps = new Set();
+    for (const entry of raw) {
+        if (typeof entry !== "string")
+            continue;
+        const cap = entry.trim();
+        if (!cap)
+            continue;
+        caps.add(cap);
+    }
+    return Array.from(caps);
+}
+function resolveAcceptance(msg) {
+    const protocolVersion = Number(msg.protocolVersion);
+    const capabilities = normalizeCapabilities(msg.capabilities);
+    if (!isCompatibleOffer(protocolVersion, capabilities))
+        return null;
+    return {
+        windowSize: normalizeWindowSize(msg.windowSize),
+        protocolVersion,
+        capabilities,
+    };
+}
+function isCompatibleOffer(protocolVersion, capabilities) {
+    if (!Number.isInteger(protocolVersion) || protocolVersion !== FILE_PROTOCOL_VERSION)
+        return false;
+    return REQUIRED_FILE_CAPABILITIES.every((cap) => capabilities.includes(cap));
+}
+function normalizeMissingSeqs(rawSeqs, totalChunks) {
+    if (!Array.isArray(rawSeqs))
+        return [];
+    const unique = new Set();
+    for (const raw of rawSeqs) {
+        const seq = Number(raw);
+        if (!Number.isInteger(seq) || seq < 0 || seq >= totalChunks)
+            continue;
+        unique.add(seq);
+    }
+    return Array.from(unique).sort((a, b) => a - b);
+}
+function normalizeReason(raw, fallback) {
+    return typeof raw === "string" && raw.trim() ? raw.trim() : fallback;
+}
+async function digestFile(file) {
+    return digestBytes(await file.arrayBuffer());
+}
+async function digestBlob(blob) {
+    return digestBytes(await blob.arrayBuffer());
+}
+async function digestBytes(buffer) {
+    const hash = await crypto.subtle.digest(HASH_ALGO, buffer);
+    return Array.from(new Uint8Array(hash))
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+}
+function base64ToUint8(b64) {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+}
+function encodeBinaryChunkFrame(id, seq, data) {
+    const idBytes = new TextEncoder().encode(id);
+    const frame = new Uint8Array(BINARY_CHUNK_MAGIC.length + 1 + 2 + 4 + idBytes.length + data.length);
+    frame.set(BINARY_CHUNK_MAGIC, 0);
+    frame[BINARY_CHUNK_MAGIC.length] = BINARY_FRAME_KIND_CHUNK;
+    const view = new DataView(frame.buffer);
+    let offset = BINARY_CHUNK_MAGIC.length + 1;
+    view.setUint16(offset, idBytes.length);
+    offset += 2;
+    view.setUint32(offset, seq);
+    offset += 4;
+    frame.set(idBytes, offset);
+    offset += idBytes.length;
+    frame.set(data, offset);
+    return frame;
+}
+function decodeBinaryChunkFrame(frame) {
+    const minHeader = BINARY_CHUNK_MAGIC.length + 1 + 2 + 4;
+    if (frame.length < minHeader)
+        return null;
+    for (let i = 0; i < BINARY_CHUNK_MAGIC.length; i++) {
+        if (frame[i] !== BINARY_CHUNK_MAGIC[i])
+            return null;
+    }
+    const kind = frame[BINARY_CHUNK_MAGIC.length];
+    if (kind !== BINARY_FRAME_KIND_CHUNK)
+        return null;
+    const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+    let offset = BINARY_CHUNK_MAGIC.length + 1;
+    const idLength = view.getUint16(offset);
+    offset += 2;
+    const seq = view.getUint32(offset);
+    offset += 4;
+    if (frame.length < offset + idLength)
+        return null;
+    const idBytes = frame.subarray(offset, offset + idLength);
+    offset += idLength;
+    const id = new TextDecoder().decode(idBytes);
+    const data = frame.slice(offset);
+    if (!id)
+        return null;
+    return { id, seq, data };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveTransport() {
+    return transportOverride ?? createWindowHostFileTransferTransport();
+}
+function teardownTransportListeners() {
+    for (const unsubscribe of transportUnsubscribers) {
+        unsubscribe();
+    }
+    transportUnsubscribers = [];
+    initializedTransport = null;
+}
+function updateTransferSpeed(state, completedBytes) {
+    const now = Date.now();
+    const elapsedMs = now - state.lastSpeedSampleAt;
+    const byteDelta = completedBytes - state.lastSpeedSampleBytes;
+    if (elapsedMs < 250 || byteDelta <= 0) {
+        return state.speedBps;
+    }
+    const instantBps = (byteDelta * 1000) / elapsedMs;
+    state.lastSpeedSampleAt = now;
+    state.lastSpeedSampleBytes = completedBytes;
+    state.speedBps = state.speedBps > 0 ? state.speedBps * 0.65 + instantBps * 0.35 : instantBps;
+    return state.speedBps;
+}
+function noteRecovery(file, now) {
+    file.lastRecoveryAt = now;
+    if (now - file.recoveryCountWindowStart > SLOW_NETWORK_RECOVERY_WINDOW_MS) {
+        file.recoveryCountWindowStart = now;
+        file.recoveryCountInWindow = 1;
+    }
+    else {
+        file.recoveryCountInWindow += 1;
+    }
+    if (!file.slowNetworkMode && file.recoveryCountInWindow >= SLOW_NETWORK_RECOVERY_THRESHOLD) {
+        file.slowNetworkMode = true;
+    }
+}
+function maybeClearSlowNetworkMode(file, now) {
+    if (!file.slowNetworkMode)
+        return;
+    if (now - file.lastRecoveryAt < SLOW_NETWORK_HEALTHY_CLEAR_MS)
+        return;
+    file.slowNetworkMode = false;
+    file.recoveryCountInWindow = 0;
+    file.recoveryCountWindowStart = now;
+}
+function scheduleOutgoingAckTimeout(id, reject) {
+    return setTimeout(() => {
+        pendingOutgoingAcks.delete(id);
+        sendCancel(id, "timed out waiting for receiver confirmation").catch(() => { });
+        reject(new Error("Timed out waiting for receiver confirmation"));
+    }, 120000);
+}
+function refreshOutgoingAckTimeout(id) {
+    const pending = pendingOutgoingAcks.get(id);
+    if (!pending)
+        return;
+    if (pending.timer !== null) {
+        clearTimeout(pending.timer);
+    }
+    pending.timer = scheduleOutgoingAckTimeout(id, pending.reject);
+}
+function startAckHeartbeat(id, file) {
+    stopAckHeartbeat(file);
+    file.ackTimer = setInterval(() => {
+        const active = incoming.get(id);
+        if (!active || active.completed)
+            return;
+        void sendWindowAck(id, active, findMissingAhead(active).length > 0);
+    }, ACK_HEARTBEAT_MS);
+}
+function stopAckHeartbeat(file) {
+    if (file.ackTimer !== null) {
+        clearInterval(file.ackTimer);
+        file.ackTimer = null;
+    }
+}
+function clearIncomingTransfer(id) {
+    const file = incoming.get(id);
+    if (!file)
+        return;
+    stopAckHeartbeat(file);
+    incoming.delete(id);
+}
+function clearIncomingTransfers() {
+    for (const file of incoming.values()) {
+        stopAckHeartbeat(file);
+    }
+    incoming.clear();
+}
+function startProbeTimer(transfer) {
+    stopProbeTimer(transfer);
+    transfer.probeTimer = setInterval(() => {
+        if (transfer.closed || transfer.ackedThrough >= transfer.totalChunks - 1)
+            return;
+        if (Date.now() - transfer.lastAckAt < WINDOW_STALL_PROBE_MS)
+            return;
+        const retryCount = retryRangeForStallCount(transfer.stalledAckCount + 1);
+        queueRetryRange(transfer, transfer.ackedThrough + 1, retryCount);
+        logTransfer("warn", transfer.offer.id, "probe timer fired; retrying frontier", {
+            ackedThrough: transfer.ackedThrough,
+            retryStart: transfer.ackedThrough + 1,
+            retryCount,
+            highestSent: transfer.nextSeqToSend - 1,
+            stalledAckCount: transfer.stalledAckCount,
+            lastProgressMs: Date.now() - transfer.lastProgressAt,
+        });
+        void pumpOutgoingTransfer(transfer);
+        void sendJson({ type: "file-window-probe", id: transfer.offer.id });
+    }, WINDOW_STALL_PROBE_MS);
+}
+function stopProbeTimer(transfer) {
+    if (transfer.probeTimer !== null) {
+        clearInterval(transfer.probeTimer);
+        transfer.probeTimer = null;
+    }
+}
+function queueRetryRange(transfer, startSeq, count) {
+    if (startSeq < 0 || startSeq >= transfer.nextSeqToSend)
+        return;
+    const endSeq = Math.min(transfer.nextSeqToSend, startSeq + Math.max(count, 1));
+    const seqs = [];
+    for (let seq = startSeq; seq < endSeq; seq++) {
+        seqs.push(seq);
+    }
+    transfer.recoveryLevel = Math.max(transfer.recoveryLevel, retryLevelForCount(Math.max(count, 1)));
+    queueResends(transfer, seqs);
+}
+function retryRangeForStallCount(stalledAckCount) {
+    if (stalledAckCount >= 6)
+        return STALL_RETRY_ESCALATION[2];
+    if (stalledAckCount >= 4)
+        return STALL_RETRY_ESCALATION[1];
+    return STALL_RETRY_ESCALATION[0];
+}
+function retryLevelForCount(count) {
+    if (count >= STALL_RETRY_ESCALATION[2])
+        return 3;
+    if (count >= STALL_RETRY_ESCALATION[1])
+        return 2;
+    if (count >= STALL_RETRY_ESCALATION[0])
+        return 1;
+    return 0;
+}
+function logOutgoingSummary(transfer, outcome, reason) {
+    logTransfer(outcome === "completed" ? "info" : "warn", transfer.offer.id, `outgoing transfer ${outcome}`, {
+        size: transfer.offer.size,
+        totalChunks: transfer.totalChunks,
+        ackedThrough: transfer.ackedThrough,
+        highestSent: transfer.nextSeqToSend - 1,
+        highestRetriedSeq: transfer.highestRetriedSeq,
+        recoveryLevel: transfer.recoveryLevel,
+        stalledAckCount: transfer.stalledAckCount,
+        protocolVersion: transfer.protocolVersion,
+        capabilities: transfer.capabilities,
+        reason,
+    });
+}
+//# sourceMappingURL=file-transfer.js.map