kinetex 1.3.0 → 1.4.0

package/dist/cjs/utils.js

@@ -1,9 +1,7 @@
 /**
  * Cross-runtime utilities for type safety, validation, and security.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 let _process;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 let _Buffer;
 // Check globalThis.process for Node.js runtime detection (no dynamic import needed)
 function getProcess() {
@@ -47,7 +45,17 @@ const DEFAULT_LIMITS = {
  * @returns Parse result with success/failure information
  */
 export function safeJSONParse(text, options = {}) {
-    const limits = { ...DEFAULT_LIMITS, ...options };
+    // `{ ...DEFAULT_LIMITS, ...options }` copies an *explicitly present*
+    // `undefined` straight over a real limit, and every comparison this file
+    // makes is `<=` / `>` against a number — so `{ maxDepth: undefined }` did not
+    // mean "use the default", it meant "there is no depth limit", silently. That
+    // is the shape config plumbing produces (`{ maxDepth: env.MAX_DEPTH }`), and
+    // the `Required<>` on `limits` says the opposite. Only defined values merge.
+    const limits = { ...DEFAULT_LIMITS };
+    for (const [key, value] of Object.entries(options)) {
+        if (value !== undefined)
+            limits[key] = value;
+    }
     // Check string length first
     if (text.length > limits.maxStringLength) {
         return {
@@ -241,6 +249,44 @@ export function parseUntrustedJSON(text) {
 // ============================================================================
 // §2  TYPE GUARDS
 // ============================================================================
+/**
+ * Exact brand test for a platform type.
+ *
+ * `instanceof` is authoritative in the current realm and — unlike a
+ * constructor-name check — survives subclasses, so `new File()` is still a
+ * `Blob`. It fails across realms (an `iframe`'s `Headers` is a different
+ * constructor), so the platform's own `Symbol.toStringTag` is consulted as a
+ * fallback: that is the tag the runtime sets on the real object, and the one
+ * thing a `Map` or a `Set` does not carry.
+ *
+ * The previous guards duck-typed on a *single* method name, which made the
+ * most common built-ins in the language pass for types they are not:
+ * `Map` and `Set` both have `has`, `FormData` has `forEach`, so
+ * `isURLSearchParams(new Map())`, `isURLSearchParams(new Set())` and
+ * `isHeaders(new FormData())` were all `true`. Meanwhile `isBlob` compared
+ * `constructor.name === "Blob"` and rejected every `File`, which is a `Blob`.
+ */
+function hasBrand(value, ctor, tag, required) {
+    if (value === null || typeof value !== "object")
+        return false;
+    if (typeof ctor === "function") {
+        try {
+            if (value instanceof ctor)
+                return true;
+        }
+        catch {
+            // A Proxy with a hostile getPrototypeOf — fall through to the brand.
+        }
+    }
+    // Cross-realm: the runtime's own brand, plus the methods that make the
+    // value usable as the type. The brand alone is one getter away from
+    // anything, and a guard whose whole job is to route a value to the right
+    // code path is not one that should hand it out on a say-so.
+    if (Object.prototype.toString.call(value) !== `[object ${tag}]`)
+        return false;
+    const obj = value;
+    return required.every((m) => typeof obj[m] === "function");
+}
 /**
  * Type guard for Uint8Array.
  *
@@ -266,10 +312,7 @@ export function isArrayBuffer(value) {
  * @returns True if the value is a ReadableStream.
  */
 export function isReadableStream(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        "getReader" in value &&
-        typeof value.getReader === "function");
+    return hasBrand(value, globalThis.ReadableStream, "ReadableStream", ["getReader", "cancel"]);
 }
 /**
  * Type guard for Headers.
@@ -278,10 +321,7 @@ export function isReadableStream(value) {
  * @returns True if the value is a Headers instance.
  */
 export function isHeaders(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        "forEach" in value &&
-        typeof value.forEach === "function");
+    return hasBrand(value, globalThis.Headers, "Headers", ["get", "set", "append", "forEach"]);
 }
 /**
  * Type guard for AbortSignal.
@@ -290,10 +330,10 @@ export function isHeaders(value) {
  * @returns True if the value is an AbortSignal.
  */
 export function isAbortSignal(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        "aborted" in value &&
-        typeof value.aborted === "boolean");
+    return hasBrand(value, globalThis.AbortSignal, "AbortSignal", [
+        "addEventListener",
+        "removeEventListener",
+    ]);
 }
 /**
  * Type guard for plain objects (\[object Object\]).
@@ -302,9 +342,17 @@ export function isAbortSignal(value) {
  * @returns True if the value is a plain Object.
  */
 export function isPlainObject(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        Object.prototype.toString.call(value) === "[object Object]");
+    if (value === null || typeof value !== "object")
+        return false;
+    // `Object.prototype.toString.call(x) === "[object Object]"` is the classic
+    // wrong way to write this: it is true for *every* object whose class does
+    // not override Symbol.toStringTag, so `new (class { constructor() { this.a = 1 } })()`
+    // passed — which is the opposite of what "plain" means, and the reason the
+    // guard cannot be trusted for the copy/merge decisions its name invites.
+    // What makes an object plain is its prototype: Object.prototype, or none at
+    // all (a null-prototype object is a dictionary, and still plain).
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
 }
 /**
  * Type guard for FormData.
@@ -313,9 +361,7 @@ export function isPlainObject(value) {
  * @returns True if the value is a FormData instance.
  */
 export function isFormData(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        value.constructor?.name === "FormData");
