@microlink/mql 0.16.1 → 0.17.1

package/dist/index.js

@@ -10,7 +10,7 @@ function getAugmentedNamespace(n) {
 			var isInstance = false;
       try {
         isInstance = this instanceof a;
-      } catch {}
+      } catch (e) {}
 			if (isInstance) {
         return Reflect.construct(f, arguments, this.constructor);
 			}
@@ -65,6 +65,10 @@ dist.flattie = flattie;
 
 /**
 Base class for all Ky-specific errors. `HTTPError`, `NetworkError`, `TimeoutError`, and `ForceRetryError` extend this class.
+
+You can use `instanceof KyError` to check if an error originated from Ky, or use the `isKyError()` type guard for cross-realm compatibility and TypeScript type narrowing.
+
+Note: `SchemaValidationError` is intentionally not considered a Ky error. `KyError` covers failures in Ky's HTTP lifecycle (bad status, timeout, retry), while schema validation errors originate from the user-provided schema, not from Ky itself.
 */
 class KyError extends Error {
     name = 'KyError';
@@ -76,7 +80,11 @@ class KyError extends Error {
 /**
 Error thrown when the response has a non-2xx status code and `throwHttpErrors` is enabled.
 
-The error has a `response` property with the `Response` object, a `request` property with the `Request` object, an `options` property with the normalized options, and a `data` property with the pre-parsed response body. The response body is automatically consumed when populating `data`, so `response.json()` and other body methods will not work. Use `data` instead.
+The error has a `response` property with the `Response` object, a `request` property with the `Request` object, an `options` property with the normalized options (either passed to `ky` when creating an instance with `ky.create()` or directly when performing the request), and a `data` property with the pre-parsed response body. For JSON responses (based on `Content-Type`), the body is parsed using the `parseJson` option if set, or `JSON.parse` by default. For other content types, it is set as plain text. If the body is empty or parsing fails, `data` will be `undefined`. To avoid hanging or excessive buffering, `error.data` population is bounded by the request timeout and a 10 MiB response body size limit. The `data` property is populated before `beforeError` hooks run, so hooks can access it.
+
+The response body is automatically consumed when populating `error.data`, so `error.response.json()` and other body methods will not work. Use `error.data` instead. The `error.response` object is still available for headers, status, etc.
+
+Be aware that some types of errors, such as network errors, inherently mean that a response was not received. In that case, the error will be an instance of `NetworkError` instead of `HTTPError` and will not contain a `response` property.
 */
 class HTTPError extends KyError {
     name = 'HTTPError';
@@ -97,9 +105,11 @@ class HTTPError extends KyError {
 }
 
 /**
-Error thrown when a network error occurs during the request (e.g., DNS failure, connection refused, offline).
+Error thrown when a network error occurs during the request (e.g., DNS failure, connection refused, offline). It has a `request` property with the `Request` object. The original error is available via the standard `cause` property.
+
+Network errors are automatically retried (for retriable methods).
 
-The error has a `request` property with the `Request` object. The original error is available via the standard `cause` property.
+Note: Network errors are detected using runtime-specific heuristics. Unrecognized runtimes may produce errors that are not wrapped in `NetworkError`. Use the `shouldRetry` option to handle such cases.
 */
 class NetworkError extends KyError {
     name = 'NetworkError';
@@ -161,7 +171,7 @@ class ForceRetryError extends KyError {
 }
 
 /**
-Thrown when a response body fails validation against a user-provided Standard Schema.
+The error thrown when [Standard Schema](https://github.com/standard-schema/standard-schema) validation fails in `.json(schema)`. It has an `issues` property with the validation issues from the schema.
 
 This error intentionally does not extend `KyError` because it does not represent a failure in Ky's HTTP lifecycle. The request succeeded; the user's schema rejected the data. As such, it is not matched by `isKyError()`.
 
@@ -192,9 +202,7 @@ class SchemaValidationError extends Error {
 }
 
 /**
-Error thrown when the request times out.
-
-The error has a `request` property with the `Request` object.
+Error thrown when the request times out. It has a `request` property with the `Request` object.
 */
 class TimeoutError extends KyError {
     name = 'TimeoutError';
@@ -281,7 +289,7 @@ const api = ky.extend({
             async ({request, response}) => {
                 // Retry based on response body content
                 if (response.status === 200) {
-                    const data = await response.clone().json();
+                    const data = await response.json();
 
                     // Simple retry with default delay
                     if (data.error?.code === 'TEMPORARY_ERROR') {
@@ -365,12 +373,6 @@ const kyOptionKeys = {
     fetch: true,
     context: true,
 };
-// Vendor-specific fetch options that should always be passed to fetch()
-// even if they appear on the Request object due to vendor patching.
-// See: https://github.com/sindresorhus/ky/issues/541
-const vendorSpecificOptions = {
-    next: true, // Next.js cache revalidation (revalidate, tags)
-};
 // Standard RequestInit options that should NOT be passed separately to fetch()
 // because they're already applied to the Request object.
 // Note: `dispatcher` and `priority` are NOT included here - they're fetch-only
@@ -495,7 +497,7 @@ const getReplaceState = (value) => isObject(value) && value[replaceSymbol] === t
         value,
     };
 /**
-Wraps a value so that `ky.extend()` will replace the parent value instead of merging with it.
+Wraps a value so that `ky.extend()` will replace the parent value instead of merging with it. Works with hooks, headers, search parameters, context, and any other deep-merged option.
 
 By default, `.extend()` deep-merges options with the parent instance: hooks get appended, headers get merged, and search parameters get accumulated. Use `replaceOption` when you want to fully replace a merged property instead.
 
@@ -549,7 +551,13 @@ const isPlainObject = (value) => {
 };
 const cloneShallow = (value) => {
     if (value instanceof URLSearchParams) {
-        return new URLSearchParams(value);
+        const copy = new URLSearchParams(value);
+        const deleted = value[deletedParametersSymbol];
+        if (deleted) {
+            // Preserve internal deletion markers so init-hook cloning does not resurrect params removed during option merging.
+            copy[deletedParametersSymbol] = new Set(deleted);
+        }
+        return copy;
     }
     if (value instanceof globalThis.Headers) {
         return new globalThis.Headers(value);
@@ -760,11 +768,13 @@ const normalizeRetryOptions = (retry = {}) => {
     if (retry.methods && !Array.isArray(retry.methods)) {
         throw new Error('retry.methods must be an array');
     }
-    retry.methods &&= retry.methods.map(method => method.toLowerCase());
     if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
         throw new Error('retry.statusCodes must be an array');
     }
-    const normalizedRetry = Object.fromEntries(Object.entries(retry).filter(([, value]) => value !== undefined));
+    const normalizedRetry = Object.fromEntries(Object.entries({
+        ...retry,
+        methods: retry.methods?.map(method => method.toLowerCase()),
+    }).filter(([, value]) => value !== undefined));
     return {
         ...defaultRetryOptions,
         ...normalizedRetry,
@@ -808,20 +818,19 @@ async function delay(ms, { signal }) {
     });
 }
 
-const findUnknownOptions = (request, options) => {
+const findUnknownOptions = (options) => {
     const unknownOptions = {};
     for (const key in options) {
         // Skip inherited properties
         if (!Object.hasOwn(options, key)) {
             continue;
         }
-        // An option is passed to fetch() if:
-        // 1. It's not a standard RequestInit option (not in requestOptionsRegistry)
-        // 2. It's not a ky-specific option (not in kyOptionKeys)
-        // 3. Either:
-        //    a. It's not on the Request object, OR
-        //    b. It's a vendor-specific option that should always be passed (in vendorSpecificOptions)
-        if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && (!(key in request) || key in vendorSpecificOptions)) {
+        // Forward every non-standard, non-Ky option to fetch().
+        // We intentionally do not check whether the key also exists on `Request`, because some runtimes
+        // patch `Request.prototype` with fetch-only extensions. For example, Next.js adds `next`, and the
+        // old `key in request` heuristic dropped it unless Ky kept a special-case allowlist.
+        // Passing all non-standard keys makes that allowlist unnecessary and preserves future fetch extensions too.
+        if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys)) {
             unknownOptions[key] = options[key];
         }
     }
@@ -849,8 +858,8 @@ const hasSearchParameters = (search) => {
 };
 
 // Inlined from https://github.com/sindresorhus/is-network-error v1.3.1
-const objectToString = Object.prototype.toString;
-const isError = (value) => objectToString.call(value) === '[object Error]';
+const objectToString$1 = Object.prototype.toString;
+const isError = (value) => objectToString$1.call(value) === '[object Error]';
 const errorMessages = new Set([
     'network error', // Chrome
     'NetworkError when attempting to fetch resource.', // Firefox
@@ -1022,16 +1031,43 @@ const createTextDecoder = (contentType) => {
     return new TextDecoder();
 };
 const invalidSchemaMessage = 'The `schema` argument must follow the Standard Schema specification';
+const cloneRetryOptions = (retry) => {
+    if (typeof retry !== 'object') {
+        return retry;
+    }
+    // Clone nested arrays too so init hooks can mutate retry config without leaking state across requests.
+    return {
+        ...retry,
+        ...(retry.methods && { methods: [...retry.methods] }),
+        ...(retry.statusCodes && { statusCodes: [...retry.statusCodes] }),
+        ...(retry.afterStatusCodes && { afterStatusCodes: [...retry.afterStatusCodes] }),
+    };
+};
+const objectToString = Object.prototype.toString;
+const isRequestInstance = (value) => value instanceof globalThis.Request || objectToString.call(value) === '[object Request]';
+// Accepted custom responses are treated as full Responses throughout Ky.
+// If a custom fetch returns one, it must behave like a Response for cloning,
+// body consumption, `json()` decoration, and any enabled stream features.
+const isResponseInstance = (value) => value instanceof globalThis.Response || objectToString.call(value) === '[object Response]';
+const cloneSearchParametersForInitHook = (searchParameters) => {
+    if (Array.isArray(searchParameters)) {
+        return searchParameters.map(parameter => [...parameter]);
+    }
+    return cloneShallow(searchParameters);
+};
 // Shallow-clone mutable option properties so init hook mutations don't leak across requests.
 function cloneInitHookOptions(options) {
-    return {
+    const clonedOptions = {
         ...options,
         json: cloneShallow(options.json),
-        retry: cloneShallow(options.retry),
         context: cloneShallow(options.context),
         headers: cloneShallow(options.headers),
-        searchParams: cloneShallow(options.searchParams),
+        searchParams: cloneSearchParametersForInitHook(options.searchParams),
     };
+    if (options.retry !== undefined) {
+        clonedOptions.retry = cloneRetryOptions(options.retry);
+    }
+    return clonedOptions;
 }
 const validateJsonWithSchema = async (jsonValue, schema) => {
     if ((typeof schema !== 'object'
@@ -1072,43 +1108,49 @@ class Ky {
             let response = beforeRequestResponse ?? await ky.#retry(async () => ky.#fetch());
             let responseFromHook = beforeRequestResponse !== undefined
                 || ky.#consumeReturnedResponseFromBeforeRetryHook();
-            if (!(response instanceof globalThis.Response)) {
-                return response;
-            }
             for (;;) {
-                try {
-                    // eslint-disable-next-line no-await-in-loop
-                    response = await ky.#runAfterResponseHooks(response);
+                // `undefined` means a hook stopped the flow without providing a response.
+                // Non-native Responses still continue through Ky if they pass `isResponseInstance()`.
+                if (response === undefined) {
+                    return response;
                 }
-                catch (error) {
-                    if (!(error instanceof ForceRetryError)) {
-                        throw error;
+                if (isResponseInstance(response)) {
+                    try {
+                        // eslint-disable-next-line no-await-in-loop
+                        response = await ky.#runAfterResponseHooks(response);
                     }
-                    // eslint-disable-next-line no-await-in-loop
-                    const retriedResponse = await ky.#retryFromError(error, async () => ky.#fetch());
-                    if (!(retriedResponse instanceof globalThis.Response)) {
-                        return retriedResponse;
+                    catch (error) {
+                        if (!(error instanceof ForceRetryError)) {
+                            throw error;
+                        }
+                        // eslint-disable-next-line no-await-in-loop
+                        const retriedResponse = await ky.#retryFromError(error, async () => ky.#fetch());
+                        if (retriedResponse === undefined) {
+                            return retriedResponse;
+                        }
+                        response = retriedResponse;
+                        responseFromHook = ky.#consumeReturnedResponseFromBeforeRetryHook();
+                        continue;
                     }
-                    response = retriedResponse;
-                    responseFromHook = ky.#consumeReturnedResponseFromBeforeRetryHook();
-                    continue;
                 }
+                const currentResponse = response;
                 // Opaque responses (`response.type === 'opaque'`) from `no-cors` requests always have `status: 0` and `ok: false`, but this is not a failure - the actual status is hidden by the browser.
-                if (!response.ok && response.type !== 'opaque' && (typeof ky.#options.throwHttpErrors === 'function'
-                    ? ky.#options.throwHttpErrors(response.status)
+                if (!currentResponse.ok && currentResponse.type !== 'opaque' && (typeof ky.#options.throwHttpErrors === 'function'
+                    ? ky.#options.throwHttpErrors(currentResponse.status)
                     : ky.#options.throwHttpErrors)) {
                     // `request` must reflect the request that actually failed, but `options` stays as Ky's
                     // normalized options snapshot. Replacement `Request` instances do not preserve the
                     // original `BodyInit`, so trying to make `options` mirror arbitrary requests would be lossy.
-                    const error = new HTTPError(response, ky.#getResponseRequest(response), ky.#getNormalizedOptions());
+                    const httpError = new HTTPError(currentResponse, ky.#getResponseRequest(currentResponse), ky.#getNormalizedOptions());
+                    const errorToThrow = httpError;
                     // eslint-disable-next-line no-await-in-loop
-                    error.data = await ky.#getResponseData(response);
+                    httpError.data = await ky.#getResponseData(currentResponse);
                     if (responseFromHook) {
-                        throw error;
+                        throw errorToThrow;
                     }
                     // eslint-disable-next-line no-await-in-loop
-                    const retriedResponse = await ky.#retryFromError(error, async () => ky.#fetch());
-                    if (!(retriedResponse instanceof globalThis.Response)) {
+                    const retriedResponse = await ky.#retryFromError(httpError, async () => ky.#fetch());
+                    if (retriedResponse === undefined) {
                         return retriedResponse;
                     }
                     response = retriedResponse;
@@ -1117,6 +1159,9 @@ class Ky {
                 }
                 break;
             }
+            if (!isResponseInstance(response)) {
+                return response;
+            }
             ky.#decorateResponse(response);
             // If `onDownloadProgress` is passed, it uses the stream API internally
             if (ky.#options.onDownloadProgress) {
@@ -1286,6 +1331,13 @@ class Ky {
         this.request = new globalThis.Request(this.#input, this.#options);
         if (hasSearchParameters(this.#options.searchParams)) {
             const url = new URL(this.request.url);
+            const deleted = this.#options.searchParams?.[deletedParametersSymbol];
+            if (deleted) {
+                // Remove keys from the input URL first so later searchParams entries can intentionally re-add them.
+                for (const key of deleted) {
+                    url.searchParams.delete(key);
+                }
+            }
             if (typeof this.#options.searchParams === 'string') {
                 const stringSearchParameters = this.#options.searchParams.replace(/^\?/, '');
                 if (stringSearchParameters !== '') {
@@ -1308,18 +1360,14 @@ class Ky {
                     }
                 }
             }
-            const deleted = this.#options.searchParams?.[deletedParametersSymbol];
-            if (deleted) {
-                for (const key of deleted) {
-                    url.searchParams.delete(key);
-                }
-            }
             // Recreate request with the updated URL. We already have all options in this.#options, including duplex.
             this.request = new globalThis.Request(url, this.#options);
         }
         if (this.#options.onUploadProgress && typeof this.#options.onUploadProgress !== 'function') {
             throw new TypeError('The `onUploadProgress` option must be a function');
         }
+        // `totalTimeout` starts when the request pipeline is created, so it also includes
+        // Ky's internal scheduling and user hook time before the first fetch attempt.
         this.#startTime = typeof this.#options.totalTimeout === 'number' ? this.#getCurrentTime() : undefined;
     }
     #calculateDelay() {
@@ -1564,52 +1612,57 @@ class Ky {
                 options: this.#getNormalizedOptions(),
                 retryCount: 0,
             });
-            if (result instanceof Response) {
-                return result;
-            }
-            if (result instanceof globalThis.Request) {
+            if (isRequestInstance(result)) {
                 this.#assignRequest(result);
             }
+            else if (isResponseInstance(result)) {
+                return result;
+            }
         }
         return undefined;
     }
     async #runAfterResponseHooks(response) {
         const responseRequest = this.#getResponseRequest(response);
         for (const hook of this.#options.hooks.afterResponse) {
-            // Clone the response before passing to hook so we can cancel it if needed
-            const clonedResponse = this.#setResponseRequest(response.clone(), responseRequest);
-            this.#decorateResponse(clonedResponse);
+            const hookResponse = this.#setResponseRequest(response.clone(), responseRequest);
+            this.#decorateResponse(hookResponse);
             let modifiedResponse;
             try {
                 // eslint-disable-next-line no-await-in-loop
                 modifiedResponse = await hook({
                     request: this.request,
                     options: this.#getNormalizedOptions(),
-                    response: clonedResponse,
+                    response: hookResponse,
                     retryCount: this.#retryCount,
                 });
             }
             catch (error) {
                 // Cancel both responses to prevent memory leaks when hook throws
-                this.#cancelResponseBody(clonedResponse);
+                if (hookResponse !== response) {
+                    this.#cancelResponseBody(hookResponse);
+                }
                 this.#cancelResponseBody(response);
                 throw error;
             }
             if (modifiedResponse instanceof RetryMarker) {
                 // Cancel both the cloned response passed to the hook and the current response to prevent resource leaks (especially important in Deno/Bun).
                 // Do not await cancellation since hooks can clone the response, leaving extra tee branches that keep cancel promises pending per the Streams spec.
-                this.#cancelResponseBody(clonedResponse);
+                if (hookResponse !== response) {
+                    this.#cancelResponseBody(hookResponse);
+                }
                 this.#cancelResponseBody(response);
                 throw new ForceRetryError(modifiedResponse.options);
             }
-            // Determine which response to use going forward
-            const nextResponse = this.#setResponseRequest(modifiedResponse instanceof globalThis.Response ? modifiedResponse : response, responseRequest);
+            const nextResponse = isResponseInstance(modifiedResponse)
+                ? this.#setResponseRequest(modifiedResponse, responseRequest)
+                : response;
             // Cancel any response bodies we won't use to prevent memory leaks.
             // Uses fire-and-forget since hooks may have cloned the response, creating tee branches that block cancellation.
-            if (clonedResponse !== nextResponse) {
-                this.#cancelResponseBody(clonedResponse);
+            // If the hook wrapped an existing body into a new Response, both Response objects can still point at the same stream.
+            if (hookResponse !== response && hookResponse !== nextResponse && hookResponse.body !== nextResponse.body) {
+                this.#cancelResponseBody(hookResponse);
             }
-            if (response !== nextResponse) {
+            if (response !== nextResponse && response.body !== nextResponse.body) {
                 this.#cancelResponseBody(response);
             }
             response = nextResponse;
@@ -1645,7 +1698,11 @@ class Ky {
         // Apply custom request from forced retry before beforeRetry hooks
         // Ensure the custom request has the correct managed signal for timeouts and user aborts
         if (error instanceof ForceRetryError && error.customRequest) {
-            this.#assignRequest(new globalThis.Request(error.customRequest, this.#options.signal ? { signal: this.#options.signal } : undefined));
+            const customRequest = new globalThis.Request(error.customRequest, this.#options.signal ? { signal: this.#options.signal } : undefined);
+            // Replacement Requests are authoritative by design. Do not rewrite headers here,
+            // even for cross-origin retries. Callers using `ky.retry({request})` explicitly
+            // opted into the exact Request they constructed.
+            this.#assignRequest(customRequest);
         }
         for (const hook of this.#options.hooks.beforeRetry) {
             let hookResult;
@@ -1665,12 +1722,13 @@ class Ky {
                 }
                 throw hookError;
             }
-            if (hookResult instanceof globalThis.Request) {
+            if (isRequestInstance(hookResult)) {
+                // Same contract as `ky.retry({request})`: a Request returned from `beforeRetry`
+                // is used as-is rather than being sanitized or otherwise rewritten by Ky.
                 this.#assignRequest(hookResult);
                 break;
             }
-            // If a Response is returned, use it and skip the retry
-            if (hookResult instanceof globalThis.Response) {
+            if (isResponseInstance(hookResult)) {
                 this.#returnedResponseFromBeforeRetryHook = true;
                 this.#retryCount++;
                 return hookResult;
@@ -1697,7 +1755,7 @@ class Ky {
             // Recreate request with new signal
             this.request = new globalThis.Request(this.request, { signal: this.#options.signal });
         }
-        const nonRequestOptions = findUnknownOptions(this.request, this.#options);
+        const nonRequestOptions = findUnknownOptions(this.#options);
         const retryRequest = this.#options.retry.limit > 0 ? this.request.clone() : undefined;
         const request = this.#wrapRequestWithUploadProgress(this.request, this.#options.body ?? undefined);
         // Cloning is done here to prepare in advance for retries.
@@ -1811,7 +1869,7 @@ var distribution = /*#__PURE__*/Object.freeze({
 
 var require$$1 = /*@__PURE__*/getAugmentedNamespace(distribution);
 
-const VERSION = '0.16.1';
+const VERSION = '0.17.1';
 
 var constants = {
   VERSION,

package/dist/index.umd.js

@@ -16,7 +16,7 @@
 				var isInstance = false;
 	      try {
 	        isInstance = this instanceof a;
-	      } catch {}
+	      } catch (e) {}
 				if (isInstance) {
 	        return Reflect.construct(f, arguments, this.constructor);
 				}
@@ -71,6 +71,10 @@
 
 	/**
 	Base class for all Ky-specific errors. `HTTPError`, `NetworkError`, `TimeoutError`, and `ForceRetryError` extend this class.
+
+	You can use `instanceof KyError` to check if an error originated from Ky, or use the `isKyError()` type guard for cross-realm compatibility and TypeScript type narrowing.
+
+	Note: `SchemaValidationError` is intentionally not considered a Ky error. `KyError` covers failures in Ky's HTTP lifecycle (bad status, timeout, retry), while schema validation errors originate from the user-provided schema, not from Ky itself.
 	*/
 	class KyError extends Error {
 	    name = 'KyError';
@@ -82,7 +86,11 @@
 	/**
 	Error thrown when the response has a non-2xx status code and `throwHttpErrors` is enabled.
 
-	The error has a `response` property with the `Response` object, a `request` property with the `Request` object, an `options` property with the normalized options, and a `data` property with the pre-parsed response body. The response body is automatically consumed when populating `data`, so `response.json()` and other body methods will not work. Use `data` instead.
+	The error has a `response` property with the `Response` object, a `request` property with the `Request` object, an `options` property with the normalized options (either passed to `ky` when creating an instance with `ky.create()` or directly when performing the request), and a `data` property with the pre-parsed response body. For JSON responses (based on `Content-Type`), the body is parsed using the `parseJson` option if set, or `JSON.parse` by default. For other content types, it is set as plain text. If the body is empty or parsing fails, `data` will be `undefined`. To avoid hanging or excessive buffering, `error.data` population is bounded by the request timeout and a 10 MiB response body size limit. The `data` property is populated before `beforeError` hooks run, so hooks can access it.
+
+	The response body is automatically consumed when populating `error.data`, so `error.response.json()` and other body methods will not work. Use `error.data` instead. The `error.response` object is still available for headers, status, etc.
+
+	Be aware that some types of errors, such as network errors, inherently mean that a response was not received. In that case, the error will be an instance of `NetworkError` instead of `HTTPError` and will not contain a `response` property.
 	*/
 	class HTTPError extends KyError {
 	    name = 'HTTPError';
@@ -103,9 +111,11 @@
 	}
 
 	/**
-	Error thrown when a network error occurs during the request (e.g., DNS failure, connection refused, offline).
+	Error thrown when a network error occurs during the request (e.g., DNS failure, connection refused, offline). It has a `request` property with the `Request` object. The original error is available via the standard `cause` property.
+
+	Network errors are automatically retried (for retriable methods).
 
-	The error has a `request` property with the `Request` object. The original error is available via the standard `cause` property.
+	Note: Network errors are detected using runtime-specific heuristics. Unrecognized runtimes may produce errors that are not wrapped in `NetworkError`. Use the `shouldRetry` option to handle such cases.
 	*/
 	class NetworkError extends KyError {
 	    name = 'NetworkError';
@@ -167,7 +177,7 @@
 	}
 
 	/**
-	Thrown when a response body fails validation against a user-provided Standard Schema.
+	The error thrown when [Standard Schema](https://github.com/standard-schema/standard-schema) validation fails in `.json(schema)`. It has an `issues` property with the validation issues from the schema.
 
 	This error intentionally does not extend `KyError` because it does not represent a failure in Ky's HTTP lifecycle. The request succeeded; the user's schema rejected the data. As such, it is not matched by `isKyError()`.
 
@@ -198,9 +208,7 @@
 	}
 
 	/**
-	Error thrown when the request times out.
-
-	The error has a `request` property with the `Request` object.
+	Error thrown when the request times out. It has a `request` property with the `Request` object.
 	*/
 	class TimeoutError extends KyError {
 	    name = 'TimeoutError';
@@ -287,7 +295,7 @@
 	            async ({request, response}) => {
 	                // Retry based on response body content
 	                if (response.status === 200) {
-	                    const data = await response.clone().json();
+	                    const data = await response.json();
 
 	                    // Simple retry with default delay
 	                    if (data.error?.code === 'TEMPORARY_ERROR') {
@@ -371,12 +379,6 @@
 	    fetch: true,
 	    context: true,
 	};
-	// Vendor-specific fetch options that should always be passed to fetch()
-	// even if they appear on the Request object due to vendor patching.
-	// See: https://github.com/sindresorhus/ky/issues/541
-	const vendorSpecificOptions = {
-	    next: true, // Next.js cache revalidation (revalidate, tags)
-	};
 	// Standard RequestInit options that should NOT be passed separately to fetch()
 	// because they're already applied to the Request object.
 	// Note: `dispatcher` and `priority` are NOT included here - they're fetch-only
@@ -501,7 +503,7 @@
 	        value,
 	    };
 	/**
-	Wraps a value so that `ky.extend()` will replace the parent value instead of merging with it.
+	Wraps a value so that `ky.extend()` will replace the parent value instead of merging with it. Works with hooks, headers, search parameters, context, and any other deep-merged option.
 
 	By default, `.extend()` deep-merges options with the parent instance: hooks get appended, headers get merged, and search parameters get accumulated. Use `replaceOption` when you want to fully replace a merged property instead.
 
@@ -555,7 +557,13 @@
 	};
 	const cloneShallow = (value) => {
 	    if (value instanceof URLSearchParams) {
-	        return new URLSearchParams(value);
+	        const copy = new URLSearchParams(value);
+	        const deleted = value[deletedParametersSymbol];
+	        if (deleted) {
+	            // Preserve internal deletion markers so init-hook cloning does not resurrect params removed during option merging.
+	            copy[deletedParametersSymbol] = new Set(deleted);
+	        }
+	        return copy;
 	    }
 	    if (value instanceof globalThis.Headers) {
 	        return new globalThis.Headers(value);
@@ -766,11 +774,13 @@
 	    if (retry.methods && !Array.isArray(retry.methods)) {
 	        throw new Error('retry.methods must be an array');
 	    }
-	    retry.methods &&= retry.methods.map(method => method.toLowerCase());
 	    if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
 	        throw new Error('retry.statusCodes must be an array');
 	    }
-	    const normalizedRetry = Object.fromEntries(Object.entries(retry).filter(([, value]) => value !== undefined));
+	    const normalizedRetry = Object.fromEntries(Object.entries({
+	        ...retry,
+	        methods: retry.methods?.map(method => method.toLowerCase()),
+	    }).filter(([, value]) => value !== undefined));
 	    return {
 	        ...defaultRetryOptions,
 	        ...normalizedRetry,
@@ -814,20 +824,19 @@
 	    });
 	}
 
-	const findUnknownOptions = (request, options) => {
+	const findUnknownOptions = (options) => {
 	    const unknownOptions = {};
 	    for (const key in options) {
 	        // Skip inherited properties
 	        if (!Object.hasOwn(options, key)) {
 	            continue;
 	        }
-	        // An option is passed to fetch() if:
-	        // 1. It's not a standard RequestInit option (not in requestOptionsRegistry)
-	        // 2. It's not a ky-specific option (not in kyOptionKeys)
-	        // 3. Either:
-	        //    a. It's not on the Request object, OR
-	        //    b. It's a vendor-specific option that should always be passed (in vendorSpecificOptions)
-	        if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && (!(key in request) || key in vendorSpecificOptions)) {
+	        // Forward every non-standard, non-Ky option to fetch().
+	        // We intentionally do not check whether the key also exists on `Request`, because some runtimes
+	        // patch `Request.prototype` with fetch-only extensions. For example, Next.js adds `next`, and the
+	        // old `key in request` heuristic dropped it unless Ky kept a special-case allowlist.
+	        // Passing all non-standard keys makes that allowlist unnecessary and preserves future fetch extensions too.
+	        if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys)) {
 	            unknownOptions[key] = options[key];
 	        }
 	    }
@@ -855,8 +864,8 @@
 	};
 
 	// Inlined from https://github.com/sindresorhus/is-network-error v1.3.1
-	const objectToString = Object.prototype.toString;
-	const isError = (value) => objectToString.call(value) === '[object Error]';
+	const objectToString$1 = Object.prototype.toString;
+	const isError = (value) => objectToString$1.call(value) === '[object Error]';
 	const errorMessages = new Set([
 	    'network error', // Chrome
 	    'NetworkError when attempting to fetch resource.', // Firefox
@@ -1028,16 +1037,43 @@
 	    return new TextDecoder();
 	};
 	const invalidSchemaMessage = 'The `schema` argument must follow the Standard Schema specification';
+	const cloneRetryOptions = (retry) => {
+	    if (typeof retry !== 'object') {
+	        return retry;
+	    }
+	    // Clone nested arrays too so init hooks can mutate retry config without leaking state across requests.
+	    return {
+	        ...retry,
+	        ...(retry.methods && { methods: [...retry.methods] }),
+	        ...(retry.statusCodes && { statusCodes: [...retry.statusCodes] }),
+	        ...(retry.afterStatusCodes && { afterStatusCodes: [...retry.afterStatusCodes] }),
+	    };
+	};
+	const objectToString = Object.prototype.toString;
+	const isRequestInstance = (value) => value instanceof globalThis.Request || objectToString.call(value) === '[object Request]';
+	// Accepted custom responses are treated as full Responses throughout Ky.
+	// If a custom fetch returns one, it must behave like a Response for cloning,
+	// body consumption, `json()` decoration, and any enabled stream features.
+	const isResponseInstance = (value) => value instanceof globalThis.Response || objectToString.call(value) === '[object Response]';
+	const cloneSearchParametersForInitHook = (searchParameters) => {
+	    if (Array.isArray(searchParameters)) {
+	        return searchParameters.map(parameter => [...parameter]);
+	    }
+	    return cloneShallow(searchParameters);
+	};
 	// Shallow-clone mutable option properties so init hook mutations don't leak across requests.
 	function cloneInitHookOptions(options) {
-	    return {
+	    const clonedOptions = {
 	        ...options,
 	        json: cloneShallow(options.json),
-	        retry: cloneShallow(options.retry),
 	        context: cloneShallow(options.context),
 	        headers: cloneShallow(options.headers),
-	        searchParams: cloneShallow(options.searchParams),
+	        searchParams: cloneSearchParametersForInitHook(options.searchParams),
 	    };
+	    if (options.retry !== undefined) {
+	        clonedOptions.retry = cloneRetryOptions(options.retry);
+	    }
+	    return clonedOptions;
 	}
 	const validateJsonWithSchema = async (jsonValue, schema) => {
 	    if ((typeof schema !== 'object'
@@ -1078,43 +1114,49 @@
 	            let response = beforeRequestResponse ?? await ky.#retry(async () => ky.#fetch());
 	            let responseFromHook = beforeRequestResponse !== undefined
 	                || ky.#consumeReturnedResponseFromBeforeRetryHook();
-	            if (!(response instanceof globalThis.Response)) {
-	                return response;
-	            }
 	            for (;;) {
-	                try {
-	                    // eslint-disable-next-line no-await-in-loop
-	                    response = await ky.#runAfterResponseHooks(response);
+	                // `undefined` means a hook stopped the flow without providing a response.
+	                // Non-native Responses still continue through Ky if they pass `isResponseInstance()`.
+	                if (response === undefined) {
+	                    return response;
 	                }
-	                catch (error) {
-	                    if (!(error instanceof ForceRetryError)) {
-	                        throw error;
+	                if (isResponseInstance(response)) {
+	                    try {
+	                        // eslint-disable-next-line no-await-in-loop
+	                        response = await ky.#runAfterResponseHooks(response);
 	                    }
-	                    // eslint-disable-next-line no-await-in-loop
-	                    const retriedResponse = await ky.#retryFromError(error, async () => ky.#fetch());
-	                    if (!(retriedResponse instanceof globalThis.Response)) {
-	                        return retriedResponse;
+	                    catch (error) {
+	                        if (!(error instanceof ForceRetryError)) {
+	                            throw error;
+	                        }
+	                        // eslint-disable-next-line no-await-in-loop
+	                        const retriedResponse = await ky.#retryFromError(error, async () => ky.#fetch());
+	                        if (retriedResponse === undefined) {
+	                            return retriedResponse;
+	                        }
+	                        response = retriedResponse;
+	                        responseFromHook = ky.#consumeReturnedResponseFromBeforeRetryHook();
+	                        continue;
 	                    }
-	                    response = retriedResponse;
-	                    responseFromHook = ky.#consumeReturnedResponseFromBeforeRetryHook();
-	                    continue;
 	                }
+	                const currentResponse = response;
 	                // Opaque responses (`response.type === 'opaque'`) from `no-cors` requests always have `status: 0` and `ok: false`, but this is not a failure - the actual status is hidden by the browser.
-	                if (!response.ok && response.type !== 'opaque' && (typeof ky.#options.throwHttpErrors === 'function'
-	                    ? ky.#options.throwHttpErrors(response.status)
+	                if (!currentResponse.ok && currentResponse.type !== 'opaque' && (typeof ky.#options.throwHttpErrors === 'function'
+	                    ? ky.#options.throwHttpErrors(currentResponse.status)
 	                    : ky.#options.throwHttpErrors)) {
 	                    // `request` must reflect the request that actually failed, but `options` stays as Ky's
 	                    // normalized options snapshot. Replacement `Request` instances do not preserve the
 	                    // original `BodyInit`, so trying to make `options` mirror arbitrary requests would be lossy.
-	                    const error = new HTTPError(response, ky.#getResponseRequest(response), ky.#getNormalizedOptions());
+	                    const httpError = new HTTPError(currentResponse, ky.#getResponseRequest(currentResponse), ky.#getNormalizedOptions());
+	                    const errorToThrow = httpError;
 	                    // eslint-disable-next-line no-await-in-loop
-	                    error.data = await ky.#getResponseData(response);
+	                    httpError.data = await ky.#getResponseData(currentResponse);
 	                    if (responseFromHook) {
-	                        throw error;
+	                        throw errorToThrow;
 	                    }
 	                    // eslint-disable-next-line no-await-in-loop
-	                    const retriedResponse = await ky.#retryFromError(error, async () => ky.#fetch());
-	                    if (!(retriedResponse instanceof globalThis.Response)) {
+	                    const retriedResponse = await ky.#retryFromError(httpError, async () => ky.#fetch());
+	                    if (retriedResponse === undefined) {
 	                        return retriedResponse;
 	                    }
 	                    response = retriedResponse;
@@ -1123,6 +1165,9 @@
 	                }
 	                break;
 	            }
+	            if (!isResponseInstance(response)) {
+	                return response;
+	            }
 	            ky.#decorateResponse(response);
 	            // If `onDownloadProgress` is passed, it uses the stream API internally
 	            if (ky.#options.onDownloadProgress) {
@@ -1292,6 +1337,13 @@
 	        this.request = new globalThis.Request(this.#input, this.#options);
 	        if (hasSearchParameters(this.#options.searchParams)) {
 	            const url = new URL(this.request.url);
+	            const deleted = this.#options.searchParams?.[deletedParametersSymbol];
+	            if (deleted) {
+	                // Remove keys from the input URL first so later searchParams entries can intentionally re-add them.
+	                for (const key of deleted) {
+	                    url.searchParams.delete(key);
+	                }
+	            }
 	            if (typeof this.#options.searchParams === 'string') {
 	                const stringSearchParameters = this.#options.searchParams.replace(/^\?/, '');
 	                if (stringSearchParameters !== '') {
@@ -1314,18 +1366,14 @@
 	                    }
 	                }
 	            }
-	            const deleted = this.#options.searchParams?.[deletedParametersSymbol];
-	            if (deleted) {
-	                for (const key of deleted) {
-	                    url.searchParams.delete(key);
-	                }
-	            }
 	            // Recreate request with the updated URL. We already have all options in this.#options, including duplex.
 	            this.request = new globalThis.Request(url, this.#options);
 	        }
 	        if (this.#options.onUploadProgress && typeof this.#options.onUploadProgress !== 'function') {
 	            throw new TypeError('The `onUploadProgress` option must be a function');
 	        }
+	        // `totalTimeout` starts when the request pipeline is created, so it also includes
+	        // Ky's internal scheduling and user hook time before the first fetch attempt.
 	        this.#startTime = typeof this.#options.totalTimeout === 'number' ? this.#getCurrentTime() : undefined;
 	    }
 	    #calculateDelay() {
@@ -1570,52 +1618,57 @@
 	                options: this.#getNormalizedOptions(),
 	                retryCount: 0,
 	            });
-	            if (result instanceof Response) {
-	                return result;
-	            }
-	            if (result instanceof globalThis.Request) {
+	            if (isRequestInstance(result)) {
 	                this.#assignRequest(result);
 	            }
+	            else if (isResponseInstance(result)) {
+	                return result;
+	            }
 	        }
 	        return undefined;
 	    }
 	    async #runAfterResponseHooks(response) {
 	        const responseRequest = this.#getResponseRequest(response);
 	        for (const hook of this.#options.hooks.afterResponse) {
-	            // Clone the response before passing to hook so we can cancel it if needed
-	            const clonedResponse = this.#setResponseRequest(response.clone(), responseRequest);
-	            this.#decorateResponse(clonedResponse);
+	            const hookResponse = this.#setResponseRequest(response.clone(), responseRequest);
+	            this.#decorateResponse(hookResponse);
 	            let modifiedResponse;
 	            try {
 	                // eslint-disable-next-line no-await-in-loop
 	                modifiedResponse = await hook({
 	                    request: this.request,
 	                    options: this.#getNormalizedOptions(),
-	                    response: clonedResponse,
+	                    response: hookResponse,
 	                    retryCount: this.#retryCount,
 	                });
 	            }
 	            catch (error) {
 	                // Cancel both responses to prevent memory leaks when hook throws
-	                this.#cancelResponseBody(clonedResponse);
+	                if (hookResponse !== response) {
+	                    this.#cancelResponseBody(hookResponse);
+	                }
 	                this.#cancelResponseBody(response);
 	                throw error;
 	            }
 	            if (modifiedResponse instanceof RetryMarker) {
 	                // Cancel both the cloned response passed to the hook and the current response to prevent resource leaks (especially important in Deno/Bun).
 	                // Do not await cancellation since hooks can clone the response, leaving extra tee branches that keep cancel promises pending per the Streams spec.
-	                this.#cancelResponseBody(clonedResponse);
+	                if (hookResponse !== response) {
+	                    this.#cancelResponseBody(hookResponse);
+	                }
 	                this.#cancelResponseBody(response);
 	                throw new ForceRetryError(modifiedResponse.options);
 	            }
-	            // Determine which response to use going forward
-	            const nextResponse = this.#setResponseRequest(modifiedResponse instanceof globalThis.Response ? modifiedResponse : response, responseRequest);
+	            const nextResponse = isResponseInstance(modifiedResponse)
+	                ? this.#setResponseRequest(modifiedResponse, responseRequest)
+	                : response;
 	            // Cancel any response bodies we won't use to prevent memory leaks.
 	            // Uses fire-and-forget since hooks may have cloned the response, creating tee branches that block cancellation.
-	            if (clonedResponse !== nextResponse) {
-	                this.#cancelResponseBody(clonedResponse);
+	            // If the hook wrapped an existing body into a new Response, both Response objects can still point at the same stream.
+	            if (hookResponse !== response && hookResponse !== nextResponse && hookResponse.body !== nextResponse.body) {
+	                this.#cancelResponseBody(hookResponse);
 	            }
-	            if (response !== nextResponse) {
+	            if (response !== nextResponse && response.body !== nextResponse.body) {
 	                this.#cancelResponseBody(response);
 	            }
 	            response = nextResponse;
@@ -1651,7 +1704,11 @@
 	        // Apply custom request from forced retry before beforeRetry hooks
 	        // Ensure the custom request has the correct managed signal for timeouts and user aborts
 	        if (error instanceof ForceRetryError && error.customRequest) {
-	            this.#assignRequest(new globalThis.Request(error.customRequest, this.#options.signal ? { signal: this.#options.signal } : undefined));
+	            const customRequest = new globalThis.Request(error.customRequest, this.#options.signal ? { signal: this.#options.signal } : undefined);
+	            // Replacement Requests are authoritative by design. Do not rewrite headers here,
+	            // even for cross-origin retries. Callers using `ky.retry({request})` explicitly
+	            // opted into the exact Request they constructed.
+	            this.#assignRequest(customRequest);
 	        }
 	        for (const hook of this.#options.hooks.beforeRetry) {
 	            let hookResult;
@@ -1671,12 +1728,13 @@
 	                }
 	                throw hookError;
 	            }
-	            if (hookResult instanceof globalThis.Request) {
+	            if (isRequestInstance(hookResult)) {
+	                // Same contract as `ky.retry({request})`: a Request returned from `beforeRetry`
+	                // is used as-is rather than being sanitized or otherwise rewritten by Ky.
 	                this.#assignRequest(hookResult);
 	                break;
 	            }
-	            // If a Response is returned, use it and skip the retry
-	            if (hookResult instanceof globalThis.Response) {
+	            if (isResponseInstance(hookResult)) {
 	                this.#returnedResponseFromBeforeRetryHook = true;
 	                this.#retryCount++;
 	                return hookResult;
@@ -1703,7 +1761,7 @@
 	            // Recreate request with new signal
 	            this.request = new globalThis.Request(this.request, { signal: this.#options.signal });
 	        }
-	        const nonRequestOptions = findUnknownOptions(this.request, this.#options);
+	        const nonRequestOptions = findUnknownOptions(this.#options);
 	        const retryRequest = this.#options.retry.limit > 0 ? this.request.clone() : undefined;
 	        const request = this.#wrapRequestWithUploadProgress(this.request, this.#options.body ?? undefined);
 	        // Cloning is done here to prepare in advance for retries.
@@ -1817,7 +1875,7 @@
 
 	var require$$1 = /*@__PURE__*/getAugmentedNamespace(distribution);
 
-	const VERSION = '0.16.1';
+	const VERSION = '0.17.1';
 
 	var constants = {
 	  VERSION,

package/package.json

@@ -2,7 +2,7 @@
   "name": "@microlink/mql",
   "description": "Microlink Query Language. The official HTTP client to interact with Microlink API for Node.js, browsers & Deno.",
   "homepage": "https://microlink.io/mql",
-  "version": "0.16.1",
+  "version": "0.17.1",
   "types": "dist/index.d.ts",
   "exports": {
     "types": "./dist/index.d.ts",
@@ -34,11 +34,12 @@
     }
   ],
   "repository": {
+    "directory": "packages/mql",
     "type": "git",
-    "url": "git+https://github.com/microlinkhq/mql.git"
+    "url": "git+https://github.com/microlinkhq/microlink.git"
   },
   "bugs": {
-    "url": "https://github.com/microlinkhq/mql/issues"
+    "url": "https://github.com/microlinkhq/microlink/issues"
   },
   "keywords": [
     "api",
@@ -52,26 +53,15 @@
     "ky": "~2.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "latest",
-    "@commitlint/config-conventional": "latest",
     "@rollup/plugin-commonjs": "latest",
     "@rollup/plugin-node-resolve": "latest",
     "@rollup/plugin-replace": "latest",
     "@rollup/plugin-terser": "latest",
     "async-listen": "latest",
     "ava": "7",
-    "c8": "latest",
-    "ci-publish": "latest",
-    "git-authors-cli": "latest",
-    "github-generate-release": "latest",
-    "nano-staged": "latest",
-    "prettier-standard": "latest",
     "rollup": "latest",
     "rollup-plugin-filesize": "latest",
-    "simple-git-hooks": "latest",
-    "standard": "latest",
-    "standard-markdown": "latest",
-    "standard-version": "latest",
+    "tinyspawn": "latest",
     "tsd": "latest"
   },
   "engines": {
@@ -85,19 +75,12 @@
   ],
   "scripts": {
     "build": "rollup -c rollup.config.js --bundleConfigAsCjs",
-    "clean": "rm -rf node_modules",
     "clean:build": "rm -rf dist/index.js",
-    "contributors": "(npx git-authors-cli && npx finepack && git add package.json && git commit -m 'build: contributors' --no-verify) || true",
-    "dev": "npm run build -- -w",
-    "lint": "standard && tsd",
-    "postrelease": "npm run release:tags && npm run release:github && (ci-publish || npm publish --access=public)",
-    "prebuild": "npm run clean:build",
-    "prepublishOnly": "npm run build",
-    "pretest": "npm run lint && npm run build",
-    "release": "standard-version -a",
-    "release:github": "github-generate-release",
-    "release:tags": "git push --follow-tags origin HEAD:master",
-    "test": "c8 ava --verbose"
+    "dev": "pnpm run build -- -w",
+    "prebuild": "pnpm run clean:build",
+    "prepublishOnly": "pnpm run build",
+    "pretest": "pnpm run build",
+    "test": "ava --verbose && tsd"
   },
   "license": "MIT",
   "ava": {
@@ -107,38 +90,6 @@
     ],
     "timeout": "1m"
   },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ],
-    "rules": {
-      "body-max-line-length": [
-        0
-      ]
-    }
-  },
-  "nano-staged": {
-    "*.js": [
-      "npx -y @kikobeats/prettier-standard",
-      "standard --fix"
-    ],
-    "*.md": [
-      "standard-markdown"
-    ],
-    "package.json": [
-      "finepack"
-    ]
-  },
-  "simple-git-hooks": {
-    "commit-msg": "npx commitlint --edit",
-    "pre-commit": "npx nano-staged"
-  },
-  "standard": {
-    "ignore": [
-      "dist/index.js",
-      "dist/index.umd.js"
-    ]
-  },
   "tsd": {
     "compilerOptions": {
       "baseUrl": ".",
@@ -149,5 +100,6 @@
       }
     },
     "directory": "test"
-  }
+  },
+  "gitHead": "28020344ffd40e3253e8cfa345e2a0bfe15deda9"
 }