@koolbase/core 12.14.0 → 12.16.0

package/dist/esm/functions.js

@@ -1,4 +1,4 @@
-import { koolbaseFetch } from './network.js';
+import { sessionFetch } from './network.js';
 import { functionInvokeError } from './function-errors.js';
 import { KoolbaseUnauthenticatedError } from './errors.js';
 import { FunctionRuntime, } from './types.js';
@@ -11,7 +11,7 @@ export class KoolbaseFunctions {
     // ─── Deploy ────────────────────────────────────────────────────────────────
     async deploy(options) {
         const runtime = options.runtime ?? FunctionRuntime.Deno;
-        const res = await koolbaseFetch(`${this.config.baseUrl}/v1/sdk/functions/deploy`, {
+        const res = await sessionFetch(`${this.config.baseUrl}/v1/sdk/functions/deploy`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -55,7 +55,7 @@ export class KoolbaseFunctions {
         if (userToken) {
             headers['Authorization'] = `Bearer ${userToken}`;
         }
-        const res = await koolbaseFetch(`${this.config.baseUrl}/v1/sdk/functions/${name}`, {
+        const res = await sessionFetch(`${this.config.baseUrl}/v1/sdk/functions/${name}`, {
             method: 'POST',
             headers,
             body: JSON.stringify({ body: body ?? {} }),

package/dist/esm/index.d.ts

@@ -20,6 +20,9 @@ export { KoolbaseRealtime } from './realtime.js';
 export { KoolbaseConnectivity } from './connectivity.js';
 export type { ConnectivityState } from './connectivity.js';
 export { KoolbaseStorage } from './storage.js';
+export { KoolbaseUploadTask } from './storage-transfer.js';
+export type { KoolbaseUploadProgress, KoolbaseUploadState } from './storage-transfer.js';
+export type { KoolbaseFileInfo, KoolbaseFilePage, KoolbaseFileSort, ListFilesOptions } from './storage-files.js';
 export { KoolbaseAnalytics, disabledAnalytics } from './analytics.js';
 export { KoolbaseFiscal, KoolbaseFiscalError, decodeFiscalResponse, isFiscalized, isPending } from './fiscal.js';
 export type { FiscalIntentResult, FiscalStatus } from './fiscal.js';

package/dist/esm/index.js

@@ -22,6 +22,7 @@ export { KoolbaseFunctions } from './functions.js';
 export { KoolbaseRealtime } from './realtime.js';
 export { KoolbaseConnectivity } from './connectivity.js';
 export { KoolbaseStorage } from './storage.js';
+export { KoolbaseUploadTask } from './storage-transfer.js';
 export { KoolbaseAnalytics, disabledAnalytics } from './analytics.js';
 export { KoolbaseFiscal, KoolbaseFiscalError, decodeFiscalResponse, isFiscalized, isPending } from './fiscal.js';
 export { KoolbaseMessaging } from './messaging.js';

package/dist/esm/network.d.ts

@@ -19,3 +19,17 @@ export declare class KoolbaseNetworkError extends TypeError {
 }
 /** fetch, with network failures turned into a KoolbaseNetworkError. */
 export declare function koolbaseFetch(input: string, init?: RequestInit): Promise<Response>;
+type Renewal = (refusedToken: string) => Promise<string | null>;
+/** Installed by Koolbase.initialize: renews the session a request was refused with. */
+export declare function setSessionRenewal(fn: Renewal | null): void;
+/**
+ * koolbaseFetch for a data request. A request refused as unauthenticated
+ * (401) while carrying the signed-in person's token is the session needing
+ * renewal, not ending: the access token expired early, the clock is off, or
+ * another tab renewed it. The session is renewed once and the request sent
+ * again with the new token, so the caller never sees the first refusal.
+ * Only when renewal is refused does the 401 reach the caller, and with it the
+ * client's onSessionExpired, which ends the session.
+ */
+export declare function sessionFetch(input: string, init?: RequestInit): Promise<Response>;
+export {};

package/dist/esm/network.js

@@ -47,3 +47,61 @@ export async function koolbaseFetch(input, init) {
         throw new KoolbaseNetworkError(input, e);
     }
 }
+let renewal = null;
+/** Installed by Koolbase.initialize: renews the session a request was refused with. */
+export function setSessionRenewal(fn) {
+    renewal = fn;
+}
+function headerOf(headers, name) {
+    if (!headers)
+        return undefined;
+    if (typeof headers.get === 'function')
+        return headers.get(name) ?? undefined;
+    if (Array.isArray(headers))
+        return headers.find(([k]) => k.toLowerCase() === name.toLowerCase())?.[1];
+    const rec = headers;
+    const key = Object.keys(rec).find((k) => k.toLowerCase() === name.toLowerCase());
+    return key ? rec[key] : undefined;
+}
+function withHeader(headers, name, value) {
+    const out = {};
+    if (headers && typeof headers.forEach === 'function' && !Array.isArray(headers)) {
+        headers.forEach((v, k) => { out[k] = v; });
+    }
+    else if (Array.isArray(headers)) {
+        for (const [k, v] of headers)
+            out[k] = v;
+    }
+    else if (headers) {
+        Object.assign(out, headers);
+    }
+    for (const k of Object.keys(out))
+        if (k.toLowerCase() === name.toLowerCase())
+            delete out[k];
+    out[name] = value;
+    return out;
+}
+/**
+ * koolbaseFetch for a data request. A request refused as unauthenticated
+ * (401) while carrying the signed-in person's token is the session needing
+ * renewal, not ending: the access token expired early, the clock is off, or
+ * another tab renewed it. The session is renewed once and the request sent
+ * again with the new token, so the caller never sees the first refusal.
+ * Only when renewal is refused does the 401 reach the caller, and with it the
+ * client's onSessionExpired, which ends the session.
+ */
+export async function sessionFetch(input, init) {
+    const res = await koolbaseFetch(input, init);
+    if (res.status !== 401 || !renewal)
+        return res;
+    const auth = headerOf(init?.headers, 'Authorization');
+    if (!auth || !auth.startsWith('Bearer '))
+        return res;
+    // Only a body that can be sent twice. Data requests send JSON text.
+    if (init?.body !== undefined && init.body !== null && typeof init.body !== 'string')
+        return res;
+    const fresh = await renewal(auth.slice('Bearer '.length));
+    if (!fresh)
+        return res;
+    return koolbaseFetch(input, { ...init, headers: withHeader(init?.headers, 'Authorization', `Bearer ${fresh}`) });
+}

package/dist/esm/storage-errors.d.ts

@@ -187,6 +187,45 @@ export declare class KoolbaseStorageMetadataInvalidError extends KoolbaseStorage
     detail?: string;
     constructor(message?: string, detail?: string);
 }
+/**
+ * An upload that was cancelled -- by `KoolbaseUploadTask.cancel()` or the
+ * upload's `signal` -- before the server began checking it. Nothing was
+ * stored. Code: `upload_cancelled`.
+ */
+export declare class KoolbaseUploadCancelledError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
+/**
+ * The confirm named an upload the server does not have: it expired, was
+ * confirmed already, or belongs to someone else. Upload the file again.
+ * Code: `upload_not_found`.
+ */
+export declare class KoolbaseUploadNotFoundError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
+/**
+ * The bucket is busy with other changes (a large move, many uploads at
+ * once). Nothing was changed; retry shortly. Code: `bucket_busy`.
+ */
+export declare class KoolbaseStorageBusyError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
+/**
+ * A listing's cursor was not one this listing issued -- made up, or from a
+ * listing with another sort or order. Start again from the first page.
+ * Code: `invalid_cursor`.
+ */
+export declare class KoolbaseStorageInvalidCursorError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
+/**
+ * The bucket's rules allow this only to someone signed in, and nobody is.
+ * Not a session that ended: the SDK's session is left alone. Code:
+ * `sign_in_required`.
+ */
+export declare class KoolbaseStorageSignInRequiredError extends KoolbaseStorageError {
+    constructor(message?: string);
+}
 /**
  * Maps a non-2xx storage-layer response to a typed
  * {@link KoolbaseStorageError}, preferring the server's stable `code` and

package/dist/esm/storage-errors.js

@@ -234,6 +234,65 @@ export class KoolbaseStorageMetadataInvalidError extends KoolbaseStorageError {
         Object.setPrototypeOf(this, KoolbaseStorageMetadataInvalidError.prototype);
     }
 }
+/**
+ * An upload that was cancelled -- by `KoolbaseUploadTask.cancel()` or the
+ * upload's `signal` -- before the server began checking it. Nothing was
+ * stored. Code: `upload_cancelled`.
+ */
+export class KoolbaseUploadCancelledError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'The upload was cancelled', 'upload_cancelled');
+        this.name = 'KoolbaseUploadCancelledError';
+        Object.setPrototypeOf(this, KoolbaseUploadCancelledError.prototype);
+    }
+}
+/**
+ * The confirm named an upload the server does not have: it expired, was
+ * confirmed already, or belongs to someone else. Upload the file again.
+ * Code: `upload_not_found`.
+ */
+export class KoolbaseUploadNotFoundError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'This upload was not found -- please upload the file again', 'upload_not_found');
+        this.name = 'KoolbaseUploadNotFoundError';
+        Object.setPrototypeOf(this, KoolbaseUploadNotFoundError.prototype);
+    }
+}
+/**
+ * The bucket is busy with other changes (a large move, many uploads at
+ * once). Nothing was changed; retry shortly. Code: `bucket_busy`.
+ */
+export class KoolbaseStorageBusyError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'The bucket is busy -- try again shortly', 'bucket_busy');
+        this.name = 'KoolbaseStorageBusyError';
+        Object.setPrototypeOf(this, KoolbaseStorageBusyError.prototype);
+    }
+}
+/**
+ * A listing's cursor was not one this listing issued -- made up, or from a
+ * listing with another sort or order. Start again from the first page.
+ * Code: `invalid_cursor`.
+ */
+export class KoolbaseStorageInvalidCursorError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'The cursor is not valid for this listing', 'invalid_cursor');
+        this.name = 'KoolbaseStorageInvalidCursorError';
+        Object.setPrototypeOf(this, KoolbaseStorageInvalidCursorError.prototype);
+    }
+}
+/**
+ * The bucket's rules allow this only to someone signed in, and nobody is.
+ * Not a session that ended: the SDK's session is left alone. Code:
+ * `sign_in_required`.
+ */
+export class KoolbaseStorageSignInRequiredError extends KoolbaseStorageError {
+    constructor(message) {
+        super(message ?? 'Sign in to do this', 'sign_in_required');
+        this.name = 'KoolbaseStorageSignInRequiredError';
+        Object.setPrototypeOf(this, KoolbaseStorageSignInRequiredError.prototype);
+    }
+}
 /**
  * Maps a non-2xx storage-layer response to a typed
  * {@link KoolbaseStorageError}, preferring the server's stable `code` and
@@ -271,6 +330,16 @@ export function koolbaseStorageError(status, body, fallbackMessage = 'Storage re
             return new KoolbaseStorageMetadataInvalidError(message, body?.detail);
         case 'upload_url_failed':
             return new KoolbaseUploadURLFailedError(message);
+        case 'upload_not_found':
+            return new KoolbaseUploadNotFoundError(message);
+        case 'bucket_busy':
+            return new KoolbaseStorageBusyError(message);
+        case 'invalid_cursor':
+            return new KoolbaseStorageInvalidCursorError(message);
+        case 'sign_in_required':
+            return new KoolbaseStorageSignInRequiredError(message);
+        case 'not_allowed':
+            return new KoolbaseStoragePermissionError(message);
     }
     // ─── status fallback (pre-code servers or uncoded paths) ───
     switch (status) {

package/dist/esm/storage-files.d.ts

@@ -0,0 +1,53 @@
+/** What a listing is ordered by. */
+export type KoolbaseFileSort = 'path' | 'createdAt' | 'updatedAt' | 'size';
+export interface ListFilesOptions {
+    bucket: string;
+    /** Only files whose path starts with this, taken literally. */
+    prefix?: string;
+    /** Files per page: 50 unless set, at most 100. */
+    limit?: number;
+    /** A page's `nextCursor`, for the page after it. */
+    cursor?: string;
+    /** By path unless set. */
+    sort?: KoolbaseFileSort;
+    /** Z to A, newest first, largest first. */
+    descending?: boolean;
+}
+/** One file. */
+export interface KoolbaseFileInfo {
+    /** Its path in the bucket: what a record stores to point at it. */
+    path: string;
+    /** The last part of its path. */
+    name: string;
+    size: number;
+    contentType: string | null;
+    etag: string | null;
+    metadata: Record<string, string>;
+    versionId: string | null;
+    /** Who uploaded it: a project user's id; null when the project did. */
+    uploadedBy: string | null;
+    /** ISO 8601. */
+    createdAt: string;
+    /** ISO 8601. */
+    updatedAt: string;
+    /**
+     * Its permanent link, while its bucket is public; null otherwise -- ask
+     * for a download link instead.
+     */
+    publicUrl: string | null;
+}
+/** One page of a listing. */
+export interface KoolbaseFilePage {
+    files: KoolbaseFileInfo[];
+    /**
+     * Pass to the next call for the page after this one; null at the end. A
+     * page can hold fewer files than asked for -- the server passes over
+     * files you may not view -- and still have a next one.
+     */
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+/** The query string for a listing. */
+export declare function listFilesQuery(o: ListFilesOptions): string;
+export declare function fileInfoFromJson(j: Record<string, unknown>): KoolbaseFileInfo;
+export declare function filePageFromJson(j: Record<string, unknown>): KoolbaseFilePage;

package/dist/esm/storage-files.js

@@ -0,0 +1,56 @@
+// A bucket's files, as an app sees them (S1).
+//
+// The server applies the bucket's view rule to every file: a listing holds
+// only files the signed-in person may view, and says nothing of the rest.
+const sortWire = {
+    path: 'path',
+    createdAt: 'created_at',
+    updatedAt: 'updated_at',
+    size: 'size',
+};
+/** The query string for a listing. */
+export function listFilesQuery(o) {
+    const q = new URLSearchParams();
+    q.set('bucket', o.bucket);
+    if (o.prefix)
+        q.set('prefix', o.prefix);
+    if (o.limit != null)
+        q.set('limit', String(o.limit));
+    if (o.cursor)
+        q.set('cursor', o.cursor);
+    q.set('sort', sortWire[o.sort ?? 'path'] ?? 'path');
+    q.set('order', o.descending ? 'desc' : 'asc');
+    return q.toString();
+}
+const str = (v) => (typeof v === 'string' && v !== '' ? v : null);
+export function fileInfoFromJson(j) {
+    const path = String(j.path ?? '');
+    const metadata = {};
+    if (j.metadata && typeof j.metadata === 'object') {
+        for (const [k, v] of Object.entries(j.metadata)) {
+            metadata[k] = typeof v === 'string' ? v : String(v);
+        }
+    }
+    return {
+        path,
+        name: path.split('/').pop() ?? path,
+        size: Number(j.size ?? 0),
+        contentType: str(j.content_type),
+        etag: str(j.etag),
+        metadata,
+        versionId: str(j.version_id),
+        uploadedBy: str(j.uploaded_by),
+        createdAt: String(j.created_at ?? ''),
+        updatedAt: String(j.updated_at ?? ''),
+        publicUrl: str(j.public_url),
+    };
+}
+export function filePageFromJson(j) {
+    const files = Array.isArray(j.files) ? j.files : [];
+    const nextCursor = str(j.next_cursor);
+    return {
+        files: files.map((f) => fileInfoFromJson(f)),
+        nextCursor,
+        hasMore: nextCursor !== null,
+    };
+}

package/dist/esm/storage-transfer.d.ts

@@ -0,0 +1,88 @@
+import type { UploadResult } from './types.js';
+/** Where an upload is. */
+export type KoolbaseUploadState = 
+/** Not started: asking the server for an upload link. */
+'pending'
+/** Sending the file's bytes; see `bytesSent`. */
+ | 'uploading'
+/** The bytes have arrived; the server is checking them and putting the file in place. It can no longer be cancelled. */
+ | 'verifying'
+/** Done: the file is in the bucket. */
+ | 'completed'
+/** It failed; `error` says why. */
+ | 'failed'
+/** Cancelled before the server began checking it. Nothing was stored. */
+ | 'cancelled';
+/** One moment of an upload. */
+export interface KoolbaseUploadProgress {
+    state: KoolbaseUploadState;
+    /** Bytes sent so far. */
+    bytesSent: number;
+    bytesTotal: number;
+    /** 0 to 1: the share of bytes sent; 1 once verifying. */
+    fraction: number;
+    /** Whether the upload has ended, one way or another. */
+    isDone: boolean;
+    /** Why it failed, when `state` is `'failed'`. */
+    error?: Error;
+}
+/** A running upload: watch it with `onProgress`, `cancel` it, await `result`. */
+export declare class KoolbaseUploadTask {
+    private _current;
+    private listeners;
+    private cancelRequested;
+    private abortTransfer;
+    private total;
+    /**
+     * The uploaded file. Rejects with `KoolbaseUploadCancelledError` if it was
+     * cancelled, or the error that made it fail.
+     */
+    readonly result: Promise<UploadResult>;
+    private resolve;
+    private reject;
+    /** @internal */
+    constructor();
+    /** Where the upload is now. */
+    get current(): KoolbaseUploadProgress;
+    /**
+     * Calls `listener` on every change of state and every chunk sent, starting
+     * with where the upload is now. Returns a function that stops it.
+     */
+    onProgress(listener: (p: KoolbaseUploadProgress) => void): () => void;
+    /**
+     * Stops the upload, if the server has not begun checking it yet. Returns
+     * whether it was stopped: false once verifying (the file will land, or
+     * fail on its own) or done.
+     */
+    cancel(): boolean;
+    /** @internal */
+    get cancelled(): boolean;
+    /** @internal Throws if the upload was cancelled, between steps. */
+    checkCancelled(): void;
+    /** @internal */
+    setTotal(total: number): void;
+    /** @internal */
+    setAbort(abort: (() => void) | null): void;
+    /** @internal */
+    emit(state: KoolbaseUploadState, sent?: number, error?: Error): void;
+    /** @internal Marks the bytes sent: from here the upload cannot be cancelled. */
+    verifying(): void;
+    /** @internal */
+    finish(result: UploadResult): void;
+    /** @internal */
+    fail(error: unknown): void;
+}
+/** Runs `body` as the task's upload, starting on the next turn so a caller can listen to every event. */
+export declare function runUploadTask(body: (task: KoolbaseUploadTask) => Promise<UploadResult>): KoolbaseUploadTask;
+interface PutResult {
+    status: number;
+    etag: string;
+}
+/**
+ * Sends `body` to a presigned `url` with PUT, reporting bytes as they are
+ * sent. XMLHttpRequest where the host has it (browsers and React Native,
+ * both report upload progress); fetch elsewhere, where progress jumps from
+ * 0 to the total. A cancel aborts it.
+ */
+export declare function putWithProgress(task: KoolbaseUploadTask, url: string, body: Blob, contentType: string): Promise<PutResult>;
+export {};

package/dist/esm/storage-transfer.js

@@ -0,0 +1,208 @@
+// An upload's lifecycle, as an app watches it (S1).
+//
+// pending -> uploading (bytes sent of total) -> verifying -> completed, or
+// failed / cancelled. Verifying is its own phase: the bytes have arrived and
+// the server is checking them (size, type, the bucket's rules and cap) and
+// putting them in place. Only completed means the file can be referenced
+// from a record.
+import { KoolbaseNetworkError } from './network.js';
+import { KoolbaseStorageError, KoolbaseUploadCancelledError } from './storage-errors.js';
+function progressOf(state, bytesSent, bytesTotal, error) {
+    let fraction;
+    if (state === 'verifying' || state === 'completed')
+        fraction = 1;
+    else if (bytesTotal <= 0)
+        fraction = 0;
+    else
+        fraction = Math.min(1, Math.max(0, bytesSent / bytesTotal));
+    return {
+        state,
+        bytesSent,
+        bytesTotal,
+        fraction,
+        isDone: state === 'completed' || state === 'failed' || state === 'cancelled',
+        ...(error ? { error } : {}),
+    };
+}
+/** A running upload: watch it with `onProgress`, `cancel` it, await `result`. */
+export class KoolbaseUploadTask {
+    /** @internal */
+    constructor() {
+        this.listeners = new Set();
+        this.cancelRequested = false;
+        this.abortTransfer = null;
+        this.total = 0;
+        this._current = progressOf('pending', 0, 0);
+        this.result = new Promise((res, rej) => {
+            this.resolve = res;
+            this.reject = rej;
+        });
+        // An app that only listens to progress is not left with an unhandled
+        // rejection; awaiting `result` still sees the error.
+        this.result.catch(() => undefined);
+    }
+    /** Where the upload is now. */
+    get current() {
+        return this._current;
+    }
+    /**
+     * Calls `listener` on every change of state and every chunk sent, starting
+     * with where the upload is now. Returns a function that stops it.
+     */
+    onProgress(listener) {
+        this.listeners.add(listener);
+        listener(this._current);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * Stops the upload, if the server has not begun checking it yet. Returns
+     * whether it was stopped: false once verifying (the file will land, or
+     * fail on its own) or done.
+     */
+    cancel() {
+        if (this._current.isDone || this._current.state === 'verifying')
+            return false;
+        this.cancelRequested = true;
+        this.abortTransfer?.();
+        return true;
+    }
+    /** @internal */
+    get cancelled() {
+        return this.cancelRequested;
+    }
+    /** @internal Throws if the upload was cancelled, between steps. */
+    checkCancelled() {
+        if (this.cancelRequested)
+            throw new KoolbaseUploadCancelledError();
+    }
+    /** @internal */
+    setTotal(total) {
+        this.total = total;
+    }
+    /** @internal */
+    setAbort(abort) {
+        this.abortTransfer = abort;
+    }
+    /** @internal */
+    emit(state, sent, error) {
+        if (this._current.isDone)
+            return;
+        this._current = progressOf(state, sent ?? this._current.bytesSent, this.total, error);
+        for (const l of [...this.listeners]) {
+            try {
+                l(this._current);
+            }
+            catch {
+                // A listener's own failure is not the upload's.
+            }
+        }
+    }
+    /** @internal Marks the bytes sent: from here the upload cannot be cancelled. */
+    verifying() {
+        this.checkCancelled();
+        this.emit('verifying', this.total);
+    }
+    /** @internal */
+    finish(result) {
+        this.emit('completed', this.total);
+        this.listeners.clear();
+        this.resolve(result);
+    }
+    /** @internal */
+    fail(error) {
+        if (this.cancelRequested) {
+            const e = new KoolbaseUploadCancelledError();
+            this.emit('cancelled');
+            this.reject(e);
+        }
+        else {
+            const e = error instanceof Error ? error : new KoolbaseStorageError(String(error));
+            this.emit('failed', undefined, e);
+            this.reject(e);
+        }
+        this.listeners.clear();
+    }
+}
+/** Runs `body` as the task's upload, starting on the next turn so a caller can listen to every event. */
+export function runUploadTask(body) {
+    const task = new KoolbaseUploadTask();
+    Promise.resolve().then(async () => {
+        try {
+            task.finish(await body(task));
+        }
+        catch (e) {
+            task.fail(e);
+        }
+    });
+    return task;
+}
+/**
+ * Sends `body` to a presigned `url` with PUT, reporting bytes as they are
+ * sent. XMLHttpRequest where the host has it (browsers and React Native,
+ * both report upload progress); fetch elsewhere, where progress jumps from
+ * 0 to the total. A cancel aborts it.
+ */
+export function putWithProgress(task, url, body, contentType) {
+    task.checkCancelled();
+    const total = body.size;
+    const report = (sent) => {
+        if (!task.cancelled)
+            task.emit('uploading', Math.min(sent, total));
+    };
+    report(0);
+    const XHR = globalThis.XMLHttpRequest;
+    if (XHR) {
+        return new Promise((resolve, reject) => {
+            const xhr = new XHR();
+            let settled = false;
+            const done = (fn) => {
+                if (settled)
+                    return;
+                settled = true;
+                task.setAbort(null);
+                fn();
+            };
+            xhr.open('PUT', url);
+            xhr.setRequestHeader('Content-Type', contentType);
+            if (xhr.upload) {
+                xhr.upload.onprogress = (ev) => report(ev.loaded);
+            }
+            xhr.onload = () => done(() => {
+                if (task.cancelled)
+                    return reject(new KoolbaseUploadCancelledError());
+                resolve({ status: xhr.status, etag: xhr.getResponseHeader('etag') ?? '' });
+            });
+            xhr.onerror = () => done(() => reject(task.cancelled ? new KoolbaseUploadCancelledError() : new KoolbaseNetworkError(url, new Error('the upload did not complete'))));
+            xhr.onabort = () => done(() => reject(new KoolbaseUploadCancelledError()));
+            task.setAbort(() => {
+                xhr.abort();
+                // Some hosts do not fire onabort for an aborted send.
+                done(() => reject(new KoolbaseUploadCancelledError()));
+            });
+            xhr.send(body);
+        });
+    }
+    const controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+    task.setAbort(() => controller?.abort());
+    return fetch(url, {
+        method: 'PUT',
+        headers: { 'Content-Type': contentType },
+        body,
+        signal: controller?.signal,
+    })
+        .then((res) => {
+        task.checkCancelled();
+        return { status: res.status, etag: res.headers.get('etag') ?? '' };
+    })
+        .catch((e) => {
+        if (task.cancelled || e?.name === 'AbortError') {
+            throw new KoolbaseUploadCancelledError();
+        }
+        if (e instanceof KoolbaseStorageError)
+            throw e;
+        throw new KoolbaseNetworkError(url, e);
+    })
+        .finally(() => task.setAbort(null));
+}