libfw-client 0.2.1 → 0.2.3

package/index.js

@@ -371,7 +371,7 @@ export class LibfwClient {
       onWriteChunk: (path, offset, data) => this._onWriteChunk(path, offset, data),
       onFileCompleted: (path) => this._onFileCompleted(path),
       onProgress: (done, total) => this._emit({ type: 'progress', done, total }),
-      loadState: (direction, path) => Idb.loadState(`${direction}:${path}`),
+      loadState: (direction, path) => this._loadResumeState(direction, path),
       saveState: (direction, path, state) => {
         // The in-memory browser-download fallback never commits bytes to
         // disk, so a persisted download offset would be a phantom that
@@ -521,7 +521,7 @@ export class LibfwClient {
         for (const p of order) {
           entries.push({
             name: this._safeEntryName(p),
-            data: this._concatBuffers(buffers.get(p) || []),
+            data: this._concatBuffers(buffers.get(p)?.chunks || []),
           });
         }
         // Include files that were announced but produced no bytes (empty).
@@ -532,7 +532,7 @@ export class LibfwClient {
         }
         this._triggerBrowserDownload(createZip(entries), this._archiveName(path));
       } else {
-        const data = this._concatBuffers(buffers.get(path) || []);
+        const data = this._concatBuffers(buffers.get(path)?.chunks || []);
         this._triggerBrowserDownload(new Blob([data], { type: 'application/octet-stream' }), this._downloadName(path));
       }
       return total;
@@ -663,16 +663,39 @@ export class LibfwClient {
     if (this._fallback) {
       // Browser-download fallback: collect chunks in memory instead of
       // streaming to disk. Chunks arrive in order, so a plain append works.
-      let bufs = this._fallback.buffers.get(path);
-      if (!bufs) {
-        bufs = [];
-        this._fallback.buffers.set(path, bufs);
+      let buf = this._fallback.buffers.get(path);
+      if (!buf) {
+        buf = { chunks: [], len: 0 };
+        this._fallback.buffers.set(path, buf);
         this._fallback.order.push(path);
       }
-      bufs.push(data);
+      // A chunk whose absolute offset is at or before the last one delivered
+      // means the engine restarted this file (an internal retry re-delivers
+      // the same byte range) — drop the partial buffer so the prefix is not
+      // duplicated in the produced blob/zip.
+      if (offset <= buf.len) {
+        buf.chunks = [];
+        buf.len = 0;
+      }
+      buf.chunks.push(data);
+      buf.len += data.length;
       return;
     }
     let entry = this._writables.get(path);
+    if (entry && offset <= entry.lastOffset) {
+      // The engine restarted this file (a network/protocol error triggered
+      // an internal retry that re-delivers the same byte range). Abort the
+      // still-open writable — discarding its uncommitted swap file — and
+      // reopen fresh, otherwise the re-delivered prefix would be appended a
+      // second time and the committed file silently corrupted.
+      this._writables.delete(path);
+      try {
+        await entry.writable.abort();
+      } catch {
+        /* best-effort discard */
+      }
+      entry = undefined;
+    }
     if (!entry) {
       const { dir, name, handle } = await this._ensureFileHandle(path);
       this._fileHandles.set(path, handle);
@@ -687,9 +710,10 @@ export class LibfwClient {
       const writable = await handle.createWritable(
         isResume ? { keepExistingData: true } : undefined
       );
-      entry = { writable, dir, name };
+      entry = { writable, dir, name, lastOffset: offset };
       this._writables.set(path, entry);
     }
+    entry.lastOffset = offset;
     await entry.writable.write(data);
   }
 
@@ -765,6 +789,66 @@ export class LibfwClient {
     }
   }
 
+  /**
+   * Resolve a file handle for a virtual path WITHOUT creating it, so a
+   * missing file returns `null` instead of throwing.
+   * @param {string} path
+   * @returns {Promise<FileSystemFileHandle|null>}
+   * @private
+   */
+  async _resolveFileHandle(path) {
+    if (!this._dirHandle) return null;
+    try {
+      const segments = splitPath(path);
+      if (segments.length === 0) return null;
+      let dir = this._dirHandle;
+      for (let i = 0; i < segments.length - 1; i += 1) {
+        dir = await dir.getDirectoryHandle(segments[i], { create: false });
+      }
+      return await dir.getFileHandle(segments[segments.length - 1], { create: false });
+    } catch {
+      return null; // missing dir or file, or no FS API
+    }
+  }
+
+  /**
+   * Load a persisted resume-state `{etag, offset}`, clamping the download
+   * `offset` down to the ACTUAL number of bytes committed on disk.
+   *
+   * `createWritable()` only commits to the real file on `close()`, so a
+   * download interrupted by a hard page kill leaves the persisted offset
+   * AHEAD of the bytes actually on disk. Resuming from that stale offset
+   * with `keepExistingData` would write past a prefix that isn't there,
+   * leaving a silent gap in the file. Clamping to the real on-disk length
+   * makes the resume pick up exactly where the file really ends.
+   * @param {string} direction
+   * @param {string} path
+   * @returns {Promise<object|null>}
+   * @private
+   */
+  async _loadResumeState(direction, path) {
+    const state = await Idb.loadState(`${direction}:${path}`);
+    if (!state) return null;
+    // Only downloads that will append onto an on-disk file need the clamp;
+    // uploads drive resume from the server's own received ranges.
+    if (direction !== 'download') return state;
+    const offset = Number(state.offset) || 0;
+    if (offset <= 0) return state;
+    const handle = await this._resolveFileHandle(path);
+    if (!handle) return state; // can't know the on-disk length → trust state
+    let diskLen = 0;
+    try {
+      diskLen = (await handle.getFile()).size;
+    } catch {
+      return state;
+    }
+    // Clamp to the bytes actually on disk. If nothing was committed (hard
+    // kill before any close), resume from 0 so the whole file is fetched
+    // again rather than leaving a gap.
+    const clamped = Math.min(offset, diskLen);
+    return { ...state, offset: clamped, size: clamped };
+  }
+
   /**
    * Close all still-open writable streams (flush to disk). Called on
    * success, failure or cancellation of a transfer.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libfw-client",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "High-performance streaming file & folder transfer SDK for the browser (libfw WASM engine + File System Access API + IndexedDB resume).",
   "license": "MIT",
   "type": "module",

package/pkg/libfw_client.js

@@ -231,6 +231,10 @@ function __wbg_get_imports() {
             const ret = arg0.apply(arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_bufferedAmount_2f95480ad75d4988: function(arg0) {
+            const ret = arg0.bufferedAmount;
+            return ret;
+        },
         __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.call(arg1, arg2);
             return ret;
@@ -360,6 +364,10 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
+        __wbg_now_86c0d4ba3fa605b8: function() {
+            const ret = Date.now();
+            return ret;
+        },
         __wbg_of_5f1b88183ddb5d94: function(arg0, arg1) {
             const ret = Array.of(arg0, arg1);
             return ret;

package/pkg/package.json

@@ -2,7 +2,7 @@
   "name": "libfw-client",
   "type": "module",
   "description": "WASM engine + JS SDK for libfw browser clients",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "license": "MIT",
   "repository": {
     "type": "git",