@shhhum/xftp-web 0.4.0 → 0.6.0

package/README.md

@@ -2,116 +2,13 @@
 
 Browser-compatible XFTP file transfer client in TypeScript.
 
-## Installation
-
-```bash
-npm install xftp-web
-```
-
-## Usage
-
-```typescript
-import {
-  XFTPAgent,
-  parseXFTPServer,
-  sendFile, receiveFile, deleteFile,
-  XFTPRetriableError, XFTPPermanentError, isRetriable,
-} from "xftp-web"
-
-// Create agent (manages connections)
-const agent = new XFTPAgent()
-
-const servers = [
-  parseXFTPServer("xftp://server1..."),
-  parseXFTPServer("xftp://server2..."),
-  parseXFTPServer("xftp://server3..."),
-]
-
-// Upload (from Uint8Array)
-const {rcvDescriptions, sndDescription, uri} = await sendFile(
-  agent, servers, fileBytes, "photo.jpg",
-  {onProgress: (uploaded, total) => console.log(`${uploaded}/${total}`)}
-)
-
-// Upload (streaming — constant memory, no full-file buffer)
-const file = inputEl.files[0]
-const result = await sendFile(
-  agent, servers, file.stream(), file.size, file.name,
-  {onProgress: (uploaded, total) => console.log(`${uploaded}/${total}`)}
-)
-
-// Download
-const {header, content} = await receiveFile(agent, uri, {
-  onProgress: (downloaded, total) => console.log(`${downloaded}/${total}`)
-})
-
-// Delete (requires sender description from upload)
-await deleteFile(agent, sndDescription)
-
-// Cleanup
-agent.close()
-```
-
-### Advanced usage
-
-For streaming encryption (avoids buffering the full encrypted file) or worker-based uploads:
-
-```typescript
-import {
-  encryptFileForUpload, uploadFile, downloadFile,
-  decodeDescriptionURI,
-} from "xftp-web"
-
-// Streaming encryption — encrypted slices emitted via callback
-const metadata = await encryptFileForUpload(fileBytes, "photo.jpg", {
-  onSlice: (data) => { /* write to OPFS, IndexedDB, etc. */ },
-  onProgress: (done, total) => {},
-})
-// metadata has {digest, key, nonce, chunkSizes} but no encData
-
-// Upload with custom chunk reader (e.g. reading from OPFS)
-const result = await uploadFile(agent, servers, metadata, {
-  readChunk: (offset, size) => readFromStorage(offset, size),
-})
-
-// Download with FileDescription object
-const fd = decodeDescriptionURI(uri)
-const {header, content} = await downloadFile(agent, fd)
-```
-
-### Upload options
-
-```typescript
-await sendFile(agent, servers, fileBytes, "photo.jpg", {
-  onProgress: (uploaded, total) => {},  // progress callback
-  auth: basicAuthBytes,                 // BasicAuth for auth-required servers
-  numRecipients: 3,                     // multiple independent download credentials (default: 1)
-})
-```
-
-### Error handling
-
-```typescript
-try {
-  await sendFile(agent, servers, fileBytes, "photo.jpg")
-} catch (e) {
-  if (e instanceof XFTPRetriableError) {
-    // Network/timeout/session errors — safe to retry
-  } else if (e instanceof XFTPPermanentError) {
-    // AUTH, NO_FILE, BLOCKED, etc. — do not retry
-  }
-  // or use: isRetriable(e)
-}
-```
-
-## Development
-
-### Prerequisites
+## Prerequisites
 
 - Haskell toolchain with `cabal` (to build `xftp-server`)
 - Node.js 20+
+- Chromium system dependencies (see below)
 
-### Setup
+## Setup
 
 ```bash
 # Build the XFTP server binary (from repo root)
@@ -120,31 +17,31 @@ cabal build xftp-server
 # Install JS dependencies
 cd xftp-web
 npm install
+
+# Install Chromium for Playwright (browser tests)
+npx playwright install chromium
 ```
 
-### Running tests
+If Chromium fails to launch due to missing system libraries, install them with:
 
 ```bash
-npm run test
+# Requires root
+npx playwright install-deps chromium
 ```
 