+    return hasBrand(value, globalThis.FormData, "FormData", ["append", "get", "getAll", "set"]);
 }
 /**
  * Type guard for Blob.
@@ -324,7 +370,10 @@ export function isFormData(value) {
  * @returns True if the value is a Blob instance.
  */
 export function isBlob(value) {
-    return (value !== null && typeof value === "object" && value.constructor?.name === "Blob");
+    // File extends Blob, and its own brand is "[object File]", so this is
+    // `instanceof`-first on purpose: a constructor-name check rejected every
+    // File, which is the single most common Blob-shaped value in a browser.
+    return hasBrand(value, globalThis.Blob, "Blob", ["arrayBuffer", "slice", "text", "stream"]);
 }
 /**
  * Type guard for URLSearchParams.
@@ -333,10 +382,12 @@ export function isBlob(value) {
  * @returns True if the value is a URLSearchParams instance.
  */
 export function isURLSearchParams(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        "has" in value &&
-        typeof value.has === "function");
+    return hasBrand(value, globalThis.URLSearchParams, "URLSearchParams", [
+        "append",
+        "get",
+        "getAll",
+        "sort",
+    ]);
 }
 // ============================================================================
 // §3  VALIDATION UTILITIES
@@ -366,13 +417,21 @@ export function isValidHeaderValue(value) {
         return false;
     if (value.length > 8192)
         return false; // Reasonable length limit
-    // Header values can contain any ASCII except CTLs and CRLF (header injection)
-    // Per RFC 7230, HT (0x09) is allowed in header values
+    // RFC 9110 §5.5: field-value is VCHAR / SP / HTAB / obs-text, where obs-text
+    // is %x80-FF. So a value may hold the Latin-1 range and nothing above it —
+    // there is no upper bound in the loop, which accepted an emoji and then let
+    // the very next `new Headers({ "X-A": "\u{1F600}" })` throw
+    // "Cannot convert argument to a ByteString because the character at index 0
+    // has a value of 55357". This guard is what a caller checks first, so a
+    // "valid" verdict that the runtime then refuses is worse than no verdict.
     for (let i = 0; i < value.length; i++) {
         const code = value.charCodeAt(i);
-        // No control characters (0-31 except 9=HT), 127
-        // No CRLF (13 = \r, 10 = \n) - prevents header injection
-        if ((code < 32 && code !== 9) || code === 127 || code === 13 || code === 10)
+        // No control characters (0-31 except 9=HT) and no DEL — CR and LF are
+        // inside that range, so this is also the header-injection guard.
+        if ((code < 32 && code !== 9) || code === 127)
+            return false;
+        // Above obs-text: a code point no ByteString header value can carry.
+        if (code > 0xff)
             return false;
     }
     return true;
@@ -581,9 +640,7 @@ function isBlockedIPv6(b) {
     if (b[0] === 0x20 && b[1] === 0x01 && b[2] === 0x0d && b[3] === 0xb8)
         return true;
     // ::ffff:0:0/96 — IPv4-mapped → apply the IPv4 checks to the tail
-    if (b.slice(0, 10).every((x) => x === 0) &&
-        b[10] === 0xff &&
-        b[11] === 0xff) {
+    if (b.slice(0, 10).every((x) => x === 0) && b[10] === 0xff && b[11] === 0xff) {
         return isBlockedIPv4(read32(12));
     }
     // ::/96 — deprecated IPv4-compatible → apply the IPv4 checks to the tail
@@ -712,7 +769,24 @@ export function deepClone(value) {
         value.forEach((v) => cloned.add(deepClone(v)));
         return cloned;
     }
-    const cloned = {};
+    // A class instance is rebuilt on *its own* prototype. The walk below
+    // produced a bare `{}` for every object that was not a plain one, so
+    // `deepClone(new (class { m() { return 1 } })())` came back as an `Object`
+    // with `m` gone — the clone was no longer the thing it was cloned from, and
+    // the failure was silent until something called a method. `new (proto)()` is
+    // not generally callable, so the instance is created with its prototype
+    // attached and its own properties copied across.
+    //
+    // A *host* object — RegExp, URL, a typed array, an Error — is not: those
+    // carry internal slots that `Object.create` cannot produce, and
+    // `Object.create(RegExp.prototype)` satisfies `instanceof` while throwing
+    // "called on non-RegExp object" the moment a getter is touched. The brand is
+    // the discriminator, and it is exact: a class instance reports the plain
+    // `[object Object]`, because the brand comes from the runtime, not the
+    // constructor. Those keep the dictionary form they always had.
+    const proto = Object.getPrototypeOf(value);
+    const isClassInstance = Object.prototype.toString.call(value) === "[object Object]";
+    const cloned = proto === Object.prototype || proto === null || !isClassInstance ? {} : Object.create(proto);
     for (const key in value) {
         // Prototype-pollution guard: never copy __proto__ / constructor / prototype
         if (key === "__proto__" || key === "constructor" || key === "prototype")
@@ -742,7 +816,27 @@ export function isPromise(value) {
  */
 export function createStructuredError(message, context) {
     const error = new Error(message);
-    Object.assign(error, context);
+    // `Object.assign` writes through [[Set]], so a context carrying an *own*
+    // `__proto__` key — which is exactly what `JSON.parse('{"__proto\u003a…}')`
+    // produces, and what a caller forwarding a remote error payload hands over —
+    // did not add a field. It reached the inherited `__proto__` setter and
+    // replaced the error's prototype, so the attacker-supplied object sat in the
+    // prototype chain of every error the client then went on to format, log or
+    // inspect. The one key that has to be expressible is written as a data
+    // property, which is what was meant.
+    for (const key of Object.keys(context)) {
+        const value = context[key];
+        if (key === "__proto__") {
+            Object.defineProperty(error, key, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+            continue;
+        }
+        error[key] = value;
+    }
     return error;
 }
 /**
@@ -758,11 +852,40 @@ export function formatError(error) {
                 context[key] = value;
             }
         }
-        const contextStr = Object.keys(context).length > 0 ? ` | ${JSON.stringify(context)}` : "";
+        const contextStr = Object.keys(context).length > 0 ? ` | ${safeStringify(context)}` : "";
         return `${error.name}: ${error.message}${contextStr}`;
     }
     return String(error);
 }
+/**
+ * `JSON.stringify` for a log line, on a value that is very likely to be
+ * hostile.
+ *
+ * The context attached by {@link createStructuredError} is whatever the failing
+ * call had in hand — a `request`, a `response`, a `cause` — and all three
+ * routinely point back at each other. `JSON.stringify` answers that with a
+ * thrown `TypeError: Converting circular structure to JSON`, and a BigInt with
+ * another, so the function whose entire job is to turn an error into a string
+ * threw instead, taking the `catch` that was logging it down with it.
+ */
+function safeStringify(value) {
+    const seen = new Set();
+    try {
+        return (JSON.stringify(value, (_key, v) => {
+            if (typeof v === "bigint")
+                return v.toString();
+            if (typeof v === "object" && v !== null) {
+                if (seen.has(v))
+                    return "[Circular]";
+                seen.add(v);
+            }
+            return v;
+        }) ?? String(value));
+    }
+    catch {
+        return String(value);
+    }
+}
 // ============================================================================
 // §5  TIME UTILITIES
 // ============================================================================
@@ -865,10 +988,16 @@ export function concatUint8Arrays(chunks) {
  * @returns Uint8Array or null if unsupported type
  */
 export function toUint8Array(data) {
+    // Both branches copy. The Uint8Array branch sliced but the ArrayBuffer
+    // branch wrapped, so the same call handed back a copy for one input type and
+    // a live view for the other: writing to the result of
+    // `toUint8Array(buffer)` wrote through to the caller's buffer, and two calls
+    // given the same buffer shared it. A function whose output is "the bytes" has
+    // to be the same kind of thing whichever type it was handed.
     if (data instanceof Uint8Array)
         return data.slice();
     if (data instanceof ArrayBuffer)
-        return new Uint8Array(data);
+        return new Uint8Array(data.slice(0));
     const b = getBuffer();
     if (b && b.isBuffer(data)) {
         return new Uint8Array(data);
@@ -929,12 +1058,37 @@ export function mergeSignals(...signals) {
     }
     if (validSignals.length === 1)
         return validSignals[0];
-    // Check if any signal is already aborted
-    if (validSignals.some((s) => s.aborted)) {
+    // Check if any signal is already aborted.
+    //
+    // `controller.abort()` with no argument installs the platform's generic
+    // `AbortError: This operation was aborted`, which threw away *why* the call
+    // was aborted. The two-live-signal branch below preserves the reason, and so
+    // does the `AbortSignal.any` path this function prefers on every current
+    // runtime — so the one case a caller is most likely to hit (a signal that
+    // already fired, e.g. `AbortSignal.timeout()`) was the only one that lost
+    // it. `interceptors.ts` re-aborts with `existing.reason` when merging, and
+    // anything reading the merged signal's reason saw a bare AbortError where it
+    // should have seen the caller's TimeoutError or their own Error.
+    const preAborted = validSignals.find((s) => s.aborted);
+    if (preAborted) {
         const controller = new AbortController();
-        controller.abort();
+        controller.abort(preAborted.reason);
         return controller.signal;
     }
+    // The platform primitive, where it exists. The hand-rolled version below
+    // attached an `abort` listener to every input and only ever removed it when
+    // one of those inputs fired — so merging a long-lived caller signal (a
+    // request-scoped controller is the usual one) accumulated one listener per
+    // merge, forever, and tripped Node's MaxListenersExceededWarning at 11.
+    // The "9.11" self-cleanup that was supposed to release them could not run:
+    // the merged controller is never handed out, so nothing but the inputs can
+    // ever abort it. `AbortSignal.any` holds its inputs weakly and adds nothing
+    // observable to them. Node 20.3+, Deno, Bun and current browsers have it;
+    // the manual path remains for Node 18 and older.
+    const nativeAny = AbortSignal.any;
+    if (typeof nativeAny === "function") {
+        return nativeAny.call(AbortSignal, validSignals);
+    }
     const controller = new AbortController();
     // abort: fire the controller and clean up ALL listeners immediately.
     const abort = () => {
@@ -942,12 +1096,6 @@ export function mergeSignals(...signals) {
             s.removeEventListener("abort", abort);
         controller.abort(_abortError());
     };
-    // 9.11: when the merged signal itself aborts (e.g. from another path), also clean up.
-    // This prevents listener accumulation when callers abort the controller externally.
-    controller.signal.addEventListener("abort", () => {
-        for (const s of validSignals)
-            s.removeEventListener("abort", abort);
-    }, { once: true });
     for (const s of validSignals)
         s.addEventListener("abort", abort, { once: true });
     return controller.signal;
@@ -1088,7 +1236,33 @@ export function hasNativeFetch() {
 export function normalizeHeaders(headers) {
     const result = {};
     headers.forEach((value, key) => {
-        result[key.toLowerCase()] = value;
+        const name = key.toLowerCase();
+        // `__proto__` is a legal header name — it is made of token characters — and
+        // `result[name] = value` is a [[Set]], so a response carrying it went
+        // through the inherited setter, which ignores a primitive. The header did
+        // not overwrite anything; it simply disappeared, and the caller reading the
+        // normalized record never learned the response had sent it.
+        if (name === "__proto__") {
+            Object.defineProperty(result, name, {
+                value,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+            return;
+        }
+        // `Set-Cookie` is the one header the Fetch spec does NOT combine: it
+        // yields each cookie as a separate `forEach` entry, while every other
+        // repeated header arrives already joined with ", ". Assigning therefore
+        // overwrote: a response setting two cookies normalized to the last one
+        // only, and the first vanished with no error anywhere. `Headers.get()`
+        // reports them combined as "a=1, b=2", so accumulate to match it — the
+        // cookie jar splits this form back apart with `splitSetCookieHeaders`.
+        if (name === "set-cookie" && Object.hasOwn(result, name)) {
+            result[name] = `${result[name]}, ${value}`;
+            return;
+        }
+        result[name] = value;
     });
     return result;
 }

package/dist/cjs/ws.js

@@ -273,15 +273,15 @@ export class WSClient {
         if (this._state === "OPEN")
             return Promise.resolve();
         return new Promise((resolve, reject) => {
-            const tid = timeoutMs > 0
-                ? setTimeout(() => {
-                    const i = this._openWaiters.findIndex((w) => w.resolve === resolve);
-                    if (i !== -1)
-                        this._openWaiters.splice(i, 1);
-                    reject(new WSConnectTimeoutError(this._url, timeoutMs));
-                }, timeoutMs)
-                : null;
-            this._openWaiters.push({
+            // The waiter is built first so the timeout can remove *this* entry by
+            // identity. It used to search for `w.resolve === resolve`, but the
+            // resolver stored on the queue is the wrapper below, not the promise's
+            // own `resolve` — so the search never matched, the timed-out waiter was
+            // never spliced out, and it stayed in `_openWaiters` for the lifetime
+            // of the client. A client whose `waitForOpen` timed out repeatedly grew
+            // that array without bound, and every later `open()`/`close()` walked
+            // the dead entries.
+            const waiter = {
                 resolve: () => {
                     if (tid)
                         clearTimeout(tid);
@@ -292,7 +292,16 @@ export class WSClient {
                         clearTimeout(tid);
                     reject(e);
                 },
-            });
+            };
+            const tid = timeoutMs > 0
+                ? setTimeout(() => {
+                    const i = this._openWaiters.indexOf(waiter);
+                    if (i !== -1)
+                        this._openWaiters.splice(i, 1);
+                    reject(new WSConnectTimeoutError(this._url, timeoutMs));
+                }, timeoutMs)
+                : null;
+            this._openWaiters.push(waiter);
         });
     }
     /**

package/dist/esm/aws-sigv4.js

@@ -162,12 +162,61 @@ export function imdsCredentials(options = {}) {
         const credsRes = await fetchWithTimeout(`${endpoint}/latest/meta-data/iam/security-credentials/${encodeURIComponent(role)}`, { headers: { "x-aws-ec2-metadata-token": token } }, timeout);
         if (!credsRes.ok)
             throw new NetworkError(`IMDS credentials fetch failed: ${credsRes.status}`);
-        const data = (await credsRes.json());
+        // Two failures used to escape this function unlabelled, and both of them
+        // turned into a silently broken signature rather than an error:
+        //
+        //  - `Response.json()` throws a bare `SyntaxError` on a non-JSON body, so
+        //    a proxy's HTML 502 page arrived with no `code` — a caller branching
+        //    on `err.code === "ENETWORK"` never saw it, and the message said
+        //    nothing about IMDS. Every other failure here is a `NetworkError`.
+        //  - A well-formed but shapeless body parsed fine and produced a
+        //    "successful" result: `{}` yielded `accessKeyId: undefined`, and
+        //    `{"AccessKeyId": null, …}` yielded nulls. Both then went on to
+        //    produce a SigV4 signature AWS rejects with an opaque
+        //    `SignatureDoesNotMatch`, pointing at the caller rather than at the
+        //    metadata endpoint that had actually answered with nonsense.
+        let data;
+        try {
+            data = (await credsRes.json());
+        }
+        catch (err) {
+            throw new NetworkError(`IMDS credentials response was not JSON: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (data === null || typeof data !== "object") {
+            throw new NetworkError(`IMDS credentials response was not an object: ${typeof data}`);
+        }
+        const { AccessKeyId, SecretAccessKey, Token, Expiration } = data;
+        const missing = [];
+        if (typeof AccessKeyId !== "string" || AccessKeyId.length === 0)
+            missing.push("AccessKeyId");
+        if (typeof SecretAccessKey !== "string" || SecretAccessKey.length === 0)
+            missing.push("SecretAccessKey");
+        if (typeof Token !== "string" || Token.length === 0)
+            missing.push("Token");
+        if (missing.length > 0) {
+            throw new NetworkError(`IMDS credentials response is missing ${missing.join(", ")} — ` +
+                "the metadata endpoint returned a body this client cannot sign with");
+        }
+        // Re-read through a narrowing helper: the checks above report every missing
+        // field at once, which is the right message but does not let the compiler
+        // carry the narrowing into this scope.
+        const requireString = (value, name) => {
+            if (typeof value !== "string" || value.length === 0) {
+                throw new NetworkError(`IMDS credentials response is missing ${name}`);
+            }
+            return value;
+        };
+        const accessKeyId = requireString(AccessKeyId, "AccessKeyId");
+        const secretAccessKey = requireString(SecretAccessKey, "SecretAccessKey");
+        const sessionToken = requireString(Token, "Token");
         return {
-            accessKeyId: data.AccessKeyId,
-            secretAccessKey: data.SecretAccessKey,
-            sessionToken: data.Token,
-            expiration: data.Expiration,
+            accessKeyId,
+            secretAccessKey,
+            sessionToken,
+            // Optional: a role without an expiry is legal, and the signer treats a
+            // missing expiration as "do not cache". Omitted rather than set to
+            // `undefined` — the project uses exactOptionalPropertyTypes.
+            ...(typeof Expiration === "string" ? { expiration: Expiration } : {}),
         };
     });
 }
@@ -339,6 +388,12 @@ function buildCanonicalHeaders(headers, unsignedExtra) {
     const entries = [];
     for (const [name, value] of Object.entries(headers)) {
         const lower = name.toLowerCase();
+        // An empty header name is not a valid HTTP field-name (RFC 9110 §5.1) and
+        // used to reach the canonical request verbatim, producing a `:value` line
+        // and a leading `;` in SignedHeaders. AWS answers that with an opaque
+        // SignatureDoesNotMatch rather than saying the header name was empty.
+        if (lower === "")
+            continue;
         if (unsigned.has(lower) && !ALWAYS_SIGNED_HEADERS.has(lower))
             continue;
         // Trim + collapse internal whitespace
@@ -446,10 +501,19 @@ export async function signRequest(request, config) {
     const amzDate = formatAmzDate(signingDate);
     const dateStamp = formatDateStamp(signingDate);
     const parsedUrl = new URL(request.url);
-    // Build the headers to sign — start from request headers
+    // Build the headers to sign — start from request headers.
+    //
+    // An explicitly-supplied `host` (in any casing) must WIN. Setting it is how
+    // you sign for a virtual-hosted-style bucket, a custom endpoint or a proxy.
+    // The URL host used to be injected unconditionally, which left both keys in
+    // the map whenever the caller used a different casing; `buildCanonicalHeaders`
+    // lowercased them and its dedupe step joined them, so the request was signed
+    // as `host:override.example,s3.amazonaws.com` — a host that can never
+    // validate, and one the library reported no error about.
+    const hasExplicitHost = Object.keys(request.headers).some((k) => k.toLowerCase() === "host");
     const headers = {
         ...request.headers,
-        host: parsedUrl.host,
+        ...(hasExplicitHost ? {} : { host: parsedUrl.host }),
         "x-amz-date": amzDate,
     };
     if (config.unsignedPayload) {
@@ -498,11 +562,22 @@ export async function presignRequest(request, config, options = {}) {
     const signingDate = resolveSigningDate(config);
     const amzDate = formatAmzDate(signingDate);
     const dateStamp = formatDateStamp(signingDate);
-    const expiresIn = options.expiresIn ?? 3600;
-    // Validate expiresIn range - different services have different limits
+    // Validate and CLAMP expiresIn. AWS enforces a hard maximum per service and
+    // rejects an out-of-range or fractional value with an opaque
+    // AuthorizationQueryParametersError at use time, long after the URL was
+    // handed out. The old code logged a warning and then wrote the caller's
+    // number straight into the query string, so `expiresIn: 0` produced
+    // `X-Amz-Expires=0`, `expiresIn: -1` produced `=-1`, and `expiresIn: 1e9`
+    // produced a link valid for ~31 years — every one of them permanently
+    // unusable, with a console warning as the only signal. Clamping can only
+    // shorten a link, never lengthen one, so it is the safe direction.
     const maxExpires = config.service === "s3" ? 604800 : 3600;
-    if (expiresIn < 1 || expiresIn > maxExpires) {
-        console.warn(`[aws-sigv4] presignRequest: expiresIn should be 1-${maxExpires} seconds for ${config.service}, got ${expiresIn}`);
+    const requested = options.expiresIn ?? 3600;
+    const expiresIn = Number.isFinite(requested)
+        ? Math.min(Math.max(Math.floor(requested), 1), maxExpires)
+        : maxExpires;
+    if (expiresIn !== requested) {
+        console.warn(`[aws-sigv4] presignRequest: expiresIn must be an integer in 1-${maxExpires} for ${config.service}, got ${requested} — clamped to ${expiresIn}`);
     }
     const parsedUrl = new URL(request.url);
     const credentialScope = `${dateStamp}/${config.region}/${config.service}/aws4_request`;
@@ -520,10 +595,14 @@ export async function presignRequest(request, config, options = {}) {
             parsedUrl.searchParams.set(k, v);
         }
     }
-    // Determine signed headers (only "host" for presigned URLs typically)
+    // Determine signed headers (only "host" for presigned URLs typically).
+    // An explicit `host` wins here for the same reason it does in sign() — a
+    // differently-cased caller header used to be merged with the URL host into
+    // `host:override.example,s3.amazonaws.com`, which can never validate.
+    const presignHasExplicitHost = Object.keys(request.headers).some((k) => k.toLowerCase() === "host");
     const headers = {
         ...request.headers,
-        host: parsedUrl.host,
+        ...(presignHasExplicitHost ? {} : { host: parsedUrl.host }),
     };
     const unsignedHdrs = config.unsignedHeaders ?? [];
     // For presigned URLs, payload hash is always UNSIGNED-PAYLOAD
@@ -666,14 +745,49 @@ export async function signS3PostPolicy(policy, config) {
  * Returns 0 if the header is absent or unparseable.
  */
 export function detectClockSkew(responseHeaders) {
-    const dateHeader = responseHeaders["date"] ?? responseHeaders["Date"];
-    if (!dateHeader)
-        return 0;
-    const serverTime = new Date(dateHeader).getTime();
-    if (isNaN(serverTime))
-        return 0;
+    // `x-amz-date` is AWS's own signed timestamp and is the one present on the
+    // clock-skew error itself. `Date` is generated by whatever proxy fronts the
+    // endpoint and is frequently absent. Reading only `Date` meant a skew was
+    // silently undetectable on exactly the responses that carry it.
+    const amzDate = responseHeaders["x-amz-date"] ?? responseHeaders["X-Amz-Date"];
+    let serverTime;
+    if (amzDate !== undefined) {
+        serverTime = parseAmzDate(amzDate);
+        if (isNaN(serverTime))
+            return 0;
+    }
+    else {
+        const dateHeader = responseHeaders["date"] ?? responseHeaders["Date"];
+        if (!dateHeader)
+            return 0;
+        serverTime = new Date(dateHeader).getTime();
+        if (isNaN(serverTime))
+            return 0;
+    }
     return Math.round((serverTime - Date.now()) / 1000);
 }
+/**
+ * Parse AWS's basic ISO 8601 timestamp (`20300101T120000Z`), which is not a
+ * form `Date` can parse.
+ *
+ * @param value - Candidate `x-amz-date` value
+ * @returns Epoch milliseconds, or `NaN` when the value is not in that form
+ */
+function parseAmzDate(value) {
+    const m = /^(\d{4})(\d{2})(\d{2})T(\d{2})(\d{2})(\d{2})Z$/.exec(value.trim());
+    if (!m)
+        return NaN;
+    const [, y, mo, d, h, mi, sec] = m;
+    // Reject values that roll over silently (e.g. month 13) instead of
+    // producing a date in the following month.
+    const t = Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(sec));
+    const dt = new Date(t);
+    if (dt.getUTCFullYear() !== Number(y) || dt.getUTCMonth() + 1 !== Number(mo))
+        return NaN;
+    if (dt.getUTCDate() !== Number(d))
+        return NaN;
+    return t;
+}
 /**
  * Determine if an error response is a clock skew error.
  */