@muhkoo/connect 0.15.0-alpha.5 → 0.15.0-alpha.6

package/dist/browser/index.js

@@ -6456,6 +6456,15 @@ async function safeText(response) {
  * manifest and reassembles the plaintext; {@link FileStorage.readFile} first
  * fetches the manifest from the space.
  */
+/**
+ * How many chunks past the one being read a multi-chunk read fetches ahead
+ * (see `chunksInOrder`). Two: enough to keep requests overlapping on a link
+ * where each one waits on its round trip. While the caller holds chunk k,
+ * up to `READ_AHEAD_CHUNKS + 1` more chunks can be in flight (the next
+ * starts as k is handed over), so at the default 4 MB chunk about 16 MB of
+ * reads in flight per file, on top of the chunk held.
+ */
+const READ_AHEAD_CHUNKS = 2;
 class FileStorage {
     space;
     shards;
@@ -6561,11 +6570,10 @@ class FileStorage {
         await this.codec.ready(this.rsWasmModule);
         // Materialize each chunk into plaintext, then concatenate. We don't
         // stream across chunks here because the consuming surface returns
-        // `Uint8Array`; a streaming variant would reuse `readChunk` unchanged.
+        // `Uint8Array`; `readChunksFromShards` is the streaming variant.
         const plaintextChunks = [];
-        for (const chunkManifest of [...manifest.chunks].sort((a, b) => a.chunkIndex - b.chunkIndex)) {
-            plaintextChunks.push(await this.readChunk(chunkManifest));
-        }
+        for await (const chunk of this.chunksInOrder(manifest))
+            plaintextChunks.push(chunk);
         let total = 0;
         for (const c of plaintextChunks)
             total += c.length;
@@ -6586,8 +6594,48 @@ class FileStorage {
      */
     async *readChunksFromShards(manifest) {
         await this.codec.ready(this.rsWasmModule);
-        for (const chunkManifest of [...manifest.chunks].sort((a, b) => a.chunkIndex - b.chunkIndex)) {
-            yield await this.readChunk(chunkManifest);
+        yield* this.chunksInOrder(manifest);
+    }
+    /**
+     * Each chunk's plaintext, in order, with the next {@link READ_AHEAD_CHUNKS}
+     * already being fetched.
+     *
+     * One chunk at a time, a large file cost a full round trip per 4 MB chunk
+     * with nothing overlapping it: a 33 MB file was eight serial requests,
+     * each mostly waiting. Within a chunk the shard reads were already
+     * parallel; this overlaps the chunks too.
+     *
+     * Bounded on purpose: while the caller holds a yielded chunk, at most
+     * `1 + READ_AHEAD_CHUNKS` more are in flight, and nothing new starts until
+     * it asks for the next — a slow consumer of the stream is not run away
+     * from. A failure surfaces at its own chunk, in order; reads already
+     * started past it are let finish, their failures swallowed rather than
+     * left unhandled. If the caller stops early (`break` or `return()`), no
+     * further read starts and the ones in flight settle on their own; they are
+     * not awaited, so `return()` is not delayed by a slow shard.
+     */
+    async *chunksInOrder(manifest) {
+        const ordered = [...manifest.chunks].sort((a, b) => a.chunkIndex - b.chunkIndex);
+        const ahead = [];
+        let next = 0;
+        const start = () => {
+            const read = this.readChunk(ordered[next++]);
+            read.catch(() => { }); // reported when its turn comes
+            ahead.push(read);
+        };
+        while (next < ordered.length && ahead.length < 1 + READ_AHEAD_CHUNKS)
+            start();
+        try {
+            while (ahead.length > 0) {
+                const chunk = await ahead.shift();
+                if (next < ordered.length)
+                    start();
+                yield chunk;
+            }
+        }
+        finally {
+            next = ordered.length; // nothing more is started
+            ahead.length = 0; // in-flight reads settle unobserved; each has its own .catch
         }
     }
     // -------------------------------------------------------------------------
@@ -6855,7 +6903,7 @@ async function parseOrThrow(response, op) {
  * expect (and isn't serving a stale cached bundle). Keep this in sync with
  * `package.json` `version`.
  */
-const VERSION = "0.15.0-alpha.5";
+const VERSION = "0.15.0-alpha.6";
 
 /**
  * `HttpClient` — the one place the unified {@link Client} talks to the