libfw-client 0.2.4 → 0.3.1

package/README.md

@@ -9,13 +9,12 @@ WASM engine, the File System Access API and IndexedDB.
 import { LibfwClient } from 'libfw-client';
 
 const client = new LibfwClient({
-  baseUrl: '/',         // server origin; the engine derives ws(s)://host/ws
-                        // from it (or set wsUrl explicitly)
-  concurrency: 4,       // max parallel file transfers (one WS connection each)
-  uploadWindow: 8,      // in-flight blocks per single file upload (raise to
+  baseUrl: '/',         // server origin (same-origin when empty)
+  concurrency: 4,       // max parallel file transfers (independent HTTP streams)
+  uploadWindow: 8,      // in-flight chunks per single file upload (raise to
                         // reduce upload stutter on high-latency links)
-  downloadWindow: 4,    // in-flight blocks per single file download (raise to
-                        // reduce download stutter on high-latency links)
+  downloadWindow: 4,    // parallel byte-range GETs per single file download
+                        // (raise to reduce download stutter on high-latency links)
   compress: true,       // zrip per-block compression
   onEvent: (e) => console.log(e), // { type: 'progress', done, total }
 });
@@ -40,29 +39,32 @@ client.cancel();
 
 ## How it works
 
-- **One WebSocket per transfer** — the engine talks to the server over
-  `ws(s)://…/ws` for **all** control commands (handshake, directory listing,
-  metadata) and data. Upload and download use the **same** block protocol:
-  the sender pipelines fixed-size blocks with **no per-block ack** (they may
-  travel out of order), and the receiver **verifies every block in real time**
-  (CRC32 + length + bounds), marks bad blocks (`NAK`) and asks the sender to
-  re-add them to its transfer queue; a wave boundary reconciles until every
-  block is verified. `downloadWindow`/`uploadWindow` bound the in-flight
-  blocks per wave (raise them on high-latency links).
-- `downloadFolder(token, dirPath?)` / `downloadFile(token, filePath)` — the
-  engine lists (for folders) and downloads each file as a receiver, reorders
-  out-of-order blocks in memory and pushes `Uint8Array` chunks to the SDK
-  strictly in order (append-mode `createWritable()`, no `.crswap` churn).
-  With the File System Access API the SDK streams them to disk via
-  `fileHandle.createWritable()`; without it (or with `downloadMode: 'browser'`)
-  the SDK buffers the chunks and saves the result through a traditional
-  browser download — a single file as-is, a folder packed into a `.zip`.
-- `upload(token, files?)` — the engine slices each file into fixed-size
-  blocks, reads them via `readFile`, compresses each block into one zstd
-  frame, and sends them over the WebSocket as the sender. Only the blocks the
-  server still misses are sent (`READY.received` seeds resume), so a
-  high-latency link stays saturated and interrupted uploads resume
-  BitTorrent-style (only the broken/lost parts are re-transmitted).
+- **HTTP transport, not WebSocket** — the engine drives all control commands
+  (directory listing, metadata) and data over plain HTTP. This is what keeps
+  transfers robust on lossy/unstable links: each transfer uses **independent
+  parallel HTTP streams**, so a lost packet stalls only that one stream
+  (which retries just its own bytes) instead of blocking a whole multiplexed
+  WebSocket connection.
+- **Downloads** — `downloadFolder(token, dirPath?)` / `downloadFile(token,
+  filePath)` list the tree (for folders) and fetch each large file as
+  `downloadWindow` concurrent `Range` GETs (tus-style parallel transfer, one
+  independent connection per range). Each chunk is retried independently
+  (only the lost part is re-fetched); the engine reorders the chunks in
+  memory and pushes `Uint8Array`s to the SDK **strictly in order**.
+  `Range`/`If-Range`/`416` give natural resume against the server ETag (the
+  server is the source of truth). With the File System Access API the SDK
+  streams chunks to disk via `fileHandle.createWritable()`; without it (or
+  with `downloadMode: 'browser'`) it buffers the chunks and saves the result
+  through a traditional browser download — a single file as-is, a folder
+  packed into a `.zip`.
+- **Uploads** — `upload(token, files?)` slices each file into chunks, reads
+  them via `readFile`, compresses each into one zstd frame and POSTs the
+  missing chunks concurrently (out of order) with `x-libfw-offset` into a
+  shared per-session temp on the server (positional writes). A final
+  `x-libfw-final` commit validates the size and atomically renames the temp
+  into place. Only the chunks the server still misses are re-sent
+  (`x-libfw-session-status` probe seeds resume), so interrupted uploads
+  resume BitTorrent-style (only the broken/lost parts are re-transmitted).
 - Resume state (`etag`, `offset`, `size`) is persisted per path in
   IndexedDB and re-validated on every retry.
 - Pause/resume/cancel drive the WASM state machine
