arthron 0.0.1 → 0.1.0

package/dist/index.d.cts

@@ -17,17 +17,37 @@ type ArthronErrorInit = {
  */
 export declare class ArthronError extends Error {
   readonly name = "ArthronError";
+  /** HTTP status of the failed response; `0` when fetch itself failed (network). */
   readonly status: number;
   readonly statusText: string;
+  /** Response headers; empty for network failures. */
   readonly headers: Headers;
+  /** Parsed body: JSON if it parses, else the text, else `undefined`. */
   readonly data: unknown;
+  /** The context that was sent — url and init after request interceptors. */
   readonly request: RequestContext;
+  /** The original Response, still readable (the body was parsed from a clone). Absent for network failures. */
   readonly response: Response | undefined;
+  /** The underlying error for network failures. */
   readonly cause: unknown;
   constructor(init: ArthronErrorInit);
 }
+/** `true` for errors arthron produced: a `!ok` response or a network failure. Cancellations and plugin bugs are not ArthronErrors. */
 export declare function isArthronError(error: unknown): error is ArthronError;
 //#endregion
+//#region src/stream.d.ts
+/** One server-sent event, as described by the WHATWG EventSource spec. */
+type SseEvent = {
+  /** The `event:` field, when the server sent one. */
+  event?: string;
+  /** All `data:` lines of the block, joined with `\n`. */
+  data: string;
+  /** The `id:` field, when present. */
+  id?: string;
+  /** The `retry:` field in ms, when present and numeric. */
+  retry?: number;
+};
+//#endregion
 //#region src/url.d.ts
 type QueryParams = Record<string, string | number | boolean | null | undefined>;
 //#endregion
@@ -83,6 +103,10 @@ type ArthronPromise = Promise<Response> & {
   blob(): Promise<Blob>;
   arrayBuffer(): Promise<ArrayBuffer>;
   formData(): Promise<FormData>;
+  /** Iterate a `text/event-stream` body as events. */
+  sse(): AsyncIterable<SseEvent>;
+  /** Iterate a newline-delimited JSON body, one parsed value per line. */
+  ndjson<T = unknown>(): AsyncIterable<T>;
 };
 type Arthron = {
   get(path: string, init?: RequestOptions): ArthronPromise;
@@ -106,26 +130,49 @@ type Arthron = {
 export declare function arthron(config?: ArthronConfig): Arthron;
 //#endregion
 //#region src/define.d.ts
+/** Identity helper: gives a middleware written in its own file the right parameter types. */
 export declare const defineMiddleware: (middleware: Middleware) => Middleware;
+/** Identity helpers for each interceptor kind — `defineInterceptor.request(fn)` etc. */
 export declare const defineInterceptor: {
   request: (interceptor: RequestInterceptor) => RequestInterceptor;
   response: (interceptor: ResponseInterceptor) => ResponseInterceptor;
   error: (interceptor: ErrorInterceptor) => ErrorInterceptor;
 };
+/** Identity helper: type-checks a plugin object literal without an annotation. */
 export declare const definePlugin: (plugin: Plugin) => Plugin;
 //#endregion
 //#region src/plugins/logging.d.ts
+type LogEventBase = {
+  method: string;
+  path: string;
+};
+type LogEvent = ({
+  phase: "start";
+} & LogEventBase) | ({
+  phase: "success";
+  status: number;
+  ms: number;
+} & LogEventBase) | ({
+  phase: "error";
+  /** HTTP status for an ArthronError (0 = network); undefined for anything else. */
+  status: number | undefined;
+  ms: number;
+  error: unknown;
+} & LogEventBase);
 type LoggingOptions = {
   /** Default `true`. The library never reads `NODE_ENV` — pass `isDev` yourself. */
   enabled?: boolean;
   logger?: Pick<Console, "log" | "error">;
+  /** Receive structured events instead of the default console lines. */
+  onEvent?: (event: LogEvent) => void;
   /** Clock in ms. Injectable for tests. */
   now?: () => number;
 };
 /**
- * One line when a request starts, one when it settles, with status and
+ * 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.
- * The query string is dropped — it tends to carry tokens.
+ * Default output is a console line per event; pass `onEvent` to get the
+ * structured event instead. Cancellations are not reported.
  */
 export declare function logging(options?: LoggingOptions): Plugin;
 //#endregion
@@ -155,5 +202,18 @@ type RetryOptions = {
  */
 export declare function retry(options?: RetryOptions): Plugin;
 //#endregion
-export type { Arthron, ArthronConfig, ArthronPromise, ErrorInterceptor, ErrorMessageResolver, LoggingOptions, Middleware, Plugin, QueryParams, RequestContext, RequestInterceptor, RequestOptions, ResponseInterceptor, RetryOptions };
+//#region src/plugins/timeout.d.ts
+/**
+ * Abort the request when it takes longer than `ms` — counted from the start
+ * of the attempt until the body has been fully read, so a server that sends
+ * headers and then stalls still trips it. Rejects with a `TimeoutError` (a
+ * `DOMException`, like `AbortSignal.timeout()` would give); it is not an
+ * `ArthronError`, so error interceptors and `retry` leave it alone.
+ *
+ * Built on `AbortController` + `setTimeout` rather than `AbortSignal.any` /
+ * `AbortSignal.timeout` so it runs on Node 18.
+ */
+export declare function timeout(ms: number): Plugin;
+//#endregion
+export type { Arthron, ArthronConfig, ArthronPromise, ErrorInterceptor, ErrorMessageResolver, LogEvent, LoggingOptions, Middleware, Plugin, QueryParams, RequestContext, RequestInterceptor, RequestOptions, ResponseInterceptor, RetryOptions, SseEvent };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -17,17 +17,37 @@ type ArthronErrorInit = {
  */
 export declare class ArthronError extends Error {
   readonly name = "ArthronError";
+  /** HTTP status of the failed response; `0` when fetch itself failed (network). */
   readonly status: number;
   readonly statusText: string;
+  /** Response headers; empty for network failures. */
   readonly headers: Headers;
+  /** Parsed body: JSON if it parses, else the text, else `undefined`. */
   readonly data: unknown;
+  /** The context that was sent — url and init after request interceptors. */
   readonly request: RequestContext;
+  /** The original Response, still readable (the body was parsed from a clone). Absent for network failures. */
   readonly response: Response | undefined;
+  /** The underlying error for network failures. */
   readonly cause: unknown;
   constructor(init: ArthronErrorInit);
 }
+/** `true` for errors arthron produced: a `!ok` response or a network failure. Cancellations and plugin bugs are not ArthronErrors. */
 export declare function isArthronError(error: unknown): error is ArthronError;
 //#endregion
+//#region src/stream.d.ts
+/** One server-sent event, as described by the WHATWG EventSource spec. */
+type SseEvent = {
+  /** The `event:` field, when the server sent one. */
+  event?: string;
+  /** All `data:` lines of the block, joined with `\n`. */
+  data: string;
+  /** The `id:` field, when present. */
+  id?: string;
+  /** The `retry:` field in ms, when present and numeric. */
+  retry?: number;
+};
+//#endregion
 //#region src/url.d.ts
 type QueryParams = Record<string, string | number | boolean | null | undefined>;
 //#endregion
@@ -83,6 +103,10 @@ type ArthronPromise = Promise<Response> & {
   blob(): Promise<Blob>;
   arrayBuffer(): Promise<ArrayBuffer>;
   formData(): Promise<FormData>;
+  /** Iterate a `text/event-stream` body as events. */
+  sse(): AsyncIterable<SseEvent>;
+  /** Iterate a newline-delimited JSON body, one parsed value per line. */
+  ndjson<T = unknown>(): AsyncIterable<T>;
 };
 type Arthron = {
   get(path: string, init?: RequestOptions): ArthronPromise;
@@ -106,26 +130,49 @@ type Arthron = {
 export declare function arthron(config?: ArthronConfig): Arthron;
 //#endregion
 //#region src/define.d.ts
+/** Identity helper: gives a middleware written in its own file the right parameter types. */
 export declare const defineMiddleware: (middleware: Middleware) => Middleware;
+/** Identity helpers for each interceptor kind — `defineInterceptor.request(fn)` etc. */
 export declare const defineInterceptor: {
   request: (interceptor: RequestInterceptor) => RequestInterceptor;
   response: (interceptor: ResponseInterceptor) => ResponseInterceptor;
   error: (interceptor: ErrorInterceptor) => ErrorInterceptor;
 };
+/** Identity helper: type-checks a plugin object literal without an annotation. */
 export declare const definePlugin: (plugin: Plugin) => Plugin;
 //#endregion
 //#region src/plugins/logging.d.ts
+type LogEventBase = {
+  method: string;
+  path: string;
+};
+type LogEvent = ({
+  phase: "start";
+} & LogEventBase) | ({
+  phase: "success";
+  status: number;
+  ms: number;
+} & LogEventBase) | ({
+  phase: "error";
+  /** HTTP status for an ArthronError (0 = network); undefined for anything else. */
+  status: number | undefined;
+  ms: number;
+  error: unknown;
+} & LogEventBase);
 type LoggingOptions = {
   /** Default `true`. The library never reads `NODE_ENV` — pass `isDev` yourself. */
   enabled?: boolean;
   logger?: Pick<Console, "log" | "error">;
+  /** Receive structured events instead of the default console lines. */
+  onEvent?: (event: LogEvent) => void;
   /** Clock in ms. Injectable for tests. */
   now?: () => number;
 };
 /**
- * One line when a request starts, one when it settles, with status and
+ * 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.
- * The query string is dropped — it tends to carry tokens.
+ * Default output is a console line per event; pass `onEvent` to get the
+ * structured event instead. Cancellations are not reported.
  */
 export declare function logging(options?: LoggingOptions): Plugin;
 //#endregion
@@ -155,5 +202,18 @@ type RetryOptions = {
  */
 export declare function retry(options?: RetryOptions): Plugin;
 //#endregion
-export type { Arthron, ArthronConfig, ArthronPromise, ErrorInterceptor, ErrorMessageResolver, LoggingOptions, Middleware, Plugin, QueryParams, RequestContext, RequestInterceptor, RequestOptions, ResponseInterceptor, RetryOptions };
+//#region src/plugins/timeout.d.ts
+/**
+ * Abort the request when it takes longer than `ms` — counted from the start
+ * of the attempt until the body has been fully read, so a server that sends
+ * headers and then stalls still trips it. Rejects with a `TimeoutError` (a
+ * `DOMException`, like `AbortSignal.timeout()` would give); it is not an
+ * `ArthronError`, so error interceptors and `retry` leave it alone.
+ *
+ * Built on `AbortController` + `setTimeout` rather than `AbortSignal.any` /
+ * `AbortSignal.timeout` so it runs on Node 18.
+ */
+export declare function timeout(ms: number): Plugin;
+//#endregion
+export type { Arthron, ArthronConfig, ArthronPromise, ErrorInterceptor, ErrorMessageResolver, LogEvent, LoggingOptions, Middleware, Plugin, QueryParams, RequestContext, RequestInterceptor, RequestOptions, ResponseInterceptor, RetryOptions, SseEvent };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -48,12 +48,18 @@ function serializeBody(body, headers) {
 */
 var ArthronError = class extends Error {
 	name = "ArthronError";
+	/** HTTP status of the failed response; `0` when fetch itself failed (network). */
 	status;
 	statusText;
+	/** Response headers; empty for network failures. */
 	headers;
+	/** Parsed body: JSON if it parses, else the text, else `undefined`. */
 	data;
+	/** The context that was sent — url and init after request interceptors. */
 	request;
+	/** The original Response, still readable (the body was parsed from a clone). Absent for network failures. */
 	response;
+	/** The underlying error for network failures. */
 	cause;
 	constructor(init) {
 		super(init.message);
@@ -66,6 +72,7 @@ var ArthronError = class extends Error {
 		this.cause = init.cause;
 	}
 };
+/** `true` for errors arthron produced: a `!ok` response or a network failure. Cancellations and plugin bugs are not ArthronErrors. */
 function isArthronError(error) {
 	return error instanceof ArthronError;
 }
@@ -94,7 +101,7 @@ async function readBody(response) {
 	}
 }
 async function responseError(response, request, resolve = defaultErrorMessage) {
-	const data = await readBody(response);
+	const data = await readBody(response.clone());
 	return new ArthronError({
 		message: resolve(data, response) ?? `Request failed with status ${response.status}`,
 		status: response.status,
@@ -195,7 +202,101 @@ async function runPipeline(plugins, ctx, send) {
 	return dispatch(0, ctx);
 }
 //#endregion
+//#region src/stream.ts
+/** Yield the body line by line, reassembling lines split across chunks. */
+async function* lines(response) {
+	if (!response.body) return;
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { value, done } = await reader.read();
+			buffer += decoder.decode(value, { stream: !done });
+			const parts = buffer.split(/\r\n|\r|\n/);
+			buffer = parts.pop() ?? "";
+			for (const line of parts) yield line;
+			if (done) break;
+		}
+		if (buffer) yield buffer;
+	} finally {
+		reader.releaseLock();
+	}
+}
+/**
+* Parse a `text/event-stream` body into events. Follows the spec: a blank
+* line dispatches, `data:` lines are joined with `\n`, one leading space
+* after the colon is dropped, lines starting with `:` are comments, and a
+* block without `data` is not dispatched. Provider sentinels like
+* `[DONE]` are passed through untouched — they are not part of the spec.
+*/
+async function* parseSse(response) {
+	let data = [];
+	let event;
+	let id;
+	let retry;
+	const flush = () => {
+		if (data.length === 0) {
+			event = id = retry = void 0;
+			return;
+		}
+		const out = { data: data.join("\n") };
+		if (event !== void 0) out.event = event;
+		if (id !== void 0) out.id = id;
+		if (retry !== void 0) out.retry = retry;
+		data = [];
+		event = id = retry = void 0;
+		return out;
+	};
+	for await (const line of lines(response)) {
+		if (line === "") {
+			const out = flush();
+			if (out) yield out;
+			continue;
+		}
+		if (line.startsWith(":")) continue;
+		const colon = line.indexOf(":");
+		const field = colon === -1 ? line : line.slice(0, colon);
+		let value = colon === -1 ? "" : line.slice(colon + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		switch (field) {
+			case "data":
+				data.push(value);
+				break;
+			case "event":
+				event = value;
+				break;
+			case "id":
+				id = value;
+				break;
+			case "retry": {
+				const ms = Number(value);
+				if (Number.isInteger(ms) && ms >= 0) retry = ms;
+				break;
+			}
+		}
+	}
+	const out = flush();
+	if (out) yield out;
+}
+/**
+* Parse newline-delimited JSON. Blank lines are skipped; a malformed line
+* rejects the iteration with the `SyntaxError` from `JSON.parse`.
+*/
+async function* parseNdjson(response) {
+	for await (const line of lines(response)) {
+		if (line.trim() === "") continue;
+		yield JSON.parse(line);
+	}
+}
+//#endregion
 //#region src/promise.ts
+/** Defer the Response until iteration starts, so the helper itself never rejects. */
+function iterate(promise, parse) {
+	return { async *[Symbol.asyncIterator]() {
+		yield* parse(await promise);
+	} };
+}
 /**
 * Sugar over `Promise<Response>`: `.json()` is `(await p).json()`. Awaiting
 * without a helper still yields the untouched `Response`.
@@ -206,7 +307,9 @@ function toArthronPromise(promise) {
 		text: () => promise.then((res) => res.text()),
 		blob: () => promise.then((res) => res.blob()),
 		arrayBuffer: () => promise.then((res) => res.arrayBuffer()),
-		formData: () => promise.then((res) => res.formData())
+		formData: () => promise.then((res) => res.formData()),
+		sse: () => iterate(promise, parseSse),
+		ndjson: () => iterate(promise, parseNdjson)
 	});
 }
 //#endregion
@@ -233,15 +336,18 @@ function resolveUrl(baseURL, path, params) {
 	let url;
 	if (isAbsoluteUrl(path)) url = path;
 	else {
-		if (baseURL === void 0) throw new TypeError(`arthron: relative path "${path}" requires a baseURL`);
+		if (baseURL === void 0) throw new TypeError(`arthron: relative path "${path}" needs a baseURL — pass baseURL in arthron({ baseURL }) or use an absolute URL`);
 		url = `${baseURL.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
 	}
 	const query = toQueryString(params);
 	if (!query) return url;
-	return `${url}${url.includes("?") ? "&" : "?"}${query}`;
+	const hash = url.indexOf("#");
+	const [base, fragment] = hash === -1 ? [url, ""] : [url.slice(0, hash), url.slice(hash)];
+	return `${base}${base.includes("?") ? "&" : "?"}${query}${fragment}`;
 }
 //#endregion
 //#region src/client.ts
+const BODYLESS_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
 /** Normalize once so `extend` can merge headers and append plugins cheaply. */
 function resolveConfig(config) {
 	const { headers, use, ...rest } = config;
@@ -257,9 +363,9 @@ function resolveConfig(config) {
 */
 function arthron(config = {}) {
 	const resolved = resolveConfig(config);
-	const fetchImpl = resolved.fetch ?? globalThis.fetch;
 	/** The one place a failure becomes an ArthronError. Cancellation passes through. */
 	const send = async (ctx) => {
+		const fetchImpl = resolved.fetch ?? globalThis.fetch;
 		let res;
 		try {
 			res = await fetchImpl(ctx.url, ctx.init);
@@ -272,6 +378,7 @@ function arthron(config = {}) {
 	};
 	const dispatch = (path, method, rawBody, { params, headers: callHeaders, ...init }) => {
 		try {
+			if (rawBody !== void 0 && BODYLESS_METHODS.has(method.toUpperCase())) throw new TypeError(`arthron: ${method.toUpperCase()} requests cannot carry a body — send it as params (query) or switch to POST`);
 			const url = resolveUrl(resolved.baseURL, path, params);
 			const { body, headers } = serializeBody(rawBody, mergeHeaders(resolved.headers, callHeaders));
 			const requestInit = {
@@ -306,7 +413,7 @@ function arthron(config = {}) {
 		patch: (path, body, init = {}) => dispatch(path, "PATCH", body, init),
 		request: (path, init) => {
 			const { method, body, ...rest } = init;
-			if (!method) return toArthronPromise(Promise.reject(/* @__PURE__ */ new TypeError("arthron: request() requires init.method")));
+			if (!method) return toArthronPromise(Promise.reject(/* @__PURE__ */ new TypeError("arthron: request() needs init.method — e.g. request(path, { method: \"OPTIONS\" }); use get/post/... for the common verbs")));
 			return dispatch(path, method, body, rest);
 		},
 		use: (...plugins) => derive({ use: plugins }),
@@ -315,41 +422,79 @@ function arthron(config = {}) {
 }
 //#endregion
 //#region src/define.ts
+/** Identity helper: gives a middleware written in its own file the right parameter types. */
 const defineMiddleware = (middleware) => middleware;
+/** Identity helpers for each interceptor kind — `defineInterceptor.request(fn)` etc. */
 const defineInterceptor = {
 	request: (interceptor) => interceptor,
 	response: (interceptor) => interceptor,
 	error: (interceptor) => interceptor
 };
+/** Identity helper: type-checks a plugin object literal without an annotation. */
 const definePlugin = (plugin) => plugin;
 //#endregion
 //#region src/plugins/logging.ts
+/** Origin + pathname only — the query and userinfo tend to carry secrets. */
+function displayPath(url) {
+	try {
+		const parsed = new URL(url);
+		return `${parsed.origin}${parsed.pathname}`;
+	} catch {
+		return url.split("?")[0] ?? url;
+	}
+}
+function consoleSink(logger) {
+	return (e) => {
+		if (e.phase === "start") logger.log(`[arthron] → ${e.method} ${e.path}`);
+		else if (e.phase === "success") logger.log(`[arthron] ← ${e.method} ${e.path} ${e.status} ${e.ms}ms`);
+		else logger.error(`[arthron] ✕ ${e.method} ${e.path} ${e.status ?? "-"} ${e.ms}ms`);
+	};
+}
 /**
-* One line when a request starts, one when it settles, with status and
+* 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.
-* The query string is dropped — it tends to carry tokens.
+* Default output is a console line per event; pass `onEvent` to get the
+* structured event instead. Cancellations are not reported.
 */
 function logging(options = {}) {
-	const { enabled = true, logger = console, now = () => performance.now() } = options;
+	const { enabled = true, logger = console, onEvent, now = () => performance.now() } = options;
+	const emit = onEvent ?? consoleSink(logger);
 	return {
 		name: "logging",
 		middleware: async (ctx, next) => {
 			if (!enabled) return next(ctx);
 			const method = ctx.init.method ?? "GET";
-			const path = ctx.url.split("?")[0];
+			const path = displayPath(ctx.url);
 			const started = now();
-			const elapsed = () => `${Math.round(now() - started)}ms`;
-			logger.log(`[arthron] → ${method} ${path}`);
+			const ms = () => Math.round(now() - started);
+			emit({
+				phase: "start",
+				method,
+				path
+			});
 			try {
 				const res = await next(ctx);
-				logger.log(`[arthron] ← ${method} ${path} ${res.status} ${elapsed()}`);
+				emit({
+					phase: "success",
+					method,
+					path,
+					status: res.status,
+					ms: ms()
+				});
 				return res;
-			} catch (thrown) {
-				if (!isCancellation(thrown)) {
-					const status = isArthronError(thrown) ? thrown.status : "-";
-					logger.error(`[arthron] ✕ ${method} ${path} ${status} ${elapsed()}`);
+			} catch (error) {
+				if (!isCancellation(error)) {
+					const status = isArthronError(error) ? error.status : void 0;
+					emit({
+						phase: "error",
+						method,
+						path,
+						status,
+						ms: ms(),
+						error
+					});
 				}
-				throw thrown;
+				throw error;
 			}
 		}
 	};
@@ -427,6 +572,85 @@ function retry(options = {}) {
 	};
 }
 //#endregion
-export { ArthronError, arthron, defineInterceptor, defineMiddleware, definePlugin, isArthronError, logging, retry };
+//#region src/plugins/timeout.ts
+/**
+* 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) {
+	const reader = body.getReader();
+	return new ReadableStream({
+		start(controller) {
+			signal.addEventListener("abort", () => {
+				controller.error(signal.reason);
+				reader.cancel(signal.reason).catch(() => {});
+			}, { once: true });
+		},
+		async pull(controller) {
+			const { value, done } = await reader.read();
+			if (done) {
+				finish();
+				controller.close();
+				return;
+			}
+			controller.enqueue(value);
+		},
+		cancel(reason) {
+			finish();
+			return reader.cancel(reason);
+		}
+	});
+}
+/**
+* Abort the request when it takes longer than `ms` — counted from the start
+* of the attempt until the body has been fully read, so a server that sends
+* headers and then stalls still trips it. Rejects with a `TimeoutError` (a
+* `DOMException`, like `AbortSignal.timeout()` would give); it is not an
+* `ArthronError`, so error interceptors and `retry` leave it alone.
+*
+* Built on `AbortController` + `setTimeout` rather than `AbortSignal.any` /
+* `AbortSignal.timeout` so it runs on Node 18.
+*/
+function timeout(ms) {
+	return {
+		name: "timeout",
+		middleware: async (ctx, next) => {
+			const controller = new AbortController();
+			const outer = ctx.init.signal;
+			const forward = () => controller.abort(outer?.reason);
+			if (outer?.aborted) forward();
+			else outer?.addEventListener("abort", forward, { once: true });
+			const timer = setTimeout(() => controller.abort(new DOMException(`arthron: request timed out after ${ms}ms`, "TimeoutError")), ms);
+			const finish = () => {
+				clearTimeout(timer);
+				outer?.removeEventListener("abort", forward);
+			};
+			let res;
+			try {
+				res = await next({
+					...ctx,
+					init: {
+						...ctx.init,
+						signal: controller.signal
+					}
+				});
+			} catch (thrown) {
+				finish();
+				throw thrown;
+			}
+			if (!res.body) {
+				finish();
+				return res;
+			}
+			return new Response(guardBody(res.body, controller.signal, finish), {
+				status: res.status,
+				statusText: res.statusText,
+				headers: res.headers
+			});
+		}
+	};
+}
+//#endregion
+export { ArthronError, arthron, defineInterceptor, defineMiddleware, definePlugin, isArthronError, logging, retry, timeout };
 
 //# sourceMappingURL=index.mjs.map