libfw-client 0.3.1 → 0.3.4

package/README.md

@@ -16,7 +16,13 @@ const client = new LibfwClient({
   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 }
+  autoTune: true,       // adaptive tuning: probes /capabilities and ramps
+                        // concurrency/windows/chunk sizes from real stats
+  onEvent: (e) => {
+    if (e.type === 'progress') updateProgressBar(e.done, e.total);
+    else if (e.type === 'tuning') renderTuning(e.phase, e.params, e.stats);
+    // other types: fileStart, fileCompleted, ...
+  },
 });
 
 // Download a whole folder. Uses showDirectoryPicker when the File System
@@ -108,12 +114,28 @@ dist/libfw-client.umd.js   UMD bundle (after build:umd)
     for the in-memory `'browser'` fallback. File sizes are pre-checked
     against it before buffering; a download that would exceed it rejects
     with a `too-large` `LibfwError` instead of risking an OOM. `0` disables.
+  - `autoTune: boolean` (default `false`) — enable the adaptive tuning
+    engine. The engine probes the server's `/capabilities` limits and
+    TCP-style ramps concurrency / windows / chunk sizes (and the zrip
+    level) from the advertised minimums using real transfer stats. When
+    disabled, the configured static values are used as-is.
+  - `tuneTtlMs: number` (default `3600000`, 1 h) — how long a settled
+    tuning result is reused for the same server origin before re-ramping.
 - `downloadFolder(token, dirPath?) → Promise<number>`
 - `downloadFile(token, filePath) → Promise<number>`
 - `upload(token, files?) → Promise<number>`
 - `clearResumeStore(direction?) → Promise<number>`
 - `pause()`, `resume()`, `cancel()`
 - `state()`, `progress()`, `doneBytes()`, `totalBytes()`
+- `tuneStatus() → { phase, params, stats, capsHash } | null` — live
+  adaptive-tuning status. `phase` is `uninitialized | ramping | settled |
+  degraded`; `params` is `{ concurrency, uploadWindow, downloadWindow,
+  chunkSize, downloadChunkSize, compressLevel }`; `stats` is
+  `{ rttMs, mbps }` (EWMA request RTT, last-window throughput). `null`
+  until the WASM engine is initialised.
+- Events: with `autoTune` enabled, `onEvent` additionally receives
+  `{ type: 'tuning', phase, params, stats }` on every phase transition /
+  window evaluation.
 - Errors: every rejection is a `LibfwError` with a stable `code`.
 
 See `index.d.ts` for the full type surface.

package/index.d.ts

@@ -36,6 +36,40 @@ export interface UploadEntry {
   mtime: number;
 }
 