@@ -91,16 +93,13 @@ dist/libfw-client.umd.js   UMD bundle (after build:umd)
 ## API
 
 - `new LibfwClient(options?)`
-  - `downloadWindow: number` (default `4`) — in-flight blocks per single file
-    download (how many blocks the server pipelines per wave before a
-    reconciliation round); raise it on high-latency links.
-  - `downloadChunkSize: number` (default `262144`, 256 KiB) — block size for
-    downloads; the engine reorders out-of-order blocks in memory (worst case
-    ≈ `downloadWindow * downloadChunkSize` bytes) so the SDK still receives
-    data in order.
-  - `wsUrl: string` — explicit WebSocket endpoint (`wss://host/ws`); when
-    omitted it is derived from `baseUrl` (`http://h:8080` → `ws://h:8080/ws`,
-    same-origin when empty).
+  - `downloadWindow: number` (default `4`) — in-flight byte-range window per
+    single file download (how many concurrent `Range` GETs); raise it on
+    high-latency links. `1` disables parallelism (sequential downloads).
+  - `downloadChunkSize: number` (default `262144`, 256 KiB) — byte range size
+    for parallel downloads; the engine reorders in-flight chunks in memory
+    (worst case ≈ `downloadWindow * downloadChunkSize` bytes) so the SDK
+    still receives data in order.
   - `downloadMode: 'auto' | 'fs' | 'browser'` (default `'auto'`) — `'fs'`
     streams downloads through the File System Access API; `'browser'` buffers
     and triggers a traditional browser download (folders become `.zip`);

package/index.d.ts

