tempest-react-sdk 0.76.0 → 0.78.0

package/dist/http/resumable-upload.js

@@ -3,22 +3,37 @@ import { isTrustedCredentialTarget as t, reportSuppressedCredential as n } from
 import { csrfHeaders as r } from "./csrf.js";
 import { TempestApiError as i, buildApiError as a, isApiError as o, isRetriableStatus as s } from "./errors.js";
 import { retry as c } from "./retry.js";
-import { generateIdempotencyKey as l } from "./idempotency.js";
+import { ownerFingerprint as l } from "../utils/owner-fingerprint.js";
+import { generateIdempotencyKey as ee } from "./idempotency.js";
 //#region src/http/resumable-upload.ts
-var u = "1.0.0", d = 5242880;
-function f(t) {
+var u = "1.0.0", d = 5242880, f = class extends Error {
+	reason;
+	constructor(e) {
+		super(e === "principal" ? "O usuário mudou durante o upload resumível." : "Os registros de upload resumível foram limpos durante o upload."), this.name = "ResumableUploadSupersededError", this.reason = e;
+	}
+}, p = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new WeakMap();
+function h(e) {
+	if (!e) return !1;
+	try {
+		let t = JSON.parse(e);
+		return typeof t == "object" && !!t && typeof t.url == "string" && typeof t.offset == "number" && typeof t.size == "number" && typeof t.idempotencyKey == "string";
+	} catch {
+		return !1;
+	}
+}
+function g(t) {
 	return e(new TextEncoder().encode(t));
 }
-function p(e) {
+function _(e) {
 	if (!e) return null;
-	let t = Object.entries(e).map(([e, t]) => `${e} ${f(t)}`);
+	let t = Object.entries(e).map(([e, t]) => `${e} ${g(t)}`);
 	return t.length > 0 ? t.join(",") : null;
 }
-function m(e, t) {
+function v(e, t) {
 	let n = t, r = typeof n.name == "string" ? n.name : "blob", i = typeof n.lastModified == "number" ? n.lastModified : 0;
 	return `${e}|${r}|${t.size}|${t.type}|${i}`;
 }
-function h(e = "tempest-upload:") {
+function y(e = "tempest-upload:") {
 	function t() {
 		try {
 			return typeof localStorage > "u" ? null : localStorage;
@@ -26,7 +41,7 @@ function h(e = "tempest-upload:") {
 			return null;
 		}
 	}
-	return {
+	let n = {
 		get(n) {
 			let r = t()?.getItem(e + n);
 			if (!r) return null;
@@ -41,10 +56,22 @@ function h(e = "tempest-upload:") {
 		},
 		delete(n) {
 			t()?.removeItem(e + n);
+		},
+		clear() {
+			p.set(e, (p.get(e) ?? 0) + 1);
+			let n = t();
+			if (!n) return;
+			let r = [];
+			for (let t = 0; t < n.length; t += 1) {
+				let i = n.key(t);
+				i?.startsWith(e) && h(n.getItem(i)) && r.push(i);
+			}
+			for (let e of r) n.removeItem(e);
 		}
 	};
+	return m.set(n, () => p.get(e) ?? 0), n;
 }
-function g(e) {
+function b(e) {
 	return new Promise((t, n) => {
 		let r = new XMLHttpRequest();
 		r.open(e.method, e.url), r.withCredentials = e.withCredentials;
@@ -63,13 +90,13 @@ function g(e) {
 		})), r.onabort = () => n(new DOMException("Aborted", "AbortError")), e.register(r), r.send(e.body);
 	});
 }
-function _(e) {
+function x(e) {
 	let t = e.header("Upload-Offset");
 	if (t === null) return null;
 	let n = Number(t);
 	return Number.isFinite(n) && n >= 0 ? n : null;
 }
-function v(e) {
+function S(e) {
 	if (!e) return null;
 	try {
 		return JSON.parse(e);
@@ -77,18 +104,18 @@ function v(e) {
 		return e;
 	}
 }
-var y = /* @__PURE__ */ new Set([409, 412]);
-function b(e) {
-	return !o(e) || y.has(e.status) ? !0 : s(e.status);
+var C = /* @__PURE__ */ new Set([409, 412]);
+function w(e) {
+	return !o(e) || C.has(e.status) ? !0 : s(e.status);
 }
-function x(e, t) {
-	let n = v(e.text), r = a(e.status, n, { get: e.header }), o = typeof n == "object" && !!n && ("detail" in n || "message" in n);
+function T(e, t) {
+	let n = S(e.text), r = a(e.status, n, { get: e.header }), o = typeof n == "object" && !!n && ("detail" in n || "message" in n);
 	return new i({
 		...r,
 		detail: o ? r.detail : t
 	});
 }
-function S(e) {
+function E(e) {
 	let t = typeof window > "u" ? void 0 : window.location.href;
 	try {
 		return new URL(e, t).href;
@@ -96,170 +123,179 @@ function S(e) {
 		return e;
 	}
 }
-function C(e) {
-	let { endpoint: a, file: o, chunkSize: s = d, metadata: f, headers: v = {}, getToken: y, trustedOrigins: C, withCredentials: w = !1, csrf: T, key: E = m(a, o), storage: D = h(), retry: O, onProgress: k, onStateChange: A } = e, j = "idle", M = 0, N = null, P = null, F = null, I = null, L = 0;
-	function R(e) {
-		j !== e && (j = e, A?.(e));
+function D(e) {
+	let { endpoint: a, file: o, chunkSize: s = d, metadata: p, headers: h = {}, getToken: g, getPrincipal: S, trustedOrigins: C, withCredentials: D = !1, csrf: O, key: k = v(a, o), storage: A = y(), retry: j, onProgress: M, onStateChange: N } = e, P = "idle", F = 0, I = null, L = null, R, z = !1, B = A ? m.get(A) : void 0, V = B?.() ?? 0;
+	function H() {
+		if (S && l("p", S()) !== R) throw new f("principal");
+		if (B && B() !== V) throw new f("cleared");
 	}
-	function z(e) {
-		k?.({
+	let U = null, W = null, G = 0;
+	function K(e) {
+		P !== e && (P = e, N?.(e));
+	}
+	function q(e) {
+		M?.({
 			loaded: e,
 			total: o.size,
 			fraction: o.size === 0 ? 1 : e / o.size,
-			resumedFrom: L
+			resumedFrom: G
 		});
 	}
-	function B(e, i) {
+	function J(e, i) {
 		let o = {
-			...v,
+			...h,
 			"Tus-Resumable": u
-		}, s = y?.();
+		}, s = g?.();
 		return s && !("Authorization" in o) && (t(e, a, C) ? o.Authorization = `Bearer ${s}` : n(e, a)), Object.assign(o, r({
 			method: i,
 			url: e,
 			reference: a,
-			csrf: T,
+			csrf: O,
 			trustedOrigins: C,
-			headers: v
+			headers: h
 		})), o;
 	}
-	function V(e) {
-		I = e;
+	function Y(e) {
+		W = e;
 	}
-	async function H() {
-		D && N && P && await D.set(E, {
-			url: N,
-			offset: M,
+	async function X() {
+		A && I && L && (H(), await A.set(k, {
+			url: I,
+			offset: F,
 			size: o.size,
-			idempotencyKey: P,
-			updatedAt: Date.now()
-		});
+			idempotencyKey: L,
+			updatedAt: Date.now(),
+			...R === void 0 ? {} : { owner: R }
+		}));
 	}
-	async function U(e) {
-		let t = await g({
+	async function Z(e) {
+		let t = await b({
 			method: "HEAD",
 			url: e,
-			headers: B(e, "HEAD"),
-			withCredentials: w,
-			register: V
+			headers: J(e, "HEAD"),
+			withCredentials: D,
+			register: Y
 		});
 		if (t.status === 404 || t.status === 410) throw new i({
 			status: t.status,
 			detail: "O upload expirou no servidor. Comece de novo."
 		});
-		let n = _(t);
-		if (n === null) throw x(t, "HEAD sem Upload-Offset.");
+		let n = x(t);
+		if (n === null) throw T(t, "HEAD sem Upload-Offset.");
 		return n;
 	}
-	async function W() {
-		let e = D ? await D.get(E) : null;
-		if (e && e.size === o.size && (P = e.idempotencyKey, e.url)) try {
-			return M = await U(e.url), N = e.url, e.url;
+	async function te() {
+		let e = S ? l("p", S()) : void 0;
+		z && e !== R && (L = null), R = e, z = !0, V = B?.() ?? 0;
+		let t = A ? await A.get(k) : null;
+		if (t && R !== void 0 && t.owner !== R && (await A?.delete(k), t = null), t && t.size === o.size && (L = t.idempotencyKey, t.url)) try {
+			return F = await Z(t.url), I = t.url, t.url;
 		} catch {
-			M = 0;
+			F = 0;
 		}
-		R("creating"), P ??= l(), N = null, M = 0, D && await D.set(E, {
+		K("creating"), L ??= ee(), I = null, F = 0, A && await A.set(k, {
 			url: "",
 			offset: 0,
 			size: o.size,
-			idempotencyKey: P,
-			updatedAt: Date.now()
+			idempotencyKey: L,
+			updatedAt: Date.now(),
+			...R === void 0 ? {} : { owner: R }
 		});
-		let t = {
-			...B(a, "POST"),
+		let n = {
+			...J(a, "POST"),
 			"Upload-Length": String(o.size),
-			"Idempotency-Key": P
-		}, n = p(f);
-		n && (t["Upload-Metadata"] = n);
-		let r = await g({
+			"Idempotency-Key": L
+		}, r = _(p);
+		r && (n["Upload-Metadata"] = r);
+		let i = await b({
 			method: "POST",
 			url: a,
-			headers: t,
-			withCredentials: w,
-			register: V
+			headers: n,
+			withCredentials: D,
+			register: Y
 		});
-		if (r.status !== 201) throw x(r, "Criação do upload recusada.");
-		let i = r.header("Location");
-		if (!i) throw x(r, "Criação do upload sem cabeçalho Location.");
-		return N = S(i), await H(), N;
+		if (i.status !== 201) throw T(i, "Criação do upload recusada.");
+		let s = i.header("Location");
+		if (!s) throw T(i, "Criação do upload sem cabeçalho Location.");
+		return I = E(s), await X(), I;
 	}
-	async function G(e, t) {
-		if (t.needed && (M = await U(e), t.needed = !1, z(M), await H(), M >= o.size)) return;
-		let n = Math.min(M + s, o.size), r = M, i = await g({
+	async function ne(e, t) {
+		if (H(), t.needed && (F = await Z(e), t.needed = !1, q(F), await X(), F >= o.size)) return;
+		let n = Math.min(F + s, o.size), r = F, i = await b({
 			method: "PATCH",
 			url: e,
 			headers: {
-				...B(e, "PATCH"),
+				...J(e, "PATCH"),
 				"Content-Type": "application/offset+octet-stream",
 				"Upload-Offset": String(r)
 			},
 			body: o.slice(r, n),
-			withCredentials: w,
-			onProgress: (e) => z(Math.min(r + e, o.size)),
-			register: V
+			withCredentials: D,
+			onProgress: (e) => q(Math.min(r + e, o.size)),
+			register: Y
 		});
-		if (i.status === 409 || i.status === 412) throw t.needed = !0, x(i, "Offset divergente — o servidor já tinha esses bytes.");
-		if (i.status !== 204 && i.status !== 200) throw x(i, "Chunk recusado pelo servidor.");
-		M = _(i) ?? n, z(M), await H();
+		if (i.status === 409 || i.status === 412) throw t.needed = !0, T(i, "Offset divergente — o servidor já tinha esses bytes.");
+		if (i.status !== 204 && i.status !== 200) throw T(i, "Chunk recusado pelo servidor.");
+		F = x(i) ?? n, q(F), await X();
 	}
-	async function K() {
-		F = null;
-		let e = await W();
-		L = M, R("uploading"), z(M);
+	async function re() {
+		U = null;
+		let e = await te();
+		G = F, K("uploading"), q(F);
 		let t = { needed: !1 };
-		for (; M < o.size && !F;) await c(() => G(e, t), {
+		for (; F < o.size && !U;) await c(() => ne(e, t), {
 			retries: 5,
-			...O,
+			...j,
 			shouldRetry: (e, n) => {
-				if (F || e instanceof DOMException && e.name === "AbortError") return !1;
-				let r = O?.shouldRetry?.(e, n) ?? b(e);
+				if (U || e instanceof f || e instanceof DOMException && e.name === "AbortError") return !1;
+				let r = j?.shouldRetry?.(e, n) ?? w(e);
 				return r && (t.needed = !0), r;
 			}
 		});
-		return F === "pause" ? (R("paused"), null) : F === "abort" ? (R("aborted"), null) : (R("done"), D && await D.delete(E), {
+		return U === "pause" ? (K("paused"), null) : U === "abort" ? (K("aborted"), null) : (K("done"), A && await A.delete(k), {
 			url: e,
 			size: o.size
 		});
 	}
-	async function q() {
+	async function Q() {
 		try {
-			return await K();
+			return await re();
 		} catch (e) {
-			if (F !== null || e instanceof DOMException && e.name === "AbortError") return R(F === "abort" ? "aborted" : "paused"), null;
-			throw R("error"), e;
+			if (U !== null || e instanceof DOMException && e.name === "AbortError") return K(U === "abort" ? "aborted" : "paused"), null;
+			throw K("error"), e;
 		} finally {
-			I = null;
+			W = null;
 		}
 	}
-	function J(e) {
-		F = e, I?.abort(), I = null;
+	function $(e) {
+		U = e, W?.abort(), W = null;
 	}
 	return {
-		start: q,
-		resume: q,
-		pause: () => J("pause"),
+		start: Q,
+		resume: Q,
+		pause: () => $("pause"),
 		abort: async ({ discard: e = !1 } = {}) => {
-			J("abort"), R("aborted"), e && (N && await g({
+			$("abort"), K("aborted"), e && (I && await b({
 				method: "DELETE",
-				url: N,
-				headers: B(N, "DELETE"),
-				withCredentials: w,
+				url: I,
+				headers: J(I, "DELETE"),
+				withCredentials: D,
 				register: () => void 0
-			}).catch(() => void 0), D && await D.delete(E));
+			}).catch(() => void 0), A && await A.delete(k));
 		},
 		get state() {
-			return j;
+			return P;
 		},
 		get offset() {
-			return M;
+			return F;
 		},
 		get url() {
-			return N;
+			return I;
 		},
-		key: E
+		key: k
 	};
 }
 //#endregion
-export { d as DEFAULT_CHUNK_SIZE, u as TUS_VERSION, h as createLocalUploadStorage, C as createResumableUpload, m as uploadFingerprint };
+export { d as DEFAULT_CHUNK_SIZE, f as ResumableUploadSupersededError, u as TUS_VERSION, y as createLocalUploadStorage, D as createResumableUpload, v as uploadFingerprint };
 
 //# sourceMappingURL=resumable-upload.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"resumable-upload.js","names":[],"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 { bytesToBase64 } from \"@/utils/base64\";\nimport { isTrustedCredentialTarget, reportSuppressedCredential } 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 * 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\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/** 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    /** Extra headers on every request. */\n    headers?: Record<string, string>;\n    /** Returns the current bearer token, read before each request. */\n    getToken?: () => string | 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     * @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 * @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:\"): ResumableUploadStorage {\n    function backend(): Storage | null {\n        try {\n            return typeof localStorage === \"undefined\" ? null : localStorage;\n        } catch {\n            return null;\n        }\n    }\n\n    return {\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    };\n}\n\n/**\n * Send one request over `XMLHttpRequest`.\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 * @param init - Method, URL, headers, optional body and progress callback.\n * @returns Status, raw text and a header reader.\n */\nfunction sendRequest(init: {\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: (xhr: XMLHttpRequest) => void;\n}): 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 * 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 (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 page, so a relative 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 * @param value - The raw `Location` header.\n * @returns An absolute URL, or the input when there is no base to resolve against.\n */\nfunction resolveUploadUrl(value: string): string {\n    const base = typeof window === \"undefined\" ? undefined : window.location.href;\n    try {\n        return new URL(value, base).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`; `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        trustedOrigins,\n        withCredentials = false,\n        csrf,\n        key = uploadFingerprint(endpoint, file),\n        storage = createLocalUploadStorage(),\n        retry: retryOptions,\n        onProgress,\n        onStateChange,\n    } = options;\n\n    let state: ResumableUploadState = \"idle\";\n    let offset = 0;\n    let url: string | null = null;\n    let idempotencyKey: string | null = null;\n    let stopping: \"pause\" | \"abort\" | null = null;\n    let inFlight: XMLHttpRequest | 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.\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 result: Record<string, string> = { ...headers, \"Tus-Resumable\": TUS_VERSION };\n        const token = getToken?.();\n        if (token && !(\"Authorization\" in result)) {\n            if (isTrustedCredentialTarget(target, endpoint, trustedOrigins)) {\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(xhr: XMLHttpRequest): void {\n        inFlight = xhr;\n    }\n\n    async function persist(): Promise<void> {\n        if (!storage || !url || !idempotencyKey) return;\n        await storage.set(key, {\n            url,\n            offset,\n            size: file.size,\n            idempotencyKey,\n            updatedAt: Date.now(),\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        });\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    async function ensureUpload(): Promise<string> {\n        const stored = storage ? await storage.get(key) : null;\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            });\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        });\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);\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        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        });\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        offset = parseOffset(response) ?? 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 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            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                }).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.js","names":[],"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 { ownerFingerprint } from \"@/utils/owner-fingerprint\";\nimport { bytesToBase64 } from \"@/utils/base64\";\nimport { isTrustedCredentialTarget, reportSuppressedCredential } 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     * `null` for an anonymous one. Absent when the upload ran without\n     * {@link ResumableUploadOptions.getPrincipal}, and on records written before\n     * 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    /** Extra headers on every request. */\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. Without it, the record is bound to\n     * the file alone (endpoint, name, size, type, mtime), so after user A\n     * signed out leaving an upload half-done, user B picking an identical file\n     * sent `HEAD`/`PATCH` to A's upload URL with B's token, and on refusal\n     * replayed A's `Idempotency-Key` with B's token (#479). Pass it on every\n     * app with more than one account per browser, and also clear the storage\n     * at session end (`createLocalUploadStorage().clear()` in `onSessionEnd`).\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     * @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/**\n * Send one request over `XMLHttpRequest`.\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 * @param init - Method, URL, headers, optional body and progress callback.\n * @returns Status, raw text and a header reader.\n */\nfunction sendRequest(init: {\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: (xhr: XMLHttpRequest) => void;\n}): 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 * 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 (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 page, so a relative 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 * @param value - The raw `Location` header.\n * @returns An absolute URL, or the input when there is no base to resolve against.\n */\nfunction resolveUploadUrl(value: string): string {\n    const base = typeof window === \"undefined\" ? undefined : window.location.href;\n    try {\n        return new URL(value, base).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`; `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,\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\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    const generationOf = storage ? localGenerations.get(storage) : undefined;\n    let generation = generationOf?.() ?? 0;\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: XMLHttpRequest | 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.\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 result: Record<string, string> = { ...headers, \"Tus-Resumable\": TUS_VERSION };\n        const token = getToken?.();\n        if (token && !(\"Authorization\" in result)) {\n            if (isTrustedCredentialTarget(target, endpoint, trustedOrigins)) {\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(xhr: XMLHttpRequest): void {\n        inFlight = xhr;\n    }\n\n    async function persist(): Promise<void> {\n        if (!storage || !url || !idempotencyKey) return;\n        assertCurrentOwner();\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        });\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     * With `getPrincipal`, it is also only trusted when it carries the current\n     * principal's fingerprint; anyone else's is deleted, and the creation that\n     * follows gets a fresh `Idempotency-Key`. The key this handle kept in memory\n     * from an earlier run is reused only while the principal is the same, which\n     * is what keeps creation idempotent across `resume()` without storage.\n     */\n    async function ensureUpload(): Promise<string> {\n        const current = getPrincipal ? ownerFingerprint(\"p\", getPrincipal()) : undefined;\n        if (attached && current !== owner) idempotencyKey = null;\n        owner = current;\n        attached = true;\n        generation = generationOf?.() ?? 0;\n        let stored = storage ? await storage.get(key) : null;\n        if (stored && owner !== undefined && stored.owner !== owner) {\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        });\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);\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        });\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        offset = parseOffset(response) ?? 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            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                }).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/retry.cjs

@@ -1,2 +1,2 @@
-const e=require("./errors.cjs");function t(t){return!e.isApiError(t)||e.isRetriableStatus(t.status)}function n(e,t){return new Promise((n,r)=>{if(t?.aborted){r(new DOMException(`Aborted`,`AbortError`));return}let i=setTimeout(n,e);t?.addEventListener(`abort`,()=>{clearTimeout(i),r(new DOMException(`Aborted`,`AbortError`))},{once:!0})})}async function r(e,r={}){let{retries:i=3,initialDelay:a=300,maxDelay:o=1e4,respectRetryAfter:s=!0,shouldRetry:c=t,onRetry:l,signal:u}=r,d=0,f;for(;d<i;){if(u?.aborted)throw new DOMException(`Aborted`,`AbortError`);try{return await e()}catch(e){if(f=e,d+=1,d>=i||!c(e,d))throw e;let t=s&&typeof e?.retryAfter==`number`?e.retryAfter*1e3:null,r=Math.min(t===null?a*2**(d-1):t,o);l?.({attempt:d,delay:r,error:e}),await n(r,u)}}throw f}exports.retry=r;
+const e=require("./errors.cjs");function t(t){return!e.isApiError(t)||e.isRetriableStatus(t.status)}function n(e,t){return new Promise((n,r)=>{if(t?.aborted){r(new DOMException(`Aborted`,`AbortError`));return}let i=setTimeout(n,e);t?.addEventListener(`abort`,()=>{clearTimeout(i),r(new DOMException(`Aborted`,`AbortError`))},{once:!0})})}async function r(e,r={}){let{retries:i=3,initialDelay:a=300,maxDelay:o=1e4,respectRetryAfter:s=!0,shouldRetry:c=t,onRetry:l,signal:u}=r,d=Number.isNaN(i)?3:Math.max(1,Math.floor(i)),f=0;for(;;){if(u?.aborted)throw new DOMException(`Aborted`,`AbortError`);try{return await e()}catch(e){if(f+=1,f>=d||!c(e,f))throw e;let t=s&&typeof e?.retryAfter==`number`?e.retryAfter*1e3:null,r=Math.min(t===null?a*2**(f-1):t,o);l?.({attempt:f,delay:r,error:e}),await n(r,u)}}}exports.retry=r;
 //# sourceMappingURL=retry.cjs.map

package/dist/http/retry.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"retry.cjs","names":[],"sources":["../../src/http/retry.ts"],"sourcesContent":["import { isApiError, isRetriableStatus } from \"./errors\";\n\nexport interface RetryOptions {\n    /** Max attempts (including the first). Default: 3. */\n    retries?: number;\n    /** Initial backoff in ms. Doubles each attempt, capped at `maxDelay`. Default: 300. */\n    initialDelay?: number;\n    /** Maximum delay between attempts. Default: 10_000. */\n    maxDelay?: number;\n    /**\n     * Honor a `Retry-After` hint on the thrown error (`error.retryAfter`, in\n     * seconds — populated by {@link createApiClient} on `429`/`503`). When\n     * present it overrides the exponential backoff for that attempt. The value\n     * is capped at `maxDelay`. Default: true.\n     */\n    respectRetryAfter?: boolean;\n    /**\n     * Return false to stop retrying for a specific error.\n     *\n     * Default: replay anything that is not a recognisable API error — a\n     * transport failure has no status to judge — and, for one that is, only the\n     * statuses {@link isRetriableStatus} accepts. A `403` on an admin-only\n     * endpoint and a `404` for a deleted record are the server's final answer;\n     * repeating them spends the caller's time to show the same error twice.\n     */\n    shouldRetry?: (error: unknown, attempt: number) => boolean;\n    /** Called before each retry with the upcoming delay. */\n    onRetry?: (info: { attempt: number; delay: number; error: unknown }) => void;\n    /** Cancel pending retries. */\n    signal?: AbortSignal;\n}\n\n/**\n * The default {@link RetryOptions.shouldRetry}.\n *\n * Permissive about what it cannot classify and strict about what it can: an\n * error with no API shape may well be a transport failure, while an API error\n * carrying a deliberate refusal will answer the same on every attempt.\n *\n * @param error - Whatever the attempt threw.\n * @returns Whether the helper should try again.\n */\nfunction defaultShouldRetry(error: unknown): boolean {\n    return !isApiError(error) || isRetriableStatus(error.status);\n}\n\nfunction wait(ms: number, signal?: AbortSignal): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n        if (signal?.aborted) {\n            reject(new DOMException(\"Aborted\", \"AbortError\"));\n            return;\n        }\n        const timer = setTimeout(resolve, ms);\n        signal?.addEventListener(\n            \"abort\",\n            () => {\n                clearTimeout(timer);\n                reject(new DOMException(\"Aborted\", \"AbortError\"));\n            },\n            { once: true },\n        );\n    });\n}\n\n/**\n * Run `factory()` with exponential backoff. Each attempt awaits an\n * increasing delay capped at `maxDelay`. Throws the last error if every\n * attempt fails.\n *\n * @example\n * const data = await retry(() => api.get(\"/flaky\"), { retries: 5 });\n */\nexport async function retry<T>(factory: () => Promise<T>, options: RetryOptions = {}): Promise<T> {\n    const {\n        retries = 3,\n        initialDelay = 300,\n        maxDelay = 10_000,\n        respectRetryAfter = true,\n        shouldRetry = defaultShouldRetry,\n        onRetry,\n        signal,\n    } = options;\n\n    let attempt = 0;\n    let lastError: unknown;\n\n    while (attempt < retries) {\n        if (signal?.aborted) throw new DOMException(\"Aborted\", \"AbortError\");\n        try {\n            return await factory();\n        } catch (error) {\n            lastError = error;\n            attempt += 1;\n            if (attempt >= retries || !shouldRetry(error, attempt)) {\n                throw error;\n            }\n            const retryAfter =\n                respectRetryAfter &&\n                typeof (error as { retryAfter?: unknown })?.retryAfter === \"number\"\n                    ? (error as { retryAfter: number }).retryAfter * 1000\n                    : null;\n            const delay =\n                retryAfter !== null\n                    ? Math.min(retryAfter, maxDelay)\n                    : Math.min(initialDelay * 2 ** (attempt - 1), maxDelay);\n            onRetry?.({ attempt, delay, error });\n            await wait(delay, signal);\n        }\n    }\n\n    throw lastError;\n}\n"],"mappings":"gCA0CA,SAAS,EAAmB,EAAyB,CACjD,MAAO,CAAC,EAAA,WAAW,CAAK,GAAK,EAAA,kBAAkB,EAAM,MAAM,CAC/D,CAEA,SAAS,EAAK,EAAY,EAAqC,CAC3D,OAAO,IAAI,SAAe,EAAS,IAAW,CAC1C,GAAI,GAAQ,QAAS,CACjB,EAAO,IAAI,aAAa,UAAW,YAAY,CAAC,EAChD,MACJ,CACA,IAAM,EAAQ,WAAW,EAAS,CAAE,EACpC,GAAQ,iBACJ,YACM,CACF,aAAa,CAAK,EAClB,EAAO,IAAI,aAAa,UAAW,YAAY,CAAC,CACpD,EACA,CAAE,KAAM,EAAK,CACjB,CACJ,CAAC,CACL,CAUA,eAAsB,EAAS,EAA2B,EAAwB,CAAC,EAAe,CAC9F,GAAM,CACF,UAAU,EACV,eAAe,IACf,WAAW,IACX,oBAAoB,GACpB,cAAc,EACd,UACA,UACA,EAEA,EAAU,EACV,EAEJ,KAAO,EAAU,GAAS,CACtB,GAAI,GAAQ,QAAS,MAAM,IAAI,aAAa,UAAW,YAAY,EACnE,GAAI,CACA,OAAO,MAAM,EAAQ,CACzB,OAAS,EAAO,CAGZ,GAFA,EAAY,EACZ,GAAW,EACP,GAAW,GAAW,CAAC,EAAY,EAAO,CAAO,EACjD,MAAM,EAEV,IAAM,EACF,GACA,OAAQ,GAAoC,YAAe,SACpD,EAAiC,WAAa,IAC/C,KACJ,EAGI,KAAK,IAFX,IAAe,KAEA,EAAe,IAAM,EAAU,GAD/B,EACmC,CAAQ,EAC9D,IAAU,CAAE,UAAS,QAAO,OAAM,CAAC,EACnC,MAAM,EAAK,EAAO,CAAM,CAC5B,CACJ,CAEA,MAAM,CACV"}
+{"version":3,"file":"retry.cjs","names":[],"sources":["../../src/http/retry.ts"],"sourcesContent":["import { isApiError, isRetriableStatus } from \"./errors\";\n\nexport interface RetryOptions {\n    /**\n     * Total attempts, the first one included. Default: 3 — one call plus two\n     * replays.\n     *\n     * The first attempt always runs: `0`, a negative number or a fraction below\n     * one all mean \"a single attempt, no replay\", and that attempt's error is the\n     * one the promise rejects with. A fraction is rounded down; `NaN` falls back\n     * to the default.\n     *\n     * The name reads like \"replays after the first\", but every surface that\n     * forwards it has always counted totals — {@link createApiClient}'s `retry`,\n     * `createResumableUpload` (\"5 attempts\"), and `lazyWithRetry`'s own\n     * `retries`. Switching to \"replays\" would add one request to every caller\n     * that passes a number, which no change of default can hide, so the count\n     * stays a total and only the values that ran nothing were fixed (#486).\n     */\n    retries?: number;\n    /** Initial backoff in ms. Doubles each attempt, capped at `maxDelay`. Default: 300. */\n    initialDelay?: number;\n    /** Maximum delay between attempts. Default: 10_000. */\n    maxDelay?: number;\n    /**\n     * Honor a `Retry-After` hint on the thrown error (`error.retryAfter`, in\n     * seconds — populated by {@link createApiClient} on `429`/`503`). When\n     * present it overrides the exponential backoff for that attempt. The value\n     * is capped at `maxDelay`. Default: true.\n     */\n    respectRetryAfter?: boolean;\n    /**\n     * Return false to stop retrying for a specific error.\n     *\n     * Default: replay anything that is not a recognisable API error — a\n     * transport failure has no status to judge — and, for one that is, only the\n     * statuses {@link isRetriableStatus} accepts. A `403` on an admin-only\n     * endpoint and a `404` for a deleted record are the server's final answer;\n     * repeating them spends the caller's time to show the same error twice.\n     */\n    shouldRetry?: (error: unknown, attempt: number) => boolean;\n    /** Called before each retry with the upcoming delay. */\n    onRetry?: (info: { attempt: number; delay: number; error: unknown }) => void;\n    /** Cancel pending retries. */\n    signal?: AbortSignal;\n}\n\n/**\n * The default {@link RetryOptions.shouldRetry}.\n *\n * Permissive about what it cannot classify and strict about what it can: an\n * error with no API shape may well be a transport failure, while an API error\n * carrying a deliberate refusal will answer the same on every attempt.\n *\n * @param error - Whatever the attempt threw.\n * @returns Whether the helper should try again.\n */\nfunction defaultShouldRetry(error: unknown): boolean {\n    return !isApiError(error) || isRetriableStatus(error.status);\n}\n\nfunction wait(ms: number, signal?: AbortSignal): Promise<void> {\n    return new Promise<void>((resolve, reject) => {\n        if (signal?.aborted) {\n            reject(new DOMException(\"Aborted\", \"AbortError\"));\n            return;\n        }\n        const timer = setTimeout(resolve, ms);\n        signal?.addEventListener(\n            \"abort\",\n            () => {\n                clearTimeout(timer);\n                reject(new DOMException(\"Aborted\", \"AbortError\"));\n            },\n            { once: true },\n        );\n    });\n}\n\n/**\n * Run `factory()` with exponential backoff. Each attempt awaits an\n * increasing delay capped at `maxDelay`. Throws the last error if every\n * attempt fails.\n *\n * `retries` is the **total** number of attempts, never fewer than one — see\n * {@link RetryOptions.retries}. `retries: 5` means one call plus four replays.\n *\n * @param factory - Starts one attempt; called again for every replay.\n * @param options - Attempt count, backoff and the retry predicate.\n * @returns What the first successful attempt resolved with.\n * @throws The error of the last attempt, or an `AbortError` once `signal` aborts.\n *\n * @example\n * const data = await retry(() => api.get(\"/flaky\"), { retries: 5 });\n */\nexport async function retry<T>(factory: () => Promise<T>, options: RetryOptions = {}): Promise<T> {\n    const {\n        retries = 3,\n        initialDelay = 300,\n        maxDelay = 10_000,\n        respectRetryAfter = true,\n        shouldRetry = defaultShouldRetry,\n        onRetry,\n        signal,\n    } = options;\n\n    const attempts = Number.isNaN(retries) ? 3 : Math.max(1, Math.floor(retries));\n    let attempt = 0;\n\n    for (;;) {\n        if (signal?.aborted) throw new DOMException(\"Aborted\", \"AbortError\");\n        try {\n            return await factory();\n        } catch (error) {\n            attempt += 1;\n            if (attempt >= attempts || !shouldRetry(error, attempt)) {\n                throw error;\n            }\n            const retryAfter =\n                respectRetryAfter &&\n                typeof (error as { retryAfter?: unknown })?.retryAfter === \"number\"\n                    ? (error as { retryAfter: number }).retryAfter * 1000\n                    : null;\n            const delay =\n                retryAfter !== null\n                    ? Math.min(retryAfter, maxDelay)\n                    : Math.min(initialDelay * 2 ** (attempt - 1), maxDelay);\n            onRetry?.({ attempt, delay, error });\n            await wait(delay, signal);\n        }\n    }\n}\n"],"mappings":"gCAyDA,SAAS,EAAmB,EAAyB,CACjD,MAAO,CAAC,EAAA,WAAW,CAAK,GAAK,EAAA,kBAAkB,EAAM,MAAM,CAC/D,CAEA,SAAS,EAAK,EAAY,EAAqC,CAC3D,OAAO,IAAI,SAAe,EAAS,IAAW,CAC1C,GAAI,GAAQ,QAAS,CACjB,EAAO,IAAI,aAAa,UAAW,YAAY,CAAC,EAChD,MACJ,CACA,IAAM,EAAQ,WAAW,EAAS,CAAE,EACpC,GAAQ,iBACJ,YACM,CACF,aAAa,CAAK,EAClB,EAAO,IAAI,aAAa,UAAW,YAAY,CAAC,CACpD,EACA,CAAE,KAAM,EAAK,CACjB,CACJ,CAAC,CACL,CAkBA,eAAsB,EAAS,EAA2B,EAAwB,CAAC,EAAe,CAC9F,GAAM,CACF,UAAU,EACV,eAAe,IACf,WAAW,IACX,oBAAoB,GACpB,cAAc,EACd,UACA,UACA,EAEE,EAAW,OAAO,MAAM,CAAO,EAAI,EAAI,KAAK,IAAI,EAAG,KAAK,MAAM,CAAO,CAAC,EACxE,EAAU,EAEd,OAAS,CACL,GAAI,GAAQ,QAAS,MAAM,IAAI,aAAa,UAAW,YAAY,EACnE,GAAI,CACA,OAAO,MAAM,EAAQ,CACzB,OAAS,EAAO,CAEZ,GADA,GAAW,EACP,GAAW,GAAY,CAAC,EAAY,EAAO,CAAO,EAClD,MAAM,EAEV,IAAM,EACF,GACA,OAAQ,GAAoC,YAAe,SACpD,EAAiC,WAAa,IAC/C,KACJ,EAGI,KAAK,IAFX,IAAe,KAEA,EAAe,IAAM,EAAU,GAD/B,EACmC,CAAQ,EAC9D,IAAU,CAAE,UAAS,QAAO,OAAM,CAAC,EACnC,MAAM,EAAK,EAAO,CAAM,CAC5B,CACJ,CACJ"}