arthron 1.1.0 → 2.0.1

package/dist/plugins.cjs

@@ -1,6 +1,847 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_plugins = require("./plugins-CVrzb8x6.cjs");
-exports.bearerAuth = require_plugins.bearerAuth;
-exports.logging = require_plugins.logging;
-exports.retry = require_plugins.retry;
-exports.timeout = require_plugins.timeout;
+const require_create_error = require("./shared.cjs");
+//#region src/plugins/bearer-auth/bearer-auth.ts
+/** 1.x option, its replacement, and how to pass it. */
+const REPLACED$1 = [
+	[
+		"token",
+		"accessTokenFn",
+		"accessTokenFn"
+	],
+	[
+		"refresh",
+		"refreshFn",
+		"refreshFn"
+	],
+	[
+		"origin",
+		"tokenOrigins",
+		"tokenOrigins: [url]"
+	]
+];
+const EXAMPLE = "tokenOrigins: [\"https://api.example.com\"]";
+/** `tokenOrigins` as origins, checked when the plugin is created. */
+function tokenOriginSet(urls) {
+	if (!Array.isArray(urls)) throw new TypeError(`arthron: bearerAuth({ tokenOrigins }) takes a list of URLs, got ${typeof urls === "string" ? "a string" : String(urls)} — e.g. ${EXAMPLE}`);
+	return require_create_error.httpOrigins(urls, {
+		empty: `arthron: bearerAuth({ tokenOrigins }) needs at least one URL — e.g. ${EXAMPLE}`,
+		invalid: (url) => `arthron: bearerAuth({ tokenOrigins }) needs http(s) URLs, got ${url} — e.g. ${EXAMPLE}`
+	});
+}
+/**
+* Bearer-token auth. A request interceptor sets `authorization: Bearer
+* <token>` on every attempt to `tokenOrigins`; with `refreshFn`, a middleware turns a
+* 401 into one refresh and one more try. Concurrent 401s share the refresh
+* (with refresh-token rotation, parallel refreshes revoke each other), and a
+* call whose token was replaced meanwhile just retries. A call opts out with
+* `meta: { bearerAuth: false }`.
+*/
+function bearerAuth(options) {
+	for (const [old, now, fix] of REPLACED$1) if (options[old] !== void 0) throw new TypeError(`arthron: bearerAuth's ${old} option was replaced by ${now} in 2.0 — pass bearerAuth({ ${fix} })`);
+	const { accessTokenFn, refreshFn } = options;
+	const allowed = tokenOriginSet(options.tokenOrigins);
+	const ours = (url) => allowed.has(require_create_error.originOf(url) ?? "");
+	const bearer = async () => {
+		const value = await accessTokenFn();
+		return value ? `Bearer ${value}` : void 0;
+	};
+	let refreshing;
+	let inRefresh = false;
+	const startRefresh = (refresh) => {
+		inRefresh = true;
+		try {
+			return refresh().finally(() => {
+				refreshing = void 0;
+			});
+		} finally {
+			inRefresh = false;
+		}
+	};
+	return {
+		pluginName: "bearerAuth",
+		requestInterceptor: async (ctx) => {
+			if (ctx.meta?.bearerAuth === false || !ours(ctx.url)) return ctx;
+			const value = await bearer();
+			if (!value) return ctx;
+			return {
+				...ctx,
+				init: {
+					...ctx.init,
+					headers: {
+						...ctx.init.headers,
+						authorization: value
+					}
+				}
+			};
+		},
+		middleware: async (ctx, next) => {
+			if (!refreshFn || ctx.meta?.bearerAuth === false) return next(ctx);
+			if (inRefresh) return next({
+				...ctx,
+				meta: {
+					...ctx.meta,
+					bearerAuth: false
+				}
+			});
+			if (require_create_error.isReadableStream(ctx.init.body)) return next(ctx);
+			try {
+				return await next(ctx);
+			} catch (error) {
+				if (!require_create_error.isArthronError(error) || error.status !== 401) throw error;
+				if (!ours(error.requestContext.url)) throw error;
+				if (error.requestContext.init.headers.authorization === await bearer()) {
+					refreshing ??= startRefresh(refreshFn);
+					await refreshing;
+				}
+				return next(ctx);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/plugins/logging/logging.ts
+function consoleSink(logger) {
+	return (e) => {
+		if (e.phase === "start") logger.log(`[arthron] → ${e.method} ${e.url}`);
+		else if (e.phase === "success") logger.log(`[arthron] ← ${e.method} ${e.url} ${e.status} ${e.duration}ms`);
+		else logger.error(`[arthron] ✕ ${e.method} ${e.url} ${e.status ?? "-"} ${e.duration}ms`);
+	};
+}
+/**
+* One event when a request starts, one when it settles, with status and
+* elapsed time. Wraps the whole call, so retries are included in the time.
+* Default output is a console line per event; pass `onEvent` to get the
+* structured event instead. Cancellations are not reported.
+*/
+function logging(options = {}) {
+	if (options.now !== void 0) throw new TypeError("arthron: logging's now option left the public options in 2.0 — mock performance.now in tests (vi.spyOn(performance, \"now\"))");
+	return loggingWithClock(options, () => performance.now());
+}
+/** `logging()` with the clock injected — for this package's tests; `arthron/plugins` does not export it. */
+function loggingWithClock(options, now) {
+	const { enabled = true, logger = console, onEvent } = options;
+	const emit = onEvent ?? consoleSink(logger);
+	return {
+		pluginName: "logging",
+		middleware: async (ctx, next) => {
+			if (!enabled) return next(ctx);
+			const method = ctx.init.method ?? "GET";
+			const url = require_create_error.redactUrl(ctx.url);
+			const started = now();
+			const duration = () => Math.round(now() - started);
+			emit({
+				phase: "start",
+				method,
+				url
+			});
+			let res;
+			try {
+				res = await next(ctx);
+			} catch (error) {
+				if (!require_create_error.isCancellation(error, ctx.init.signal)) {
+					const status = require_create_error.isArthronError(error) ? error.status : void 0;
+					emit({
+						phase: "error",
+						method,
+						url,
+						status,
+						duration: duration(),
+						error
+					});
+				}
+				throw error;
+			}
+			emit({
+				phase: "success",
+				method,
+				url,
+				status: res.status,
+				duration: duration()
+			});
+			return res;
+		}
+	};
+}
+//#endregion
+//#region src/plugins/retry/retry.ts
+const DEFAULT_STATUSES = [
+	408,
+	429,
+	500,
+	502,
+	503,
+	504
+];
+const DEFAULT_METHODS = [
+	"GET",
+	"HEAD",
+	"OPTIONS",
+	"QUERY",
+	"PUT",
+	"DELETE"
+];
+const DEFAULT_MAX_RETRY_AFTER = 6e4;
+/** setTimeout fires at once past this, so every wait is capped to it. */
+const MAX_TIMER_MS$1 = 2 ** 31 - 1;
+function defaultSleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(signal.reason);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason);
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/** `Retry-After` as ms — seconds or an HTTP-date. `undefined` when absent or unparsable. */
+function retryAfterMs(error) {
+	const value = error.headers.get("retry-after")?.trim();
+	if (!value) return void 0;
+	const seconds = Number(value);
+	if (!Number.isNaN(seconds)) return Math.max(0, seconds * 1e3);
+	const at = Date.parse(value);
+	if (Number.isNaN(at)) return void 0;
+	return Math.max(0, at - Date.now());
+}
+/**
+* `delayFn`'s answer, checked: setTimeout fires at once for NaN and
+* negatives, so a 1.x `delay` moved over with its arguments swapped would
+* retry in a tight loop.
+*/
+function checkedDelay(ms) {
+	if (typeof ms === "number" && Number.isFinite(ms) && ms >= 0) return ms;
+	const shown = typeof ms === "string" ? JSON.stringify(ms) : String(ms);
+	throw new TypeError(`arthron: retry's delayFn returned ${shown} — return the wait in ms, a finite number ≥ 0`);
+}
+/** The rule without `shouldRetry`: a network error or a status in `statuses`, on a method in `methods`. */
+function byDefault(thrown, method, settings) {
+	if (!settings.allowedMethods.has(method) || !require_create_error.isArthronError(thrown)) return false;
+	return thrown.status === 0 || settings.statuses.includes(thrown.status);
+}
+/** 1.x options and what replaced them: unknown keys would be ignored. */
+const REPLACED = {
+	delay: "delayFn",
+	retryOn: "statuses"
+};
+/** Defaults filled in and `retries` checked — `attempt >= NaN` is never true, so an unset env var would retry forever. */
+function resolveRetryOptions(options, where) {
+	const given = options;
+	for (const [old, now] of Object.entries(REPLACED)) if (given[old] !== void 0) {
+		const fix = where === "meta.retry" ? `meta: { retry: { ${now} } }` : `retry({ ${now} })`;
+		throw new TypeError(`arthron: ${where} ${old} was replaced by ${now} in 2.0 — pass ${fix}`);
+	}
+	if (given.sleep !== void 0) throw new TypeError(`arthron: ${where} sleep left the public options in 2.0 — use fake timers in tests (vi.useFakeTimers())`);
+	const { retries = 2, statuses = DEFAULT_STATUSES, methods = DEFAULT_METHODS, delayFn = (attempt) => Math.random() * 300 * 2 ** attempt, maxRetryAfter = DEFAULT_MAX_RETRY_AFTER, shouldRetry, onRetry } = options;
+	if (!Number.isInteger(retries) || retries < 0) throw new TypeError(`arthron: ${where} retries: ${retries} needs a whole number ≥ 0 — e.g. retries: 2`);
+	return {
+		retries,
+		statuses,
+		allowedMethods: new Set(methods.map((m) => m.toUpperCase())),
+		delayFn,
+		maxRetryAfter,
+		shouldRetry,
+		onRetry
+	};
+}
+/**
+* Retry on network errors and the configured statuses by calling `next`
+* again — the whole attempt (request interceptors included) is re-run.
+* Only `ArthronError` is considered; cancellation and plugin bugs pass through.
+* A call can turn it off or override its options with `meta.retry`.
+*/
+function retry(options = {}) {
+	return retryWithSleep(options, defaultSleep);
+}
+/** `retry()` with the wait injected — for this package's tests; `arthron/plugins` does not export it. */
+function retryWithSleep(options, sleep) {
+	const base = resolveRetryOptions(options, "retry()");
+	return {
+		pluginName: "retry",
+		middleware: async (ctx, next) => {
+			const override = ctx.meta?.retry;
+			if (override === false) return next(ctx);
+			const settings = override ? resolveRetryOptions({
+				...options,
+				...override
+			}, "meta.retry") : base;
+			const method = (ctx.init.method ?? "GET").toUpperCase();
+			const resendable = !require_create_error.isReadableStream(ctx.init.body);
+			for (let attempt = 0;; attempt += 1) try {
+				return await next(ctx);
+			} catch (thrown) {
+				if (!resendable || attempt >= settings.retries) throw thrown;
+				if (ctx.init.signal?.aborted) throw thrown;
+				const verdict = settings.shouldRetry?.(thrown, attempt, ctx);
+				if (verdict === false) throw thrown;
+				if (verdict === void 0 && !byDefault(thrown, method, settings)) throw thrown;
+				const retryAfter = require_create_error.isArthronError(thrown) ? retryAfterMs(thrown) : void 0;
+				if (retryAfter !== void 0 && retryAfter > settings.maxRetryAfter) throw thrown;
+				const delay = Math.min(retryAfter ?? checkedDelay(settings.delayFn(attempt, thrown)), MAX_TIMER_MS$1);
+				settings.onRetry?.(thrown, attempt, delay);
+				await sleep(delay, ctx.init.signal);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/plugins/timeout/timeout.ts
+const MAX_TIMER_MS = 2 ** 31 - 1;
+/**
+* Wrap `body` so the deadline keeps running until it is fully read, and so an
+* abort while reading surfaces as a stream error instead of a silent stall.
+*/
+function guardBody(body, signal, finish, onChunk) {
+	const reader = body.getReader();
+	let onAbort = () => {};
+	const release = () => {
+		signal.removeEventListener("abort", onAbort);
+		finish();
+	};
+	return new ReadableStream({
+		start(controller) {
+			onAbort = () => {
+				controller.error(signal.reason);
+				reader.cancel(signal.reason).catch(() => {});
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+		},
+		async pull(controller) {
+			let chunk;
+			try {
+				chunk = await reader.read();
+			} catch (error) {
+				release();
+				throw error;
+			}
+			if (chunk.done) {
+				release();
+				controller.close();
+				return;
+			}
+			onChunk();
+			controller.enqueue(chunk.value);
+		},
+		cancel(reason) {
+			release();
+			return reader.cancel(reason);
+		}
+	});
+}
+/** setTimeout fires at once for NaN, negatives and anything past 2^31-1. */
+function checkDeadline(ms, where) {
+	if (ms === Number.POSITIVE_INFINITY || ms >= 0 && ms <= MAX_TIMER_MS) return;
+	throw new TypeError(`arthron: ${where} needs 0–${MAX_TIMER_MS} ms — pass Infinity for no deadline`);
+}
+/** A timer that aborts `controller` with a TimeoutError and never keeps Node alive on its own. */
+function deadlineTimer(controller, ms, message) {
+	const timer = setTimeout(() => controller.abort(new DOMException(message, "TimeoutError")), ms);
+	timer.unref?.();
+	return timer;
+}
+/** `timeout(ms)` or `timeout({ total, idle })`, checked. */
+function resolveTimeoutOptions(first) {
+	if (typeof first === "number") {
+		checkDeadline(first, `timeout(${first})`);
+		return {
+			ms: first,
+			idle: void 0
+		};
+	}
+	const { total, idle } = first;
+	if (total === void 0 && idle === void 0) throw new TypeError("arthron: timeout({}) needs total or idle — e.g. timeout({ total: 10_000 }) or timeout({ idle: 30_000 })");
+	if (total !== void 0) checkDeadline(total, `timeout({ total: ${total} })`);
+	if (idle !== void 0) checkDeadline(idle, `timeout({ idle: ${idle} })`);
+	return {
+		ms: total ?? Number.POSITIVE_INFINITY,
+		idle
+	};
+}
+/** One call's deadlines: the plugin's, with `meta.timeout` applied and checked. */
+function forCall(base, override) {
+	if (override === void 0) return base;
+	if (override === false) return {
+		ms: Number.POSITIVE_INFINITY,
+		idle: void 0
+	};
+	if (typeof override === "number") {
+		checkDeadline(override, `meta.timeout: ${override}`);
+		return {
+			...base,
+			ms: override
+		};
+	}
+	const { total, idle } = override;
+	if (total !== void 0) checkDeadline(total, `meta.timeout: { total: ${total} }`);
+	if (idle !== void 0) checkDeadline(idle, `meta.timeout: { idle: ${idle} }`);
+	return {
+		ms: total ?? base.ms,
+		idle: idle ?? base.idle
+	};
+}
+function timeout(first, removed) {
+	if (typeof removed === "object" && removed !== null) throw new TypeError("arthron: timeout(ms, { idle }) was removed in 2.0 — pass one object, timeout({ total: ms, idle })");
+	const base = resolveTimeoutOptions(first);
+	return {
+		pluginName: "timeout",
+		middleware: async (ctx, next) => {
+			const { ms: deadline, idle } = forCall(base, ctx.meta?.timeout);
+			const idleMs = idle === Number.POSITIVE_INFINITY ? void 0 : idle;
+			if (deadline === Number.POSITIVE_INFINITY && idleMs === void 0) return next(ctx);
+			const controller = new AbortController();
+			const outer = ctx.init.signal;
+			const signal = outer ? AbortSignal.any([outer, controller.signal]) : controller.signal;
+			const total = deadline === Number.POSITIVE_INFINITY ? void 0 : deadlineTimer(controller, deadline, `arthron: request timed out after ${deadline}ms`);
+			let quiet;
+			const stillAlive = () => {
+				if (idleMs === void 0) return;
+				clearTimeout(quiet);
+				quiet = deadlineTimer(controller, idleMs, `arthron: no data for ${idleMs}ms`);
+			};
+			const finish = () => {
+				clearTimeout(total);
+				clearTimeout(quiet);
+			};
+			stillAlive();
+			let res;
+			try {
+				res = await next({
+					...ctx,
+					init: {
+						...ctx.init,
+						signal
+					}
+				});
+			} catch (thrown) {
+				finish();
+				throw thrown;
+			}
+			if (!res.body) {
+				finish();
+				return res;
+			}
+			stillAlive();
+			return require_create_error.rebuildResponse(res, guardBody(res.body, signal, finish, stillAlive));
+		}
+	};
+}
+//#endregion
+//#region src/plugins/upload-progress/form-data.ts
+const encoder = new TextEncoder();
+/** Names and filenames inside the quoted Content-Disposition parameters. */
+const escapeName = (name) => name.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
+/** String values go out with CRLF line breaks, as the runtime's encoder sends them. */
+const normalizeBreaks = (value) => value.replace(/\r\n|\r|\n/g, "\r\n");
+function boundary() {
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(12));
+	return `----arthron${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+/**
+* A FormData body as multipart/form-data, with its length known before
+* anything is read: the parts' headers and string values are encoded up
+* front, files are only counted by size and streamed while the body is
+* sent — a large file is not held in memory to learn the length.
+*/
+function encodeFormData(form) {
+	const b = boundary();
+	const parts = [];
+	for (const [name, value] of form) {
+		let head = `--${b}\r\nContent-Disposition: form-data; name="${escapeName(name)}"`;
+		if (typeof value === "string") {
+			parts.push(encoder.encode(`${head}\r\n\r\n`));
+			parts.push(encoder.encode(normalizeBreaks(value)));
+		} else {
+			head += `; filename="${escapeName(value.name)}"\r\nContent-Type: ${value.type || "application/octet-stream"}`;
+			parts.push(encoder.encode(`${head}\r\n\r\n`));
+			parts.push(value);
+		}
+		parts.push(encoder.encode("\r\n"));
+	}
+	parts.push(encoder.encode(`--${b}--\r\n`));
+	const total = parts.reduce((sum, part) => sum + (part instanceof Uint8Array ? part.byteLength : part.size), 0);
+	let index = 0;
+	let reader;
+	return {
+		stream: new ReadableStream({
+			async pull(controller) {
+				for (;;) {
+					if (reader) {
+						const { value, done } = await reader.read();
+						if (!done) return controller.enqueue(value);
+						reader = void 0;
+					}
+					const part = parts[index++];
+					if (part === void 0) return controller.close();
+					if (part instanceof Uint8Array) return controller.enqueue(part);
+					reader = part.stream().getReader();
+				}
+			},
+			cancel: (reason) => reader?.cancel(reason)
+		}, { highWaterMark: 0 }),
+		total,
+		type: `multipart/form-data; boundary=${b}`
+	};
+}
+//#endregion
+//#region src/plugins/upload-progress/progress-event.ts
+/** An empty body is complete at once, not `0 / 0`. */
+function progressEvent(loaded, total) {
+	return {
+		loaded,
+		total,
+		fraction: total === void 0 ? void 0 : total === 0 ? 1 : loaded / total
+	};
+}
+//#endregion
+//#region src/plugins/upload-progress/request-parts.ts
+/**
+* What sending an upload needs from fetch's arguments, in any shape a plugin
+* wrapping it may pass: arthron sends a URL string and a lowercase header
+* record, a wrapper may pass a Request, a URL or Headers.
+*/
+const urlOf = (input) => input instanceof Request ? input.url : String(input);
+/** A Request's headers, then init's on top, as one lowercase record. */
+function headersOf(input, init) {
+	const merged = new Headers(input instanceof Request ? input.headers : void 0);
+	for (const [name, value] of new Headers(init.headers)) merged.set(name, value);
+	return Object.fromEntries(merged);
+}
+//#endregion
+//#region src/plugins/upload-progress/counting-fetch.ts
+/**
+* The most one progress step covers. Chunks are cut to it whatever their
+* source: Node hands an in-memory Blob over as a single chunk, which would
+* jump from 0 to 100%.
+*/
+const SLICE = 65536;
+const fromBytes = (bytes, type) => ({
+	stream: new ReadableStream({ start(controller) {
+		controller.enqueue(bytes);
+		controller.close();
+	} }),
+	total: bytes.byteLength,
+	type: type ?? void 0
+});
+/** The body as bytes to count, or `undefined` for none (or one fetch should get as is). */
+async function sourceOf(body, headers) {
+	if (body === void 0 || body === null) return void 0;
+	if (typeof body === "string") return fromBytes(new TextEncoder().encode(body), "text/plain;charset=UTF-8");
+	if (ArrayBuffer.isView(body)) return fromBytes(new Uint8Array(body.buffer, body.byteOffset, body.byteLength));
+	switch (require_create_error.tagOf(body)) {
+		case "Blob":
+		case "File": {
+			const blob = body;
+			return {
+				stream: blob.stream(),
+				total: blob.size,
+				type: blob.type || void 0
+			};
+		}
+		case "ArrayBuffer": return fromBytes(new Uint8Array(body));
+		case "URLSearchParams": return fromBytes(new TextEncoder().encode(String(body)), "application/x-www-form-urlencoded;charset=UTF-8");
+		case "FormData": {
+			const { stream, total, type } = encodeFormData(body);
+			return {
+				stream,
+				total,
+				type
+			};
+		}
+		case "ReadableStream": {
+			const length = Number(headers["content-length"]);
+			return {
+				stream: body,
+				total: Number.isSafeInteger(length) && length >= 0 ? length : void 0,
+				type: void 0
+			};
+		}
+		default: return;
+	}
+}
+/**
+* `base` with the request body counted as it is read. The body is swapped
+* here, inside the call, so the context the plugins see keeps the caller's
+* own. A callback that throws fails the call with its own error, not the
+* "fetch failed" the body error would become.
+*/
+function countingFetch(base, onProgress) {
+	return (async (input, init = {}) => {
+		const headers = headersOf(input, init);
+		const source = await sourceOf(init.body, headers);
+		if (!source) return base(input, init);
+		const { total, type } = source;
+		if (total !== void 0 && !("content-length" in headers)) headers["content-length"] = String(total);
+		if (type && !("content-type" in headers)) headers["content-type"] = type;
+		const signal = init.signal;
+		const reader = source.stream.getReader();
+		let loaded = 0;
+		let rest;
+		let reported = false;
+		let answered = false;
+		let failure;
+		const report = () => {
+			if (answered) return;
+			reported = true;
+			try {
+				onProgress(progressEvent(loaded, total));
+			} catch (error) {
+				failure = { error };
+				throw error;
+			}
+		};
+		const body = new ReadableStream({
+			async pull(controller) {
+				const stopped = async () => {
+					if (!signal?.aborted) return false;
+					await reader.cancel(signal.reason).catch(() => {});
+					controller.error(signal.reason);
+					return true;
+				};
+				if (await stopped()) return;
+				let chunk = rest;
+				if (!chunk?.byteLength) {
+					const { value, done } = await reader.read();
+					if (done) {
+						if (!reported) report();
+						return controller.close();
+					}
+					chunk = value;
+					if (await stopped()) return;
+				}
+				rest = chunk.subarray(SLICE);
+				const piece = chunk.subarray(0, SLICE);
+				loaded += piece.byteLength;
+				report();
+				controller.enqueue(piece);
+			},
+			cancel: (reason) => reader.cancel(reason)
+		}, { highWaterMark: 0 });
+		try {
+			const res = await base(input, {
+				...init,
+				body,
+				headers,
+				duplex: "half"
+			});
+			answered = true;
+			return res;
+		} catch (error) {
+			throw failure ? failure.error : error;
+		}
+	});
+}
+//#endregion
+//#region src/plugins/upload-progress/xhr-fetch.ts
+const NULL_BODY_STATUSES = /* @__PURE__ */ new Set([
+	101,
+	204,
+	205,
+	304
+]);
+/** `getAllResponseHeaders()` as `Headers`; lines without a name are skipped. */
+function parseResponseHeaders(raw) {
+	const headers = new Headers();
+	for (const line of raw.split(/\r?\n/)) {
+		const colon = line.indexOf(":");
+		if (colon <= 0) continue;
+		const name = line.slice(0, colon).trim();
+		if (name) headers.append(name, line.slice(colon + 1).trim());
+	}
+	return headers;
+}
+/**
+* What fetch would report for this response. XHR gives only the final URL;
+* the request URL is normalized (case, default port, no fragment) before
+* comparing, so writing it differently is not a redirect.
+*/
+function responseFields(requestUrl, responseURL, pageHref) {
+	const requested = new URL(requestUrl, pageHref);
+	requested.hash = "";
+	const final = new URL(responseURL || requested.href, pageHref);
+	const sameOrigin = pageHref !== void 0 && final.origin === new URL(pageHref).origin;
+	return {
+		url: final.href,
+		redirected: final.href !== requested.href,
+		type: sameOrigin ? "basic" : "cors"
+	};
+}
+/**
+* A fetch over XMLHttpRequest, for the one thing fetch cannot do in a
+* browser: report upload progress. It honours what an arthron attempt
+* carries — method, headers, body, `credentials: "include"`, `signal` — and
+* fails the way fetch does, so `send` makes the same ArthronErrors: a
+* network failure rejects with a TypeError, an abort with the signal's
+* reason. The response arrives whole; XHR does not stream it.
+*/
+function xhrFetch(onProgress) {
+	return ((input, init = {}) => new Promise((resolve, reject) => {
+		const url = urlOf(input);
+		const { signal } = init;
+		if (signal?.aborted) return reject(signal.reason);
+		const xhr = new XMLHttpRequest();
+		let settled = false;
+		const settle = (done) => {
+			if (settled) return;
+			settled = true;
+			signal?.removeEventListener("abort", onAbort);
+			done();
+		};
+		const fail = (error) => {
+			settle(() => reject(error));
+			xhr.abort();
+		};
+		const onAbort = () => fail(signal?.reason);
+		signal?.addEventListener("abort", onAbort, { once: true });
+		let reported;
+		const report = (loaded, total) => {
+			if (settled || reported?.loaded === loaded && reported.total === total) return;
+			reported = progressEvent(loaded, total);
+			try {
+				onProgress(reported);
+			} catch (error) {
+				fail(error);
+			}
+		};
+		const fromEvent = (e) => report(e.loaded, e.lengthComputable ? e.total : void 0);
+		xhr.upload.onprogress = fromEvent;
+		xhr.upload.onload = fromEvent;
+		xhr.onload = () => {
+			if (!reported) report(0, 0);
+			if (xhr.status === 0) return settle(() => reject(/* @__PURE__ */ new TypeError("Network request failed")));
+			const headers = parseResponseHeaders(xhr.getAllResponseHeaders());
+			const body = NULL_BODY_STATUSES.has(xhr.status) ? null : xhr.response;
+			const res = new Response(body, {
+				status: xhr.status,
+				statusText: xhr.statusText,
+				headers
+			});
+			const page = globalThis.location?.href;
+			settle(() => resolve(require_create_error.withFields(res, responseFields(url, xhr.responseURL, page))));
+		};
+		xhr.onerror = xhr.ontimeout = () => settle(() => reject(/* @__PURE__ */ new TypeError("Network request failed")));
+		xhr.open(init.method ?? "GET", url);
+		xhr.responseType = "arraybuffer";
+		if (init.credentials === "include") xhr.withCredentials = true;
+		for (const [name, value] of Object.entries(headersOf(input, init))) xhr.setRequestHeader(name, value);
+		xhr.send(init.body ?? null);
+	}));
+}
+//#endregion
+//#region src/plugins/upload-progress/upload-progress.ts
+/**
+* How a progress call can be sent here: a counted body on the runtime's
+* fetch, or XMLHttpRequest. Node first — jsdom on Node has an
+* XMLHttpRequest too, but Node's own fetch sends the requests there. Bun,
+* Deno, Electron and Cloudflare Workers also expose `process.versions.node`;
+* only Node was shown to keep content-length on a counted body, and an
+* Electron renderer has XHR.
+*/
+function uploadModeFor(runtime) {
+	const { versions, hasXhr, userAgent, deno } = runtime;
+	if (Boolean(versions?.node) && !versions?.bun && !versions?.electron && !deno && userAgent !== "Cloudflare-Workers") return "countedFetch";
+	return hasXhr ? "xhr" : void 0;
+}
+function currentRuntime() {
+	const g = globalThis;
+	const runtime = {
+		hasXhr: typeof XMLHttpRequest === "function",
+		deno: "Deno" in globalThis
+	};
+	if (g.process?.versions) runtime.versions = g.process.versions;
+	if (g.navigator?.userAgent) runtime.userAgent = g.navigator.userAgent;
+	return runtime;
+}
+/**
+* What an XHR cannot honour and whose loss would change the call: it always
+* follows redirects, has no no-cors mode, always sends cookies to its own
+* origin, sends the page's referrer whatever the call asked for, and checks
+* no integrity. `undefined` when the call can go over XHR.
+*/
+function xhrRefusal(init, url, pageHref) {
+	if (init.redirect === "manual" || init.redirect === "error") return `redirect: "${init.redirect}" — XMLHttpRequest always follows redirects`;
+	if (init.mode === "no-cors") return "mode: \"no-cors\" — XMLHttpRequest has no no-cors mode";
+	if (init.credentials === "omit" && pageHref) {
+		const page = new URL(pageHref).origin;
+		if (new URL(url, pageHref).origin === page) return "credentials: \"omit\" on this origin — XMLHttpRequest always sends cookies to its own origin";
+	}
+	if (init.referrerPolicy) return `referrerPolicy: "${init.referrerPolicy}" — XMLHttpRequest sends the page's referrer under the page's policy`;
+	if (init.referrer !== void 0 && init.referrer !== "about:client") return `referrer: ${JSON.stringify(init.referrer)} — XMLHttpRequest sends the page's referrer`;
+	if (init.integrity) return `integrity: "${init.integrity}" — XMLHttpRequest cannot check it`;
+}
+/**
+* The attempt with its own signal, joined to the call's. A callback that
+* throws aborts the attempt with its error: send passes an abort reason on
+* untouched, so it stays a plugin exception — not a network ArthronError
+* that error interceptors would see and retry would repeat.
+*/
+function withOwnSignal(ctx, onProgress) {
+	const own = new AbortController();
+	const outer = ctx.init.signal;
+	const signal = outer ? AbortSignal.any([outer, own.signal]) : own.signal;
+	const report = (event) => {
+		if (own.signal.aborted) return;
+		try {
+			onProgress(event);
+		} catch (error) {
+			own.abort(error);
+		}
+	};
+	return {
+		ctx: {
+			...ctx,
+			init: {
+				...ctx.init,
+				signal
+			}
+		},
+		report
+	};
+}
+/**
+* Does nothing by itself — only a call that passes `meta.uploadProgress`
+* reports upload progress. On such a call it changes how that one attempt
+* is sent: over XMLHttpRequest in a browser, with a counted body in Node.
+* Every other call, on this client too, goes out exactly as before.
+*
+* Progress needs the runtime's own fetch: with a client `fetchFn`, another
+* plugin's fetchFn, or a runtime that is neither (Deno, Bun, Cloudflare
+* Workers, a service worker), the call is sent as usual without progress.
+* Put it last in `plugins`: the call's signal carries a throwing callback's
+* error, and an interceptor after it that replaces the signal would cut it.
+*/
+function uploadProgress() {
+	return {
+		pluginName: "uploadProgress",
+		requestInterceptor: (ctx) => {
+			if (ctx.meta?.onUploadProgress !== void 0) throw new TypeError("arthron: meta.onUploadProgress was replaced by meta.uploadProgress in 2.0 — pass meta: { uploadProgress: { onProgress } }");
+			const options = ctx.meta?.uploadProgress;
+			if (typeof options === "function") throw new TypeError("arthron: meta.uploadProgress takes options — pass meta: { uploadProgress: { onProgress } }");
+			const onProgress = options?.onProgress;
+			const { body } = ctx.init;
+			if (!onProgress || body === void 0 || body === null) return ctx;
+			if (ctx.fetchFn !== globalThis.fetch) return ctx;
+			const uploadMode = uploadModeFor(currentRuntime());
+			if (!uploadMode) return ctx;
+			if (uploadMode === "xhr") {
+				const page = globalThis.location?.href;
+				const refusal = xhrRefusal(ctx.init, ctx.url, page);
+				if (refusal) throw new TypeError(`arthron: meta.uploadProgress cannot be combined with ${refusal}; drop one of them`);
+				if (require_create_error.isReadableStream(body)) return ctx;
+			}
+			const { ctx: withSignal, report } = withOwnSignal(ctx, onProgress);
+			return {
+				...withSignal,
+				fetchFn: uploadMode === "xhr" ? xhrFetch(report) : countingFetch(ctx.fetchFn, report)
+			};
+		}
+	};
+}
+//#endregion
+exports.bearerAuth = bearerAuth;
+exports.logging = logging;
+exports.retry = retry;
+exports.timeout = timeout;
+exports.uploadProgress = uploadProgress;