Tauri fs plugin UI-blocking

[CaseSens]

I'm currently making a file server, and the FileHandle.read() function blocks the UI's thread. Here's what the uploadChunk() function looks like in zustand:

Code

uploadChunkLoop: async (file: UploadItemStatus) => {
        // ....
        const file_handle: FileHandle = await open(file.path, {
          read: true,
          write: false,
        });
        
        // ....

        try {
          while (next_offset < size) {
            const currentFileState = get().files.find((f) => f.path === path);

            const start = next_offset;
            const endExclusive = Math.min(start + DEFAULT_CHUNK_SIZE, size);
            const length = endExclusive - start;

            await file_handle.seek(start, SeekMode.Start);
            const bytes = new Uint8Array(length);

            await file_handle.read(bytes);

            console.log("bytes length: ", bytes.byteLength);

            // Upload chunk
            const res = await putChunk({
              upload_id: currentFileState.init_details!.upload_id,
              start,
              end: endExclusive - 1,
              total: size,
              bytes: bytes,
              signal: currentFileState.abortController!.signal,
              token: user?.token,
            });

            if (!res.ok) {
              throw new Error(`Chunk upload failed: ${await res.text()}`);
            }

            const data: UploadChunkResponse = await res.json();
            next_offset = data.next_offset;
            
            }
            
            // .....

          finalize(file.init_details.upload_id, user?.token);
        } catch (err) {
            // .....
        } finally {
          await file_handle.close();
        }
      },

Question

Are there any clever workarounds for the UI blocking await read() function? Or is it a logic thing where I should change the code to no longer need to await file.read()? Currently the DEFAULT_CHUNK_SIZE is set to 4MB and it seems almost smooth, but it leads to a bunch of network calls for larger files and through testing, setting it to larger chunk sizes increases performance by quite a bit, although introduces freezing.