tempest-react-sdk 0.83.0 → 0.84.0

package/dist/http/resumable-upload.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"resumable-upload.cjs","names":["bytesToBase64","TempestApiError","isApiError","isRetriableStatus","buildApiError","resolveRequestUrl","sessionIdentityOf","ownerFingerprint","isTrustedCredentialTarget","csrfHeaders","generateIdempotencyKey","retry","require_errors","require_base64","require_credential_scope","require_csrf","require_retry","require_session_identity","require_owner_fingerprint","require_idempotency","TUS_VERSION","DEFAULT_CHUNK_SIZE","ResumableUploadSupersededError","reason","clearGenerations","localGenerations","isUploadRecord","raw","value","base64Utf8","encodeMetadata","metadata","parts","name","uploadFingerprint","named","file","modified","endpoint","createLocalUploadStorage","backend","storage","prefix","key","record","store","owned","index","UPLOAD_REDIRECT_REFUSED","UPLOAD_OFFSET_STALLED","sendRequest","init","sendWithoutRedirects","sendOverXhr","controller","response","text","xhr","report","event","resolve","reject","parseOffset","parseErrorBody","RESYNCABLE_STATUSES","isRetriableChunkFailure","error","failed","body","envelope","hasDetail","detail","resolveUploadUrl","createResumableUpload","principalOption","retryOptions","options","getPrincipal","getToken","state","offset","url","idempotencyKey","owner","attached","abandoned","generationOf","generation","currentOwner","assertCurrentOwner","stopping","inFlight","resumedFrom","setState","next","onStateChange","onProgress","loaded","baseHeaders","inScope","target","trustedOrigins","result","headers","token","register","request","holdsRedirects","persist","probe","confirmed","ensureUpload","current","ownUrl","stored","ownRecord","creationHeaders","encoded","locationHeader","writeChunk","resync","end","chunkSize","from","run","again","attempt","guarded","stop","discard"],"sources":["../../src/http/resumable-upload.ts"],"sourcesContent":["/**\n * @tempest-limits file-lines, function-lines — a resumable upload is one long-lived\n * state machine: chunk the file, negotiate the offset the server already has, upload\n * with retry and backoff, honour pause, resume and abort, and report progress\n * throughout. Every stage reads the same cursor and the same abort signal, and\n * createResumableUpload is the closure that owns them.\n */\nimport { sessionIdentityOf } from \"@/auth/session-identity\";\nimport { ownerFingerprint } from \"@/utils/owner-fingerprint\";\nimport { bytesToBase64 } from \"@/utils/base64\";\nimport {\n    isTrustedCredentialTarget,\n    reportSuppressedCredential,\n    resolveRequestUrl,\n} from \"./credential-scope\";\nimport { csrfHeaders } from \"./csrf\";\nimport type { CsrfOptions } from \"./csrf\";\nimport { buildApiError, isApiError, isRetriableStatus, TempestApiError } from \"./errors\";\nimport { generateIdempotencyKey } from \"./idempotency\";\nimport { retry, type RetryOptions } from \"./retry\";\n\n/** The tus protocol version this client speaks. */\nexport const TUS_VERSION = \"1.0.0\";\n\n/** Default chunk size: 5 MiB, the size most tus servers are tuned for. */\nexport const DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024;\n\n/**\n * Thrown by `start()`/`resume()` when the run can no longer go on as the\n * account that started it.\n *\n * - `\"principal\"` — `getPrincipal` names someone else than when the run\n *   attached: the next chunk would carry the new account's token to the\n *   previous account's upload URL, and the record would be stamped for the\n *   wrong owner.\n * - `\"cleared\"` — `createLocalUploadStorage().clear()` ran for this storage's\n *   prefix (typically in `onSessionEnd`): writing the record back would undo\n *   the clear.\n *\n * Not a pause: the run cannot be resumed as the new account. The state moves\n * to `\"error\"`, and the previous owner's record is left as it was.\n */\nexport class ResumableUploadSupersededError extends Error {\n    /** Why the run stopped. */\n    readonly reason: \"principal\" | \"cleared\";\n\n    /**\n     * @param reason - Why the run stopped.\n     */\n    constructor(reason: \"principal\" | \"cleared\") {\n        super(\n            reason === \"principal\"\n                ? \"O usuário mudou durante o upload resumível.\"\n                : \"Os registros de upload resumível foram limpos durante o upload.\",\n        );\n        this.name = \"ResumableUploadSupersededError\";\n        this.reason = reason;\n    }\n}\n\n/**\n * How many times `clear()` ran per local-storage prefix, so a run can tell its\n * record was cleared under it — even through another\n * `createLocalUploadStorage()` object with the same prefix, which is what an\n * `onSessionEnd` builds.\n */\nconst clearGenerations = new Map<string, number>();\n\n/**\n * The clear generation reader of each storage built by\n * `createLocalUploadStorage`. A custom storage has none, and its runs only\n * stop on a principal change.\n */\nconst localGenerations = new WeakMap<ResumableUploadStorage, () => number>();\n\n/**\n * Whether a stored value has the shape of a {@link ResumableUploadRecord}.\n *\n * `clear()` matches keys by prefix, and a prefix with no delimiter (`\"app\"`)\n * also matches an app's own keys (`\"appSettings\"`). Changing how keys are\n * built would orphan every record already stored under a custom prefix, so\n * `clear()` removes only values this storage could have written.\n *\n * @param raw - The stored string.\n * @returns Whether it parses as a record.\n */\nfunction isUploadRecord(raw: string | null): boolean {\n    if (!raw) return false;\n    try {\n        const value = JSON.parse(raw) as Partial<ResumableUploadRecord> | null;\n        return (\n            typeof value === \"object\" &&\n            value !== null &&\n            typeof value.url === \"string\" &&\n            typeof value.offset === \"number\" &&\n            typeof value.size === \"number\" &&\n            typeof value.idempotencyKey === \"string\"\n        );\n    } catch {\n        return false;\n    }\n}\n\n/**\n * Where a resumable upload is.\n *\n * `\"paused\"` and `\"aborted\"` are both \"not running\", but only `\"paused\"` keeps the\n * persisted offset — `abort({ discard: true })` throws it away.\n */\nexport type ResumableUploadState =\n    \"idle\" | \"creating\" | \"uploading\" | \"paused\" | \"done\" | \"error\" | \"aborted\";\n\n/** Byte-level progress for a resumable upload. */\nexport interface ResumableUploadProgress {\n    /** Bytes the server holds, including anything a resume skipped. */\n    loaded: number;\n    /** Total size of the file. */\n    total: number;\n    /** `loaded / total`, between 0 and 1. */\n    fraction: number;\n    /** Bytes already on the server when this run started. `0` on a fresh upload. */\n    resumedFrom: number;\n}\n\n/** What has to survive a page reload for a resume to be possible. */\nexport interface ResumableUploadRecord {\n    /** Upload URL the creation POST returned, absolute. */\n    url: string;\n    /** Last offset the server confirmed. */\n    offset: number;\n    /** File size, so a different file under the same key is not resumed into. */\n    size: number;\n    /** Idempotency key of the creation request, reused if creation is retried. */\n    idempotencyKey: string;\n    /** Epoch ms of the last write, so an app can sweep stale records. */\n    updatedAt: number;\n    /**\n     * One-way fingerprint of the principal that created the upload (`\"p:<hex>\"`)\n     * or, without {@link ResumableUploadOptions.getPrincipal}, of the bearer\n     * token of its last write (`\"t:<hex>\"`, since 0.82.0); `null` for an\n     * anonymous one. Absent when the upload ran with neither getter, and on\n     * records written before 0.78.0.\n     */\n    owner?: string | null;\n}\n\n/**\n * Persistence for resume state. Sync or async — both are awaited.\n *\n * Implement it over anything: the default is `localStorage`, and\n * `createOfflineStore` from `@/offline` slots in when you already have a Dexie\n * database open.\n */\nexport interface ResumableUploadStorage {\n    /** Read the record for `key`, or `null`. */\n    get(key: string): Promise<ResumableUploadRecord | null> | ResumableUploadRecord | null;\n    /** Write the record for `key`. */\n    set(key: string, record: ResumableUploadRecord): Promise<void> | void;\n    /** Forget the record for `key`. */\n    delete(key: string): Promise<void> | void;\n}\n\n/**\n * The default `localStorage` storage, which can also forget every record it\n * holds.\n */\nexport interface LocalUploadStorage extends ResumableUploadStorage {\n    /**\n     * Forget every record under this storage's prefix — the call for\n     * `onSessionEnd`, so the next account on the browser does not find the\n     * previous one's upload URLs. Synchronous; a no-op without `localStorage`.\n     *\n     * Only values shaped like a record are removed, so a prefix without a\n     * delimiter does not take the app's own keys with it. A run still going on\n     * this prefix stops before its next chunk with\n     * {@link ResumableUploadSupersededError} (`\"cleared\"`) instead of writing\n     * its record back.\n     */\n    clear(): void;\n}\n\n/** Options for {@link createResumableUpload}. */\nexport interface ResumableUploadOptions {\n    /** tus creation endpoint, e.g. `\"/api/uploads\"`. */\n    endpoint: string;\n    /** The bytes to upload. A `File` also supplies the default resume key. */\n    file: Blob | File;\n    /** Bytes per `PATCH`. Default {@link DEFAULT_CHUNK_SIZE}. */\n    chunkSize?: number;\n    /** Sent as `Upload-Metadata` (base64-encoded values), e.g. `{ filename }`. */\n    metadata?: Record<string, string>;\n    /**\n     * Extra headers on every request inside the credential scope — the\n     * `endpoint`'s origin plus {@link trustedOrigins}. A `Location` on another\n     * host gets only the tus headers, never these (since 0.82.0).\n     *\n     * A request that carries them never follows a redirect (since 0.83.0): it\n     * goes out over `fetch` with `redirect: \"manual\"`, and a redirect rejects\n     * with a `TempestApiError` of `code: \"REDIRECT_REFUSED\"`. An\n     * `XMLHttpRequest` follows every redirect, and these headers went with it\n     * to the other origin (#564). The cost: `fetch` reports no upload\n     * progress, so `onProgress` then ticks once per confirmed chunk — lower\n     * `chunkSize` for a finer bar, or send the credential through `getToken`,\n     * which keeps the `XMLHttpRequest` (the browser strips `Authorization` on\n     * a cross-origin redirect).\n     */\n    headers?: Record<string, string>;\n    /** Returns the current bearer token, read before each request. */\n    getToken?: () => string | null | undefined;\n    /**\n     * Who is signed in — a user id, or `null`/`undefined` for nobody — read when\n     * `start()`/`resume()` attaches to the upload. The same getter the error\n     * reporter and `provideBackgroundSyncCredentials` take.\n     *\n     * The resume record is stamped with a one-way fingerprint of it, and a\n     * record stamped by anyone else — another user, nobody, or no stamp at all\n     * — is deleted instead of resumed: its upload URL is not probed, and its\n     * `Idempotency-Key` is never replayed (#479).\n     *\n     * Without it, since 0.82.0 the record is bound to a fingerprint of the\n     * `getToken` token instead, so another account's record is still never\n     * adopted (#528) — but a token rotates: a reload after a refresh that no\n     * chunk landed under starts the upload over. Pass `getPrincipal` to keep\n     * resuming across refreshes, and always with a cookie session, where there\n     * is no token to bind to and the record stays unbound.\n     *\n     * `getToken: auth.getToken` — the getter of `createTempestAuth` itself, not\n     * an arrow around it — binds to that preset's session instead, as if\n     * `getPrincipal: auth.sessionKey` were passed: the record survives token\n     * rotation, a switch of account stops the run, and a new `login()`, even\n     * into the same account, starts over.\n     *\n     * It is read again before every chunk and every record write: when it\n     * names someone else mid-run, the run stops with\n     * {@link ResumableUploadSupersededError} (`\"principal\"`) before the new\n     * account's token reaches the previous one's upload URL. Without it, call\n     * `abort()` on the uploads in progress from `onSessionEnd`.\n     */\n    getPrincipal?: () => string | number | null | undefined;\n    /**\n     * Origins besides `endpoint`'s that may receive the `getToken` credential.\n     *\n     * Since 0.66.0 the bearer token is scoped to the origin of `endpoint`, and\n     * the creation response's `Location` no longer decides where it goes. A\n     * server that hands the upload to object storage on another host still\n     * works — the `PATCH` requests simply carry no `Authorization`, which is\n     * what a presigned storage URL expects anyway.\n     *\n     * List the storage origin here when it does need the API's token.\n     */\n    trustedOrigins?: readonly string[];\n    /** Send cookies. Default `false`. */\n    withCredentials?: boolean;\n    /**\n     * Send a CSRF token on the creation `POST`, every chunk `PATCH` and the\n     * discarding `DELETE` — never on the offset `HEAD`. Off by default; `true`\n     * reads the `csrf_token` cookie into `X-CSRF-Token`, as `createApiClient`\n     * does.\n     *\n     * Scoped like the bearer token, to `endpoint`'s origin plus\n     * {@link trustedOrigins}: a `Location` pointing at object storage on\n     * another host gets neither.\n     */\n    csrf?: boolean | CsrfOptions;\n    /**\n     * Resume key. Defaults to a fingerprint of endpoint + file name/size/mtime, so\n     * picking the same file after a reload resumes instead of restarting.\n     */\n    key?: string;\n    /**\n     * Where to persist resume state. Defaults to `localStorage`. Pass `null` to\n     * disable persistence — resume then only survives a network blip, not a reload.\n     */\n    storage?: ResumableUploadStorage | null;\n    /** Backoff for a failed chunk. Forwarded to `retry`. Default 5 attempts. */\n    retry?: RetryOptions;\n    /** Called on every upload-progress tick and after every confirmed chunk. */\n    onProgress?: (progress: ResumableUploadProgress) => void;\n    /** Called whenever {@link ResumableUpload.state} changes. */\n    onStateChange?: (state: ResumableUploadState) => void;\n}\n\n/** What a finished upload resolves with. */\nexport interface ResumableUploadResult {\n    /** The tus upload URL — hand this to your API to link the stored file. */\n    url: string;\n    /** Total bytes uploaded. */\n    size: number;\n}\n\n/** A resumable upload in progress. Build one with {@link createResumableUpload}. */\nexport interface ResumableUpload {\n    /**\n     * Create (or re-attach to) the upload and push chunks until it is complete.\n     *\n     * Resolves `null` when the run stopped because of `pause()` or `abort()` —\n     * neither is a failure. Rejects with a `TempestApiError` when the server\n     * refused and the retries ran out.\n     */\n    start(): Promise<ResumableUploadResult | null>;\n    /** Stop after the in-flight chunk is dropped, keeping the resume point. */\n    pause(): void;\n    /** Continue from the server's offset. Same resolution contract as `start`. */\n    resume(): Promise<ResumableUploadResult | null>;\n    /**\n     * Stop for good.\n     *\n     * A later `start()`/`resume()` on the same handle attaches as a new handle\n     * would (since 0.83.0): it resumes the stored record only when the current\n     * owner stamped it, and otherwise creates a new upload with a fresh\n     * `Idempotency-Key`. Until then a token-bound handle resumed its own upload\n     * with whatever token was current — after an account switch, the next\n     * account's (#561).\n     *\n     * @param options - `discard: true` also sends `DELETE` (tus termination) and\n     *   forgets the persisted record, so the next `start()` uploads from zero.\n     */\n    abort(options?: { discard?: boolean }): Promise<void>;\n    /** Current state. */\n    readonly state: ResumableUploadState;\n    /** Bytes the server has confirmed. */\n    readonly offset: number;\n    /** The upload URL, once creation succeeded. */\n    readonly url: string | null;\n    /** The resume key in use. */\n    readonly key: string;\n}\n\ninterface RawResponse {\n    status: number;\n    text: string;\n    header(name: string): string | null;\n}\n\n/**\n * Encode a string as standard base64 (padded), UTF-8 first.\n *\n * `Upload-Metadata` carries base64 values precisely so a filename with accents\n * survives an HTTP header, so the UTF-8 step is not optional: `btoa` alone throws\n * on any code point above U+00FF. Only that step is specific here — the\n * bytes-to-text half is {@link bytesToBase64}.\n *\n * @param value - Text to encode.\n * @returns Padded base64.\n */\nfunction base64Utf8(value: string): string {\n    return bytesToBase64(new TextEncoder().encode(value));\n}\n\n/**\n * Build the `Upload-Metadata` header value: comma-separated `key base64(value)`.\n *\n * @param metadata - Plain string map.\n * @returns The header value, or `null` when there is nothing to send.\n */\nfunction encodeMetadata(metadata: Record<string, string> | undefined): string | null {\n    if (!metadata) return null;\n    const parts = Object.entries(metadata).map(([name, value]) => `${name} ${base64Utf8(value)}`);\n    return parts.length > 0 ? parts.join(\",\") : null;\n}\n\n/**\n * A stable-enough identity for a file, used as the default resume key.\n *\n * Name + size + last-modified is what the tus reference clients fingerprint on:\n * it is cheap (hashing the bytes of a 400 MB recording is not) and it changes\n * whenever the file does, which is the property that matters — resuming into the\n * wrong file would corrupt it silently.\n *\n * @param endpoint - Creation endpoint, so the same file to two servers is two uploads.\n * @param file - The blob or file being uploaded.\n * @returns A key safe to use in `localStorage`.\n */\nexport function uploadFingerprint(endpoint: string, file: Blob | File): string {\n    const named = file as File;\n    const name = typeof named.name === \"string\" ? named.name : \"blob\";\n    const modified = typeof named.lastModified === \"number\" ? named.lastModified : 0;\n    return `${endpoint}|${name}|${file.size}|${file.type}|${modified}`;\n}\n\n/**\n * `localStorage`-backed resume storage — the default.\n *\n * `localStorage` and not IndexedDB on purpose. The record is four fields and a\n * URL; the requirement is only that it survives a reload, and pulling Dexie in for\n * that would put an IndexedDB dependency in the bundle of every app that uploads a\n * file. Apps that already have `createOfflineStore` open can pass their own\n * {@link ResumableUploadStorage} instead.\n *\n * `clear()` forgets every record under the prefix. Call it from\n * `onSessionEnd`: a record outlives the session that wrote it, and only\n * completing the upload or `abort({ discard: true })` removes it otherwise.\n *\n * @param prefix - Key prefix. Default `\"tempest-upload:\"`.\n * @returns A storage that no-ops when `localStorage` is unavailable.\n */\nexport function createLocalUploadStorage(prefix = \"tempest-upload:\"): LocalUploadStorage {\n    function backend(): Storage | null {\n        try {\n            return typeof localStorage === \"undefined\" ? null : localStorage;\n        } catch {\n            return null;\n        }\n    }\n\n    const storage: LocalUploadStorage = {\n        get(key) {\n            const raw = backend()?.getItem(prefix + key);\n            if (!raw) return null;\n            try {\n                return JSON.parse(raw) as ResumableUploadRecord;\n            } catch {\n                return null;\n            }\n        },\n        set(key, record) {\n            backend()?.setItem(prefix + key, JSON.stringify(record));\n        },\n        delete(key) {\n            backend()?.removeItem(prefix + key);\n        },\n        clear() {\n            clearGenerations.set(prefix, (clearGenerations.get(prefix) ?? 0) + 1);\n            const store = backend();\n            if (!store) return;\n            const owned: string[] = [];\n            for (let index = 0; index < store.length; index += 1) {\n                const name = store.key(index);\n                if (name?.startsWith(prefix) && isUploadRecord(store.getItem(name))) {\n                    owned.push(name);\n                }\n            }\n            for (const name of owned) store.removeItem(name);\n        },\n    };\n    localGenerations.set(storage, () => clearGenerations.get(prefix) ?? 0);\n    return storage;\n}\n\n/** Something a run can cancel: the open `XMLHttpRequest`, or a `fetch`'s controller. */\ninterface InFlightRequest {\n    abort(): void;\n}\n\n/** One tus request, as the transports take it. */\ninterface TusRequest {\n    method: \"POST\" | \"HEAD\" | \"PATCH\" | \"DELETE\";\n    url: string;\n    headers: Record<string, string>;\n    body?: Blob;\n    withCredentials: boolean;\n    onProgress?: (loaded: number) => void;\n    register: (request: InFlightRequest) => void;\n    /**\n     * Refuse a redirect instead of following it — set when the request carries\n     * the static `headers`, see {@link sendRequest}.\n     */\n    holdRedirects: boolean;\n}\n\n/**\n * The `code` of the {@link TempestApiError} a request carrying the static\n * `headers` rejects with when the server answers it with a redirect — the same\n * code `createApiClient` uses for the same refusal (#554). Never retried:\n * replaying gets the same redirect back.\n */\nconst UPLOAD_REDIRECT_REFUSED = \"REDIRECT_REFUSED\";\n\n/**\n * The `code` of the {@link TempestApiError} a chunk rejects with when the\n * server confirms the `PATCH` (`200`/`204`) but its `Upload-Offset` did not\n * move past the offset the chunk was written at (#569).\n *\n * tus 1.0.0 says the new offset \"MUST be the sum of the offset before the\n * `PATCH` request and the number of bytes received\", so a confirmed write\n * that reports the same offset (or a smaller one) is a protocol violation —\n * the shape a redirect produces when it turns the chunk into a body-less\n * `GET` answered `200`, or a proxy that drops the body. Until 0.83.0 the\n * chunk loop took that answer as success and wrote the same bytes again,\n * forever: measured during #568, more than 1500 requests in 4 s, even with\n * `retries: 0`, because every iteration of the loop got a fresh retry budget\n * and none of them ever failed.\n *\n * It is counted as a chunk failure, not refused outright: the next attempt\n * re-reads the offset with `HEAD` first (the server may have stored the bytes\n * and only reported badly), and the run rejects once the `retries` budget is\n * spent — `retries: 0` sends one `PATCH`. That is the same budget rule the\n * reference client (`tus-js-client`) applies, where only an offset that moved\n * refills the retry counter.\n */\nconst UPLOAD_OFFSET_STALLED = \"UPLOAD_OFFSET_STALLED\";\n\n/**\n * Send one tus request.\n *\n * `XMLHttpRequest` rather than `fetch` for the same reason `uploadWithProgress`\n * uses it — `fetch` still cannot report upload progress in any browser — plus one\n * more: tus answers every write with the new `Upload-Offset` in a **response\n * header**, and `uploadWithProgress` only hands back a parsed body, so it could\n * not be reused here.\n *\n * Except when the request carries the static `headers` (#564). An\n * `XMLHttpRequest` always follows a redirect, and measured in Chrome 150 —\n * the packaged `createResumableUpload` against a server on `127.0.0.1:5340`\n * that answered `301`/`302`/`303`/`307`/`308` towards `localhost:5341` —\n * `X-Api-Key` reached the other origin on every one of them, on the creation\n * `POST` and on the chunk `PATCH`, along with the bytes; only `Authorization`\n * was stripped by the browser. Reading `responseURL` afterwards tells where\n * the request ended up, but by then the header is gone. So such a request goes\n * out over `fetch` with `redirect: \"manual\"`, and a redirect is refused, as in\n * `createApiClient`. The cost is the progress inside a chunk: `fetch` reports\n * none, so `onProgress` ticks once per confirmed chunk for those requests.\n *\n * @param init - The request.\n * @returns Status, raw text and a header reader.\n */\nfunction sendRequest(init: TusRequest): Promise<RawResponse> {\n    return init.holdRedirects ? sendWithoutRedirects(init) : sendOverXhr(init);\n}\n\n/**\n * Send one tus request over `fetch` with `redirect: \"manual\"`, refusing the\n * redirect it may be answered with, see {@link sendRequest}.\n *\n * A browser hands the stopped redirect back as an `opaqueredirect` with\n * status `0` (measured for #554); a server runtime hands back the real `3xx`.\n * Both are refused; `304` is a cache answer, not a redirect.\n *\n * @param init - The request.\n * @returns Status, raw text and a header reader.\n * @throws {TempestApiError} `code: \"REDIRECT_REFUSED\"` on a redirect, status\n *   `0` on a network failure.\n */\nasync function sendWithoutRedirects(init: TusRequest): Promise<RawResponse> {\n    const controller = new AbortController();\n    init.register(controller);\n    let response: Response;\n    try {\n        response = await fetch(init.url, {\n            method: init.method,\n            headers: init.headers,\n            body: init.body,\n            credentials: init.withCredentials ? \"include\" : \"same-origin\",\n            redirect: \"manual\",\n            signal: controller.signal,\n        });\n    } catch {\n        if (controller.signal.aborted) throw new DOMException(\"Aborted\", \"AbortError\");\n        throw new TempestApiError({ status: 0, detail: \"Falha de rede no upload resumível.\" });\n    }\n    if (\n        response.type === \"opaqueredirect\" ||\n        (response.status >= 300 && response.status < 400 && response.status !== 304)\n    ) {\n        throw new TempestApiError({\n            status: response.status,\n            code: UPLOAD_REDIRECT_REFUSED,\n            detail: \"Redirect não seguido: a requisição do upload levava os headers fixos.\",\n        });\n    }\n    const text = init.method === \"HEAD\" ? \"\" : await response.text();\n    return { status: response.status, text, header: (name) => response.headers.get(name) };\n}\n\n/**\n * Send one tus request over `XMLHttpRequest`, which reports upload progress\n * and follows redirects, see {@link sendRequest}.\n *\n * @param init - The request.\n * @returns Status, raw text and a header reader.\n */\nfunction sendOverXhr(init: TusRequest): Promise<RawResponse> {\n    return new Promise<RawResponse>((resolve, reject) => {\n        const xhr = new XMLHttpRequest();\n        xhr.open(init.method, init.url);\n        xhr.withCredentials = init.withCredentials;\n        for (const [name, value] of Object.entries(init.headers)) {\n            xhr.setRequestHeader(name, value);\n        }\n        if (init.onProgress) {\n            const report = init.onProgress;\n            xhr.upload.onprogress = (event: ProgressEvent) => report(event.loaded);\n        }\n        xhr.onload = () =>\n            resolve({\n                status: xhr.status,\n                text: xhr.responseText,\n                header: (name) => xhr.getResponseHeader(name),\n            });\n        xhr.onerror = () =>\n            reject(\n                new TempestApiError({\n                    status: 0,\n                    detail: \"Falha de rede no upload resumível.\",\n                }),\n            );\n        xhr.onabort = () => reject(new DOMException(\"Aborted\", \"AbortError\"));\n        init.register(xhr);\n        xhr.send(init.body);\n    });\n}\n\nfunction parseOffset(response: RawResponse): number | null {\n    const raw = response.header(\"Upload-Offset\");\n    if (raw === null) return null;\n    const value = Number(raw);\n    return Number.isFinite(value) && value >= 0 ? value : null;\n}\n\n/**\n * Read an error body without assuming it is JSON.\n *\n * A tus proxy that rejects a chunk often answers with plain text or an HTML error\n * page, and `JSON.parse` throwing there would replace a useful status with a parse\n * error.\n *\n * @param text - Raw response text.\n * @returns The parsed object, the raw text, or `null` when the body was empty.\n */\nfunction parseErrorBody(text: string): unknown {\n    if (!text) return null;\n    try {\n        return JSON.parse(text);\n    } catch {\n        return text;\n    }\n}\n\n/**\n * Turn a refused tus response into a `TempestApiError`.\n *\n * The fallback `detail` is used unless the server sent a real error envelope,\n * because `buildApiError`'s own fallback (`\"Erro 409\"`) says nothing about which\n * step of the protocol broke — and that is the whole diagnostic value here.\n *\n * @param response - The raw response that was not acceptable.\n * @param detail - Message to use when the body carries none.\n * @returns The error to throw.\n */\n/**\n * The two statuses a chunk retry fixes that the shared policy cannot know about.\n *\n * `409` and `412` are the offset-divergence answers, and they are the entire\n * reason `resync` exists: the next attempt re-reads the server's offset with\n * `HEAD` and writes from there. They are 4xx refusals a replay genuinely fixes,\n * which is the one thing {@link isRetriableStatus} has no way to tell — from\n * outside this protocol they look like any other deliberate rejection.\n */\nconst RESYNCABLE_STATUSES: ReadonlySet<number> = new Set([409, 412]);\n\n/**\n * Whether a chunk failure is worth another attempt.\n *\n * The default used to be `true` for everything, which cost five round trips\n * before surfacing an answer the first one already gave. Two groups matter here\n * and both are specific to the resume protocol:\n *\n * - **`409`/`412` retry**, even though the shared policy rejects 4xx: they mean\n *   \"your offset is wrong\", and `resync` is how the next attempt fixes it.\n * - **`404`/`410` do not**, even though a lost resource can look transient.\n *   `probe()` turns them into \"O upload expirou no servidor. Comece de novo.\" and\n *   recreating the upload only happens in `ensureUpload`, at attach time — never\n *   inside the chunk loop. So a retry here re-runs `HEAD` against a resource that\n *   is gone, five times, and then reports the same thing with the backoff added\n *   on top.\n *\n * - **`UPLOAD_OFFSET_STALLED` retries**, though its status is a `2xx` the\n *   shared policy knows nothing about: the next attempt resyncs with `HEAD`,\n *   and the budget is what stops a server that keeps confirming nothing.\n *\n * Anything with no API shape still retries: a transport failure has no status to\n * judge, and losing a large upload to one dropped connection is the outcome this\n * whole module exists to avoid.\n *\n * @param error - Whatever the attempt threw.\n * @returns Whether the chunk loop should try again.\n */\nfunction isRetriableChunkFailure(error: unknown): boolean {\n    if (!isApiError(error)) return true;\n    if (error.code === UPLOAD_REDIRECT_REFUSED) return false;\n    if (error.code === UPLOAD_OFFSET_STALLED) return true;\n    if (RESYNCABLE_STATUSES.has(error.status)) return true;\n    return isRetriableStatus(error.status);\n}\n\nfunction failed(response: RawResponse, detail: string): TempestApiError {\n    const body = parseErrorBody(response.text);\n    const envelope = buildApiError(response.status, body, { get: response.header });\n    const hasDetail =\n        typeof body === \"object\" && body !== null && (\"detail\" in body || \"message\" in body);\n    return new TempestApiError({ ...envelope, detail: hasDetail ? envelope.detail : detail });\n}\n\n/**\n * Resolve a `Location` header against the creation endpoint, so a relative\n * upload URL works.\n *\n * tus servers are free to answer creation with either an absolute URL or a\n * path, and the spec does not prefer one — a client that only handles absolute\n * URLs breaks against half the implementations.\n *\n * The base is the URL the creation `POST` went to, as RFC 9110 §10.2.2 says\n * for `Location`, resolved the way the transport resolved it. Until 0.82.0 it\n * was the page's address: with an absolute `endpoint` on a tus host, a\n * `Location: /files/abc` pointed the chunks at the app's own origin (#530).\n *\n * @param value - The raw `Location` header.\n * @param endpoint - The creation endpoint the `POST` went to.\n * @returns An absolute URL, or the input when there is no base to resolve against.\n */\nfunction resolveUploadUrl(value: string, endpoint: string): string {\n    try {\n        return new URL(value, resolveRequestUrl(endpoint) ?? undefined).href;\n    } catch {\n        return value;\n    }\n}\n\n/**\n * Chunked, resumable upload speaking the **tus 1.0.0** protocol (core plus the\n * *creation* and *termination* extensions).\n *\n * ## Why tus and not a bespoke scheme\n *\n * A resumable client whose wire format is undocumented cannot be integrated, and\n * inventing one means the backend is ours forever. tus is a published spec with\n * off-the-shelf servers (`tusd`, `tuspy`, `tus-node-server`), so a caller can point\n * this at something they did not write.\n *\n * ## What the backend must implement\n *\n * Every request carries `Tus-Resumable: 1.0.0`.\n *\n * | Step | Request | Expected response |\n * | --- | --- | --- |\n * | Create | `POST {endpoint}` + `Upload-Length`, `Upload-Metadata`, `Idempotency-Key` | `201` + `Location` (the upload URL, absolute or endpoint-relative) |\n * | Probe | `HEAD {uploadUrl}` | `200`/`204` + `Upload-Offset` |\n * | Write | `PATCH {uploadUrl}` + `Upload-Offset`, `Content-Type: application/offset+octet-stream`, chunk body | `204` + the new `Upload-Offset`, past the one sent; `409` when the offset does not match |\n * | Discard | `DELETE {uploadUrl}` | `204` |\n *\n * ## The failure that actually happens\n *\n * A chunk that the server stored but whose response never arrived. The client\n * cannot tell that from a chunk that was lost, and re-sending it blindly would\n * duplicate bytes. Two things prevent that:\n *\n * - **Writes are addressed, not appended.** Every `PATCH` states the offset it\n *   writes at, so a retry after a lost response is asked to write bytes the server\n *   already has and answers `409`. On any retry the client re-reads the truth with\n *   `HEAD` first and continues from there.\n * - **Creation carries an `Idempotency-Key`** (from `generateIdempotencyKey`),\n *   persisted before the first attempt and reused on retry. tus has no idempotent\n *   creation of its own, so without this a lost `201` leaves an orphan upload on\n *   the server. A backend that honours the header returns the same `Location`; one\n *   that ignores it still works, it just keeps the orphan.\n *\n * @param options - Endpoint, file, and the knobs above.\n * @returns A handle with `start`/`pause`/`resume`/`abort` and live `state`/`offset`.\n *\n * @example\n * const upload = createResumableUpload({\n *     endpoint: \"/api/uploads\",\n *     file: recording,\n *     metadata: { filename: \"nota.webm\", ticket: ticketId },\n *     getToken: () => auth.getToken(),\n *     onProgress: ({ fraction }) => setPercent(Math.round(fraction * 100)),\n * });\n *\n * const done = await upload.start();\n * if (done) await api.post(\"/api/tickets/1/audio\", { body: { url: done.url } });\n */\nexport function createResumableUpload(options: ResumableUploadOptions): ResumableUpload {\n    const {\n        endpoint,\n        file,\n        chunkSize = DEFAULT_CHUNK_SIZE,\n        metadata,\n        headers = {},\n        getToken,\n        getPrincipal: principalOption,\n        trustedOrigins,\n        withCredentials = false,\n        csrf,\n        key = uploadFingerprint(endpoint, file),\n        storage = createLocalUploadStorage(),\n        retry: retryOptions,\n        onProgress,\n        onStateChange,\n    } = options;\n    const getPrincipal = principalOption ?? sessionIdentityOf(getToken)?.current;\n\n    let state: ResumableUploadState = \"idle\";\n    let offset = 0;\n    let url: string | null = null;\n    let idempotencyKey: string | null = null;\n    let owner: string | null | undefined;\n    let attached = false;\n    let abandoned = false;\n    const generationOf = storage ? localGenerations.get(storage) : undefined;\n    let generation = generationOf?.() ?? 0;\n\n    /**\n     * Who the resume record belongs to right now, as the fingerprint it is\n     * stamped with.\n     *\n     * `getPrincipal` wins when given (`\"p:…\"`), and so does the session of a\n     * `getToken` that `createTempestAuth` handed out, read as its principal.\n     * Without either, a `getToken` getter\n     * still names the credential every request carries, so the record is bound\n     * to a fingerprint of the token (`\"t:…\"`) — never the token itself. Until\n     * 0.82.0 a record written without `getPrincipal` had no owner at all and\n     * was adopted by whoever picked an identical file next: `HEAD`/`PATCH` with\n     * their token to the previous user's upload URL, and the previous user's\n     * `Idempotency-Key` replayed on their creation (#528).\n     *\n     * A token rotates, a principal does not, which is why `getPrincipal` is\n     * still the better binding: a reload after a refresh that happened while\n     * no chunk was landing starts the upload over. `undefined` — no binding —\n     * only when there is neither getter: an anonymous upload, or a cookie\n     * session the SDK cannot see.\n     *\n     * @returns The fingerprint, `null` for nobody, `undefined` for unbound.\n     */\n    function currentOwner(): string | null | undefined {\n        if (getPrincipal) return ownerFingerprint(\"p\", getPrincipal());\n        if (getToken) return ownerFingerprint(\"t\", getToken());\n        return undefined;\n    }\n\n    /**\n     * Throw when the run can no longer go on as the account that attached it:\n     * the principal changed, or the local storage was cleared under it.\n     *\n     * @throws {ResumableUploadSupersededError} In either case.\n     */\n    function assertCurrentOwner(): void {\n        if (getPrincipal && ownerFingerprint(\"p\", getPrincipal()) !== owner) {\n            throw new ResumableUploadSupersededError(\"principal\");\n        }\n        if (generationOf && generationOf() !== generation) {\n            throw new ResumableUploadSupersededError(\"cleared\");\n        }\n    }\n    let stopping: \"pause\" | \"abort\" | null = null;\n    let inFlight: InFlightRequest | null = null;\n    let resumedFrom = 0;\n\n    function setState(next: ResumableUploadState): void {\n        if (state === next) return;\n        state = next;\n        onStateChange?.(next);\n    }\n\n    function report(loaded: number): void {\n        onProgress?.({\n            loaded,\n            total: file.size,\n            fraction: file.size === 0 ? 1 : loaded / file.size,\n            resumedFrom,\n        });\n    }\n\n    /**\n     * Headers every tus request carries, with the credential scoped to the\n     * endpoint's origin.\n     *\n     * The target is a parameter because after creation it is not ours: tus\n     * answers `POST {endpoint}` with a `Location` the server chooses, and the\n     * spec allows an absolute URL on another host — handing the upload to\n     * object storage is the ordinary deployment, not an attack. Before 0.66.0\n     * the bearer token followed that header wherever it pointed, along with the\n     * file bytes.\n     *\n     * The CSRF token follows the same scope, and only on the methods that\n     * write — which is why the method is a parameter too. So do the static\n     * `headers` since 0.82.0: an `X-Api-Key` there is a credential, and until\n     * then it went to a foreign `Location` along with the bytes (#530).\n     *\n     * @param target - The URL this particular request goes to.\n     * @param method - The HTTP method of this request.\n     * @returns The headers to send.\n     */\n    function baseHeaders(target: string, method: string): Record<string, string> {\n        const inScope = isTrustedCredentialTarget(target, endpoint, trustedOrigins);\n        const result: Record<string, string> = {\n            ...(inScope ? headers : {}),\n            \"Tus-Resumable\": TUS_VERSION,\n        };\n        const token = getToken?.();\n        if (token && !(\"Authorization\" in headers)) {\n            if (inScope) {\n                result.Authorization = `Bearer ${token}`;\n            } else {\n                reportSuppressedCredential(target, endpoint);\n            }\n        }\n        Object.assign(\n            result,\n            csrfHeaders({\n                method,\n                url: target,\n                reference: endpoint,\n                csrf,\n                trustedOrigins,\n                headers,\n            }),\n        );\n        return result;\n    }\n\n    function register(request: InFlightRequest): void {\n        inFlight = request;\n    }\n\n    /**\n     * Whether a request to `target` carries the static `headers` — inside the\n     * credential scope, with at least one — and must therefore refuse a\n     * redirect, see {@link sendRequest}. Only those: the bearer token is\n     * stripped by the browser on a cross-origin redirect, and the CSRF token\n     * follows the reasoning `createApiClient` documents for it.\n     *\n     * @param target - The URL the request goes to.\n     * @returns Whether the request goes out over `fetch` without redirects.\n     */\n    function holdsRedirects(target: string): boolean {\n        return (\n            Object.keys(headers).length > 0 &&\n            isTrustedCredentialTarget(target, endpoint, trustedOrigins)\n        );\n    }\n\n    /**\n     * Write the resume record, stamped with whoever owns it now.\n     *\n     * Restamped on every write rather than fixed at attach, so a token refresh\n     * mid-upload does not orphan the record: the next reload, with the new\n     * token, still resumes it. With `getPrincipal` the stamp cannot drift —\n     * {@link assertCurrentOwner} stops the run first.\n     */\n    async function persist(): Promise<void> {\n        if (!storage || !url || !idempotencyKey) return;\n        assertCurrentOwner();\n        owner = currentOwner();\n        await storage.set(key, {\n            url,\n            offset,\n            size: file.size,\n            idempotencyKey,\n            updatedAt: Date.now(),\n            ...(owner === undefined ? {} : { owner }),\n        });\n    }\n\n    /**\n     * Ask the server how much it holds. The only source of truth after any failure.\n     */\n    async function probe(target: string): Promise<number> {\n        const response = await sendRequest({\n            method: \"HEAD\",\n            url: target,\n            headers: baseHeaders(target, \"HEAD\"),\n            withCredentials,\n            register,\n            holdRedirects: holdsRedirects(target),\n        });\n        if (response.status === 404 || response.status === 410) {\n            throw new TempestApiError({\n                status: response.status,\n                detail: \"O upload expirou no servidor. Comece de novo.\",\n            });\n        }\n        const confirmed = parseOffset(response);\n        if (confirmed === null) throw failed(response, \"HEAD sem Upload-Offset.\");\n        return confirmed;\n    }\n\n    /**\n     * Re-attach to a persisted upload, or create a new one.\n     *\n     * The persisted record is only trusted when the file size still matches, and the\n     * offset it holds is re-checked with `HEAD` — the client's copy can be ahead of\n     * the server's whenever the last response was lost.\n     *\n     * It is also only trusted when it carries the current owner's fingerprint\n     * (see {@link currentOwner}); anyone else's is deleted, and the creation\n     * that follows gets a fresh `Idempotency-Key`. With `getPrincipal`, the key\n     * this handle kept in memory from an earlier run is reused only while the\n     * principal is the same, which is what keeps creation idempotent across\n     * `resume()` without storage.\n     *\n     * Bound by token, the handle's own record is the exception: a `resume()`\n     * after a refresh finds the record it wrote itself, stamped with the token\n     * of its last write, and continues it instead of starting over.\n     *\n     * The exception ends at `abort()` (#561). A token-bound handle cannot tell\n     * a refresh from another account's sign-in — both are just a new token —\n     * and `abort()` from `onSessionEnd` is what the docs give such a handle to\n     * say the session ended. Until 0.82.0 a `resume()` after it still found\n     * \"its own\" record and sent the next account's token to the previous\n     * account's upload URL, with the previous account's `Idempotency-Key`.\n     * Exempting only an unchanged owner fingerprint, as the audit suggested,\n     * would not have worked: the fingerprint of a token-bound record changes on\n     * every refresh, so the exception would have covered nothing. So a\n     * `start()`/`resume()` after `abort()` attaches as a new handle would: the\n     * URL and the `Idempotency-Key` kept in memory are dropped, and the stored\n     * record is resumed only when its owner is the current one.\n     */\n    async function ensureUpload(): Promise<string> {\n        if (abandoned) {\n            abandoned = false;\n            attached = false;\n            url = null;\n            idempotencyKey = null;\n        }\n        const current = currentOwner();\n        if (attached && getPrincipal && current !== owner) idempotencyKey = null;\n        const ownUrl = attached && !getPrincipal ? url : null;\n        owner = current;\n        attached = true;\n        generation = generationOf?.() ?? 0;\n        let stored = storage ? await storage.get(key) : null;\n        const ownRecord = stored !== null && ownUrl !== null && stored.url === ownUrl;\n        if (stored && owner !== undefined && stored.owner !== owner && !ownRecord) {\n            await storage?.delete(key);\n            stored = null;\n        }\n        if (stored && stored.size === file.size) {\n            idempotencyKey = stored.idempotencyKey;\n            if (stored.url) {\n                try {\n                    offset = await probe(stored.url);\n                    url = stored.url;\n                    return stored.url;\n                } catch {\n                    offset = 0;\n                }\n            }\n        }\n\n        setState(\"creating\");\n        idempotencyKey ??= generateIdempotencyKey();\n        url = null;\n        offset = 0;\n        if (storage) {\n            await storage.set(key, {\n                url: \"\",\n                offset: 0,\n                size: file.size,\n                idempotencyKey,\n                updatedAt: Date.now(),\n                ...(owner === undefined ? {} : { owner }),\n            });\n        }\n\n        const creationHeaders: Record<string, string> = {\n            ...baseHeaders(endpoint, \"POST\"),\n            \"Upload-Length\": String(file.size),\n            \"Idempotency-Key\": idempotencyKey,\n        };\n        const encoded = encodeMetadata(metadata);\n        if (encoded) creationHeaders[\"Upload-Metadata\"] = encoded;\n\n        const response = await sendRequest({\n            method: \"POST\",\n            url: endpoint,\n            headers: creationHeaders,\n            withCredentials,\n            register,\n            holdRedirects: holdsRedirects(endpoint),\n        });\n        if (response.status !== 201) throw failed(response, \"Criação do upload recusada.\");\n        const locationHeader = response.header(\"Location\");\n        if (!locationHeader) throw failed(response, \"Criação do upload sem cabeçalho Location.\");\n\n        url = resolveUploadUrl(locationHeader, endpoint);\n        await persist();\n        return url;\n    }\n\n    /** Push one chunk, resyncing the offset first when a previous attempt failed. */\n    async function writeChunk(target: string, resync: { needed: boolean }): Promise<void> {\n        assertCurrentOwner();\n        if (resync.needed) {\n            offset = await probe(target);\n            resync.needed = false;\n            report(offset);\n            await persist();\n            if (offset >= file.size) return;\n        }\n\n        const end = Math.min(offset + chunkSize, file.size);\n        const from = offset;\n        const response = await sendRequest({\n            method: \"PATCH\",\n            url: target,\n            headers: {\n                ...baseHeaders(target, \"PATCH\"),\n                \"Content-Type\": \"application/offset+octet-stream\",\n                \"Upload-Offset\": String(from),\n            },\n            body: file.slice(from, end),\n            withCredentials,\n            onProgress: (loaded) => report(Math.min(from + loaded, file.size)),\n            register,\n            holdRedirects: holdsRedirects(target),\n        });\n\n        if (response.status === 409 || response.status === 412) {\n            resync.needed = true;\n            throw failed(response, \"Offset divergente — o servidor já tinha esses bytes.\");\n        }\n        if (response.status !== 204 && response.status !== 200) {\n            throw failed(response, \"Chunk recusado pelo servidor.\");\n        }\n\n        const confirmed = parseOffset(response);\n        if (confirmed !== null && confirmed <= from) {\n            throw new TempestApiError({\n                status: response.status,\n                code: UPLOAD_OFFSET_STALLED,\n                detail: `O servidor confirmou o chunk sem avançar o Upload-Offset (${from} → ${confirmed}).`,\n            });\n        }\n        offset = confirmed ?? end;\n        report(offset);\n        await persist();\n    }\n\n    /**\n     * Drive the whole upload: attach or create, then chunk until complete.\n     *\n     * The `shouldRetry` predicate does double duty — besides deciding, it arms\n     * `resync` so the next attempt re-reads the server's offset with `HEAD` before\n     * writing. That is deliberate: it is the one place that sees *every* chunk\n     * failure, whatever the cause, and after any failure the client's idea of the\n     * offset is exactly what cannot be trusted.\n     *\n     * `resync` is armed only when the attempt is actually going to happen. A\n     * caller's own `shouldRetry` still wins the decision, and still arms the\n     * resync when it says yes — the flag describes what the *next* attempt must\n     * do, so setting it for an attempt that never comes describes nothing.\n     * {@link isRetriableChunkFailure} is the default, and it is where `409`/`412`\n     * earn a retry the shared policy would refuse and `404`/`410` lose one it\n     * would have granted.\n     *\n     * @returns The result, or `null` when `pause`/`abort` stopped the run.\n     */\n    async function run(): Promise<ResumableUploadResult | null> {\n        stopping = null;\n        const target = await ensureUpload();\n        resumedFrom = offset;\n        setState(\"uploading\");\n        report(offset);\n\n        const resync = { needed: false };\n        while (offset < file.size) {\n            if (stopping) break;\n            await retry(() => writeChunk(target, resync), {\n                retries: 5,\n                ...retryOptions,\n                shouldRetry: (error, attempt) => {\n                    if (stopping) return false;\n                    if (error instanceof ResumableUploadSupersededError) return false;\n                    if (error instanceof DOMException && error.name === \"AbortError\") return false;\n                    const again =\n                        retryOptions?.shouldRetry?.(error, attempt) ??\n                        isRetriableChunkFailure(error);\n                    if (again) resync.needed = true;\n                    return again;\n                },\n            });\n        }\n\n        if (stopping === \"pause\") {\n            setState(\"paused\");\n            return null;\n        }\n        if (stopping === \"abort\") {\n            setState(\"aborted\");\n            return null;\n        }\n\n        setState(\"done\");\n        if (storage) await storage.delete(key);\n        return { url: target, size: file.size };\n    }\n\n    async function guarded(): Promise<ResumableUploadResult | null> {\n        try {\n            return await run();\n        } catch (error) {\n            if (\n                stopping !== null ||\n                (error instanceof DOMException && error.name === \"AbortError\")\n            ) {\n                setState(stopping === \"abort\" ? \"aborted\" : \"paused\");\n                return null;\n            }\n            setState(\"error\");\n            throw error;\n        } finally {\n            inFlight = null;\n        }\n    }\n\n    function stop(reason: \"pause\" | \"abort\"): void {\n        stopping = reason;\n        inFlight?.abort();\n        inFlight = null;\n    }\n\n    return {\n        start: guarded,\n        resume: guarded,\n        pause: () => stop(\"pause\"),\n        abort: async ({ discard = false } = {}) => {\n            stop(\"abort\");\n            abandoned = true;\n            setState(\"aborted\");\n            if (!discard) return;\n            if (url) {\n                await sendRequest({\n                    method: \"DELETE\",\n                    url,\n                    headers: baseHeaders(url, \"DELETE\"),\n                    withCredentials,\n                    register: () => undefined,\n                    holdRedirects: holdsRedirects(url),\n                }).catch(() => undefined);\n            }\n            if (storage) await storage.delete(key);\n        },\n        get state() {\n            return state;\n        },\n        get offset() {\n            return offset;\n        },\n        get url() {\n            return url;\n        },\n        key,\n    };\n}\n"],"mappings":"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"}
+{"version":3,"file":"resumable-upload.cjs","names":["bytesToBase64","TempestApiError","isApiError","isRetriableStatus","buildApiError","resolveRequestUrl","sessionIdentityOf","ownerFingerprint","isTrustedCredentialTarget","csrfHeaders","generateIdempotencyKey","retry","require_errors","require_base64","require_credential_scope","require_csrf","require_retry","require_session_identity","require_owner_fingerprint","require_idempotency","TUS_VERSION","DEFAULT_CHUNK_SIZE","ResumableUploadSupersededError","reason","clearGenerations","localGenerations","isUploadRecord","raw","value","base64Utf8","encodeMetadata","metadata","parts","name","uploadFingerprint","named","file","modified","endpoint","createLocalUploadStorage","backend","storage","prefix","key","record","store","owned","index","UPLOAD_REDIRECT_REFUSED","UPLOAD_OFFSET_STALLED","sendRequest","init","sendWithoutRedirects","sendOverXhr","controller","response","text","xhr","report","event","resolve","reject","parseOffset","parseErrorBody","RESYNCABLE_STATUSES","isRetriableChunkFailure","error","failed","body","envelope","hasDetail","detail","resolveUploadUrl","createResumableUpload","principalOption","retryOptions","options","getPrincipal","getToken","state","offset","url","idempotencyKey","owner","attached","abandoned","generationOf","generation","currentOwner","assertCurrentOwner","stopping","inFlight","resumedFrom","setState","next","onStateChange","onProgress","loaded","baseHeaders","inScope","target","trustedOrigins","result","headers","token","register","request","holdsRedirects","persist","probe","confirmed","ensureUpload","current","ownUrl","stored","ownRecord","creationHeaders","encoded","locationHeader","writeChunk","resync","end","chunkSize","from","run","again","attempt","guarded","stop","discard"],"sources":["../../src/http/resumable-upload.ts"],"sourcesContent":["/**\n * @tempest-limits file-lines, function-lines — a resumable upload is one long-lived\n * state machine: chunk the file, negotiate the offset the server already has, upload\n * with retry and backoff, honour pause, resume and abort, and report progress\n * throughout. Every stage reads the same cursor and the same abort signal, and\n * createResumableUpload is the closure that owns them.\n */\nimport { sessionIdentityOf } from \"@/auth/session-identity\";\nimport { ownerFingerprint } from \"@/utils/owner-fingerprint\";\nimport { bytesToBase64 } from \"@/utils/base64\";\nimport {\n    isTrustedCredentialTarget,\n    reportSuppressedCredential,\n    resolveRequestUrl,\n} from \"./credential-scope\";\nimport { csrfHeaders } from \"./csrf\";\nimport type { CsrfOptions } from \"./csrf\";\nimport { buildApiError, isApiError, isRetriableStatus, TempestApiError } from \"./errors\";\nimport { generateIdempotencyKey } from \"./idempotency\";\nimport { retry, type RetryOptions } from \"./retry\";\n\n/** The tus protocol version this client speaks. */\nexport const TUS_VERSION = \"1.0.0\";\n\n/** Default chunk size: 5 MiB, the size most tus servers are tuned for. */\nexport const DEFAULT_CHUNK_SIZE = 5 * 1024 * 1024;\n\n/**\n * Thrown by `start()`/`resume()` when the run can no longer go on as the\n * account that started it.\n *\n * - `\"principal\"` — `getPrincipal` names someone else than when the run\n *   attached: the next chunk would carry the new account's token to the\n *   previous account's upload URL, and the record would be stamped for the\n *   wrong owner.\n * - `\"cleared\"` — `createLocalUploadStorage().clear()` ran for this storage's\n *   prefix (typically in `onSessionEnd`): writing the record back would undo\n *   the clear.\n *\n * Not a pause: the run cannot be resumed as the new account. The state moves\n * to `\"error\"`, and the previous owner's record is left as it was.\n */\nexport class ResumableUploadSupersededError extends Error {\n    /** Why the run stopped. */\n    readonly reason: \"principal\" | \"cleared\";\n\n    /**\n     * @param reason - Why the run stopped.\n     */\n    constructor(reason: \"principal\" | \"cleared\") {\n        super(\n            reason === \"principal\"\n                ? \"O usuário mudou durante o upload resumível.\"\n                : \"Os registros de upload resumível foram limpos durante o upload.\",\n        );\n        this.name = \"ResumableUploadSupersededError\";\n        this.reason = reason;\n    }\n}\n\n/**\n * How many times `clear()` ran per local-storage prefix, so a run can tell its\n * record was cleared under it — even through another\n * `createLocalUploadStorage()` object with the same prefix, which is what an\n * `onSessionEnd` builds.\n */\nconst clearGenerations = new Map<string, number>();\n\n/**\n * The clear generation reader of each storage built by\n * `createLocalUploadStorage`. A custom storage has none, and its runs only\n * stop on a principal change.\n */\nconst localGenerations = new WeakMap<ResumableUploadStorage, () => number>();\n\n/**\n * Whether a stored value has the shape of a {@link ResumableUploadRecord}.\n *\n * `clear()` matches keys by prefix, and a prefix with no delimiter (`\"app\"`)\n * also matches an app's own keys (`\"appSettings\"`). Changing how keys are\n * built would orphan every record already stored under a custom prefix, so\n * `clear()` removes only values this storage could have written.\n *\n * @param raw - The stored string.\n * @returns Whether it parses as a record.\n */\nfunction isUploadRecord(raw: string | null): boolean {\n    if (!raw) return false;\n    try {\n        const value = JSON.parse(raw) as Partial<ResumableUploadRecord> | null;\n        return (\n            typeof value === \"object\" &&\n            value !== null &&\n            typeof value.url === \"string\" &&\n            typeof value.offset === \"number\" &&\n            typeof value.size === \"number\" &&\n            typeof value.idempotencyKey === \"string\"\n        );\n    } catch {\n        return false;\n    }\n}\n\n/**\n * Where a resumable upload is.\n *\n * `\"paused\"` and `\"aborted\"` are both \"not running\", but only `\"paused\"` keeps the\n * persisted offset — `abort({ discard: true })` throws it away.\n */\nexport type ResumableUploadState =\n    \"idle\" | \"creating\" | \"uploading\" | \"paused\" | \"done\" | \"error\" | \"aborted\";\n\n/** Byte-level progress for a resumable upload. */\nexport interface ResumableUploadProgress {\n    /** Bytes the server holds, including anything a resume skipped. */\n    loaded: number;\n    /** Total size of the file. */\n    total: number;\n    /** `loaded / total`, between 0 and 1. */\n    fraction: number;\n    /** Bytes already on the server when this run started. `0` on a fresh upload. */\n    resumedFrom: number;\n}\n\n/** What has to survive a page reload for a resume to be possible. */\nexport interface ResumableUploadRecord {\n    /** Upload URL the creation POST returned, absolute. */\n    url: string;\n    /** Last offset the server confirmed. */\n    offset: number;\n    /** File size, so a different file under the same key is not resumed into. */\n    size: number;\n    /** Idempotency key of the creation request, reused if creation is retried. */\n    idempotencyKey: string;\n    /** Epoch ms of the last write, so an app can sweep stale records. */\n    updatedAt: number;\n    /**\n     * One-way fingerprint of the principal that created the upload (`\"p:<hex>\"`)\n     * or, without {@link ResumableUploadOptions.getPrincipal}, of the bearer\n     * token of its last write (`\"t:<hex>\"`, since 0.82.0); `null` for an\n     * anonymous one. Absent when the upload ran with neither getter, and on\n     * records written before 0.78.0.\n     */\n    owner?: string | null;\n}\n\n/**\n * Persistence for resume state. Sync or async — both are awaited.\n *\n * Implement it over anything: the default is `localStorage`, and\n * `createOfflineStore` from `@/offline` slots in when you already have a Dexie\n * database open.\n */\nexport interface ResumableUploadStorage {\n    /** Read the record for `key`, or `null`. */\n    get(key: string): Promise<ResumableUploadRecord | null> | ResumableUploadRecord | null;\n    /** Write the record for `key`. */\n    set(key: string, record: ResumableUploadRecord): Promise<void> | void;\n    /** Forget the record for `key`. */\n    delete(key: string): Promise<void> | void;\n}\n\n/**\n * The default `localStorage` storage, which can also forget every record it\n * holds.\n */\nexport interface LocalUploadStorage extends ResumableUploadStorage {\n    /**\n     * Forget every record under this storage's prefix — the call for\n     * `onSessionEnd`, so the next account on the browser does not find the\n     * previous one's upload URLs. Synchronous; a no-op without `localStorage`.\n     *\n     * Only values shaped like a record are removed, so a prefix without a\n     * delimiter does not take the app's own keys with it. A run still going on\n     * this prefix stops before its next chunk with\n     * {@link ResumableUploadSupersededError} (`\"cleared\"`) instead of writing\n     * its record back.\n     */\n    clear(): void;\n}\n\n/** Options for {@link createResumableUpload}. */\nexport interface ResumableUploadOptions {\n    /** tus creation endpoint, e.g. `\"/api/uploads\"`. */\n    endpoint: string;\n    /** The bytes to upload. A `File` also supplies the default resume key. */\n    file: Blob | File;\n    /** Bytes per `PATCH`. Default {@link DEFAULT_CHUNK_SIZE}. */\n    chunkSize?: number;\n    /** Sent as `Upload-Metadata` (base64-encoded values), e.g. `{ filename }`. */\n    metadata?: Record<string, string>;\n    /**\n     * Extra headers on every request inside the credential scope — the\n     * `endpoint`'s origin plus {@link trustedOrigins}. A `Location` on another\n     * host gets only the tus headers, never these (since 0.82.0).\n     *\n     * A request that carries them never follows a redirect (since 0.83.0): it\n     * goes out over `fetch` with `redirect: \"manual\"`, and a redirect rejects\n     * with a `TempestApiError` of `code: \"REDIRECT_REFUSED\"`. An\n     * `XMLHttpRequest` follows every redirect, and these headers went with it\n     * to the other origin (#564). The cost: `fetch` reports no upload\n     * progress, so `onProgress` then ticks once per confirmed chunk — lower\n     * `chunkSize` for a finer bar, or send the credential through `getToken`,\n     * which keeps the `XMLHttpRequest` (the browser strips `Authorization` on\n     * a cross-origin redirect).\n     */\n    headers?: Record<string, string>;\n    /** Returns the current bearer token, read before each request. */\n    getToken?: () => string | null | undefined;\n    /**\n     * Who is signed in — a user id, or `null`/`undefined` for nobody — read when\n     * `start()`/`resume()` attaches to the upload. The same getter the error\n     * reporter and `provideBackgroundSyncCredentials` take.\n     *\n     * The resume record is stamped with a one-way fingerprint of it, and a\n     * record stamped by anyone else — another user, nobody, or no stamp at all\n     * — is deleted instead of resumed: its upload URL is not probed, and its\n     * `Idempotency-Key` is never replayed (#479).\n     *\n     * Without it, since 0.82.0 the record is bound to a fingerprint of the\n     * `getToken` token instead, so another account's record is still never\n     * adopted (#528) — but a token rotates: a reload after a refresh that no\n     * chunk landed under starts the upload over. Pass `getPrincipal` to keep\n     * resuming across refreshes, and always with a cookie session, where there\n     * is no token to bind to and the record stays unbound.\n     *\n     * `getToken: auth.getToken` — the getter of `createTempestAuth` itself, not\n     * an arrow around it — binds to that preset's session instead, as if\n     * `getPrincipal: auth.sessionKey` were passed: the record survives token\n     * rotation, a switch of account stops the run, and a new `login()`, even\n     * into the same account, starts over.\n     *\n     * It is read again before every chunk and every record write: when it\n     * names someone else mid-run, the run stops with\n     * {@link ResumableUploadSupersededError} (`\"principal\"`) before the new\n     * account's token reaches the previous one's upload URL. Without it,\n     * `createLocalUploadStorage().clear()` from `onSessionEnd` stops the runs in\n     * flight and, since 0.84.0, makes a paused handle start over with a fresh\n     * `Idempotency-Key`; with a custom `storage`, call `abort()` on the uploads\n     * in progress there instead.\n     */\n    getPrincipal?: () => string | number | null | undefined;\n    /**\n     * Origins besides `endpoint`'s that may receive the `getToken` credential.\n     *\n     * Since 0.66.0 the bearer token is scoped to the origin of `endpoint`, and\n     * the creation response's `Location` no longer decides where it goes. A\n     * server that hands the upload to object storage on another host still\n     * works — the `PATCH` requests simply carry no `Authorization`, which is\n     * what a presigned storage URL expects anyway.\n     *\n     * List the storage origin here when it does need the API's token.\n     */\n    trustedOrigins?: readonly string[];\n    /** Send cookies. Default `false`. */\n    withCredentials?: boolean;\n    /**\n     * Send a CSRF token on the creation `POST`, every chunk `PATCH` and the\n     * discarding `DELETE` — never on the offset `HEAD`. Off by default; `true`\n     * reads the `csrf_token` cookie into `X-CSRF-Token`, as `createApiClient`\n     * does.\n     *\n     * Scoped like the bearer token, to `endpoint`'s origin plus\n     * {@link trustedOrigins}: a `Location` pointing at object storage on\n     * another host gets neither.\n     */\n    csrf?: boolean | CsrfOptions;\n    /**\n     * Resume key. Defaults to a fingerprint of endpoint + file name/size/mtime, so\n     * picking the same file after a reload resumes instead of restarting.\n     */\n    key?: string;\n    /**\n     * Where to persist resume state. Defaults to `localStorage`. Pass `null` to\n     * disable persistence — resume then only survives a network blip, not a reload.\n     */\n    storage?: ResumableUploadStorage | null;\n    /** Backoff for a failed chunk. Forwarded to `retry`. Default 5 attempts. */\n    retry?: RetryOptions;\n    /** Called on every upload-progress tick and after every confirmed chunk. */\n    onProgress?: (progress: ResumableUploadProgress) => void;\n    /** Called whenever {@link ResumableUpload.state} changes. */\n    onStateChange?: (state: ResumableUploadState) => void;\n}\n\n/** What a finished upload resolves with. */\nexport interface ResumableUploadResult {\n    /** The tus upload URL — hand this to your API to link the stored file. */\n    url: string;\n    /** Total bytes uploaded. */\n    size: number;\n}\n\n/** A resumable upload in progress. Build one with {@link createResumableUpload}. */\nexport interface ResumableUpload {\n    /**\n     * Create (or re-attach to) the upload and push chunks until it is complete.\n     *\n     * Resolves `null` when the run stopped because of `pause()` or `abort()` —\n     * neither is a failure. Rejects with a `TempestApiError` when the server\n     * refused and the retries ran out.\n     */\n    start(): Promise<ResumableUploadResult | null>;\n    /** Stop after the in-flight chunk is dropped, keeping the resume point. */\n    pause(): void;\n    /** Continue from the server's offset. Same resolution contract as `start`. */\n    resume(): Promise<ResumableUploadResult | null>;\n    /**\n     * Stop for good.\n     *\n     * A later `start()`/`resume()` on the same handle attaches as a new handle\n     * would (since 0.83.0): it resumes the stored record only when the current\n     * owner stamped it, and otherwise creates a new upload with a fresh\n     * `Idempotency-Key`. Until then a token-bound handle resumed its own upload\n     * with whatever token was current — after an account switch, the next\n     * account's (#561).\n     *\n     * @param options - `discard: true` also sends `DELETE` (tus termination) and\n     *   forgets the persisted record, so the next `start()` uploads from zero.\n     */\n    abort(options?: { discard?: boolean }): Promise<void>;\n    /** Current state. */\n    readonly state: ResumableUploadState;\n    /** Bytes the server has confirmed. */\n    readonly offset: number;\n    /** The upload URL, once creation succeeded. */\n    readonly url: string | null;\n    /** The resume key in use. */\n    readonly key: string;\n}\n\ninterface RawResponse {\n    status: number;\n    text: string;\n    header(name: string): string | null;\n}\n\n/**\n * Encode a string as standard base64 (padded), UTF-8 first.\n *\n * `Upload-Metadata` carries base64 values precisely so a filename with accents\n * survives an HTTP header, so the UTF-8 step is not optional: `btoa` alone throws\n * on any code point above U+00FF. Only that step is specific here — the\n * bytes-to-text half is {@link bytesToBase64}.\n *\n * @param value - Text to encode.\n * @returns Padded base64.\n */\nfunction base64Utf8(value: string): string {\n    return bytesToBase64(new TextEncoder().encode(value));\n}\n\n/**\n * Build the `Upload-Metadata` header value: comma-separated `key base64(value)`.\n *\n * @param metadata - Plain string map.\n * @returns The header value, or `null` when there is nothing to send.\n */\nfunction encodeMetadata(metadata: Record<string, string> | undefined): string | null {\n    if (!metadata) return null;\n    const parts = Object.entries(metadata).map(([name, value]) => `${name} ${base64Utf8(value)}`);\n    return parts.length > 0 ? parts.join(\",\") : null;\n}\n\n/**\n * A stable-enough identity for a file, used as the default resume key.\n *\n * Name + size + last-modified is what the tus reference clients fingerprint on:\n * it is cheap (hashing the bytes of a 400 MB recording is not) and it changes\n * whenever the file does, which is the property that matters — resuming into the\n * wrong file would corrupt it silently.\n *\n * @param endpoint - Creation endpoint, so the same file to two servers is two uploads.\n * @param file - The blob or file being uploaded.\n * @returns A key safe to use in `localStorage`.\n */\nexport function uploadFingerprint(endpoint: string, file: Blob | File): string {\n    const named = file as File;\n    const name = typeof named.name === \"string\" ? named.name : \"blob\";\n    const modified = typeof named.lastModified === \"number\" ? named.lastModified : 0;\n    return `${endpoint}|${name}|${file.size}|${file.type}|${modified}`;\n}\n\n/**\n * `localStorage`-backed resume storage — the default.\n *\n * `localStorage` and not IndexedDB on purpose. The record is four fields and a\n * URL; the requirement is only that it survives a reload, and pulling Dexie in for\n * that would put an IndexedDB dependency in the bundle of every app that uploads a\n * file. Apps that already have `createOfflineStore` open can pass their own\n * {@link ResumableUploadStorage} instead.\n *\n * `clear()` forgets every record under the prefix. Call it from\n * `onSessionEnd`: a record outlives the session that wrote it, and only\n * completing the upload or `abort({ discard: true })` removes it otherwise.\n * It also ends every handle built over a storage with the same prefix: a run\n * in flight stops with {@link ResumableUploadSupersededError} (`\"cleared\"`),\n * and a paused one's next `resume()` starts a new upload with a fresh\n * `Idempotency-Key` (since 0.84.0, #528).\n *\n * @param prefix - Key prefix. Default `\"tempest-upload:\"`.\n * @returns A storage that no-ops when `localStorage` is unavailable.\n */\nexport function createLocalUploadStorage(prefix = \"tempest-upload:\"): LocalUploadStorage {\n    function backend(): Storage | null {\n        try {\n            return typeof localStorage === \"undefined\" ? null : localStorage;\n        } catch {\n            return null;\n        }\n    }\n\n    const storage: LocalUploadStorage = {\n        get(key) {\n            const raw = backend()?.getItem(prefix + key);\n            if (!raw) return null;\n            try {\n                return JSON.parse(raw) as ResumableUploadRecord;\n            } catch {\n                return null;\n            }\n        },\n        set(key, record) {\n            backend()?.setItem(prefix + key, JSON.stringify(record));\n        },\n        delete(key) {\n            backend()?.removeItem(prefix + key);\n        },\n        clear() {\n            clearGenerations.set(prefix, (clearGenerations.get(prefix) ?? 0) + 1);\n            const store = backend();\n            if (!store) return;\n            const owned: string[] = [];\n            for (let index = 0; index < store.length; index += 1) {\n                const name = store.key(index);\n                if (name?.startsWith(prefix) && isUploadRecord(store.getItem(name))) {\n                    owned.push(name);\n                }\n            }\n            for (const name of owned) store.removeItem(name);\n        },\n    };\n    localGenerations.set(storage, () => clearGenerations.get(prefix) ?? 0);\n    return storage;\n}\n\n/** Something a run can cancel: the open `XMLHttpRequest`, or a `fetch`'s controller. */\ninterface InFlightRequest {\n    abort(): void;\n}\n\n/** One tus request, as the transports take it. */\ninterface TusRequest {\n    method: \"POST\" | \"HEAD\" | \"PATCH\" | \"DELETE\";\n    url: string;\n    headers: Record<string, string>;\n    body?: Blob;\n    withCredentials: boolean;\n    onProgress?: (loaded: number) => void;\n    register: (request: InFlightRequest) => void;\n    /**\n     * Refuse a redirect instead of following it — set when the request carries\n     * the static `headers`, see {@link sendRequest}.\n     */\n    holdRedirects: boolean;\n}\n\n/**\n * The `code` of the {@link TempestApiError} a request carrying the static\n * `headers` rejects with when the server answers it with a redirect — the same\n * code `createApiClient` uses for the same refusal (#554). Never retried:\n * replaying gets the same redirect back.\n */\nconst UPLOAD_REDIRECT_REFUSED = \"REDIRECT_REFUSED\";\n\n/**\n * The `code` of the {@link TempestApiError} a chunk rejects with when the\n * server confirms the `PATCH` (`200`/`204`) but its `Upload-Offset` did not\n * move past the offset the chunk was written at (#569).\n *\n * tus 1.0.0 says the new offset \"MUST be the sum of the offset before the\n * `PATCH` request and the number of bytes received\", so a confirmed write\n * that reports the same offset (or a smaller one) is a protocol violation —\n * the shape a redirect produces when it turns the chunk into a body-less\n * `GET` answered `200`, or a proxy that drops the body. Until 0.83.0 the\n * chunk loop took that answer as success and wrote the same bytes again,\n * forever: measured during #568, more than 1500 requests in 4 s, even with\n * `retries: 0`, because every iteration of the loop got a fresh retry budget\n * and none of them ever failed.\n *\n * It is counted as a chunk failure, not refused outright: the next attempt\n * re-reads the offset with `HEAD` first (the server may have stored the bytes\n * and only reported badly), and the run rejects once the `retries` budget is\n * spent — `retries: 0` sends one `PATCH`. That is the same budget rule the\n * reference client (`tus-js-client`) applies, where only an offset that moved\n * refills the retry counter.\n */\nconst UPLOAD_OFFSET_STALLED = \"UPLOAD_OFFSET_STALLED\";\n\n/**\n * Send one tus request.\n *\n * `XMLHttpRequest` rather than `fetch` for the same reason `uploadWithProgress`\n * uses it — `fetch` still cannot report upload progress in any browser — plus one\n * more: tus answers every write with the new `Upload-Offset` in a **response\n * header**, and `uploadWithProgress` only hands back a parsed body, so it could\n * not be reused here.\n *\n * Except when the request carries the static `headers` (#564). An\n * `XMLHttpRequest` always follows a redirect, and measured in Chrome 150 —\n * the packaged `createResumableUpload` against a server on `127.0.0.1:5340`\n * that answered `301`/`302`/`303`/`307`/`308` towards `localhost:5341` —\n * `X-Api-Key` reached the other origin on every one of them, on the creation\n * `POST` and on the chunk `PATCH`, along with the bytes; only `Authorization`\n * was stripped by the browser. Reading `responseURL` afterwards tells where\n * the request ended up, but by then the header is gone. So such a request goes\n * out over `fetch` with `redirect: \"manual\"`, and a redirect is refused, as in\n * `createApiClient`. The cost is the progress inside a chunk: `fetch` reports\n * none, so `onProgress` ticks once per confirmed chunk for those requests.\n *\n * @param init - The request.\n * @returns Status, raw text and a header reader.\n */\nfunction sendRequest(init: TusRequest): Promise<RawResponse> {\n    return init.holdRedirects ? sendWithoutRedirects(init) : sendOverXhr(init);\n}\n\n/**\n * Send one tus request over `fetch` with `redirect: \"manual\"`, refusing the\n * redirect it may be answered with, see {@link sendRequest}.\n *\n * A browser hands the stopped redirect back as an `opaqueredirect` with\n * status `0` (measured for #554); a server runtime hands back the real `3xx`.\n * Both are refused; `304` is a cache answer, not a redirect.\n *\n * @param init - The request.\n * @returns Status, raw text and a header reader.\n * @throws {TempestApiError} `code: \"REDIRECT_REFUSED\"` on a redirect, status\n *   `0` on a network failure.\n */\nasync function sendWithoutRedirects(init: TusRequest): Promise<RawResponse> {\n    const controller = new AbortController();\n    init.register(controller);\n    let response: Response;\n    try {\n        response = await fetch(init.url, {\n            method: init.method,\n            headers: init.headers,\n            body: init.body,\n            credentials: init.withCredentials ? \"include\" : \"same-origin\",\n            redirect: \"manual\",\n            signal: controller.signal,\n        });\n    } catch {\n        if (controller.signal.aborted) throw new DOMException(\"Aborted\", \"AbortError\");\n        throw new TempestApiError({ status: 0, detail: \"Falha de rede no upload resumível.\" });\n    }\n    if (\n        response.type === \"opaqueredirect\" ||\n        (response.status >= 300 && response.status < 400 && response.status !== 304)\n    ) {\n        throw new TempestApiError({\n            status: response.status,\n            code: UPLOAD_REDIRECT_REFUSED,\n            detail: \"Redirect não seguido: a requisição do upload levava os headers fixos.\",\n        });\n    }\n    const text = init.method === \"HEAD\" ? \"\" : await response.text();\n    return { status: response.status, text, header: (name) => response.headers.get(name) };\n}\n\n/**\n * Send one tus request over `XMLHttpRequest`, which reports upload progress\n * and follows redirects, see {@link sendRequest}.\n *\n * @param init - The request.\n * @returns Status, raw text and a header reader.\n */\nfunction sendOverXhr(init: TusRequest): Promise<RawResponse> {\n    return new Promise<RawResponse>((resolve, reject) => {\n        const xhr = new XMLHttpRequest();\n        xhr.open(init.method, init.url);\n        xhr.withCredentials = init.withCredentials;\n        for (const [name, value] of Object.entries(init.headers)) {\n            xhr.setRequestHeader(name, value);\n        }\n        if (init.onProgress) {\n            const report = init.onProgress;\n            xhr.upload.onprogress = (event: ProgressEvent) => report(event.loaded);\n        }\n        xhr.onload = () =>\n            resolve({\n                status: xhr.status,\n                text: xhr.responseText,\n                header: (name) => xhr.getResponseHeader(name),\n            });\n        xhr.onerror = () =>\n            reject(\n                new TempestApiError({\n                    status: 0,\n                    detail: \"Falha de rede no upload resumível.\",\n                }),\n            );\n        xhr.onabort = () => reject(new DOMException(\"Aborted\", \"AbortError\"));\n        init.register(xhr);\n        xhr.send(init.body);\n    });\n}\n\nfunction parseOffset(response: RawResponse): number | null {\n    const raw = response.header(\"Upload-Offset\");\n    if (raw === null) return null;\n    const value = Number(raw);\n    return Number.isFinite(value) && value >= 0 ? value : null;\n}\n\n/**\n * Read an error body without assuming it is JSON.\n *\n * A tus proxy that rejects a chunk often answers with plain text or an HTML error\n * page, and `JSON.parse` throwing there would replace a useful status with a parse\n * error.\n *\n * @param text - Raw response text.\n * @returns The parsed object, the raw text, or `null` when the body was empty.\n */\nfunction parseErrorBody(text: string): unknown {\n    if (!text) return null;\n    try {\n        return JSON.parse(text);\n    } catch {\n        return text;\n    }\n}\n\n/**\n * Turn a refused tus response into a `TempestApiError`.\n *\n * The fallback `detail` is used unless the server sent a real error envelope,\n * because `buildApiError`'s own fallback (`\"Erro 409\"`) says nothing about which\n * step of the protocol broke — and that is the whole diagnostic value here.\n *\n * @param response - The raw response that was not acceptable.\n * @param detail - Message to use when the body carries none.\n * @returns The error to throw.\n */\n/**\n * The two statuses a chunk retry fixes that the shared policy cannot know about.\n *\n * `409` and `412` are the offset-divergence answers, and they are the entire\n * reason `resync` exists: the next attempt re-reads the server's offset with\n * `HEAD` and writes from there. They are 4xx refusals a replay genuinely fixes,\n * which is the one thing {@link isRetriableStatus} has no way to tell — from\n * outside this protocol they look like any other deliberate rejection.\n */\nconst RESYNCABLE_STATUSES: ReadonlySet<number> = new Set([409, 412]);\n\n/**\n * Whether a chunk failure is worth another attempt.\n *\n * The default used to be `true` for everything, which cost five round trips\n * before surfacing an answer the first one already gave. Two groups matter here\n * and both are specific to the resume protocol:\n *\n * - **`409`/`412` retry**, even though the shared policy rejects 4xx: they mean\n *   \"your offset is wrong\", and `resync` is how the next attempt fixes it.\n * - **`404`/`410` do not**, even though a lost resource can look transient.\n *   `probe()` turns them into \"O upload expirou no servidor. Comece de novo.\" and\n *   recreating the upload only happens in `ensureUpload`, at attach time — never\n *   inside the chunk loop. So a retry here re-runs `HEAD` against a resource that\n *   is gone, five times, and then reports the same thing with the backoff added\n *   on top.\n *\n * - **`UPLOAD_OFFSET_STALLED` retries**, though its status is a `2xx` the\n *   shared policy knows nothing about: the next attempt resyncs with `HEAD`,\n *   and the budget is what stops a server that keeps confirming nothing.\n *\n * Anything with no API shape still retries: a transport failure has no status to\n * judge, and losing a large upload to one dropped connection is the outcome this\n * whole module exists to avoid.\n *\n * @param error - Whatever the attempt threw.\n * @returns Whether the chunk loop should try again.\n */\nfunction isRetriableChunkFailure(error: unknown): boolean {\n    if (!isApiError(error)) return true;\n    if (error.code === UPLOAD_REDIRECT_REFUSED) return false;\n    if (error.code === UPLOAD_OFFSET_STALLED) return true;\n    if (RESYNCABLE_STATUSES.has(error.status)) return true;\n    return isRetriableStatus(error.status);\n}\n\nfunction failed(response: RawResponse, detail: string): TempestApiError {\n    const body = parseErrorBody(response.text);\n    const envelope = buildApiError(response.status, body, { get: response.header });\n    const hasDetail =\n        typeof body === \"object\" && body !== null && (\"detail\" in body || \"message\" in body);\n    return new TempestApiError({ ...envelope, detail: hasDetail ? envelope.detail : detail });\n}\n\n/**\n * Resolve a `Location` header against the creation endpoint, so a relative\n * upload URL works.\n *\n * tus servers are free to answer creation with either an absolute URL or a\n * path, and the spec does not prefer one — a client that only handles absolute\n * URLs breaks against half the implementations.\n *\n * The base is the URL the creation `POST` went to, as RFC 9110 §10.2.2 says\n * for `Location`, resolved the way the transport resolved it. Until 0.82.0 it\n * was the page's address: with an absolute `endpoint` on a tus host, a\n * `Location: /files/abc` pointed the chunks at the app's own origin (#530).\n *\n * @param value - The raw `Location` header.\n * @param endpoint - The creation endpoint the `POST` went to.\n * @returns An absolute URL, or the input when there is no base to resolve against.\n */\nfunction resolveUploadUrl(value: string, endpoint: string): string {\n    try {\n        return new URL(value, resolveRequestUrl(endpoint) ?? undefined).href;\n    } catch {\n        return value;\n    }\n}\n\n/**\n * Chunked, resumable upload speaking the **tus 1.0.0** protocol (core plus the\n * *creation* and *termination* extensions).\n *\n * ## Why tus and not a bespoke scheme\n *\n * A resumable client whose wire format is undocumented cannot be integrated, and\n * inventing one means the backend is ours forever. tus is a published spec with\n * off-the-shelf servers (`tusd`, `tuspy`, `tus-node-server`), so a caller can point\n * this at something they did not write.\n *\n * ## What the backend must implement\n *\n * Every request carries `Tus-Resumable: 1.0.0`.\n *\n * | Step | Request | Expected response |\n * | --- | --- | --- |\n * | Create | `POST {endpoint}` + `Upload-Length`, `Upload-Metadata`, `Idempotency-Key` | `201` + `Location` (the upload URL, absolute or endpoint-relative) |\n * | Probe | `HEAD {uploadUrl}` | `200`/`204` + `Upload-Offset` |\n * | Write | `PATCH {uploadUrl}` + `Upload-Offset`, `Content-Type: application/offset+octet-stream`, chunk body | `204` + the new `Upload-Offset`, past the one sent; `409` when the offset does not match |\n * | Discard | `DELETE {uploadUrl}` | `204` |\n *\n * ## The failure that actually happens\n *\n * A chunk that the server stored but whose response never arrived. The client\n * cannot tell that from a chunk that was lost, and re-sending it blindly would\n * duplicate bytes. Two things prevent that:\n *\n * - **Writes are addressed, not appended.** Every `PATCH` states the offset it\n *   writes at, so a retry after a lost response is asked to write bytes the server\n *   already has and answers `409`. On any retry the client re-reads the truth with\n *   `HEAD` first and continues from there.\n * - **Creation carries an `Idempotency-Key`** (from `generateIdempotencyKey`),\n *   persisted before the first attempt and reused on retry. tus has no idempotent\n *   creation of its own, so without this a lost `201` leaves an orphan upload on\n *   the server. A backend that honours the header returns the same `Location`; one\n *   that ignores it still works, it just keeps the orphan.\n *\n * @param options - Endpoint, file, and the knobs above.\n * @returns A handle with `start`/`pause`/`resume`/`abort` and live `state`/`offset`.\n *\n * @example\n * const upload = createResumableUpload({\n *     endpoint: \"/api/uploads\",\n *     file: recording,\n *     metadata: { filename: \"nota.webm\", ticket: ticketId },\n *     getToken: () => auth.getToken(),\n *     onProgress: ({ fraction }) => setPercent(Math.round(fraction * 100)),\n * });\n *\n * const done = await upload.start();\n * if (done) await api.post(\"/api/tickets/1/audio\", { body: { url: done.url } });\n */\nexport function createResumableUpload(options: ResumableUploadOptions): ResumableUpload {\n    const {\n        endpoint,\n        file,\n        chunkSize = DEFAULT_CHUNK_SIZE,\n        metadata,\n        headers = {},\n        getToken,\n        getPrincipal: principalOption,\n        trustedOrigins,\n        withCredentials = false,\n        csrf,\n        key = uploadFingerprint(endpoint, file),\n        storage = createLocalUploadStorage(),\n        retry: retryOptions,\n        onProgress,\n        onStateChange,\n    } = options;\n    const getPrincipal = principalOption ?? sessionIdentityOf(getToken)?.current;\n\n    let state: ResumableUploadState = \"idle\";\n    let offset = 0;\n    let url: string | null = null;\n    let idempotencyKey: string | null = null;\n    let owner: string | null | undefined;\n    let attached = false;\n    let abandoned = false;\n    const generationOf = storage ? localGenerations.get(storage) : undefined;\n    let generation = generationOf?.() ?? 0;\n\n    /**\n     * Who the resume record belongs to right now, as the fingerprint it is\n     * stamped with.\n     *\n     * `getPrincipal` wins when given (`\"p:…\"`), and so does the session of a\n     * `getToken` that `createTempestAuth` handed out, read as its principal.\n     * Without either, a `getToken` getter\n     * still names the credential every request carries, so the record is bound\n     * to a fingerprint of the token (`\"t:…\"`) — never the token itself. Until\n     * 0.82.0 a record written without `getPrincipal` had no owner at all and\n     * was adopted by whoever picked an identical file next: `HEAD`/`PATCH` with\n     * their token to the previous user's upload URL, and the previous user's\n     * `Idempotency-Key` replayed on their creation (#528).\n     *\n     * A token rotates, a principal does not, which is why `getPrincipal` is\n     * still the better binding: a reload after a refresh that happened while\n     * no chunk was landing starts the upload over. `undefined` — no binding —\n     * only when there is neither getter: an anonymous upload, or a cookie\n     * session the SDK cannot see.\n     *\n     * @returns The fingerprint, `null` for nobody, `undefined` for unbound.\n     */\n    function currentOwner(): string | null | undefined {\n        if (getPrincipal) return ownerFingerprint(\"p\", getPrincipal());\n        if (getToken) return ownerFingerprint(\"t\", getToken());\n        return undefined;\n    }\n\n    /**\n     * Throw when the run can no longer go on as the account that attached it:\n     * the principal changed, or the local storage was cleared under it.\n     *\n     * @throws {ResumableUploadSupersededError} In either case.\n     */\n    function assertCurrentOwner(): void {\n        if (getPrincipal && ownerFingerprint(\"p\", getPrincipal()) !== owner) {\n            throw new ResumableUploadSupersededError(\"principal\");\n        }\n        if (generationOf && generationOf() !== generation) {\n            throw new ResumableUploadSupersededError(\"cleared\");\n        }\n    }\n    let stopping: \"pause\" | \"abort\" | null = null;\n    let inFlight: InFlightRequest | null = null;\n    let resumedFrom = 0;\n\n    function setState(next: ResumableUploadState): void {\n        if (state === next) return;\n        state = next;\n        onStateChange?.(next);\n    }\n\n    function report(loaded: number): void {\n        onProgress?.({\n            loaded,\n            total: file.size,\n            fraction: file.size === 0 ? 1 : loaded / file.size,\n            resumedFrom,\n        });\n    }\n\n    /**\n     * Headers every tus request carries, with the credential scoped to the\n     * endpoint's origin.\n     *\n     * The target is a parameter because after creation it is not ours: tus\n     * answers `POST {endpoint}` with a `Location` the server chooses, and the\n     * spec allows an absolute URL on another host — handing the upload to\n     * object storage is the ordinary deployment, not an attack. Before 0.66.0\n     * the bearer token followed that header wherever it pointed, along with the\n     * file bytes.\n     *\n     * The CSRF token follows the same scope, and only on the methods that\n     * write — which is why the method is a parameter too. So do the static\n     * `headers` since 0.82.0: an `X-Api-Key` there is a credential, and until\n     * then it went to a foreign `Location` along with the bytes (#530).\n     *\n     * @param target - The URL this particular request goes to.\n     * @param method - The HTTP method of this request.\n     * @returns The headers to send.\n     */\n    function baseHeaders(target: string, method: string): Record<string, string> {\n        const inScope = isTrustedCredentialTarget(target, endpoint, trustedOrigins);\n        const result: Record<string, string> = {\n            ...(inScope ? headers : {}),\n            \"Tus-Resumable\": TUS_VERSION,\n        };\n        const token = getToken?.();\n        if (token && !(\"Authorization\" in headers)) {\n            if (inScope) {\n                result.Authorization = `Bearer ${token}`;\n            } else {\n                reportSuppressedCredential(target, endpoint);\n            }\n        }\n        Object.assign(\n            result,\n            csrfHeaders({\n                method,\n                url: target,\n                reference: endpoint,\n                csrf,\n                trustedOrigins,\n                headers,\n            }),\n        );\n        return result;\n    }\n\n    function register(request: InFlightRequest): void {\n        inFlight = request;\n    }\n\n    /**\n     * Whether a request to `target` carries the static `headers` — inside the\n     * credential scope, with at least one — and must therefore refuse a\n     * redirect, see {@link sendRequest}. Only those: the bearer token is\n     * stripped by the browser on a cross-origin redirect, and the CSRF token\n     * follows the reasoning `createApiClient` documents for it.\n     *\n     * @param target - The URL the request goes to.\n     * @returns Whether the request goes out over `fetch` without redirects.\n     */\n    function holdsRedirects(target: string): boolean {\n        return (\n            Object.keys(headers).length > 0 &&\n            isTrustedCredentialTarget(target, endpoint, trustedOrigins)\n        );\n    }\n\n    /**\n     * Write the resume record, stamped with whoever owns it now.\n     *\n     * Restamped on every write rather than fixed at attach, so a token refresh\n     * mid-upload does not orphan the record: the next reload, with the new\n     * token, still resumes it. With `getPrincipal` the stamp cannot drift —\n     * {@link assertCurrentOwner} stops the run first.\n     */\n    async function persist(): Promise<void> {\n        if (!storage || !url || !idempotencyKey) return;\n        assertCurrentOwner();\n        owner = currentOwner();\n        await storage.set(key, {\n            url,\n            offset,\n            size: file.size,\n            idempotencyKey,\n            updatedAt: Date.now(),\n            ...(owner === undefined ? {} : { owner }),\n        });\n    }\n\n    /**\n     * Ask the server how much it holds. The only source of truth after any failure.\n     */\n    async function probe(target: string): Promise<number> {\n        const response = await sendRequest({\n            method: \"HEAD\",\n            url: target,\n            headers: baseHeaders(target, \"HEAD\"),\n            withCredentials,\n            register,\n            holdRedirects: holdsRedirects(target),\n        });\n        if (response.status === 404 || response.status === 410) {\n            throw new TempestApiError({\n                status: response.status,\n                detail: \"O upload expirou no servidor. Comece de novo.\",\n            });\n        }\n        const confirmed = parseOffset(response);\n        if (confirmed === null) throw failed(response, \"HEAD sem Upload-Offset.\");\n        return confirmed;\n    }\n\n    /**\n     * Re-attach to a persisted upload, or create a new one.\n     *\n     * The persisted record is only trusted when the file size still matches, and the\n     * offset it holds is re-checked with `HEAD` — the client's copy can be ahead of\n     * the server's whenever the last response was lost.\n     *\n     * It is also only trusted when it carries the current owner's fingerprint\n     * (see {@link currentOwner}); anyone else's is deleted, and the creation\n     * that follows gets a fresh `Idempotency-Key`. With `getPrincipal`, the key\n     * this handle kept in memory from an earlier run is reused only while the\n     * principal is the same, which is what keeps creation idempotent across\n     * `resume()` without storage.\n     *\n     * Bound by token, the handle's own record is the exception: a `resume()`\n     * after a refresh finds the record it wrote itself, stamped with the token\n     * of its last write, and continues it instead of starting over.\n     *\n     * The exception ends at `abort()` (#561). A token-bound handle cannot tell\n     * a refresh from another account's sign-in — both are just a new token —\n     * and `abort()` from `onSessionEnd` is what the docs give such a handle to\n     * say the session ended. Until 0.82.0 a `resume()` after it still found\n     * \"its own\" record and sent the next account's token to the previous\n     * account's upload URL, with the previous account's `Idempotency-Key`.\n     * Exempting only an unchanged owner fingerprint, as the audit suggested,\n     * would not have worked: the fingerprint of a token-bound record changes on\n     * every refresh, so the exception would have covered nothing. So a\n     * `start()`/`resume()` after `abort()` attaches as a new handle would: the\n     * URL and the `Idempotency-Key` kept in memory are dropped, and the stored\n     * record is resumed only when its owner is the current one.\n     *\n     * A `clear()` of the default storage since the handle last attached ends\n     * it the same way (#528). `clear()` in `onSessionEnd` is the only teardown\n     * a session the SDK cannot see has — an HttpOnly cookie, with neither\n     * `getToken` nor `getPrincipal` — and it already deleted the records and\n     * stopped the runs in flight. A handle paused before it, though, kept the\n     * previous session's `Idempotency-Key` in memory, and the next account's\n     * `resume()` created its upload with it: a server whose idempotency store\n     * is not scoped by caller answers that with the previous account's upload.\n     */\n    async function ensureUpload(): Promise<string> {\n        if (abandoned || (attached && generationOf && generationOf() !== generation)) {\n            abandoned = false;\n            attached = false;\n            url = null;\n            idempotencyKey = null;\n        }\n        const current = currentOwner();\n        if (attached && getPrincipal && current !== owner) idempotencyKey = null;\n        const ownUrl = attached && !getPrincipal ? url : null;\n        owner = current;\n        attached = true;\n        generation = generationOf?.() ?? 0;\n        let stored = storage ? await storage.get(key) : null;\n        const ownRecord = stored !== null && ownUrl !== null && stored.url === ownUrl;\n        if (stored && owner !== undefined && stored.owner !== owner && !ownRecord) {\n            await storage?.delete(key);\n            stored = null;\n        }\n        if (stored && stored.size === file.size) {\n            idempotencyKey = stored.idempotencyKey;\n            if (stored.url) {\n                try {\n                    offset = await probe(stored.url);\n                    url = stored.url;\n                    return stored.url;\n                } catch {\n                    offset = 0;\n                }\n            }\n        }\n\n        setState(\"creating\");\n        idempotencyKey ??= generateIdempotencyKey();\n        url = null;\n        offset = 0;\n        if (storage) {\n            await storage.set(key, {\n                url: \"\",\n                offset: 0,\n                size: file.size,\n                idempotencyKey,\n                updatedAt: Date.now(),\n                ...(owner === undefined ? {} : { owner }),\n            });\n        }\n\n        const creationHeaders: Record<string, string> = {\n            ...baseHeaders(endpoint, \"POST\"),\n            \"Upload-Length\": String(file.size),\n            \"Idempotency-Key\": idempotencyKey,\n        };\n        const encoded = encodeMetadata(metadata);\n        if (encoded) creationHeaders[\"Upload-Metadata\"] = encoded;\n\n        const response = await sendRequest({\n            method: \"POST\",\n            url: endpoint,\n            headers: creationHeaders,\n            withCredentials,\n            register,\n            holdRedirects: holdsRedirects(endpoint),\n        });\n        if (response.status !== 201) throw failed(response, \"Criação do upload recusada.\");\n        const locationHeader = response.header(\"Location\");\n        if (!locationHeader) throw failed(response, \"Criação do upload sem cabeçalho Location.\");\n\n        url = resolveUploadUrl(locationHeader, endpoint);\n        await persist();\n        return url;\n    }\n\n    /** Push one chunk, resyncing the offset first when a previous attempt failed. */\n    async function writeChunk(target: string, resync: { needed: boolean }): Promise<void> {\n        assertCurrentOwner();\n        if (resync.needed) {\n            offset = await probe(target);\n            resync.needed = false;\n            report(offset);\n            await persist();\n            if (offset >= file.size) return;\n        }\n\n        const end = Math.min(offset + chunkSize, file.size);\n        const from = offset;\n        const response = await sendRequest({\n            method: \"PATCH\",\n            url: target,\n            headers: {\n                ...baseHeaders(target, \"PATCH\"),\n                \"Content-Type\": \"application/offset+octet-stream\",\n                \"Upload-Offset\": String(from),\n            },\n            body: file.slice(from, end),\n            withCredentials,\n            onProgress: (loaded) => report(Math.min(from + loaded, file.size)),\n            register,\n            holdRedirects: holdsRedirects(target),\n        });\n\n        if (response.status === 409 || response.status === 412) {\n            resync.needed = true;\n            throw failed(response, \"Offset divergente — o servidor já tinha esses bytes.\");\n        }\n        if (response.status !== 204 && response.status !== 200) {\n            throw failed(response, \"Chunk recusado pelo servidor.\");\n        }\n\n        const confirmed = parseOffset(response);\n        if (confirmed !== null && confirmed <= from) {\n            throw new TempestApiError({\n                status: response.status,\n                code: UPLOAD_OFFSET_STALLED,\n                detail: `O servidor confirmou o chunk sem avançar o Upload-Offset (${from} → ${confirmed}).`,\n            });\n        }\n        offset = confirmed ?? end;\n        report(offset);\n        await persist();\n    }\n\n    /**\n     * Drive the whole upload: attach or create, then chunk until complete.\n     *\n     * The `shouldRetry` predicate does double duty — besides deciding, it arms\n     * `resync` so the next attempt re-reads the server's offset with `HEAD` before\n     * writing. That is deliberate: it is the one place that sees *every* chunk\n     * failure, whatever the cause, and after any failure the client's idea of the\n     * offset is exactly what cannot be trusted.\n     *\n     * `resync` is armed only when the attempt is actually going to happen. A\n     * caller's own `shouldRetry` still wins the decision, and still arms the\n     * resync when it says yes — the flag describes what the *next* attempt must\n     * do, so setting it for an attempt that never comes describes nothing.\n     * {@link isRetriableChunkFailure} is the default, and it is where `409`/`412`\n     * earn a retry the shared policy would refuse and `404`/`410` lose one it\n     * would have granted.\n     *\n     * @returns The result, or `null` when `pause`/`abort` stopped the run.\n     */\n    async function run(): Promise<ResumableUploadResult | null> {\n        stopping = null;\n        const target = await ensureUpload();\n        resumedFrom = offset;\n        setState(\"uploading\");\n        report(offset);\n\n        const resync = { needed: false };\n        while (offset < file.size) {\n            if (stopping) break;\n            await retry(() => writeChunk(target, resync), {\n                retries: 5,\n                ...retryOptions,\n                shouldRetry: (error, attempt) => {\n                    if (stopping) return false;\n                    if (error instanceof ResumableUploadSupersededError) return false;\n                    if (error instanceof DOMException && error.name === \"AbortError\") return false;\n                    const again =\n                        retryOptions?.shouldRetry?.(error, attempt) ??\n                        isRetriableChunkFailure(error);\n                    if (again) resync.needed = true;\n                    return again;\n                },\n            });\n        }\n\n        if (stopping === \"pause\") {\n            setState(\"paused\");\n            return null;\n        }\n        if (stopping === \"abort\") {\n            setState(\"aborted\");\n            return null;\n        }\n\n        setState(\"done\");\n        if (storage) await storage.delete(key);\n        return { url: target, size: file.size };\n    }\n\n    async function guarded(): Promise<ResumableUploadResult | null> {\n        try {\n            return await run();\n        } catch (error) {\n            if (\n                stopping !== null ||\n                (error instanceof DOMException && error.name === \"AbortError\")\n            ) {\n                setState(stopping === \"abort\" ? \"aborted\" : \"paused\");\n                return null;\n            }\n            setState(\"error\");\n            throw error;\n        } finally {\n            inFlight = null;\n        }\n    }\n\n    function stop(reason: \"pause\" | \"abort\"): void {\n        stopping = reason;\n        inFlight?.abort();\n        inFlight = null;\n    }\n\n    return {\n        start: guarded,\n        resume: guarded,\n        pause: () => stop(\"pause\"),\n        abort: async ({ discard = false } = {}) => {\n            stop(\"abort\");\n            abandoned = true;\n            setState(\"aborted\");\n            if (!discard) return;\n            if (url) {\n                await sendRequest({\n                    method: \"DELETE\",\n                    url,\n                    headers: baseHeaders(url, \"DELETE\"),\n                    withCredentials,\n                    register: () => undefined,\n                    holdRedirects: holdsRedirects(url),\n                }).catch(() => undefined);\n            }\n            if (storage) await storage.delete(key);\n        },\n        get state() {\n            return state;\n        },\n        get offset() {\n            return offset;\n        },\n        get url() {\n            return url;\n        },\n        key,\n    };\n}\n"],"mappings":"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"}

package/dist/http/resumable-upload.js

@@ -228,7 +228,7 @@ function A(t) {
 		return r;
 	}
 	async function oe() {
-		R && (R = !1, L = !1, P = null, F = null);
+		(R || L && z && z() !== B) && (R = !1, L = !1, P = null, F = null);
 		let e = V();
 		L && j && e !== I && (F = null);
 		let t = L && !j ? P : null;