+/** Adaptive-tuning parameters the engine is currently tuned to. */
+export interface TuningParams {
+  /** Cross-file transfer concurrency. */
+  concurrency: number;
+  /** In-flight chunks per single-file upload. */
+  uploadWindow: number;
+  /** In-flight byte-range GETs per single-file download. */
+  downloadWindow: number;
+  /** Upload chunk size in bytes. */
+  chunkSize: number;
+  /** Download byte-range size in bytes. */
+  downloadChunkSize: number;
+  /** zrip compression level (negative = faster, positive = smaller). */
+  compressLevel: number;
+}
+
+/** Last-window transfer statistics reported by the tuning engine. */
+export interface TuningStats {
+  /** EWMA request round-trip time in milliseconds. */
+  rttMs: number;
+  /** Last-window throughput in megabits per second. */
+  mbps: number;
+}
+
+/** Live adaptive-tuning status (see {@link LibfwClient.tuneStatus}). */
+export interface TuneStatus {
+  /** `uninitialized` until the first measurement window completes. */
+  phase: 'uninitialized' | 'ramping' | 'settled' | 'degraded';
+  params: TuningParams;
+  stats: TuningStats;
+  /** Hash of the server `/capabilities` payload the tuning is based on. */
+  capsHash: string;
+}
+
 /** Progress / lifecycle event delivered via `options.onEvent`. */
 export interface LibfwEvent {
   /** `fileStart`, `fileCompleted`, `progress`. */
@@ -48,6 +82,14 @@ export interface LibfwEvent {
   total?: number;
 }
 
+/** Tuning event delivered via `options.onEvent` when `autoTune` is enabled. */
+export interface LibfwTuningEvent {
+  type: 'tuning';
+  phase: TuneStatus['phase'];
+  params: TuningParams;
+  stats: TuningStats;
+}
+
 /** Options accepted by the {@link LibfwClient} constructor. */
 export interface LibfwClientOptions {
   /**
@@ -114,8 +156,21 @@ export interface LibfwClientOptions {
    * limit. Default `536870912` (512 MiB).
    */
   maxFallbackBytes?: number;
-  /** Optional progress/state listener. */
-  onEvent?: (event: LibfwEvent) => void;
+  /**
+   * Enable the adaptive tuning engine: the engine probes the server's
+   * `/capabilities` limits and TCP-style ramps concurrency / windows /
+   * chunk sizes (and the zrip level) from the advertised minimums using
+   * real transfer stats. When disabled the configured static values are
+   * used as-is. Default `false`.
+   */
+  autoTune?: boolean;
+  /**
+   * How long (ms) a settled tuning result is reused for the same server
+   * origin before re-ramping. Default `3600000` (1 hour).
+   */
+  tuneTtlMs?: number;
+  /** Optional progress/state listener. Tuning updates arrive as `{ type: 'tuning', phase, params, stats }`. */
+  onEvent?: (event: LibfwEvent | LibfwTuningEvent) => void;
 }
 
 /**
@@ -192,6 +247,19 @@ export declare class LibfwClient {
   /** Total bytes to transfer. */
   totalBytes(): number;
 
+  /**
+   * Live adaptive-tuning status.
+   *
+   * @returns `{ phase, params, stats, capsHash }` — `phase` is
+   *   `uninitialized | ramping | settled | degraded`; `params` holds the
+   *   tuned `concurrency` / `uploadWindow` / `downloadWindow` / `chunkSize`
+   *   / `downloadChunkSize` / `compressLevel`; `stats` is
+   *   `{ rttMs, mbps }` (EWMA request RTT, last-window throughput).
+   *   `null` until the WASM engine is initialised (or when `autoTune` is
+   *   disabled, `phase` stays `uninitialized`).
+   */
+  tuneStatus(): TuneStatus | null;
+
   /**
    * Delete persisted resume state (IndexedDB).
    *

package/index.js

@@ -235,8 +235,16 @@ export class LibfwClient {
    *        before any bytes are buffered; a download that would exceed it is
    *        rejected with a `too-large` error instead of risking an OOM.
    *        `0` disables the limit.
+   * @param {boolean} [options.autoTune=false] enable the adaptive tuning
+   *        engine: the engine probes the server's `/capabilities` limits and
+   *        TCP-style ramps concurrency / windows / chunk sizes (and the zrip
+   *        level) from the advertised minimums using real transfer stats.
+   *        When disabled the configured static values are used as-is.
+   * @param {number} [options.tuneTtlMs=3600000] how long a settled tuning
+   *        result is reused for the same server origin before re-ramping
    * @param {(event: {type: string, done: number, total: number, path?: string, error?: string}) => void} [options.onEvent]
-   *        optional progress/state listener
+   *        optional progress/state listener. Tuning updates arrive as
+   *        `{ type: 'tuning', phase, params, stats }` events.
    */
   constructor(options = {}) {
     this._options = {
@@ -254,6 +262,8 @@ export class LibfwClient {
       wasmUrl: null,
       downloadMode: 'auto',
       maxFallbackBytes: 512 * 1024 * 1024,
+      autoTune: false,
+      tuneTtlMs: 3600000,
       onEvent: null,
       ...options,
     };
@@ -310,8 +320,15 @@ export class LibfwClient {
       baseRetryDelayMs: this._options.baseRetryDelayMs,
       maxRetryDelayMs: this._options.maxRetryDelayMs,
       timeoutMs: this._options.timeoutMs,
+      autoTune: this._options.autoTune,
+      tuneTtlMs: this._options.tuneTtlMs,
     });
     engine.set_callbacks(this._makeCallbacks());
+    // Forward tuning state changes (phase transitions, window evaluations)
+    // to the SDK consumer as `{ type: 'tuning', phase, params, stats }`.
+    engine.set_tune_callback((phase, params, stats) => {
+      this._emit({ type: 'tuning', phase, params, stats });
+    });
     this._engine = engine;
     return engine;
   }
@@ -673,11 +690,14 @@ export class LibfwClient {
         this._fallback.buffers.set(path, buf);
         this._fallback.order.push(path);
       }
-      // 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) {
+      // A chunk whose absolute offset is BEFORE the buffered span 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. Note: `offset === buf.len` is the NORMAL
+      // next-chunk case (chunk N ends exactly where chunk N+1 begins), so it
+      // must NOT be treated as a restart — otherwise the first chunk of every
+      // browser-mode download is silently dropped.
+      if (offset < buf.len) {
         buf.chunks = [];
         buf.len = 0;
       }
@@ -935,6 +955,20 @@ export class LibfwClient {
    * @throws {LibfwError}
    */
   async upload(token, files) {
+    // Snapshot the FileList SYNCHRONOUSLY, before any await: `input.files`
+    // is a LIVE list that the page typically clears (`input.value = ''`)
+    // right after the change event — while we await WASM init below, that
+    // clear would empty a captured FileList to zero entries and the upload
+    // would silently transfer 0 bytes. Copying the File objects now keeps
+    // them valid regardless of what the page does to the input afterwards.
+    if (
+      files !== undefined &&
+      files !== null &&
+      !Array.isArray(files) &&
+      typeof files[Symbol.iterator] === 'function'
+    ) {
+      files = Array.from(files);
+    }
     const engine = await this._ready();
     this._uploadFiles.clear();
     this._uploadPlan = [];
@@ -1084,6 +1118,23 @@ export class LibfwClient {
     return this._engine ? this._engine.total_bytes() : 0;
   }
 
+  /**
+   * Live adaptive-tuning status: `{ phase, params, stats, capsHash }`.
+   *
+   * - `phase`: `uninitialized | ramping | settled | degraded`
+   * - `params`: `{ concurrency, uploadWindow, downloadWindow, chunkSize,
+   *   downloadChunkSize, compressLevel }` — the parameters the engine is
+   *   currently tuned to
+   * - `stats`: `{ rttMs, mbps }` — EWMA request RTT and last-window
+   *   throughput of the most recent transfer
+   *
+   * `null` until the WASM engine is initialised.
+   * @returns {object|null}
+   */
+  tuneStatus() {
+    return this._engine ? this._engine.tune_state() : null;
+  }
+
   // ------------------------------------------------------------- resume store
 
   /**

package/package.json

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

@@ -34,8 +34,8 @@ export class LibfwClient {
     /**
      * Create an engine. `options` may include:
      * `{ concurrency, uploadWindow, downloadWindow, downloadChunkSize,
-     * compress, chunkSize, maxRetries, baseRetryDelayMs, maxRetryDelayMs,
-     * timeoutMs }`.
+     * compress, compressLevel, chunkSize, maxRetries, baseRetryDelayMs,
+     * maxRetryDelayMs, timeoutMs, autoTune, tuneTtlMs }`.
      */
     constructor(opts: any);
     /**
@@ -54,6 +54,11 @@ export class LibfwClient {
      * Install the JS callbacks object (required before any transfer).
      */
     set_callbacks(callbacks: any): void;
+    /**
+     * Install an `onTuning(phase, params, stats)` callback, invoked on
+     * every tuning state change (phase transitions and window evaluations).
+     */
+    set_tune_callback(cb: any): void;
     /**
      * Current state: `idle | downloading | uploading | paused | completed |
      * failed`.
@@ -63,6 +68,10 @@ export class LibfwClient {
      * Total bytes to transfer.
      */
     total_bytes(): number;
+    /**
+     * Snapshot the tuning engine: `{ phase, params, stats, capsHash }`.
+     */
+    tune_state(): any;
     /**
      * Upload the files reported by the JS `getFileList` callback.
      *
@@ -76,6 +85,8 @@ export class LibfwClient {
  */
 export function js_option_string(obj: any, key: string): string | undefined;
 
+export function start(): void;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
@@ -92,19 +103,23 @@ export interface InitOutput {
     readonly libfwclient_progress: (a: number) => number;
     readonly libfwclient_resume: (a: number) => void;
     readonly libfwclient_set_callbacks: (a: number, b: any) => void;
+    readonly libfwclient_set_tune_callback: (a: number, b: any) => void;
     readonly libfwclient_state: (a: number) => [number, number];
     readonly libfwclient_total_bytes: (a: number) => number;
+    readonly libfwclient_tune_state: (a: number) => any;
     readonly libfwclient_upload: (a: number, b: number, c: number, d: number, e: number) => any;
+    readonly start: () => void;
     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_cda36541fa15086d___features__gen_ProgressEvent__ProgressEvent______true_: (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;
     readonly __externref_table_alloc: () => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;
-    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
     readonly __externref_table_dealloc: (a: number) => void;
     readonly __wbindgen_start: () => void;
 }

package/pkg/libfw_client.js

@@ -77,8 +77,8 @@ export class LibfwClient {
     /**
      * Create an engine. `options` may include:
      * `{ concurrency, uploadWindow, downloadWindow, downloadChunkSize,
-     * compress, chunkSize, maxRetries, baseRetryDelayMs, maxRetryDelayMs,
-     * timeoutMs }`.
+     * compress, compressLevel, chunkSize, maxRetries, baseRetryDelayMs,
+     * maxRetryDelayMs, timeoutMs, autoTune, tuneTtlMs }`.
      * @param {any} opts
      */
     constructor(opts) {
@@ -114,6 +114,14 @@ export class LibfwClient {
     set_callbacks(callbacks) {
         wasm.libfwclient_set_callbacks(this.__wbg_ptr, callbacks);
     }
+    /**
+     * Install an `onTuning(phase, params, stats)` callback, invoked on
+     * every tuning state change (phase transitions and window evaluations).
+     * @param {any} cb
+     */
+    set_tune_callback(cb) {
+        wasm.libfwclient_set_tune_callback(this.__wbg_ptr, cb);
+    }
     /**
      * Current state: `idle | downloading | uploading | paused | completed |
      * failed`.
@@ -139,6 +147,14 @@ export class LibfwClient {
         const ret = wasm.libfwclient_total_bytes(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Snapshot the tuning engine: `{ phase, params, stats, capsHash }`.
+     * @returns {any}
+     */
+    tune_state() {
+        const ret = wasm.libfwclient_tune_state(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Upload the files reported by the JS `getFileList` callback.
      *
@@ -175,6 +191,10 @@ export function js_option_string(obj, key) {
     }
     return v2;
 }
+
+export function start() {
+    wasm.start();
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -242,6 +262,10 @@ function __wbg_get_imports() {
             const ret = arg0.body;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_call_44b7209e1e252e6a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = arg0.call(arg1, arg2, arg3, arg4);
+            return ret;
+        }, arguments); },
         __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.call(arg1, arg2);
             return ret;
@@ -253,6 +277,17 @@ function __wbg_get_imports() {
             const ret = encodeURIComponent(getStringFromWasm0(arg0, arg1));
             return ret;
         },
+        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
         __wbg_fetch_6ecc661950e58d49: function(arg0, arg1) {
             const ret = arg0.fetch(arg1);
             return ret;
@@ -261,6 +296,13 @@ function __wbg_get_imports() {
             const ret = Array.from(arg0);
             return ret;
         },
+        __wbg_getItem_b96269ddc16cf24a: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg1.getItem(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_getReader_7455d080fa48369b: function(arg0) {
             const ret = arg0.getReader();
             return ret;
@@ -322,10 +364,22 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_loaded_e4436631cb081781: function(arg0) {
+            const ret = arg0.loaded;
+            return ret;
+        },
+        __wbg_localStorage_5bf6ce3f8e51412a: function() { return handleError(function (arg0) {
+            const ret = arg0.localStorage;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        }, arguments); },
         __wbg_new_0d809930cd1354c6: function() { return handleError(function () {
             const ret = new Headers();
             return ret;
         }, arguments); },
+        __wbg_new_227d7c05414eb861: function() {
+            const ret = new Error();
+            return ret;
+        },
         __wbg_new_32b398fb48b6d94a: function() {
             const ret = new Array();
             return ret;
@@ -427,6 +481,9 @@ function __wbg_get_imports() {
             const ret = arg0.readyState;
             return ret;
         },
+        __wbg_removeItem_78e03a38da96e0ae: function() { return handleError(function (arg0, arg1, arg2) {
+            arg0.removeItem(getStringFromWasm0(arg1, arg2));
+        }, arguments); },
         __wbg_resolve_2191a4dfe481c25b: function(arg0) {
             const ret = Promise.resolve(arg0);
             return ret;
@@ -438,6 +495,9 @@ function __wbg_get_imports() {
             const ret = arg0.setInterval(arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_setItem_364a11cf21db9039: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.setItem(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
         __wbg_setRequestHeader_fe390ff50d349432: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             arg0.setRequestHeader(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
@@ -477,6 +537,13 @@ function __wbg_get_imports() {
         __wbg_set_onreadystatechange_14ce44725c7e0789: function(arg0, arg1) {
             arg0.onreadystatechange = arg1;
         },
+        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+            const ret = arg1.stack;
+            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_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -509,26 +576,35 @@ function __wbg_get_imports() {
             const ret = arg0.then(arg1);
             return ret;
         },
+        __wbg_total_21672ff1bd8d23ea: function(arg0) {
+            const ret = arg0.total;
+            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: 163, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 198, 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: [], shim_idx: 5, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("ProgressEvent")], shim_idx: 5, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_cda36541fa15086d___features__gen_ProgressEvent__ProgressEvent______true_);
+            return ret;
+        },
+        __wbindgen_cast_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 7, 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_0000000000000003: function(arg0) {
+        __wbindgen_cast_0000000000000004: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
@@ -553,6 +629,10 @@ function wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke_______true
     wasm.wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke_______true_(arg0, arg1);
 }
 
+function wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_cda36541fa15086d___features__gen_ProgressEvent__ProgressEvent______true_(arg0, arg1, arg2) {
+    wasm.wasm_bindgen_1e05ddb24c0b7df4___convert__closures_____invoke___web_sys_cda36541fa15086d___features__gen_ProgressEvent__ProgressEvent______true_(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]) {

package/pkg/libfw_client_bg.wasm.d.ts

@@ -13,18 +13,22 @@ export const libfwclient_pause: (a: number) => void;
 export const libfwclient_progress: (a: number) => number;
 export const libfwclient_resume: (a: number) => void;
 export const libfwclient_set_callbacks: (a: number, b: any) => void;
+export const libfwclient_set_tune_callback: (a: number, b: any) => void;
 export const libfwclient_state: (a: number) => [number, number];
 export const libfwclient_total_bytes: (a: number) => number;
+export const libfwclient_tune_state: (a: number) => any;
 export const libfwclient_upload: (a: number, b: number, c: number, d: number, e: number) => any;
+export const start: () => void;
 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_cda36541fa15086d___features__gen_ProgressEvent__ProgressEvent______true_: (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;
 export const __externref_table_alloc: () => number;
 export const __wbindgen_externrefs: WebAssembly.Table;
-export const __wbindgen_destroy_closure: (a: number, b: number) => void;
 export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_destroy_closure: (a: number, b: number) => void;
 export const __externref_table_dealloc: (a: number) => void;
 export const __wbindgen_start: () => 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.3.1",
+  "version": "0.3.4",
   "license": "MIT",
   "repository": {
     "type": "git",