@lat-murmeldjur/weeb_3 0.0.332001 → 0.0.334001

package/package.json

@@ -2,7 +2,7 @@
   "name": "@lat-murmeldjur/weeb_3",
   "type": "module",
   "description": "A Swarm client for browsers",
-  "version": "0.0.332001",
+  "version": "0.0.334001",
   "license": "MIT",
   "repository": {
     "type": "git",

package/service.js

@@ -10,10 +10,14 @@ const RAW_ROUTE_KINDS = [
 ];
 const FETCH_TIMEOUT_MS = 240000;
 const SERVICE_WORKER_MARKER = "forwarder-default20";
-const SERVICE_WORKER_PROTOCOL = 5;
+const SERVICE_WORKER_PROTOCOL = 8;
 const MIB_BYTES = 1024 * 1024;
 const STREAM_STORAGE_WINDOW_BYTES = MIB_BYTES / 2;
 const STREAM_LOOKAHEAD_CHUNKS = 8;
+const HLS_STREAM_LOOKAHEAD_CHUNKS = 4;
+const HLS_STREAM_READY_ADMISSION_THRESHOLD = HLS_STREAM_LOOKAHEAD_CHUNKS - 1;
+const HLS_STREAM_MAX_OUTSTANDING =
+  HLS_STREAM_LOOKAHEAD_CHUNKS + HLS_STREAM_READY_ADMISSION_THRESHOLD - 1;
 const HLS_REQUEST_FLIGHTS = new Map();
 const CLIENT_RUNTIME_PROBES = new Map();
 const CLIENT_RUNTIME_PROBE_TIMEOUT_MS = 1_500;
@@ -604,13 +608,14 @@ function responseHeaders(headerRows) {
   return headers;
 }
 
-function requestRustRange(clients, url, start, end, networkId) {
+function requestRustRange(clients, url, start, end, networkId, streamToken = "") {
   return messageFirstClient(clients, {
     type: "WEEB3_FETCH_REQUEST",
     url,
     method: "GET",
     range: `bytes=${start}-${end}`,
-    networkId
+    networkId,
+    streamToken
   }).then((response) => {
     if (!response || !response.ok) {
       return response || { ok: false, status: 503, error: "empty weeb-3 range response" };
@@ -630,56 +635,237 @@ function requestRustRange(clients, url, start, end, networkId) {
   });
 }
 
-function createRustRangeStream(clients, url, size, networkId, stagedStart) {
+function parseCriticalPrefixWindows(value, size) {
+  if (!/^[1-9][0-9]*$/.test(value || "") || !Number.isSafeInteger(size) || size <= 0) {
+    return null;
+  }
+  const requested = Number(value);
+  const total = Math.ceil(size / STREAM_STORAGE_WINDOW_BYTES);
+  return Number.isSafeInteger(requested) && requested > 0
+    ? Math.min(requested, total)
+    : null;
+}
+
+function createRustRangeStream(
+  clients,
+  url,
+  size,
+  networkId,
+  stagedStart,
+  streamToken = "",
+  criticalPrefixWindows = null
+) {
   let position = 0;
   let schedulePosition = 0;
-  let stagedWindows = stagedStart ? 4 : 0;
+  const lookahead = stagedStart ? HLS_STREAM_LOOKAHEAD_CHUNKS : STREAM_LOOKAHEAD_CHUNKS;
+  const managedPrefixEnd = stagedStart && Number.isSafeInteger(criticalPrefixWindows)
+    ? Math.min(size, criticalPrefixWindows * STREAM_STORAGE_WINDOW_BYTES)
+    : 0;
+  let schedulingAdmissionOpen = true;
+  let lookaheadAdmitted = !stagedStart;
+  let knownRangeFailure = false;
   const scheduled = new Map();
+  const activeRequests = new Map();
+  const retainedResponses = new Map();
+
+  const nextRangeBounds = () => {
+    if (!schedulingAdmissionOpen || schedulePosition >= size) {
+      return null;
+    }
+
+    const start = schedulePosition;
+    const end = Math.min(start + STREAM_STORAGE_WINDOW_BYTES - 1, size - 1);
+    schedulePosition = end + 1;
+    return { start, end };
+  };
+
+  const admitOrdinaryRange = () => {
+    const range = nextRangeBounds();
+    if (!range) {
+      return null;
+    }
+    const { start, end } = range;
+    const request = requestRustRange(clients, url, start, end, networkId, streamToken);
+    scheduled.set(start, request);
+    return { start, request };
+  };
+
+  const admitStagedRange = () => {
+    const range = nextRangeBounds();
+    if (!range) {
+      return null;
+    }
+    const { start, end } = range;
+    const pending = requestRustRange(clients, url, start, end, networkId, streamToken);
+    let request;
+    request = pending.then(
+      (response) => {
+        activeRequests.delete(start);
+        const result = { response };
+        retainedResponses.set(start, result);
+        if (!response || !response.ok) {
+          knownRangeFailure = true;
+        } else if (schedulingAdmissionOpen && position >= managedPrefixEnd) {
+          scheduleMore();
+        }
+        return result;
+      },
+      (error) => {
+        activeRequests.delete(start);
+        const result = { error };
+        retainedResponses.set(start, result);
+        knownRangeFailure = true;
+        return result;
+      }
+    );
+    activeRequests.set(start, request);
+    return { start, request };
+  };
 
   const scheduleMore = () => {
-    const lookahead = stagedWindows > 0 ? 4 : STREAM_LOOKAHEAD_CHUNKS;
-    while (schedulePosition < size && scheduled.size < lookahead) {
-      const start = schedulePosition;
-      const end = Math.min(start + STREAM_STORAGE_WINDOW_BYTES - 1, size - 1);
-      scheduled.set(start, requestRustRange(clients, url, start, end, networkId));
-      schedulePosition = end + 1;
+    if (!schedulingAdmissionOpen || !lookaheadAdmitted || knownRangeFailure) {
+      return;
+    }
+
+    if (!stagedStart) {
+      while (schedulePosition < size && scheduled.size < lookahead) {
+        if (!admitOrdinaryRange()) {
+          break;
+        }
+      }
+      return;
+    }
+
+    if (position < managedPrefixEnd) {
+      if (activeRequests.size + retainedResponses.size < 1) {
+        admitStagedRange();
+      }
+      return;
+    }
+
+    while (
+      schedulePosition < size
+      && activeRequests.size < HLS_STREAM_LOOKAHEAD_CHUNKS
+      && retainedResponses.size < HLS_STREAM_READY_ADMISSION_THRESHOLD
+      && activeRequests.size + retainedResponses.size < HLS_STREAM_MAX_OUTSTANDING
+    ) {
+      if (!admitStagedRange()) {
+        break;
+      }
+    }
+  };
+
+  const drainScheduledRanges = () => {
+    const dispatched = stagedStart
+      ? Array.from(activeRequests.values())
+      : Array.from(scheduled.values());
+    return Promise.allSettled(dispatched).then(() => {
+      activeRequests.clear();
+      retainedResponses.clear();
+      scheduled.clear();
+    });
+  };
+
+  const closeAdmission = () => {
+    schedulingAdmissionOpen = false;
+    lookaheadAdmitted = false;
+  };
+
+  const failStream = async (controller, error) => {
+    if (!schedulingAdmissionOpen) {
+      return;
     }
+    closeAdmission();
+    controller.error(error);
+    await drainScheduledRanges();
   };
 
   return new ReadableStream({
     async pull(controller) {
       try {
         if (position >= size) {
+          closeAdmission();
           controller.close();
+          await drainScheduledRanges();
           return;
         }
 
-        scheduleMore();
+        if (lookaheadAdmitted) {
+          scheduleMore();
+        }
         const start = Math.floor(position / STREAM_STORAGE_WINDOW_BYTES) * STREAM_STORAGE_WINDOW_BYTES;
-        const request = scheduled.get(start);
-        if (!request) {
-          controller.error(new Error("weeb-3 stream window was not scheduled"));
-          return;
+        let response;
+        if (stagedStart) {
+          let result = retainedResponses.get(start);
+          if (!result) {
+            let request = activeRequests.get(start);
+            if (!request) {
+              const foreground = admitStagedRange();
+              if (!foreground || foreground.start !== start) {
+                await failStream(
+                  controller,
+                  new Error("weeb-3 foreground stream window was not admitted")
+                );
+                return;
+              }
+              request = foreground.request;
+            }
+            result = await request;
+          }
+          retainedResponses.delete(start);
+          if (!schedulingAdmissionOpen) {
+            return;
+          }
+          if (result.error) {
+            await failStream(
+              controller,
+              result.error instanceof Error ? result.error : new Error(String(result.error))
+            );
+            return;
+          }
+          response = result.response;
+        } else {
+          let request = scheduled.get(start);
+          if (!request) {
+            const foreground = admitOrdinaryRange();
+            if (!foreground || foreground.start !== start) {
+              await failStream(
+                controller,
+                new Error("weeb-3 foreground stream window was not admitted")
+              );
+              return;
+            }
+            request = foreground.request;
+          }
+          response = await request;
+          scheduled.delete(start);
         }
 
-        const response = await request;
-        scheduled.delete(start);
+        if (!schedulingAdmissionOpen) {
+          return;
+        }
         if (!response || !response.ok) {
-          controller.error(new Error(response && response.error ? response.error : "weeb-3 range request failed"));
+          await failStream(
+            controller,
+            new Error(response && response.error ? response.error : "weeb-3 range request failed")
+          );
           return;
         }
 
         const body = toUint8Array(response.body);
         position = start + body.byteLength;
         controller.enqueue(body);
-        stagedWindows = Math.max(0, stagedWindows - 1);
+        lookaheadAdmitted = true;
         scheduleMore();
       } catch (error) {
-        controller.error(error);
+        if (schedulingAdmissionOpen) {
+          await failStream(controller, error);
+        }
       }
     },
     cancel() {
-      scheduled.clear();
+      closeAdmission();
+      return drainScheduledRanges();
     }
   });
 }
@@ -715,7 +901,22 @@ async function forwardRequestToRust(request, event) {
     if (response.stream && request.method !== "HEAD") {
       const size = Number(headers.get("Content-Length") || "0");
       const stagedStart = headers.get("X-Weeb3-Stream-Start") === "1";
-      return new Response(createRustRangeStream(clients, request.url, size, networkId, stagedStart), {
+      const streamToken = headers.get("X-Weeb3-Stream-Token") || "";
+      const criticalPrefixWindows = stagedStart
+        ? parseCriticalPrefixWindows(
+            headers.get("X-Weeb3-HLS-Critical-Prefix-Windows"),
+            size
+          )
+        : null;
+      return new Response(createRustRangeStream(
+        clients,
+        request.url,
+        size,
+        networkId,
+        stagedStart,
+        streamToken,
+        criticalPrefixWindows
+      ), {
         status,
         headers
       });

package/weeb_3.d.ts

@@ -84,11 +84,12 @@ export interface InitOutput {
     readonly __wbg_requestarguments_free: (a: number, b: number) => void;
     readonly requestarguments_method: (a: number, b: number) => void;
     readonly requestarguments_params: (a: number) => number;
-    readonly __wasm_bindgen_func_elem_591: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_1589: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_1591: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_3752: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_3678: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_649: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_1753: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_1755: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_4088: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_1758: (a: number, b: number) => number;
+    readonly __wasm_bindgen_func_elem_4014: (a: number, b: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/weeb_3.js

@@ -619,6 +619,10 @@ function __wbg_get_imports() {
             const ret = decodeURIComponent(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_deleteProperty_8c8a05da881fea59: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.deleteProperty(getObject(arg0), getObject(arg1));
+            return ret;
+        }, arguments); },
         __wbg_destroy_91b983e1d85d5306: function() { return handleError(function (arg0) {
             getObject(arg0).destroy();
         }, arguments); },
@@ -634,6 +638,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).done;
             return ret;
         },
+        __wbg_duration_56d63063c1dcc6d7: function(arg0) {
+            const ret = getObject(arg0).duration;
+            return ret;
+        },
         __wbg_encodeURIComponent_46e9eafddd38cb39: function(arg0, arg1) {
             const ret = encodeURIComponent(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
@@ -1049,6 +1057,10 @@ function __wbg_get_imports() {
             const ret = Number.isSafeInteger(getObject(arg0));
             return ret;
         },
+        __wbg_is_f29129f676e5410c: function(arg0, arg1) {
+            const ret = Object.is(getObject(arg0), getObject(arg1));
+            return ret;
+        },
         __wbg_item_c79c0bccbcfd8735: function(arg0, arg1) {
             const ret = getObject(arg0).item(arg1 >>> 0);
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -1182,7 +1194,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_1589(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_1753(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1305,6 +1317,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).parentNode;
             return isLikeNone(ret) ? 0 : addHeapObject(ret);
         },
+        __wbg_parse_708461a1feddfb38: function() { return handleError(function (arg0, arg1) {
+            const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_pathname_b2267fae358b49a7: function() { return handleError(function (arg0, arg1) {
             const ret = getObject(arg1).pathname;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -1406,6 +1422,9 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).register(getStringFromWasm0(arg1, arg2), getObject(arg3));
             return addHeapObject(ret);
         },
+        __wbg_reload_c8ca3f3b07f9e534: function() { return handleError(function (arg0) {
+            getObject(arg0).reload();
+        }, arguments); },
         __wbg_removeAttribute_87259aab06d9f286: function() { return handleError(function (arg0, arg1, arg2) {
             getObject(arg0).removeAttribute(getStringFromWasm0(arg1, arg2));
         }, arguments); },
@@ -1506,6 +1525,9 @@ function __wbg_get_imports() {
         __wbg_set_auto_increment_5ef604f4f193fa58: function(arg0, arg1) {
             getObject(arg0).autoIncrement = arg1 !== 0;
         },
+        __wbg_set_autoplay_a63d23ab32fd1826: function(arg0, arg1) {
+            getObject(arg0).autoplay = arg1 !== 0;
+        },
         __wbg_set_binaryType_5bbf62e9f705dc1a: function(arg0, arg1) {
             getObject(arg0).binaryType = __wbindgen_enum_BinaryType[arg1];
         },
@@ -1593,6 +1615,9 @@ function __wbg_get_imports() {
         __wbg_set_onupgradeneeded_c887b74722b6ce77: function(arg0, arg1) {
             getObject(arg0).onupgradeneeded = getObject(arg1);
         },
+        __wbg_set_preload_8046ead18b4d246a: function(arg0, arg1, arg2) {
+            getObject(arg0).preload = getStringFromWasm0(arg1, arg2);
+        },
         __wbg_set_scope_c18e6f8045aa3843: function(arg0, arg1, arg2) {
             getObject(arg0).scope = getStringFromWasm0(arg1, arg2);
         },
@@ -1762,66 +1787,71 @@ function __wbg_get_imports() {
             console.warn(getObject(arg0));
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [Externref, Externref], shim_idx: 21, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_591, __wasm_bindgen_func_elem_1589);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [Externref, Externref], shim_idx: 22, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_649, __wasm_bindgen_func_elem_1753);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [Externref], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_591, __wasm_bindgen_func_elem_3752);
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_649, __wasm_bindgen_func_elem_4088);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_591, __wasm_bindgen_func_elem_3752);
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_649, __wasm_bindgen_func_elem_4088);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [NamedExternref("Event")], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_591, __wasm_bindgen_func_elem_3752);
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_649, __wasm_bindgen_func_elem_4088);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 23, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_591, __wasm_bindgen_func_elem_1591);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [NamedExternref("IDBVersionChangeEvent")], shim_idx: 24, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_649, __wasm_bindgen_func_elem_1755);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000006: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_591, __wasm_bindgen_func_elem_3752);
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_649, __wasm_bindgen_func_elem_4088);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000007: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [], shim_idx: 99, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_591, __wasm_bindgen_func_elem_3678);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [], shim_idx: 101, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_649, __wasm_bindgen_func_elem_4014);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3, function: Function { arguments: [], shim_idx: 26, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_649, __wasm_bindgen_func_elem_1758);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000008: function(arg0) {
+        __wbindgen_cast_0000000000000009: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_0000000000000009: function(arg0) {
+        __wbindgen_cast_000000000000000a: function(arg0) {
             // Cast intrinsic for `I64 -> Externref`.
             const ret = arg0;
             return addHeapObject(ret);
         },
-        __wbindgen_cast_000000000000000a: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000b: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_000000000000000b: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000c: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_000000000000000c: function(arg0) {
+        __wbindgen_cast_000000000000000d: function(arg0) {
             // Cast intrinsic for `U64 -> Externref`.
             const ret = BigInt.asUintN(64, arg0);
             return addHeapObject(ret);
         },
-        __wbindgen_cast_000000000000000d: function(arg0, arg1) {
+        __wbindgen_cast_000000000000000e: function(arg0, arg1) {
             var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
             wasm.__wbindgen_export4(arg0, arg1 * 1, 1);
             // Cast intrinsic for `Vector(U8) -> Externref`.
@@ -1846,22 +1876,27 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_3678(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_3678(arg0, arg1);
+function __wasm_bindgen_func_elem_4014(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_4014(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_1758(arg0, arg1) {
+    const ret = wasm.__wasm_bindgen_func_elem_1758(arg0, arg1);
+    return takeObject(ret);
 }
 
-function __wasm_bindgen_func_elem_3752(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_3752(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_4088(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_4088(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_1589(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1589(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_1753(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1753(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
-function __wasm_bindgen_func_elem_1591(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_1755(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_1591(retptr, arg0, arg1, addHeapObject(arg2));
+        wasm.__wasm_bindgen_func_elem_1755(retptr, arg0, arg1, addHeapObject(arg2));
         var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
         var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
         if (r1) {

package/weeb_3_bg.wasm.d.ts

@@ -32,11 +32,12 @@ export const weeb3no103_uploadWithRedundancy: (a: number, b: number, c: number,
 export const __wbg_requestarguments_free: (a: number, b: number) => void;
 export const requestarguments_method: (a: number, b: number) => void;
 export const requestarguments_params: (a: number) => number;
-export const __wasm_bindgen_func_elem_591: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_1589: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_1591: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_3752: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_3678: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_649: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_1753: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_1755: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_4088: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_1758: (a: number, b: number) => number;
+export const __wasm_bindgen_func_elem_4014: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;