-The `pretest` script automatically installs Chromium and sets up the libsodium symlink. The browser test starts an `xftp-server` instance on port 7000 via `globalSetup`.
-
-If Chromium fails to launch due to missing system libraries:
+## Running tests
 
 ```bash
-# Requires root
-npx playwright install-deps chromium
+# Browser round-trip test (vitest + Playwright headless Chromium)
+npm run test
 ```
 
-### Build
+The browser test automatically starts an `xftp-server` instance on port 7000 via `globalSetup`, using certs from `tests/fixtures/`.
+
+## Build
 
 ```bash
 npm run build
 ```
 
 Output goes to `dist/`.
-
-## License
-
-[AGPL-3.0-only](https://www.gnu.org/licenses/agpl-3.0.html)

package/dist/agent.d.ts

@@ -1,7 +1,6 @@
-export { prepareEncryption, type EncryptionParams } from "./crypto/file.js";
 import { type FileDescription } from "./protocol/description.js";
-import { XFTPAgent } from "./client.js";
-export { XFTPAgent, type TransportConfig, XFTPRetriableError, XFTPPermanentError, isRetriable, categorizeError, humanReadableMessage } from "./client.js";
+import { type XFTPClientAgent } from "./client.js";
+export { newXFTPAgent, closeXFTPAgent, type XFTPClientAgent, type TransportConfig } from "./client.js";
 import type { XFTPServer } from "./protocol/address.js";
 import type { FileHeader } from "./crypto/file.js";
 export interface EncryptedFileMetadata {
@@ -14,7 +13,7 @@ export interface EncryptedFileInfo extends EncryptedFileMetadata {
     encData: Uint8Array;
 }
 export interface UploadResult {
-    rcvDescriptions: FileDescription[];
+    rcvDescription: FileDescription;
     sndDescription: FileDescription;
     uri: string;
 }
@@ -24,29 +23,13 @@ export interface DownloadResult {
 }
 export declare function encodeDescriptionURI(fd: FileDescription): string;
 export declare function decodeDescriptionURI(fragment: string): FileDescription;
-export interface EncryptForUploadOptions {
-    onProgress?: (done: number, total: number) => void;
-    onSlice?: (data: Uint8Array) => void | Promise<void>;
-}
-export declare function encryptFileForUpload(source: Uint8Array, fileName: string, options: EncryptForUploadOptions & {
-    onSlice: NonNullable<EncryptForUploadOptions['onSlice']>;
-}): Promise<EncryptedFileMetadata>;
-export declare function encryptFileForUpload(source: Uint8Array, fileName: string, options?: EncryptForUploadOptions): Promise<EncryptedFileInfo>;
+export declare function encryptFileForUpload(source: Uint8Array, fileName: string): EncryptedFileInfo;
 export interface UploadOptions {
     onProgress?: (uploaded: number, total: number) => void;
     redirectThreshold?: number;
     readChunk?: (offset: number, size: number) => Promise<Uint8Array>;
-    auth?: Uint8Array;
-    numRecipients?: number;
-}
-export declare function uploadFile(agent: XFTPAgent, servers: XFTPServer[], encrypted: EncryptedFileMetadata, options?: UploadOptions): Promise<UploadResult>;
-export interface SendFileOptions {
-    onProgress?: (uploaded: number, total: number) => void;
-    auth?: Uint8Array;
-    numRecipients?: number;
 }
-export declare function sendFile(agent: XFTPAgent, servers: XFTPServer[], source: Uint8Array, fileName: string, options?: SendFileOptions): Promise<UploadResult>;
-export declare function sendFile(agent: XFTPAgent, servers: XFTPServer[], source: AsyncIterable<Uint8Array>, sourceSize: number, fileName: string, options?: SendFileOptions): Promise<UploadResult>;
+export declare function uploadFile(agent: XFTPClientAgent, servers: XFTPServer[], encrypted: EncryptedFileMetadata, options?: UploadOptions): Promise<UploadResult>;
 export interface RawDownloadedChunk {
     chunkNo: number;
     dhSecret: Uint8Array;
@@ -56,11 +39,8 @@ export interface RawDownloadedChunk {
 }
 export interface DownloadRawOptions {
     onProgress?: (downloaded: number, total: number) => void;
+    concurrency?: number;
 }
-export declare function downloadFileRaw(agent: XFTPAgent, fd: FileDescription, onRawChunk: (chunk: RawDownloadedChunk) => Promise<void>, options?: DownloadRawOptions): Promise<FileDescription>;
-export declare function downloadFile(agent: XFTPAgent, fd: FileDescription, onProgress?: (downloaded: number, total: number) => void): Promise<DownloadResult>;
-export declare function receiveFile(agent: XFTPAgent, uri: string, options?: {
-    onProgress?: (downloaded: number, total: number) => void;
-}): Promise<DownloadResult>;
-export declare function deleteFile(agent: XFTPAgent, sndDescription: FileDescription): Promise<void>;
-//# sourceMappingURL=agent.d.ts.map
+export declare function downloadFileRaw(agent: XFTPClientAgent, fd: FileDescription, onRawChunk: (chunk: RawDownloadedChunk) => Promise<void>, options?: DownloadRawOptions): Promise<FileDescription>;
+export declare function downloadFile(agent: XFTPClientAgent, fd: FileDescription, onProgress?: (downloaded: number, total: number) => void): Promise<DownloadResult>;
+export declare function deleteFile(agent: XFTPClientAgent, sndDescription: FileDescription): Promise<void>;

package/dist/agent.js

@@ -3,16 +3,13 @@
 // Combines all building blocks: encryption, chunking, XFTP client commands,
 // file descriptions, and DEFLATE-compressed URI encoding.
 import pako from "pako";
-import { encryptFileAsync, prepareEncryption } from "./crypto/file.js";
-import { sbInit, sbEncryptChunk, sbAuth } from "./crypto/secretbox.js";
-import { concatBytes, encodeInt64 } from "./protocol/encoding.js";
-export { prepareEncryption } from "./crypto/file.js";
+import { encryptFile, encodeFileHeader } from "./crypto/file.js";
 import { generateEd25519KeyPair, encodePubKeyEd25519, encodePrivKeyEd25519, decodePrivKeyEd25519, ed25519KeyPairFromSeed } from "./crypto/keys.js";
-import { sha512Streaming, sha512Init, sha512Update, sha512Final } from "./crypto/digest.js";
-import { prepareChunkSpecs, getChunkDigest } from "./protocol/chunks.js";
+import { sha512Streaming } from "./crypto/digest.js";
+import { prepareChunkSizes, prepareChunkSpecs, getChunkDigest, fileSizeLen, authTagSize } from "./protocol/chunks.js";
 import { encodeFileDescription, decodeFileDescription, validateFileDescription, base64urlEncode, base64urlDecode } from "./protocol/description.js";
-import { createXFTPChunk, addXFTPRecipients, uploadXFTPChunk, downloadXFTPChunk, downloadXFTPChunkRaw, deleteXFTPChunk, ackXFTPChunk } from "./client.js";
-export { XFTPAgent, XFTPRetriableError, XFTPPermanentError, isRetriable, categorizeError, humanReadableMessage } from "./client.js";
+import { createXFTPChunk, uploadXFTPChunk, downloadXFTPChunk, downloadXFTPChunkRaw, deleteXFTPChunk } from "./client.js";
+export { newXFTPAgent, closeXFTPAgent } from "./client.js";
 import { processDownloadedFile, decryptReceivedChunk } from "./download.js";
 import { formatXFTPServer, parseXFTPServer } from "./protocol/address.js";
 // -- URI encoding/decoding (RFC section 4.1: DEFLATE + base64url)
@@ -30,61 +27,27 @@ export function decodeDescriptionURI(fragment) {
         throw new Error("decodeDescriptionURI: " + err);
     return fd;
 }
-export async function encryptFileForUpload(source, fileName, options) {
-    const { onProgress, onSlice } = options ?? {};
-    const { fileHdr, key, nonce, fileSize, encSize, chunkSizes } = prepareEncryption(source.length, fileName);
-    if (onSlice) {
-        const hashState = sha512Init();
-        await encryptFileAsync(source, fileHdr, key, nonce, fileSize, encSize, onProgress, (data) => {
-            sha512Update(hashState, data);
-            return onSlice(data);
-        });
-        const digest = sha512Final(hashState);
-        return { digest, key, nonce, chunkSizes };
-    }
-    else {
-        const encData = await encryptFileAsync(source, fileHdr, key, nonce, fileSize, encSize, onProgress);
-        const digest = sha512Streaming([encData]);
-        console.log(`[AGENT-DBG] encrypt: encData.len=${encData.length} digest=${_dbgHex(digest, 64)} chunkSizes=[${chunkSizes.join(',')}]`);
-        return { encData, digest, key, nonce, chunkSizes };
-    }
+// -- Upload
+export function encryptFileForUpload(source, fileName) {
+    const key = new Uint8Array(32);
+    const nonce = new Uint8Array(24);
+    crypto.getRandomValues(key);
+    crypto.getRandomValues(nonce);
+    const fileHdr = encodeFileHeader({ fileName, fileExtra: null });
+    const fileSize = BigInt(fileHdr.length + source.length);
+    const payloadSize = Number(fileSize) + fileSizeLen + authTagSize;
+    const chunkSizes = prepareChunkSizes(payloadSize);
+    const encSize = BigInt(chunkSizes.reduce((a, b) => a + b, 0));
+    const encData = encryptFile(source, fileHdr, key, nonce, fileSize, encSize);
+    const digest = sha512Streaming([encData]);
+    console.log(`[AGENT-DBG] encrypt: encData.len=${encData.length} digest=${_dbgHex(digest, 64)} chunkSizes=[${chunkSizes.join(',')}]`);
+    return { encData, digest, key, nonce, chunkSizes };
 }
 const DEFAULT_REDIRECT_THRESHOLD = 400;
-const MAX_RECIPIENTS_PER_REQUEST = 200; // each key is ~46 bytes; 200 keys fit within 16KB XFTP block
-async function uploadSingleChunk(agent, server, chunkNo, chunkData, chunkSize, numRecipients, auth) {
-    const sndKp = generateEd25519KeyPair();
-    const rcvKps = Array.from({ length: numRecipients }, () => generateEd25519KeyPair());
-    const chunkDigest = getChunkDigest(chunkData);
-    const fileInfo = {
-        sndKey: encodePubKeyEd25519(sndKp.publicKey),
-        size: chunkSize,
-        digest: chunkDigest
-    };
-    const firstBatch = Math.min(numRecipients, MAX_RECIPIENTS_PER_REQUEST);
-    const firstBatchKeys = rcvKps.slice(0, firstBatch).map(kp => encodePubKeyEd25519(kp.publicKey));
-    const { senderId, recipientIds: firstIds } = await createXFTPChunk(agent, server, sndKp.privateKey, fileInfo, firstBatchKeys, auth);
-    const allRecipientIds = [...firstIds];
-    let added = firstBatch;
-    while (added < numRecipients) {
-        const batchSize = Math.min(numRecipients - added, MAX_RECIPIENTS_PER_REQUEST);
-        const batchKeys = rcvKps.slice(added, added + batchSize).map(kp => encodePubKeyEd25519(kp.publicKey));
-        const moreIds = await addXFTPRecipients(agent, server, sndKp.privateKey, senderId, batchKeys);
-        allRecipientIds.push(...moreIds);
-        added += batchSize;
-    }
-    await uploadXFTPChunk(agent, server, sndKp.privateKey, senderId, chunkData);
-    return {
-        chunkNo, senderId, senderKey: sndKp.privateKey,
-        recipients: allRecipientIds.map((rid, ri) => ({
-            recipientId: rid, recipientKey: rcvKps[ri].privateKey
-        })),
-        chunkSize, digest: chunkDigest, server
-    };
-}
 export async function uploadFile(agent, servers, encrypted, options) {
     if (servers.length === 0)
         throw new Error("uploadFile: servers list is empty");
-    const { onProgress, redirectThreshold, readChunk: readChunkOpt, auth, numRecipients = 1 } = options ?? {};
+    const { onProgress, redirectThreshold, readChunk: readChunkOpt } = options ?? {};
     const readChunk = readChunkOpt
         ? readChunkOpt
         : ('encData' in encrypted
@@ -92,7 +55,7 @@ export async function uploadFile(agent, servers, encrypted, options) {
             : () => { throw new Error("uploadFile: readChunk required when encData is absent"); });
     const total = encrypted.chunkSizes.reduce((a, b) => a + b, 0);
     const specs = prepareChunkSpecs(encrypted.chunkSizes);
-    // Pre-assign servers and group by server (matching Haskell groupAllOn)
+    // Pre-assign servers and group by server for parallel upload
     const chunkJobs = specs.map((spec, i) => ({
         index: i,
         spec,
@@ -111,104 +74,39 @@ export async function uploadFile(agent, servers, encrypted, options) {
     await Promise.all([...byServer.values()].map(async (jobs) => {
         for (const { index, spec, server } of jobs) {
             const chunkNo = index + 1;
+            const sndKp = generateEd25519KeyPair();
+            const rcvKp = generateEd25519KeyPair();
             const chunkData = await readChunk(spec.chunkOffset, spec.chunkSize);
-            sentChunks[index] = await uploadSingleChunk(agent, server, chunkNo, chunkData, spec.chunkSize, numRecipients, auth ?? null);
+            const chunkDigest = getChunkDigest(chunkData);
+            const fileInfo = {
+                sndKey: encodePubKeyEd25519(sndKp.publicKey),
+                size: spec.chunkSize,
+                digest: chunkDigest
+            };
+            const rcvKeysForChunk = [encodePubKeyEd25519(rcvKp.publicKey)];
+            const { senderId, recipientIds } = await createXFTPChunk(agent, server, sndKp.privateKey, fileInfo, rcvKeysForChunk);
+            await uploadXFTPChunk(agent, server, sndKp.privateKey, senderId, chunkData);
+            sentChunks[index] = {
+                chunkNo, senderId, senderKey: sndKp.privateKey,
+                recipientId: recipientIds[0], recipientKey: rcvKp.privateKey,
+                chunkSize: spec.chunkSize, digest: chunkDigest, server
+            };
             uploaded += spec.chunkSize;
             onProgress?.(uploaded, total);
         }
     }));
-    const rcvDescriptions = Array.from({ length: numRecipients }, (_, ri) => buildDescription("recipient", ri, encrypted, sentChunks));
-    const sndDescription = buildDescription("sender", 0, encrypted, sentChunks);
-    let uri = encodeDescriptionURI(rcvDescriptions[0]);
-    let finalRcvDescriptions = rcvDescriptions;
+    const rcvDescription = buildDescription("recipient", encrypted, sentChunks);
+    const sndDescription = buildDescription("sender", encrypted, sentChunks);
+    let uri = encodeDescriptionURI(rcvDescription);
+    let finalRcvDescription = rcvDescription;
     const threshold = redirectThreshold ?? DEFAULT_REDIRECT_THRESHOLD;
     if (uri.length > threshold && sentChunks.length > 1) {
-        const redirected = await uploadRedirectDescription(agent, servers, rcvDescriptions[0], auth);
-        finalRcvDescriptions = [redirected, ...rcvDescriptions.slice(1)];
-        uri = encodeDescriptionURI(redirected);
-    }
-    return { rcvDescriptions: finalRcvDescriptions, sndDescription, uri };
-}
-export async function sendFile(agent, servers, source, fileNameOrSize, fileNameOrOptions, maybeOptions) {
-    let sourceSize, fileName, options;
-    if (source instanceof Uint8Array) {
-        sourceSize = source.length;
-        fileName = fileNameOrSize;
-        options = fileNameOrOptions;
-    }
-    else {
-        sourceSize = fileNameOrSize;
-        fileName = fileNameOrOptions;
-        options = maybeOptions;
-    }
-    if (servers.length === 0)
-        throw new Error("sendFile: servers list is empty");
-    const { onProgress, auth, numRecipients = 1 } = options ?? {};
-    const params = prepareEncryption(sourceSize, fileName);
-    const specs = prepareChunkSpecs(params.chunkSizes);
-    const total = params.chunkSizes.reduce((a, b) => a + b, 0);
-    const encState = sbInit(params.key, params.nonce);
-    const hashState = sha512Init();
-    const sentChunks = new Array(specs.length);
-    let specIdx = 0, chunkOff = 0, uploaded = 0;
-    let chunkBuf = new Uint8Array(specs[0].chunkSize);
-    async function flushChunk() {
-        const server = servers[Math.floor(Math.random() * servers.length)];
-        sentChunks[specIdx] = await uploadSingleChunk(agent, server, specIdx + 1, chunkBuf, specs[specIdx].chunkSize, numRecipients, auth ?? null);
-        uploaded += specs[specIdx].chunkSize;
-        onProgress?.(uploaded, total);
-        specIdx++;
-        if (specIdx < specs.length) {
-            chunkBuf = new Uint8Array(specs[specIdx].chunkSize);
-            chunkOff = 0;
-        }
-    }
-    async function feedEncrypted(data) {
-        sha512Update(hashState, data);
-        let off = 0;
-        while (off < data.length) {
-            const space = specs[specIdx].chunkSize - chunkOff;
-            const n = Math.min(space, data.length - off);
-            chunkBuf.set(data.subarray(off, off + n), chunkOff);
-            chunkOff += n;
-            off += n;
-            if (chunkOff === specs[specIdx].chunkSize)
-                await flushChunk();
-        }
-    }
-    await feedEncrypted(sbEncryptChunk(encState, concatBytes(encodeInt64(params.fileSize), params.fileHdr)));
-    const SLICE = 65536;
-    if (source instanceof Uint8Array) {
-        for (let off = 0; off < source.length; off += SLICE) {
-            await feedEncrypted(sbEncryptChunk(encState, source.subarray(off, Math.min(off + SLICE, source.length))));
-        }
-    }
-    else {
-        for await (const chunk of source) {
-            for (let off = 0; off < chunk.length; off += SLICE) {
-                await feedEncrypted(sbEncryptChunk(encState, chunk.subarray(off, Math.min(off + SLICE, chunk.length))));
-            }
-        }
+        finalRcvDescription = await uploadRedirectDescription(agent, servers, rcvDescription);
+        uri = encodeDescriptionURI(finalRcvDescription);
     }
-    const padLen = Number(params.encSize - 16n - params.fileSize - 8n);
-    const padding = new Uint8Array(padLen);
-    padding.fill(0x23);
-    await feedEncrypted(sbEncryptChunk(encState, padding));
-    await feedEncrypted(sbAuth(encState));
-    const digest = sha512Final(hashState);
-    const encrypted = { digest, key: params.key, nonce: params.nonce, chunkSizes: params.chunkSizes };
-    const rcvDescriptions = Array.from({ length: numRecipients }, (_, ri) => buildDescription("recipient", ri, encrypted, sentChunks));
-    const sndDescription = buildDescription("sender", 0, encrypted, sentChunks);
-    let uri = encodeDescriptionURI(rcvDescriptions[0]);
-    let finalRcvDescriptions = rcvDescriptions;
-    if (uri.length > DEFAULT_REDIRECT_THRESHOLD && sentChunks.length > 1) {
-        const redirected = await uploadRedirectDescription(agent, servers, rcvDescriptions[0], auth);
-        finalRcvDescriptions = [redirected, ...rcvDescriptions.slice(1)];
-        uri = encodeDescriptionURI(redirected);
-    }
-    return { rcvDescriptions: finalRcvDescriptions, sndDescription, uri };
+    return { rcvDescription: finalRcvDescription, sndDescription, uri };
 }
-function buildDescription(party, recipientIndex, enc, chunks) {
+function buildDescription(party, enc, chunks) {
     const defChunkSize = enc.chunkSizes[0];
     return {
         party,
@@ -223,38 +121,41 @@ function buildDescription(party, recipientIndex, enc, chunks) {
             digest: c.digest,
             replicas: [{
                     server: formatXFTPServer(c.server),
-                    replicaId: party === "recipient" ? c.recipients[recipientIndex].recipientId : c.senderId,
-                    replicaKey: encodePrivKeyEd25519(party === "recipient" ? c.recipients[recipientIndex].recipientKey : c.senderKey)
+                    replicaId: party === "recipient" ? c.recipientId : c.senderId,
+                    replicaKey: encodePrivKeyEd25519(party === "recipient" ? c.recipientKey : c.senderKey)
                 }]
         })),
         redirect: null
     };
 }
-async function uploadRedirectDescription(agent, servers, innerFd, auth) {
+async function uploadRedirectDescription(agent, servers, innerFd) {
     const yaml = encodeFileDescription(innerFd);
     const yamlBytes = new TextEncoder().encode(yaml);
-    const enc = await encryptFileForUpload(yamlBytes, "");
+    const enc = encryptFileForUpload(yamlBytes, "");
     const specs = prepareChunkSpecs(enc.chunkSizes);
-    const chunkJobs = specs.map((spec, i) => ({
-        index: i,
-        spec,
-        server: servers[Math.floor(Math.random() * servers.length)]
-    }));
-    const byServer = new Map();
-    for (const job of chunkJobs) {
-        const key = formatXFTPServer(job.server);
-        if (!byServer.has(key))
-            byServer.set(key, []);
-        byServer.get(key).push(job);
+    const sentChunks = [];
+    for (let i = 0; i < specs.length; i++) {
+        const spec = specs[i];
+        const chunkNo = i + 1;
+        const server = servers[Math.floor(Math.random() * servers.length)];
+        const sndKp = generateEd25519KeyPair();
+        const rcvKp = generateEd25519KeyPair();
+        const chunkData = enc.encData.subarray(spec.chunkOffset, spec.chunkOffset + spec.chunkSize);
+        const chunkDigest = getChunkDigest(chunkData);
+        const fileInfo = {
+            sndKey: encodePubKeyEd25519(sndKp.publicKey),
+            size: spec.chunkSize,
+            digest: chunkDigest
+        };
+        const rcvKeysForChunk = [encodePubKeyEd25519(rcvKp.publicKey)];
+        const { senderId, recipientIds } = await createXFTPChunk(agent, server, sndKp.privateKey, fileInfo, rcvKeysForChunk);
+        await uploadXFTPChunk(agent, server, sndKp.privateKey, senderId, chunkData);
+        sentChunks.push({
+            chunkNo, senderId, senderKey: sndKp.privateKey,
+            recipientId: recipientIds[0], recipientKey: rcvKp.privateKey,
+            chunkSize: spec.chunkSize, digest: chunkDigest, server
+        });
     }
-    const sentChunks = new Array(specs.length);
-    await Promise.all([...byServer.values()].map(async (jobs) => {
-        for (const { index, spec, server } of jobs) {
-            const chunkNo = index + 1;
-            const chunkData = enc.encData.subarray(spec.chunkOffset, spec.chunkOffset + spec.chunkSize);
-            sentChunks[index] = await uploadSingleChunk(agent, server, chunkNo, chunkData, spec.chunkSize, 1, auth ?? null);
-        }
-    }));
     return {
         party: "recipient",
         size: enc.chunkSizes.reduce((a, b) => a + b, 0),
@@ -268,8 +169,8 @@ async function uploadRedirectDescription(agent, servers, innerFd, auth) {
             digest: c.digest,
             replicas: [{
                     server: formatXFTPServer(c.server),
-                    replicaId: c.recipients[0].recipientId,
-                    replicaKey: encodePrivKeyEd25519(c.recipients[0].recipientKey)
+                    replicaId: c.recipientId,
+                    replicaKey: encodePrivKeyEd25519(c.recipientKey)
                 }]
         })),
         redirect: { size: innerFd.size, digest: innerFd.digest }
@@ -279,7 +180,7 @@ export async function downloadFileRaw(agent, fd, onRawChunk, options) {
     const err = validateFileDescription(fd);
     if (err)
         throw new Error("downloadFileRaw: " + err);
-    const { onProgress } = options ?? {};
+    const { onProgress, concurrency = 1 } = options ?? {};
     // Resolve redirect on main thread (redirect data is small)
     if (fd.redirect !== null) {
         console.log(`[AGENT-DBG] resolving redirect: outer size=${fd.size} chunks=${fd.chunks.length}`);
@@ -313,7 +214,6 @@ export async function downloadFileRaw(agent, fd, onRawChunk, options) {
                 body: raw.body,
                 digest: chunk.digest
             });
-            await ackXFTPChunk(agent, server, kp.privateKey, replica.replicaId);
             downloaded += chunk.chunkSize;
             onProgress?.(downloaded, resolvedFd.size);
         }
@@ -333,32 +233,18 @@ export async function downloadFile(agent, fd, onProgress) {
         throw new Error("downloadFile: file digest mismatch");
     return processDownloadedFile(resolvedFd, chunks);
 }
-export async function receiveFile(agent, uri, options) {
-    const fd = decodeDescriptionURI(uri);
-    return downloadFile(agent, fd, options?.onProgress);
-}
 async function resolveRedirect(agent, fd) {
     const plaintextChunks = new Array(fd.chunks.length);
-    const byServer = new Map();
     for (const chunk of fd.chunks) {
-        const srv = chunk.replicas[0]?.server ?? "";
-        if (!byServer.has(srv))
-            byServer.set(srv, []);
-        byServer.get(srv).push(chunk);
+        const replica = chunk.replicas[0];
+        if (!replica)
+            throw new Error("resolveRedirect: chunk has no replicas");
+        const server = parseXFTPServer(replica.server);
+        const seed = decodePrivKeyEd25519(replica.replicaKey);
+        const kp = ed25519KeyPairFromSeed(seed);
+        const data = await downloadXFTPChunk(agent, server, kp.privateKey, replica.replicaId, chunk.digest);
+        plaintextChunks[chunk.chunkNo - 1] = data;
     }
-    await Promise.all([...byServer.entries()].map(async ([srv, chunks]) => {
-        const server = parseXFTPServer(srv);
-        for (const chunk of chunks) {
-            const replica = chunk.replicas[0];
-            if (!replica)
-                throw new Error("resolveRedirect: chunk has no replicas");
-            const seed = decodePrivKeyEd25519(replica.replicaKey);
-            const kp = ed25519KeyPairFromSeed(seed);
-            const data = await downloadXFTPChunk(agent, server, kp.privateKey, replica.replicaId, chunk.digest);
-            plaintextChunks[chunk.chunkNo - 1] = data;
-            await ackXFTPChunk(agent, server, kp.privateKey, replica.replicaId);
-        }
-    }));
     const totalSize = plaintextChunks.reduce((s, c) => s + c.length, 0);
     if (totalSize !== fd.size)
         throw new Error("resolveRedirect: redirect file size mismatch");
@@ -379,24 +265,15 @@ async function resolveRedirect(agent, fd) {
 }
 // -- Delete
 export async function deleteFile(agent, sndDescription) {
-    const byServer = new Map();
     for (const chunk of sndDescription.chunks) {
-        const srv = chunk.replicas[0]?.server ?? "";
-        if (!byServer.has(srv))
-            byServer.set(srv, []);
-        byServer.get(srv).push(chunk);
+        const replica = chunk.replicas[0];
+        if (!replica)
+            throw new Error("deleteFile: chunk has no replicas");
+        const server = parseXFTPServer(replica.server);
+        const seed = decodePrivKeyEd25519(replica.replicaKey);
+        const kp = ed25519KeyPairFromSeed(seed);
+        await deleteXFTPChunk(agent, server, kp.privateKey, replica.replicaId);
     }
-    await Promise.all([...byServer.entries()].map(async ([srv, chunks]) => {
-        const server = parseXFTPServer(srv);
-        for (const chunk of chunks) {
-            const replica = chunk.replicas[0];
-            if (!replica)
-                throw new Error("deleteFile: chunk has no replicas");
-            const seed = decodePrivKeyEd25519(replica.replicaKey);
-            const kp = ed25519KeyPairFromSeed(seed);
-            await deleteXFTPChunk(agent, server, kp.privateKey, replica.replicaId);
-        }
-    }));
 }
 // -- Internal
 function _dbgHex(b, n = 8) {