@@ -51,39 +51,39 @@ export interface LibfwEvent {
 /** Options accepted by the {@link LibfwClient} constructor. */
 export interface LibfwClientOptions {
   /**
-   * Base URL the libfw server is served from. The engine derives the
-   * WebSocket endpoint from it (`http://h:8080` → `ws://h:8080/ws`);
-   * same-origin when empty. All control commands and data transfer travel
-   * over that WebSocket. Default `''`.
+   * Base URL the libfw server is served from (same-origin when empty). The
+   * engine drives all control commands and data transfer over plain HTTP
+   * (parallel `Range` downloads, tus-style chunked uploads) — no WebSocket
+   * is used. Default `''`.
    */
   baseUrl?: string;
   /** Max concurrently-transferring files. Default `4`. */
   concurrency?: number;
   /**
-   * In-flight block window for a single file's upload, independent of
-   * `concurrency`. Blocks are pipelined over one WebSocket without per-block
-   * acknowledgments; this bounds how many are in flight before a
-   * reconciliation round. A higher value keeps high-latency links saturated.
-   * Default `8`.
+   * In-flight chunk window for a single file's upload, independent of
+   * `concurrency`. The missing chunks are POSTed concurrently (out of
+   * order) into a shared per-session temp on the server; a higher value
+   * keeps high-latency links saturated. Default `8`.
    */
   uploadWindow?: number;
   /**
-   * In-flight block window for a single file's download. The server
-   * pipelines up to this many blocks per wave; a higher value keeps
-   * high-latency links saturated. The engine reorders out-of-order blocks in
-   * memory (worst case ≈ `downloadWindow * downloadChunkSize` bytes) so the
-   * SDK still receives data strictly in order. Default `4`.
+   * In-flight byte-range window for a single file's download. Large files
+   * are fetched as `downloadWindow` concurrent `Range` GETs (tus-style
+   * parallel transfer), so a single file's throughput is bounded by
+   * bandwidth instead of one connection's `chunkSize / RTT`. `1` disables
+   * parallelism (sequential downloads). Default `4`.
    */
   downloadWindow?: number;
   /**
-   * Block size for downloads. The engine reorders in-flight blocks in
-   * memory (worst case ≈ `downloadWindow * downloadChunkSize` bytes) so the
-   * SDK still receives data strictly in order. Default `262144` (256 KiB).
+   * Byte range size for parallel downloads. The engine reorders in-flight
+   * chunks in memory (worst case ≈ `downloadWindow * downloadChunkSize`
+   * bytes) so the SDK still receives data strictly in order. Default
+   * `262144` (256 KiB).
    */
   downloadChunkSize?: number;
   /** Negotiate zrip compression. Default `true`. */
   compress?: boolean;
-  /** Upload block size in bytes. Default 2 MiB. */
+  /** Upload chunk size in bytes. Default 2 MiB. */
   chunkSize?: number;
   /** Retries per chunk/file before failing. Default `3`. */
   maxRetries?: number;
@@ -93,11 +93,6 @@ export interface LibfwClientOptions {
   maxRetryDelayMs?: number;
   /** Per-read timeout (ms). Default `60000`. */
   timeoutMs?: number;
-  /**
-   * Explicit WebSocket endpoint (e.g. `wss://host/ws`). When omitted it is
-   * derived from `baseUrl`.
-   */
-  wsUrl?: string;
   /**
    * Explicit URL of `libfw_client_bg.wasm`. When omitted it is resolved
    * automatically for both ESM and classic-`<script>`/UMD consumers.

package/index.js

@@ -187,15 +187,20 @@ const BUNDLE_SCRIPT_SRC =
 export class LibfwClient {
   /**
    * @param {object} [options]
-   * @param {string} [options.baseUrl=''] base URL the server is served from. The
-   *        engine derives the WebSocket endpoint from it (e.g. `http://h:8080`
-   *        → `ws://h:8080/ws`); same-origin when empty. All control commands
-   *        and data transfer travel over that WebSocket.
-   * @param {number} [options.concurrency=4] max concurrently-transferring files
-   * @param {number} [options.uploadWindow=8] in-flight chunk window for a
-   *        single file's upload; independent of `concurrency`, keeps a
-   *        high-latency link saturated (raise it to reduce upload stutter;
-   *        keep within your server's connection limit, ~6 for HTTP/1.1)
+   * @param {string} [options.baseUrl=''] base URL the server is served from
+   *        (same-origin when empty). The engine drives all control commands
+   *        and data transfer over plain HTTP (parallel `Range` downloads,
+   *        tus-style chunked uploads) — no WebSocket is used.
+   * @param {number} [options.concurrency=4] global cap on concurrent
+   *        in-flight HTTP transfers (files and per-file chunk/range windows
+   *        combined). Every chunk upload and range download takes a shared
+   *        permit, so this is what actually bounds the engine's network
+   *        parallelism — set it to your server/browser connection budget
+   *        (e.g. 1 = strictly one transfer at a time).
+   * @param {number} [options.uploadWindow=8] per-file scheduling window for a
+   *        single file's upload: keeps that file's read/compress pipeline
+   *        full on high-latency links, but the TOTAL in-flight requests never
+   *        exceed `concurrency`
    * @param {number} [options.downloadWindow=4] in-flight byte-range window
    *        for a single file's download. Large files are fetched as
    *        `downloadWindow` concurrent `Range` GETs (tus-style parallel
@@ -209,12 +214,13 @@ export class LibfwClient {
    *        SDK still receives data strictly in order.
    * @param {boolean} [options.compress=true] negotiate zrip compression
    * @param {number} [options.chunkSize=2097152] upload chunk size in bytes
+   *        (each chunk is split into many small ~64 KiB compressed frames, so
+   *        any value works; larger = fewer, bigger POST requests — bounded
+   *        only by the server's upload limit and client memory)
    * @param {number} [options.maxRetries=3] retries per chunk/file before failing
    * @param {number} [options.baseRetryDelayMs=500] initial backoff (ms)
    * @param {number} [options.maxRetryDelayMs=30000] backoff ceiling (ms)
    * @param {number} [options.timeoutMs=60000] per-read timeout (ms)
-   * @param {string} [options.wsUrl] explicit WebSocket endpoint (e.g.
-   *        `wss://host/ws`); when omitted it is derived from `baseUrl`
    * @param {string} [options.wasmUrl] explicit URL of `libfw_client_bg.wasm`;
    *        when omitted it is resolved automatically for both ESM and
    *        classic-`<script>`/UMD consumers (see {@link LibfwClient#_wasmUrl})
@@ -245,7 +251,6 @@ export class LibfwClient {
       baseRetryDelayMs: 500,
       maxRetryDelayMs: 30000,
       timeoutMs: 60000,
-      wsUrl: null,
       wasmUrl: null,
       downloadMode: 'auto',
       maxFallbackBytes: 512 * 1024 * 1024,
@@ -305,7 +310,6 @@ export class LibfwClient {
       baseRetryDelayMs: this._options.baseRetryDelayMs,
       maxRetryDelayMs: this._options.maxRetryDelayMs,
       timeoutMs: this._options.timeoutMs,
-      wsUrl: this._options.wsUrl,
     });
     engine.set_callbacks(this._makeCallbacks());
     this._engine = engine;
@@ -729,7 +733,20 @@ export class LibfwClient {
       this._emit({ type: 'fileCompleted', path });
       return;
     }
-    await this._closeWritable(path);
+    if (this._writables.has(path)) {
+      await this._closeWritable(path);
+    } else {
+      // No bytes were written this run — either a zero-byte file or a file
+      // already fully on disk from a resume. Materialize the target so an
+      // empty file still appears on disk. `getFileHandle({ create: true })`
+      // only creates a missing file, so an already-complete (resumed) file
+      // is never truncated here.
+      try {
+        await this._ensureFileHandle(path);
+      } catch {
+        /* best-effort: never fail the transfer on materialization errors */
+      }
+    }
     this._emit({ type: 'fileCompleted', path });
   }
 
