abysshub 0.1.1-dev.4 → 0.1.1-dev.6

package/README.md

@@ -103,7 +103,7 @@ const paths = await run.save("output"); // ["output/charts/a.png", "output/outpu
 - **A string passes through** as an `https` URL or an upload id. A multi-file Field takes a list, which may mix all three kinds.
 - **Before the press,** each file is uploaded with `POST /v1/widgets/{widget}/uploads`, then sent to storage, in parallel, and its id goes in the input. An upload refusal (`held_input_*`) raises before any press. A retried press reuses the ids; it never uploads again.
 - **`await run.save(dir)`** writes every output file under `dir` at its `path`, making folders, and answers the paths it wrote.
-- **Each of `run.output_files`** has `await f.save(path)` and `await f.read()`, which answers a `Uint8Array`. An expired URL is refreshed once, by reading the run again with `GET /v1/runs/{id}`.
+- **Each of `run.output_files`** has `await f.save(path)` and `await f.read()`, which answers a `Uint8Array`. An expired URL is refreshed once, by reading the run again with `GET /v1/runs/{id}`. A file of 64 MiB or more downloads as 16 parallel byte ranges of its one URL.
 
 ## Errors
 

package/dist/run.d.ts

@@ -1,6 +1,10 @@
 import type { RunData, RunError, RunFileData, RunStatus } from "./types.js";
 /** Reads the run again with `GET /v1/runs/{id}`. */
 export type Reread = () => Promise<RunData>;
+/** A file this many bytes or larger downloads as parallel byte ranges: 64 MiB. */
+export declare const RANGED_FROM: number;
+/** How many parallel byte ranges a large file downloads as. */
+export declare const RANGES = 16;
 /** A run, with `/v1`'s names. */
 export declare class Run {
     #private;
@@ -26,7 +30,12 @@ export declare class RunFile {
     content_type: string;
     url: string;
     constructor(data: RunFileData, refresh: () => Promise<void>);
-    /** Downloads the file. An expired `url` is refreshed once, by reading the run again. */
+    /**
+     * Downloads the file. An expired `url` is refreshed once, by reading the run again. A
+     * file of `RANGED_FROM` bytes or more downloads as `RANGES` parallel byte ranges of its
+     * one `url`: the first goes alone, and once it answers 206 the others go together. A
+     * storage that ignores `Range` answers the whole file to the first, which is kept.
+     */
     read(): Promise<Uint8Array>;
     /** Downloads the file to `path`, making its folders, and answers `path`. */
     save(path: string): Promise<string>;

package/dist/run.js

@@ -1,5 +1,19 @@
 import { AbyssError } from "./error.js";
 import { nodeFS, nodePath } from "./node.js";
+/** A file this many bytes or larger downloads as parallel byte ranges: 64 MiB. */
+export const RANGED_FROM = 64 * 1024 * 1024;
+/** How many parallel byte ranges a large file downloads as. */
+export const RANGES = 16;
+/** The byte ranges a file of `size` bytes downloads as, or null when it downloads whole. */
+function ranges(size) {
+    if (size < RANGED_FROM)
+        return null;
+    const step = Math.ceil(size / RANGES);
+    const parts = [];
+    for (let first = 0; first < size; first += step)
+        parts.push([first, Math.min(first + step, size) - 1]);
+    return parts;
+}
 /** A run, with `/v1`'s names. */
 export class Run {
     id;
@@ -67,23 +81,78 @@ export class RunFile {
         this.url = data.url;
         this.#refresh = refresh;
     }
-    /** Downloads the file. An expired `url` is refreshed once, by reading the run again. */
+    /**
+     * Downloads the file. An expired `url` is refreshed once, by reading the run again. A
+     * file of `RANGED_FROM` bytes or more downloads as `RANGES` parallel byte ranges of its
+     * one `url`: the first goes alone, and once it answers 206 the others go together. A
+     * storage that ignores `Range` answers the whole file to the first, which is kept.
+     */
     async read() {
-        let response = await fetch(this.url);
-        if (response.status === 403) {
-            await response.body?.cancel();
-            await this.#refresh();
-            response = await fetch(this.url);
+        const parts = ranges(this.size);
+        const stop = new AbortController();
+        try {
+            let response = await this.#get(parts?.[0], stop.signal);
+            if (response.status === 403) {
+                await response.body?.cancel();
+                await this.#refresh();
+                response = await this.#get(parts?.[0], stop.signal);
+            }
+            if (!response.ok) {
+                await response.body?.cancel();
+                throw this.#answered(response.status);
+            }
+            if (!parts || response.status !== 206)
+                return new Uint8Array(await response.arrayBuffer());
+            const first = response;
+            const reads = parts.map(async (part, index) => this.#part(index === 0 ? first : await this.#get(part, stop.signal), part));
+            try {
+                const bytes = new Uint8Array(this.size);
+                for (const [index, part] of (await Promise.all(reads)).entries())
+                    bytes.set(part, parts[index][0]);
+                return bytes;
+            }
+            catch (error) {
+                stop.abort();
+                await Promise.allSettled(reads);
+                throw error;
+            }
         }
-        if (!response.ok) {
+        catch (error) {
+            if (error instanceof AbyssError)
+                throw error;
+            throw new AbyssError({
+                code: "connection_error",
+                message: "The connection to storage dropped during a download.",
+                cause: error,
+            });
+        }
+    }
+    /** Fetches the file from storage, without the API key: whole, or the byte range `part`. */
+    #get(part, signal) {
+        return fetch(this.url, { signal, ...(part ? { headers: { Range: `bytes=${part[0]}-${part[1]}` } } : {}) });
+    }
+    /** The bytes of one range, which must answer 206 with exactly the range's length. */
+    async #part(response, [first, last]) {
+        if (response.status !== 206) {
             await response.body?.cancel();
+            throw this.#answered(response.status);
+        }
+        const bytes = new Uint8Array(await response.arrayBuffer());
+        if (bytes.length !== last - first + 1) {
             throw new AbyssError({
                 code: "unexpected_response",
-                message: `The download of ${this.path} answered ${response.status}.`,
+                message: `The download of ${this.path} answered ${bytes.length} bytes for the range ${first}-${last}.`,
                 status: response.status,
             });
         }
-        return new Uint8Array(await response.arrayBuffer());
+        return bytes;
+    }
+    #answered(status) {
+        return new AbyssError({
+            code: "unexpected_response",
+            message: `The download of ${this.path} answered ${status}.`,
+            status,
+        });
     }
     /** Downloads the file to `path`, making its folders, and answers `path`. */
     async save(path) {

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** This package's version, written from package.json by scripts/version.js at build. */
-export declare const VERSION = "0.1.1-dev.4";
+export declare const VERSION = "0.1.1-dev.6";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** This package's version, written from package.json by scripts/version.js at build. */
-export const VERSION = "0.1.1-dev.4";
+export const VERSION = "0.1.1-dev.6";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abysshub",
-  "version": "0.1.1-dev.4",
+  "version": "0.1.1-dev.6",
   "description": "The official JavaScript library for the Abyss API.",
   "license": "MIT",
   "homepage": "https://github.com/Abysshub/abysshub-sdk/tree/main/js#readme",