libfw-client 0.1.4 → 0.2.1

package/README.md

@@ -9,14 +9,14 @@ WASM engine, the File System Access API and IndexedDB.
 import { LibfwClient } from 'libfw-client';
 
 const client = new LibfwClient({
-  baseUrl: '/api',      // where libfw-server routes are mounted
-  concurrency: 4,       // max parallel file transfers
-  uploadWindow: 8,      // in-flight chunks per single file upload (raise to
+  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
                         // reduce upload stutter on high-latency links)
-  downloadWindow: 4,    // in-flight byte-range GETs per single file download
-                        // (tus-style parallel download: one file's throughput
-                        // isn't bounded by a single connection's RTT)
-  compress: true,       // zrip streaming compression
+  downloadWindow: 4,    // in-flight blocks 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,28 +40,29 @@ 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 with `Range`/`If-Range`
-  resume, decompresses the zrip stream, and pushes `Uint8Array` chunks to the
-  SDK. Large files use the **tus-style parallel path**: `downloadWindow`
-  concurrent byte-range GETs, reordered in memory so the SDK still receives
-  bytes strictly in order (append-mode `createWritable()`, no `.crswap`
-  churn), with per-chunk independent retries. 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`.
+  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
-  chunks, reads them via `readFile`, compresses each chunk into one zstd
-  frame, and POSTs them with an absolute `x-libfw-offset` into a shared
-  per-session temp file. Up to `uploadWindow` chunks of one file are kept in
-  flight concurrently (independent of the cross-file `concurrency`), so a
-  high-latency link stays saturated. Uploads are **tus-style
-  verify-then-complete**: the server is the source of truth — the client
-  probes the byte ranges the server actually persisted and re-sends only the
-  still-missing blocks, filling gaps a lost response may have left (and
-  re-probing + refilling if a commit fails) before the final `x-libfw-final`
-  request merges the temp into place.
+  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).
 - 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
@@ -90,12 +91,16 @@ dist/libfw-client.umd.js   UMD bundle (after build:umd)
 ## API
 
 - `new LibfwClient(options?)`
-  - `downloadWindow: number` (default `4`) — in-flight byte-range GETs per
-    single file download; `1` disables parallelism.
-  - `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.
+  - `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).
   - `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

@@ -50,35 +50,40 @@ export interface LibfwEvent {
 
 /** Options accepted by the {@link LibfwClient} constructor. */
 export interface LibfwClientOptions {
-  /** Base URL the libfw server routes are mounted under. Default `''`. */
+  /**
+   * 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 `''`.
+   */
   baseUrl?: string;
   /** Max concurrently-transferring files. Default `4`. */
   concurrency?: number;
   /**
-   * In-flight chunk window for a single file's upload, independent of
-   * `concurrency`. A higher value keeps high-latency links saturated and
-   * reduces upload stutter; keep it within your server's connection limit
-   * (~6 for HTTP/1.1). Default `8`.
+   * 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`.
    */
   uploadWindow?: number;
   /**
-   * 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` on high-latency
-   * links. `1` disables parallelism. Default `4`.
+   * 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`.
    */
   downloadWindow?: number;
   /**
-   * Byte range size for parallel downloads. Smaller than the upload chunk
-   * on purpose: 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).
+   * 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).
    */
   downloadChunkSize?: number;
   /** Negotiate zrip compression. Default `true`. */
   compress?: boolean;
-  /** Upload chunk size in bytes. Default 2 MiB. */
+  /** Upload block size in bytes. Default 2 MiB. */
   chunkSize?: number;
   /** Retries per chunk/file before failing. Default `3`. */
   maxRetries?: number;
@@ -86,8 +91,13 @@ export interface LibfwClientOptions {
   baseRetryDelayMs?: number;
   /** Backoff ceiling (ms). Default `30000`. */
   maxRetryDelayMs?: number;
-  /** Per-request timeout (ms). Default `60000`. */
+  /** 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,7 +187,10 @@ const BUNDLE_SCRIPT_SRC =
 export class LibfwClient {
   /**
    * @param {object} [options]
-   * @param {string} [options.baseUrl=''] base URL the server routes are mounted under
+   * @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
@@ -209,7 +212,9 @@ export class LibfwClient {
    * @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-request timeout (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})
@@ -240,6 +245,7 @@ export class LibfwClient {
       baseRetryDelayMs: 500,
       maxRetryDelayMs: 30000,
       timeoutMs: 60000,
+      wsUrl: null,
       wasmUrl: null,
       downloadMode: 'auto',
       maxFallbackBytes: 512 * 1024 * 1024,
@@ -299,6 +305,7 @@ 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libfw-client",
-  "version": "0.1.4",
+  "version": "0.2.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,6 +97,9 @@ 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 __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

@@ -231,41 +231,18 @@ function __wbg_get_imports() {
             const ret = arg0.apply(arg1, arg2);
             return ret;
         }, arguments); },
-        __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_encodeURIComponent_d0140ae6e13eb27b: function(arg0, arg1) {
-            const ret = encodeURIComponent(getStringFromWasm0(arg0, arg1));
-            return ret;
-        },
-        __wbg_fetch_6ecc661950e58d49: function(arg0, arg1) {
-            const ret = arg0.fetch(arg1);
+        __wbg_data_328de4280640da92: function(arg0) {
+            const ret = arg0.data;
             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;
@@ -274,10 +251,13 @@ function __wbg_get_imports() {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_headers_cf9c80f30e2a4eff: function(arg0) {
-            const ret = arg0.headers;
-            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_instanceof_ArrayBuffer_4480b9e0068a8adb: function(arg0) {
             let result;
             try {
@@ -316,10 +296,10 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_new_0d809930cd1354c6: function() { return handleError(function () {
-            const ret = new Headers();
+        __wbg_location_c9a2271428996698: function(arg0) {
+            const ret = arg0.location;
             return ret;
-        }, arguments); },
+        },
         __wbg_new_32b398fb48b6d94a: function() {
             const ret = new Array();
             return ret;
@@ -346,6 +326,10 @@ 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;
@@ -376,14 +360,17 @@ 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_of_5f1b88183ddb5d94: function(arg0, arg1) {
             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);
+        }, arguments); },
         __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
@@ -402,14 +389,13 @@ function __wbg_get_imports() {
             const ret = Promise.race(arg0);
             return ret;
         },
-        __wbg_read_8afa15f12a160ef8: function(arg0) {
-            const ret = arg0.read();
-            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));
+        }, arguments); },
         __wbg_setTimeout_725a27c387d005c7: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = arg0.setTimeout(arg1, arg2, arg3);
             return ret;
@@ -418,21 +404,24 @@ 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_body_029f2d171e0a005f: function(arg0, arg1) {
-            arg0.body = arg1;
+        __wbg_set_binaryType_a37b086c78ca7c29: function(arg0, arg1) {
+            arg0.binaryType = __wbindgen_enum_BinaryType[arg1];
+        },
+        __wbg_set_onclose_f706475385ecce07: function(arg0, arg1) {
+            arg0.onclose = arg1;
         },
-        __wbg_set_headers_9c61d123c3ee1f10: function(arg0, arg1) {
-            arg0.headers = arg1;
+        __wbg_set_onerror_9f5773fd31512333: function(arg0, arg1) {
+            arg0.onerror = arg1;
         },
-        __wbg_set_method_5532d59b92d76467: function(arg0, arg1, arg2) {
-            arg0.method = getStringFromWasm0(arg1, arg2);
+        __wbg_set_onmessage_836d2f72130b4706: function(arg0, arg1) {
+            arg0.onmessage = arg1;
+        },
+        __wbg_set_onopen_4f65470ae522a61a: function(arg0, arg1) {
+            arg0.onopen = arg1;
         },
         __wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
             const ret = typeof global === 'undefined' ? null : global;
@@ -450,10 +439,6 @@ function __wbg_get_imports() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __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;
@@ -463,16 +448,31 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 145, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // 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`.
             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) {
+        __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);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000005: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000006: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
@@ -493,6 +493,18 @@ 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___wasm_bindgen_1e05ddb24c0b7df4___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_1e05ddb24c0b7df4___JsError___true_(arg0, arg1, arg2) {
     const ret = wasm.wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___wasm_bindgen_1e05ddb24c0b7df4___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_1e05ddb24c0b7df4___JsError___true_(arg0, arg1, arg2);
     if (ret[1]) {
@@ -504,6 +516,8 @@ 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,6 +18,9 @@ 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 __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.1.4",
+  "version": "0.2.1",
   "license": "MIT",
   "repository": {
     "type": "git",