@@ -835,7 +852,13 @@ export class LibfwClient {
     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
+    if (!handle) {
+      // No on-disk file to resume from: whatever offset was persisted has
+      // nothing behind it. Restart from 0 instead of trusting a stale offset
+      // that would make the engine skip the download entirely (producing an
+      // empty/missing file while reporting "complete").
+      return { ...state, offset: 0, size: 0 };
+    }
     let diskLen = 0;
     try {
       diskLen = (await handle.getFile()).size;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libfw-client",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "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.d.ts

@@ -97,9 +97,7 @@ export interface InitOutput {
     readonly libfwclient_upload: (a: number, b: number, c: number, d: number, e: number) => any;
     readonly wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___wasm_bindgen_1e05ddb24c0b7df4___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_1e05ddb24c0b7df4___JsError___true_: (a: number, b: number, c: any) => [number, number];
     readonly wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___js_sys_bb6c79d0abe11c10___Function_fn_wasm_bindgen_1e05ddb24c0b7df4___JsValue_____wasm_bindgen_1e05ddb24c0b7df4___sys__Undefined___js_sys_bb6c79d0abe11c10___Function_fn_wasm_bindgen_1e05ddb24c0b7df4___JsValue_____wasm_bindgen_1e05ddb24c0b7df4___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
-    readonly wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true_: (a: number, b: number, c: any) => void;
-    readonly wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true__2: (a: number, b: number, c: any) => void;
-    readonly wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true__3: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke_______true_: (a: number, b: number) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;

package/pkg/libfw_client.js

@@ -227,26 +227,51 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_fffb441def202758: function(arg0) {
             arg0._wbg_cb_unref();
         },
+        __wbg_abort_4426bc6bd4153680: function() { return handleError(function (arg0) {
+            arg0.abort();
+        }, arguments); },
         __wbg_apply_3ac86a26fdb56c05: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.apply(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_bufferedAmount_2f95480ad75d4988: function(arg0) {
-            const ret = arg0.bufferedAmount;
+        __wbg_arrayBuffer_3b637f0fa65c5351: function() { return handleError(function (arg0) {
+            const ret = arg0.arrayBuffer();
             return ret;
+        }, arguments); },
+        __wbg_body_18c9f2ac15ead4b2: function(arg0) {
+            const ret = arg0.body;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
         __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_data_328de4280640da92: function(arg0) {
-            const ret = arg0.data;
+        __wbg_clearInterval_2e2069e95ad09d4f: function(arg0, arg1) {
+            arg0.clearInterval(arg1);
+        },
+        __wbg_encodeURIComponent_d0140ae6e13eb27b: function(arg0, arg1) {
+            const ret = encodeURIComponent(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_fetch_6ecc661950e58d49: function(arg0, arg1) {
+            const ret = arg0.fetch(arg1);
             return ret;
         },
         __wbg_from_13e323c65fc8f464: function(arg0) {
             const ret = Array.from(arg0);
             return ret;
         },
+        __wbg_getReader_7455d080fa48369b: function(arg0) {
+            const ret = arg0.getReader();
+            return ret;
+        },
+        __wbg_get_18e0163e38e5048d: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg1.get(getStringFromWasm0(arg2, arg3));
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
         __wbg_get_78f252d074a84d0b: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
@@ -255,13 +280,10 @@ function __wbg_get_imports() {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_host_21c8d54c9bdcd04a: function() { return handleError(function (arg0, arg1) {
-            const ret = arg1.host;
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        }, arguments); },
+        __wbg_headers_cf9c80f30e2a4eff: function(arg0) {
+            const ret = arg0.headers;
+            return ret;
+        },
         __wbg_instanceof_ArrayBuffer_4480b9e0068a8adb: function(arg0) {
             let result;
             try {
@@ -300,14 +322,18 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_location_c9a2271428996698: function(arg0) {
-            const ret = arg0.location;
+        __wbg_new_0d809930cd1354c6: function() { return handleError(function () {
+            const ret = new Headers();
             return ret;
-        },
+        }, arguments); },
         __wbg_new_32b398fb48b6d94a: function() {
             const ret = new Array();
             return ret;
         },
+        __wbg_new_6b1dd7bed0e5462c: function() { return handleError(function () {
+            const ret = new XMLHttpRequest();
+            return ret;
+        }, arguments); },
         __wbg_new_aec3e25493d729fe: function(arg0, arg1) {
             try {
                 var state0 = {a: arg0, b: arg1};
@@ -330,10 +356,6 @@ function __wbg_get_imports() {
             const ret = new Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_new_bf8729ffe10e9ee7: function() { return handleError(function (arg0, arg1) {
-            const ret = new WebSocket(getStringFromWasm0(arg0, arg1));
-            return ret;
-        }, arguments); },
         __wbg_new_cd45aabdf6073e84: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
@@ -364,6 +386,10 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
+        __wbg_new_with_str_and_init_d95cbe11ce28e65e: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
+            return ret;
+        }, arguments); },
         __wbg_now_86c0d4ba3fa605b8: function() {
             const ret = Date.now();
             return ret;
@@ -372,12 +398,8 @@ function __wbg_get_imports() {
             const ret = Array.of(arg0, arg1);
             return ret;
         },
-        __wbg_protocol_0598aef25eb71eae: function() { return handleError(function (arg0, arg1) {
-            const ret = arg1.protocol;
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        __wbg_open_90286a4ce0ae2098: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), arg5 !== 0);
         }, arguments); },
         __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
@@ -397,12 +419,27 @@ function __wbg_get_imports() {
             const ret = Promise.race(arg0);
             return ret;
         },
+        __wbg_read_8afa15f12a160ef8: function(arg0) {
+            const ret = arg0.read();
+            return ret;
+        },
+        __wbg_readyState_e916e521239696c1: function(arg0) {
+            const ret = arg0.readyState;
+            return ret;
+        },
         __wbg_resolve_2191a4dfe481c25b: function(arg0) {
             const ret = Promise.resolve(arg0);
             return ret;
         },
-        __wbg_send_a321b376d40ec867: function() { return handleError(function (arg0, arg1, arg2) {
-            arg0.send(getArrayU8FromWasm0(arg1, arg2));
+        __wbg_send_4a966e8f532ab09b: function() { return handleError(function (arg0, arg1, arg2) {
+            arg0.send(arg1 === 0 ? undefined : getArrayU8FromWasm0(arg1, arg2));
+        }, arguments); },
+        __wbg_setInterval_93ec7461c3650c76: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.setInterval(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_setRequestHeader_fe390ff50d349432: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.setRequestHeader(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
         __wbg_setTimeout_725a27c387d005c7: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = arg0.setTimeout(arg1, arg2, arg3);
@@ -412,24 +449,33 @@ function __wbg_get_imports() {
             const ret = arg0.setTimeout(arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_set_0de9c62c23d04ad5: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
         __wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_set_binaryType_a37b086c78ca7c29: function(arg0, arg1) {
-            arg0.binaryType = __wbindgen_enum_BinaryType[arg1];
+        __wbg_set_body_029f2d171e0a005f: function(arg0, arg1) {
+            arg0.body = arg1;
+        },
+        __wbg_set_headers_9c61d123c3ee1f10: function(arg0, arg1) {
+            arg0.headers = arg1;
+        },
+        __wbg_set_method_5532d59b92d76467: function(arg0, arg1, arg2) {
+            arg0.method = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_onclose_f706475385ecce07: function(arg0, arg1) {
-            arg0.onclose = arg1;
+        __wbg_set_onabort_549ef96670787286: function(arg0, arg1) {
+            arg0.onabort = arg1;
         },
-        __wbg_set_onerror_9f5773fd31512333: function(arg0, arg1) {
+        __wbg_set_onerror_c810587e53729112: function(arg0, arg1) {
             arg0.onerror = arg1;
         },
-        __wbg_set_onmessage_836d2f72130b4706: function(arg0, arg1) {
-            arg0.onmessage = arg1;
+        __wbg_set_onprogress_ba0113ededd552ae: function(arg0, arg1) {
+            arg0.onprogress = arg1;
         },
-        __wbg_set_onopen_4f65470ae522a61a: function(arg0, arg1) {
-            arg0.onopen = arg1;
+        __wbg_set_onreadystatechange_14ce44725c7e0789: function(arg0, arg1) {
+            arg0.onreadystatechange = arg1;
         },
         __wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
             const ret = typeof global === 'undefined' ? null : global;
@@ -447,6 +493,14 @@ function __wbg_get_imports() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_status_bab532bcb3b5d775: function() { return handleError(function (arg0) {
+            const ret = arg0.status;
+            return ret;
+        }, arguments); },
+        __wbg_status_c45b3b9b3033184a: function(arg0) {
+            const ret = arg0.status;
+            return ret;
+        },
         __wbg_then_16d107c451e9905d: function(arg0, arg1, arg2) {
             const ret = arg0.then(arg1, arg2);
             return ret;
@@ -455,32 +509,26 @@ function __wbg_get_imports() {
             const ret = arg0.then(arg1);
             return ret;
         },
+        __wbg_upload_65cdbdfcc901f1b1: function() { return handleError(function (arg0) {
+            const ret = arg0.upload;
+            return ret;
+        }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 151, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 163, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___wasm_bindgen_1e05ddb24c0b7df4___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_1e05ddb24c0b7df4___JsError___true_);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true_);
-            return ret;
-        },
-        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true__2);
-            return ret;
-        },
-        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true__3);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 5, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke_______true_);
             return ret;
         },
-        __wbindgen_cast_0000000000000005: function(arg0) {
+        __wbindgen_cast_0000000000000003: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
@@ -501,16 +549,8 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true_(arg0, arg1, arg2) {
-    wasm.wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true_(arg0, arg1, arg2);
-}
-
-function wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true__2(arg0, arg1, arg2) {
-    wasm.wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true__2(arg0, arg1, arg2);
-}
-
-function wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true__3(arg0, arg1, arg2) {
-    wasm.wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true__3(arg0, arg1, arg2);
+function wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke_______true_(arg0, arg1) {
+    wasm.wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke_______true_(arg0, arg1);
 }
 
 function wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___wasm_bindgen_1e05ddb24c0b7df4___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_1e05ddb24c0b7df4___JsError___true_(arg0, arg1, arg2) {
@@ -524,8 +564,6 @@ function wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___js_sys_b
     wasm.wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___js_sys_bb6c79d0abe11c10___Function_fn_wasm_bindgen_1e05ddb24c0b7df4___JsValue_____wasm_bindgen_1e05ddb24c0b7df4___sys__Undefined___js_sys_bb6c79d0abe11c10___Function_fn_wasm_bindgen_1e05ddb24c0b7df4___JsValue_____wasm_bindgen_1e05ddb24c0b7df4___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
 }
 
-
-const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
 const LibfwClientFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_libfwclient_free(ptr, 1));

package/pkg/libfw_client_bg.wasm.d.ts

@@ -18,9 +18,7 @@ export const libfwclient_total_bytes: (a: number) => number;
 export const libfwclient_upload: (a: number, b: number, c: number, d: number, e: number) => any;
 export const wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___wasm_bindgen_1e05ddb24c0b7df4___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_1e05ddb24c0b7df4___JsError___true_: (a: number, b: number, c: any) => [number, number];
 export const wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___js_sys_bb6c79d0abe11c10___Function_fn_wasm_bindgen_1e05ddb24c0b7df4___JsValue_____wasm_bindgen_1e05ddb24c0b7df4___sys__Undefined___js_sys_bb6c79d0abe11c10___Function_fn_wasm_bindgen_1e05ddb24c0b7df4___JsValue_____wasm_bindgen_1e05ddb24c0b7df4___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
-export const wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true_: (a: number, b: number, c: any) => void;
-export const wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true__2: (a: number, b: number, c: any) => void;
-export const wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_86e1b1c7d411e716___features__gen_CloseEvent__CloseEvent______true__3: (a: number, b: number, c: any) => void;
+export const wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke_______true_: (a: number, b: number) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

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.4",
+  "version": "0.3.1",
   "license": "MIT",
   "repository": {
     "type": "git",