kinetex 1.0.0 → 1.2.0

package/dist/browser/kinetex.js

@@ -1,4 +1,4 @@
-/* kinetex v1.0.0 | MIT | https://github.com/kinetexjs/kinetex */
+/* kinetex v1.2.0 | MIT | https://github.com/kinetexjs/kinetex */
 "use strict";
 var kinetex = (() => {
   var __create = Object.create;
@@ -51,160 +51,6 @@ var kinetex = (() => {
   var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
   var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
-  // dist/esm/types.js
-  function toRequestId(id) {
-    return id;
-  }
-  function validateErrorCode(code) {
-    if (typeof code === "string") {
-      for (const valid of VALID_ERROR_CODES) {
-        if (valid === code)
-          return valid;
-      }
-    }
-    return void 0;
-  }
-  var VALID_ERROR_CODES, KinetexError, SizeLimitError, HTTPStatusError, AbortError, NetworkError, ValidationError, AuthError, ProxyError, RedirectError, TimeoutError;
-  var init_types = __esm({
-    "dist/esm/types.js"() {
-      "use strict";
-      VALID_ERROR_CODES = [
-        "ENETWORK",
-        "ETIMEOUT",
-        "EABORT",
-        "EHTTPSTATUS",
-        "ESIZELIMIT",
-        "EPARSE",
-        "EVALIDATION",
-        "EAUTH",
-        "EPROXY",
-        "EREDIRECT",
-        "EUNKNOWN"
-      ];
-      KinetexError = class extends Error {
-        /**
-         * @param message - Human-readable error description.
-         * @param code - Machine-readable error code.
-         * @param options - Additional context (request, response, cause).
-         */
-        constructor(message, code, options) {
-          super(message);
-          /** Machine-readable error code. */
-          __publicField(this, "code");
-          /** Original request, if available. */
-          __publicField(this, "request");
-          /** Response, if available (for HTTP-level errors). */
-          __publicField(this, "response");
-          /** Underlying cause. */
-          __publicField(this, "cause");
-          this.name = "KinetexError";
-          this.code = code;
-          if (options?.request !== void 0)
-            this.request = options.request;
-          if (options?.response !== void 0)
-            this.response = options.response;
-          if (options?.cause !== void 0)
-            this.cause = options.cause;
-        }
-        /** True if the error is a network/transport failure (not proxy-related). */
-        get isNetwork() {
-          return this.code === "ENETWORK";
-        }
-        /** True if the error is a proxy-related failure. */
-        get isProxy() {
-          return this.code === "EPROXY";
-        }
-        /** True if the error is a timeout. */
-        get isTimeout() {
-          return this.code === "ETIMEOUT";
-        }
-        /** True if the request was aborted by the caller. */
-        get isAbort() {
-          return this.code === "EABORT";
-        }
-        /** True if the server returned a 4xx or 5xx status. */
-        get isHTTPError() {
-          return this.code === "EHTTPSTATUS";
-        }
-        /** HTTP status code shorthand (null for non-HTTP errors). */
-        get status() {
-          return this.response?.status ?? null;
-        }
-      };
-      SizeLimitError = class extends KinetexError {
-        constructor(bytesRead, limit, request) {
-          super(`Response size limit exceeded: ${bytesRead} bytes read, limit is ${limit} bytes`, "ESIZELIMIT", request !== void 0 ? { request } : {});
-          __publicField(this, "bytesRead");
-          __publicField(this, "limit");
-          this.bytesRead = bytesRead;
-          this.limit = limit;
-          this.name = "SizeLimitError";
-        }
-      };
-      HTTPStatusError = class extends KinetexError {
-        constructor(response, request) {
-          super(`HTTP ${response.status} ${response.statusText} \u2014 ${response.url}`, "EHTTPSTATUS", {
-            request,
-            response
-          });
-          this.name = "HTTPStatusError";
-        }
-        /** True if the status is a 4xx client error. */
-        get isClientError() {
-          return (this.status ?? 0) >= 400 && (this.status ?? 0) < 500;
-        }
-        /** True if the status is a 5xx server error. */
-        get isServerError() {
-          return (this.status ?? 0) >= 500;
-        }
-      };
-      AbortError = class extends KinetexError {
-        constructor(request) {
-          super("Request was aborted", "EABORT", request !== void 0 ? { request } : {});
-          this.name = "AbortError";
-        }
-      };
-      NetworkError = class extends KinetexError {
-        constructor(message, request) {
-          super(message, "ENETWORK", request !== void 0 ? { request } : {});
-          this.name = "NetworkError";
-        }
-      };
-      ValidationError = class extends KinetexError {
-        constructor(message, request) {
-          super(message, "EVALIDATION", request !== void 0 ? { request } : {});
-          this.name = "ValidationError";
-        }
-      };
-      AuthError = class extends KinetexError {
-        constructor(message, request) {
-          super(message, "EAUTH", request !== void 0 ? { request } : {});
-          this.name = "AuthError";
-        }
-      };
-      ProxyError = class extends KinetexError {
-        constructor(message, request) {
-          super(message, "EPROXY", request !== void 0 ? { request } : {});
-          this.name = "ProxyError";
-        }
-      };
-      RedirectError = class extends KinetexError {
-        constructor(message, request) {
-          super(message, "EREDIRECT", request !== void 0 ? { request } : {});
-          this.name = "RedirectError";
-        }
-      };
-      TimeoutError = class extends KinetexError {
-        constructor(timeoutMs, request) {
-          super(`Request timed out after ${timeoutMs}ms`, "ETIMEOUT", request !== void 0 ? { request } : {});
-          __publicField(this, "timeoutMs");
-          this.timeoutMs = timeoutMs;
-          this.name = "TimeoutError";
-        }
-      };
-    }
-  });
-
   // dist/esm/utils.js
   function getProcess() {
     if (_process)
@@ -346,6 +192,25 @@ var kinetex = (() => {
     const result = safeJSONParse(text);
     return result.success ? result.value : text;
   }
+  function sanitizeParsedJSON(value) {
+    if (value === null || typeof value !== "object")
+      return value;
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        value[i] = sanitizeParsedJSON(value[i]);
+      }
+      return value;
+    }
+    const obj = value;
+    for (const key of Object.keys(obj)) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        delete obj[key];
+        continue;
+      }
+      sanitizeParsedJSON(obj[key]);
+    }
+    return value;
+  }
   function parseUntrustedJSON(text) {
     return safeJSONParse(text, {
       maxDepth: 16,
@@ -401,6 +266,130 @@ var kinetex = (() => {
     }
     return true;
   }
+  function isBlockedIPv4(n) {
+    return IPV4_BLOCKED_RANGES.some(([lo, hi]) => n >= lo && n <= hi);
+  }
+  function parseIPv4Component(p) {
+    if (p === "")
+      return null;
+    if (/^0[xX][0-9a-fA-F]+$/.test(p))
+      return parseInt(p, 16);
+    if (/^0[0-7]+$/.test(p))
+      return parseInt(p, 8);
+    if (/^\d+$/.test(p))
+      return parseInt(p, 10);
+    return null;
+  }
+  function parseIPv4Host(host) {
+    if (host.includes(":") || !/^[0-9a-fA-FxX.]+$/.test(host))
+      return null;
+    const bare = host.endsWith(".") ? host.slice(0, -1) : host;
+    if (bare === "")
+      return null;
+    const parts = bare.split(".");
+    if (parts.length > 4 || parts.length < 1)
+      return null;
+    if (parts.length === 1) {
+      const v = parseIPv4Component(parts[0]);
+      if (v === null || v > 4294967295)
+        return null;
+      return v >>> 0;
+    }
+    const octets = [];
+    for (let i = 0; i < parts.length - 1; i++) {
+      const v = parseIPv4Component(parts[i]);
+      if (v === null || v > 255)
+        return null;
+      octets.push(v);
+    }
+    const last = parseIPv4Component(parts[parts.length - 1]);
+    const lastCap = 2 ** (8 * (5 - parts.length));
+    if (last === null || last >= lastCap)
+      return null;
+    for (let shift = 8 * (4 - parts.length); shift >= 0; shift -= 8) {
+      octets.push(last >>> shift & 255);
+    }
+    return (octets[0] << 24 | octets[1] << 16 | octets[2] << 8 | octets[3]) >>> 0;
+  }
+  function parseIPv6Host(host) {
+    if (!host.includes(":"))
+      return null;
+    const bare = host.split("%")[0];
+    const halves = bare.split("::");
+    if (halves.length > 2)
+      return null;
+    const expandGroups = (part) => {
+      if (part === "")
+        return [];
+      const groups = part.split(":");
+      const out = [];
+      for (let i = 0; i < groups.length; i++) {
+        const g2 = groups[i];
+        if (g2 === "")
+          return null;
+        if (g2.includes(".")) {
+          if (i !== groups.length - 1)
+            return null;
+          const n = parseIPv4Host(g2);
+          if (n === null)
+            return null;
+          out.push(n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255);
+        } else {
+          if (!/^[0-9a-fA-F]{1,4}$/.test(g2))
+            return null;
+          const v = parseInt(g2, 16);
+          out.push(v >>> 8 & 255, v & 255);
+        }
+      }
+      return out;
+    };
+    let bytes;
+    if (halves.length === 2) {
+      const left = expandGroups(halves[0]);
+      const right = expandGroups(halves[1]);
+      if (!left || !right)
+        return null;
+      const fill = 16 - left.length - right.length;
+      if (fill < 0)
+        return null;
+      bytes = [...left, ...new Array(fill).fill(0), ...right];
+    } else {
+      const all = expandGroups(bare);
+      if (!all || all.length !== 16)
+        return null;
+      bytes = all;
+    }
+    return bytes.length === 16 ? new Uint8Array(bytes) : null;
+  }
+  function isBlockedIPv6(b) {
+    const read32 = (i) => (b[i] << 24 | b[i + 1] << 16 | b[i + 2] << 8 | b[i + 3]) >>> 0;
+    if (b.every((x) => x === 0))
+      return true;
+    if (b.slice(0, 15).every((x) => x === 0) && b[15] === 1)
+      return true;
+    const first = b[0];
+    if ((first & 254) === 252)
+      return true;
+    if (first === 254 && (b[1] & 192) === 128)
+      return true;
+    if (first === 255)
+      return true;
+    if (b[0] === 32 && b[1] === 1 && b[2] === 13 && b[3] === 184)
+      return true;
+    if (b.slice(0, 10).every((x) => x === 0) && b[10] === 255 && b[11] === 255) {
+      return isBlockedIPv4(read32(12));
+    }
+    if (b.slice(0, 12).every((x) => x === 0)) {
+      return isBlockedIPv4(read32(12));
+    }
+    if (b[0] === 0 && b[1] === 100 && b[2] === 255 && b[3] === 155 && b.slice(4, 12).every((x) => x === 0)) {
+      return isBlockedIPv4(read32(12));
+    }
+    if (b[0] === 32 && b[1] === 2) {
+      return isBlockedIPv4(read32(2));
+    }
+    return false;
+  }
   function isSafeURL(url, allowedSchemes = ["http", "https"]) {
     try {
       const parsed = typeof url === "string" ? new URL(url) : url;
@@ -412,14 +401,20 @@ var kinetex = (() => {
         return false;
       }
       let host = parsed.hostname.toLowerCase();
-      if (host.startsWith("[") && host.endsWith("]"))
+      const isV6Literal = host.startsWith("[") && host.endsWith("]");
+      if (isV6Literal)
         host = host.slice(1, -1);
-      if (host === "0:0:0:0:0:0:0:1")
-        host = "::1";
-      if (host === "localhost" || host === "0.0.0.0")
-        return false;
-      if (PRIVATE_IP_RANGES.some((r) => r.test(host)))
+      if (host === "localhost" || host.endsWith(".localhost") || host === "0.0.0.0")
         return false;
+      if (isV6Literal || host.includes(":")) {
+        const v6 = parseIPv6Host(host);
+        if (v6 === null || isBlockedIPv6(v6))
+          return false;
+      } else {
+        const v4 = parseIPv4Host(host);
+        if (v4 !== null && isBlockedIPv4(v4))
+          return false;
+      }
       if (parsed.hostname.includes("..") || parsed.pathname.includes("..")) {
         return false;
       }
@@ -463,6 +458,8 @@ var kinetex = (() => {
     }
     const cloned = {};
     for (const key in value) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype")
+        continue;
       if (Object.prototype.hasOwnProperty.call(value, key)) {
         cloned[key] = deepClone(value[key]);
       }
@@ -619,17 +616,14 @@ var kinetex = (() => {
     return false;
   }
   function randomBytes(byteCount) {
+    if (!Number.isInteger(byteCount) || byteCount < 0 || byteCount > 65536) {
+      throw new Error(`randomBytes: invalid byteCount ${byteCount}`);
+    }
     const arr = new Uint8Array(byteCount);
     if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
       crypto.getRandomValues(arr);
     } else {
-      const uuid = typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID().replace(/-/g, "") : "";
-      if (uuid.length >= byteCount * 2) {
-        return uuid.slice(0, byteCount * 2);
-      }
-      for (let i = 0; i < arr.length; i++) {
-        arr[i] = Math.floor(Math.random() * 256);
-      }
+      throw new Error("randomBytes: no CSPRNG available in this runtime \u2014 crypto.getRandomValues is required");
     }
     return Array.from(arr).map((b) => b.toString(16).padStart(2, "0")).join("");
   }
@@ -681,7 +675,7 @@ var kinetex = (() => {
     });
     return result;
   }
-  var _process, _Buffer, DEFAULT_LIMITS, HEADER_NAME_PATTERN, FORBIDDEN_SCHEMES, PRIVATE_IP_RANGES, cachedRuntime;
+  var _process, _Buffer, DEFAULT_LIMITS, HEADER_NAME_PATTERN, FORBIDDEN_SCHEMES, IPV4_BLOCKED_RANGES, cachedRuntime;
   var init_utils = __esm({
     "dist/esm/utils.js"() {
       "use strict";
@@ -717,53 +711,194 @@ var kinetex = (() => {
         "webcal",
         "urn"
       ]);
-      PRIVATE_IP_RANGES = [
-        /^127\./,
-        // loopback
-        /^10\./,
-        // RFC 1918
-        /^192\.168\./,
-        // RFC 1918
-        /^172\.(1[6-9]|2\d|3[01])\./,
-        // RFC 1918
-        /^169\.254\./,
-        // link-local (AWS IMDS, etc.)
-        /^0\./,
-        // this-network
-        /^::1$/i,
-        // IPv6 loopback
-        /^fc00:/i,
-        // IPv6 ULA (fc00::/7 - includes fc00: and fd00:)
-        /^fd00:/i,
-        // IPv6 ULA (fd00::/8 - unique local)
-        /^fe80:/i,
-        // IPv6 link-local (fe80::/10)
-        /^2001:db8:/i,
-        // IPv6 documentation range
-        /^::0?ffff:/i,
-        // IPv4-mapped IPv6 (::ffff:...)
-        /^0:0:0:0:0:ffff:/i,
-        // IPv4-mapped compressed form
-        // FIX 4: IPv4-mapped IPv6 SSRF bypass — e.g. http://[::ffff:127.0.0.1]
-        /^::ffff:127\./i,
-        // IPv4-mapped loopback
-        /^::ffff:10\./i,
-        // IPv4-mapped RFC 1918
-        /^::ffff:192\.168\./i,
-        // IPv4-mapped RFC 1918
-        /^::ffff:172\.(1[6-9]|2\d|3[01])\./i,
-        // IPv4-mapped RFC 1918
-        /^::ffff:169\.254\./i,
-        // IPv4-mapped link-local
-        /^0:0:0:0:0:ffff:7f/i,
-        // compressed form of ::ffff:127.x
-        /^::$/i
-        // IPv4-compatible :: (any ::/96)
+      IPV4_BLOCKED_RANGES = [
+        [0, 16777215],
+        // 0.0.0.0/8 — this-network
+        [167772160, 184549375],
+        // 10.0.0.0/8 — RFC 1918 private
+        [1681915904, 1686110207],
+        // 100.64.0.0/10 — CGNAT (RFC 6598)
+        [2130706432, 2147483647],
+        // 127.0.0.0/8 — loopback
+        [2851995648, 2852061183],
+        // 169.254.0.0/16 — link-local (AWS IMDS etc.)
+        [2886729728, 2887778303],
+        // 172.16.0.0/12 — RFC 1918 private
+        [3221225472, 3221225727],
+        // 192.0.0.0/24 — IETF protocol assignments
+        [3221225984, 3221226239],
+        // 192.0.2.0/24 — TEST-NET-1
+        [3232235520, 3232301055],
+        // 192.168.0.0/16 — RFC 1918 private
+        [3323068416, 3323199487],
+        // 198.18.0.0/15 — benchmarking
+        [3325256704, 3325256959],
+        // 198.51.100.0/24 — TEST-NET-2
+        [3405803776, 3405804031],
+        // 203.0.113.0/24 — TEST-NET-3
+        [3758096384, 4026531839],
+        // 224.0.0.0/4 — multicast
+        [4026531840, 4294967295]
+        // 240.0.0.0/4 — reserved (incl. 255.255.255.255)
       ];
       cachedRuntime = null;
     }
   });
 
+  // dist/esm/types.js
+  function toRequestId(id) {
+    return id;
+  }
+  function validateErrorCode(code) {
+    if (typeof code === "string") {
+      for (const valid of VALID_ERROR_CODES) {
+        if (valid === code)
+          return valid;
+      }
+    }
+    return void 0;
+  }
+  var VALID_ERROR_CODES, KinetexError, SizeLimitError, HTTPStatusError, AbortError, NetworkError, ValidationError, AuthError, ProxyError, RedirectError, TimeoutError;
+  var init_types = __esm({
+    "dist/esm/types.js"() {
+      "use strict";
+      VALID_ERROR_CODES = [
+        "ENETWORK",
+        "ETIMEOUT",
+        "EABORT",
+        "EHTTPSTATUS",
+        "ESIZELIMIT",
+        "EPARSE",
+        "EVALIDATION",
+        "EAUTH",
+        "EPROXY",
+        "EREDIRECT",
+        "EUNKNOWN"
+      ];
+      KinetexError = class extends Error {
+        /**
+         * @param message - Human-readable error description.
+         * @param code - Machine-readable error code.
+         * @param options - Additional context (request, response, cause).
+         */
+        constructor(message, code, options) {
+          super(message);
+          /** Machine-readable error code. */
+          __publicField(this, "code");
+          /** Original request, if available. */
+          __publicField(this, "request");
+          /** Response, if available (for HTTP-level errors). */
+          __publicField(this, "response");
+          /** Underlying cause. */
+          __publicField(this, "cause");
+          this.name = "KinetexError";
+          this.code = code;
+          if (options?.request !== void 0)
+            this.request = options.request;
+          if (options?.response !== void 0)
+            this.response = options.response;
+          if (options?.cause !== void 0)
+            this.cause = options.cause;
+        }
+        /** True if the error is a network/transport failure (not proxy-related). */
+        get isNetwork() {
+          return this.code === "ENETWORK";
+        }
+        /** True if the error is a proxy-related failure. */
+        get isProxy() {
+          return this.code === "EPROXY";
+        }
+        /** True if the error is a timeout. */
+        get isTimeout() {
+          return this.code === "ETIMEOUT";
+        }
+        /** True if the request was aborted by the caller. */
+        get isAbort() {
+          return this.code === "EABORT";
+        }
+        /** True if the server returned a 4xx or 5xx status. */
+        get isHTTPError() {
+          return this.code === "EHTTPSTATUS";
+        }
+        /** HTTP status code shorthand (null for non-HTTP errors). */
+        get status() {
+          return this.response?.status ?? null;
+        }
+      };
+      SizeLimitError = class extends KinetexError {
+        constructor(bytesRead, limit, request) {
+          super(`Response size limit exceeded: ${bytesRead} bytes read, limit is ${limit} bytes`, "ESIZELIMIT", request !== void 0 ? { request } : {});
+          __publicField(this, "bytesRead");
+          __publicField(this, "limit");
+          this.bytesRead = bytesRead;
+          this.limit = limit;
+          this.name = "SizeLimitError";
+        }
+      };
+      HTTPStatusError = class extends KinetexError {
+        constructor(response, request) {
+          super(`HTTP ${response.status} ${response.statusText} \u2014 ${response.url}`, "EHTTPSTATUS", {
+            request,
+            response
+          });
+          this.name = "HTTPStatusError";
+        }
+        /** True if the status is a 4xx client error. */
+        get isClientError() {
+          return (this.status ?? 0) >= 400 && (this.status ?? 0) < 500;
+        }
+        /** True if the status is a 5xx server error. */
+        get isServerError() {
+          return (this.status ?? 0) >= 500;
+        }
+      };
+      AbortError = class extends KinetexError {
+        constructor(request) {
+          super("Request was aborted", "EABORT", request !== void 0 ? { request } : {});
+          this.name = "AbortError";
+        }
+      };
+      NetworkError = class extends KinetexError {
+        constructor(message, request) {
+          super(message, "ENETWORK", request !== void 0 ? { request } : {});
+          this.name = "NetworkError";
+        }
+      };
+      ValidationError = class extends KinetexError {
+        constructor(message, request) {
+          super(message, "EVALIDATION", request !== void 0 ? { request } : {});
+          this.name = "ValidationError";
+        }
+      };
+      AuthError = class extends KinetexError {
+        constructor(message, request) {
+          super(message, "EAUTH", request !== void 0 ? { request } : {});
+          this.name = "AuthError";
+        }
+      };
+      ProxyError = class extends KinetexError {
+        constructor(message, request) {
+          super(message, "EPROXY", request !== void 0 ? { request } : {});
+          this.name = "ProxyError";
+        }
+      };
+      RedirectError = class extends KinetexError {
+        constructor(message, request) {
+          super(message, "EREDIRECT", request !== void 0 ? { request } : {});
+          this.name = "RedirectError";
+        }
+      };
+      TimeoutError = class extends KinetexError {
+        constructor(timeoutMs, request) {
+          super(`Request timed out after ${timeoutMs}ms`, "ETIMEOUT", request !== void 0 ? { request } : {});
+          __publicField(this, "timeoutMs");
+          this.timeoutMs = timeoutMs;
+          this.name = "TimeoutError";
+        }
+      };
+    }
+  });
+
   // dist/esm/cache.js
   var cache_exports = {};
   __export(cache_exports, {
@@ -3706,7 +3841,7 @@ var kinetex = (() => {
     const charset = options.charset ?? parseContentType2(ct ?? "")?.charset ?? null;
     const text = decodeBody(bytes, charset, url);
     try {
-      return JSON.parse(text);
+      return sanitizeParsedJSON(JSON.parse(text));
     } catch (err) {
       throw new ResponseDecodeError(`JSON parse failed: ${err}`, "json", url);
     }
@@ -3761,7 +3896,7 @@ var kinetex = (() => {
           const trimmed = buffer.trim();
           if (trimmed) {
             try {
-              yield JSON.parse(trimmed);
+              yield sanitizeParsedJSON(JSON.parse(trimmed));
             } catch (err) {
               options.onParseError?.(err, trimmed);
             }
@@ -3776,7 +3911,7 @@ var kinetex = (() => {
           if (!trimmed || trimmed.startsWith("#"))
             continue;
           try {
-            yield JSON.parse(trimmed);
+            yield sanitizeParsedJSON(JSON.parse(trimmed));
           } catch (err) {
             options.onParseError?.(err, trimmed);
           }
@@ -3809,7 +3944,7 @@ var kinetex = (() => {
           const remaining = flushBuffer();
           if (remaining) {
             try {
-              const obj = JSON.parse(remaining);
+              const obj = sanitizeParsedJSON(JSON.parse(remaining));
               options.onObject?.(obj);
               yield obj;
             } catch (err) {
@@ -3830,7 +3965,7 @@ var kinetex = (() => {
             if (depth === 0 && startIdx !== -1) {
               const objStr = buffer.slice(startIdx, i + 1);
               try {
-                const obj = JSON.parse(objStr);
+                const obj = sanitizeParsedJSON(JSON.parse(objStr));
                 options.onObject?.(obj);
                 yield obj;
               } catch (err) {
@@ -4374,7 +4509,7 @@ var kinetex = (() => {
     }
   }
   function createTransport(fetchFn, preferHTTP2 = true, sessionOptions, transportOptions) {
-    if (IS_NODE && preferHTTP2) {
+    if (IS_NODE && preferHTTP2 && !fetchFn) {
       return new NodeHTTP2Transport({
         ...sessionOptions?.sessionTTLMs !== void 0 ? { sessionTTLMs: sessionOptions.sessionTTLMs } : {},
         ...sessionOptions?.pingIntervalMs !== void 0 ? { pingIntervalMs: sessionOptions.pingIntervalMs } : {},
@@ -4399,8 +4534,11 @@ var kinetex = (() => {
     }, timeoutMs);
     const signal = mergeSignals(request.signal, controller.signal) ?? null;
     const req = { ...request, signal };
+    const timeoutPromise = new Promise((_, reject) => {
+      controller.signal.addEventListener("abort", () => reject(new TimeoutError(timeoutMs, request)), { once: true });
+    });
     try {
-      const result = await transport.send(req);
+      const result = await Promise.race([transport.send(req), timeoutPromise]);
       clearTimeout(timer);
       if (controller.signal.aborted) {
         throw new TimeoutError(timeoutMs, request);
@@ -4408,7 +4546,7 @@ var kinetex = (() => {
       return result;
     } catch (err) {
       clearTimeout(timer);
-      if (controller.signal.aborted) {
+      if (controller.signal.aborted && !(err instanceof TimeoutError)) {
         throw new TimeoutError(timeoutMs, request);
       }
       throw err;
@@ -4782,6 +4920,8 @@ var kinetex = (() => {
           __publicField(this, "sessionUsage", /* @__PURE__ */ new Map());
           __publicField(this, "_strict");
           __publicField(this, "_onDroppedHeader");
+          /** Optional CA bundle for origins with self-signed / private-PKI certificates. */
+          __publicField(this, "_ca");
           /** FIX 11: Configurable connect timeout (replaces hardcoded 30 000 ms) */
           __publicField(this, "_connectTimeoutMs");
           /** FIX 11: Configurable per-request stream timeout (replaces hardcoded 30 000 ms) */
@@ -4793,6 +4933,7 @@ var kinetex = (() => {
           this.maxSessions = options.maxSessions ?? 100;
           this._strict = options.strict ?? false;
           this._onDroppedHeader = options.onDroppedHeader;
+          this._ca = options.ca;
           this._connectTimeoutMs = options.connectTimeoutMs ?? 3e4;
           this._requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
         }
@@ -4842,7 +4983,10 @@ var kinetex = (() => {
             }
           }
           const session = await new Promise((resolve, reject) => {
-            const s = http2.connect(origin, { rejectUnauthorized: true });
+            const s = http2.connect(origin, {
+              rejectUnauthorized: true,
+              ...this._ca !== void 0 ? { ca: this._ca } : {}
+            });
             const connectTimeout = setTimeout(() => {
               s.destroy();
               reject(new KinetexError(`HTTP/2 connection to ${origin} timed out`, "ETIMEOUT", {
@@ -4955,27 +5099,28 @@ var kinetex = (() => {
               ":authority": currentUrl.host,
               ...currentReq.headers
             };
-            if (this._strict) {
-              for (const [hName, hValue] of Object.entries(h2ReqHeaders)) {
-                if (hName.startsWith(":"))
-                  continue;
-                const hStr = Array.isArray(hValue) ? hValue.join(", ") : String(hValue);
-                let hasForbidden = false;
-                for (let ci = 0; ci < hStr.length; ci++) {
-                  const code = hStr.charCodeAt(ci);
-                  if (code >= 0 && code <= 8 || code >= 10 && code <= 31 || code === 127) {
-                    hasForbidden = true;
-                    break;
-                  }
+            for (const [hName, hValue] of Object.entries(h2ReqHeaders)) {
+              if (hName.startsWith(":"))
+                continue;
+              const hStr = Array.isArray(hValue) ? hValue.join(", ") : String(hValue);
+              let hasForbidden = false;
+              for (let ci = 0; ci < hStr.length; ci++) {
+                const code = hStr.charCodeAt(ci);
+                if (code >= 0 && code <= 8 || code >= 10 && code <= 31 || code === 127) {
+                  hasForbidden = true;
+                  break;
                 }
-                if (hasForbidden) {
-                  if (this._onDroppedHeader) {
-                    this._onDroppedHeader(hName, hStr);
-                    delete h2ReqHeaders[hName];
-                  } else {
-                    throw new KinetexError(`Strict mode: header "${hName}" contains forbidden control characters`, "EVALIDATION", { request: currentReq });
-                  }
+              }
+              if (hasForbidden) {
+                if (this._strict) {
+                  throw new KinetexError(`Strict mode: header "${hName}" contains forbidden control characters`, "EVALIDATION", { request: currentReq });
                 }
+                if (this._onDroppedHeader) {
+                  this._onDroppedHeader(hName, hStr);
+                } else if (typeof console !== "undefined") {
+                  console.warn(`[kinetex] Invalid header dropped (HTTP/2): "${hName}" \u2014 value contains illegal control characters. Pass strictHeaders: true to throw instead.`);
+                }
+                delete h2ReqHeaders[hName];
               }
             }
             const endStream = !currentReq.body || currentReq.method === "GET" || currentReq.method === "HEAD";
@@ -7325,6 +7470,10 @@ var kinetex = (() => {
                   continue;
                 if (!sameSiteAllows(cookie.sameSite, context))
                   continue;
+                if (cookie.name.startsWith("__Secure-") && !(cookie.secure && isSecure))
+                  continue;
+                if (cookie.name.startsWith("__Host-") && !(cookie.secure && isSecure && cookie.path === "/" && cookie.hostOnly))
+                  continue;
                 result.push(cookie);
               }
             }
@@ -7797,9 +7946,11 @@ var kinetex = (() => {
     const [head, ...rest] = path;
     if (head === void 0)
       return;
+    if (head === "__proto__" || head === "constructor" || head === "prototype")
+      return;
     const o = obj;
     if (rest.length === 0) {
-      if (head in o)
+      if (Object.prototype.hasOwnProperty.call(o, head))
         o[head] = "***";
       return;
     }
@@ -7882,6 +8033,7 @@ var kinetex = (() => {
   var init_logging = __esm({
     "dist/esm/logging.js"() {
       "use strict";
+      init_utils();
       getNodeEnv = () => {
         try {
           return globalThis.process?.env?.["NODE_ENV"];
@@ -8241,7 +8393,7 @@ var kinetex = (() => {
           const size = str.length;
           if (ct.includes("application/json") && this.bodyFields.length > 0) {
             try {
-              const parsed = JSON.parse(str);
+              const parsed = sanitizeParsedJSON(JSON.parse(str));
               for (const path of this.bodyFields)
                 redactObjectPath(parsed, path.split("."));
               str = JSON.stringify(parsed);
@@ -8512,7 +8664,7 @@ var kinetex = (() => {
       if (!evt.data && evt.data !== "")
         continue;
       try {
-        const data = JSON.parse(evt.data, options.reviver);
+        const data = sanitizeParsedJSON(JSON.parse(evt.data, options.reviver));
         yield { event: evt.event, data, id: evt.id };
       } catch (err) {
         options.onError?.(err, evt);
@@ -8552,6 +8704,7 @@ var kinetex = (() => {
   var init_sse = __esm({
     "dist/esm/sse.js"() {
       "use strict";
+      init_utils();
       SSEParser = class {
         constructor() {
           __publicField(this, "lines", []);
@@ -8991,7 +9144,7 @@ var kinetex = (() => {
         onJSON(eventType, handler) {
           return this.on(eventType, async (data, evt) => {
             try {
-              const parsed = JSON.parse(data);
+              const parsed = sanitizeParsedJSON(JSON.parse(data));
               await handler(parsed, evt);
             } catch {
             }
@@ -9315,11 +9468,18 @@ var kinetex = (() => {
     let current = obj;
     for (let i = 0; i < parts.length - 1; i++) {
       const key = parts[i];
+      if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        throw new ValidationError(`Invalid upload path: "${path}" \u2014 reserved key "${key}"`);
+      }
       if (!current[key] || typeof current[key] !== "object")
         current[key] = {};
       current = current[key];
     }
-    current[parts[parts.length - 1]] = value;
+    const leaf = parts[parts.length - 1];
+    if (leaf === "__proto__" || leaf === "constructor" || leaf === "prototype") {
+      throw new ValidationError(`Invalid upload path: "${path}" \u2014 reserved key "${leaf}"`);
+    }
+    current[leaf] = value;
   }
   async function parseGraphQLResponse(response, req) {
     const ct = response.headers.get("content-type") ?? "";
@@ -9330,7 +9490,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
     }
     let json;
     try {
-      json = await response.json();
+      json = sanitizeParsedJSON(await response.json());
     } catch (err) {
       throw new GraphQLClientError("Failed to parse GraphQL response as JSON", "EPARSE", void 0, req, void 0, err);
     }
@@ -9366,7 +9526,8 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
       fetchHeaders["content-type"] = "application/json";
     const controller = new AbortController();
     const timer = config.timeoutMs > 0 ? setTimeout(() => controller.abort(), config.timeoutMs) : null;
-    signal?.addEventListener("abort", () => controller.abort(), { once: true });
+    const onExternalAbort = () => controller.abort();
+    signal?.addEventListener("abort", onExternalAbort, { once: true });
     let response;
     try {
       response = await config.fetch(fetchUrl, {
@@ -9385,6 +9546,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
     } finally {
       if (timer)
         clearTimeout(timer);
+      signal?.removeEventListener("abort", onExternalAbort);
     }
     return parseGraphQLResponse(response, req);
   }
@@ -9477,6 +9639,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
     "dist/esm/graphql.js"() {
       "use strict";
       init_types();
+      init_utils();
       GraphQLClientError = class extends Error {
         /**
          * @param message       - Human-readable error description
@@ -9742,7 +9905,8 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
           delete headers["content-type"];
           const form = buildMultipartBody(req, uploads);
           const controller = new AbortController();
-          options.signal?.addEventListener("abort", () => controller.abort(), { once: true });
+          const onExternalAbort = () => controller.abort();
+          options.signal?.addEventListener("abort", onExternalAbort, { once: true });
           this.config.onRequest(req);
           let response;
           try {
@@ -9756,6 +9920,8 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
             const clientErr = new GraphQLClientError(err instanceof Error ? err.message : "Upload network error", "ENETWORK", void 0, req, void 0, err);
             this.config.onError(clientErr, req);
             throw clientErr;
+          } finally {
+            options.signal?.removeEventListener("abort", onExternalAbort);
           }
           const gqlRes = await parseGraphQLResponse(response, req);
           this.config.onResponse(gqlRes, req);
@@ -9786,7 +9952,8 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
         async batch(requests, options = {}) {
           const headers = await buildHeaders(this.config);
           const controller = new AbortController();
-          options.signal?.addEventListener("abort", () => controller.abort(), { once: true });
+          const onExternalAbort = () => controller.abort();
+          options.signal?.addEventListener("abort", onExternalAbort, { once: true });
           let response;
           try {
             response = await this.config.fetch(this.config.url, {
@@ -9797,8 +9964,10 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
             });
           } catch (err) {
             throw new GraphQLClientError(err instanceof Error ? err.message : "Batch network error", "ENETWORK", void 0, requests[0], void 0, err);
+          } finally {
+            options.signal?.removeEventListener("abort", onExternalAbort);
           }
-          const rawResults = await response.json();
+          const rawResults = sanitizeParsedJSON(await response.json());
           if (!Array.isArray(rawResults)) {
             throw new GraphQLClientError("Batch response must be an array of GraphQL responses", "EINVALIDRESPONSE", void 0, requests[0], rawResults);
           }
@@ -9886,7 +10055,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
               continue;
             let gqlRes;
             try {
-              gqlRes = JSON.parse(event.data);
+              gqlRes = sanitizeParsedJSON(JSON.parse(event.data));
             } catch {
               continue;
             }
@@ -10413,7 +10582,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
   }
   function deserializePaginationState(serialized) {
     try {
-      return JSON.parse(atob(serialized));
+      return sanitizeParsedJSON(JSON.parse(atob(serialized)));
     } catch {
       throw new Error("Invalid pagination state string");
     }
@@ -10460,6 +10629,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
   var init_pagination = __esm({
     "dist/esm/pagination.js"() {
       "use strict";
+      init_utils();
     }
   });
 
@@ -10768,6 +10938,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
     retryLink: () => retryLink,
     safeJSONParse: () => safeJSONParse,
     safeParseURL: () => safeParseURL,
+    sanitizeParsedJSON: () => sanitizeParsedJSON,
     sanitizeURL: () => sanitizeURL,
     securityHeaders: () => securityHeaders,
     sendWithTimeout: () => sendWithTimeout,
@@ -10936,11 +11107,12 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
           controller.error(new DOMException("Upload aborted", "AbortError"));
           return;
         }
-        options.signal?.addEventListener("abort", () => {
+        const onUploadAbort = () => {
           reader.cancel("aborted").catch(() => {
           });
           controller.error(new DOMException("Upload aborted", "AbortError"));
-        }, { once: true });
+        };
+        options.signal?.addEventListener("abort", onUploadAbort, { once: true });
         try {
           while (true) {
             const { done, value } = await reader.read();
@@ -10955,6 +11127,8 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
         } catch (err) {
           tracker.complete();
           controller.error(err);
+        } finally {
+          options.signal?.removeEventListener("abort", onUploadAbort);
         }
       }
     });
@@ -11045,11 +11219,11 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
       });
       throw new DOMException("Stream aborted", "AbortError");
     }
+    const abortHandler = () => {
+      reader.cancel("aborted").catch(() => {
+      });
+    };
     if (options.signal) {
-      const abortHandler = () => {
-        reader.cancel("aborted").catch(() => {
-        });
-      };
       options.signal.addEventListener("abort", abortHandler, { once: true });
     }
     try {
@@ -11062,6 +11236,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
       }
     } finally {
       reader.releaseLock();
+      options.signal?.removeEventListener("abort", abortHandler);
     }
     tracker.complete();
     const totalBytes = chunks.reduce((acc, c) => acc + c.byteLength, 0);
@@ -11782,6 +11957,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
   }
 
   // dist/esm/ws.js
+  init_utils();
   var WSError = class extends Error {
     /**
      * @param message - Human-readable error description
@@ -11874,6 +12050,10 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
       __publicField(this, "_openWaiters", []);
       __publicField(this, "_correlations", /* @__PURE__ */ new Map());
       __publicField(this, "_aborted", false);
+      /** Optional external abort signal from config (listener detached on close). */
+      __publicField(this, "_externalSignal", null);
+      /** Bound abort handler for the optional external `cfg.signal` (removed on close). */
+      __publicField(this, "_onExternalAbort", () => this.close(1e3, "AbortSignal aborted"));
       // ── Async iterator ──────────────────────────────────────────────────────
       __publicField(this, "_iterQueue", []);
       __publicField(this, "_iterWaiter", null);
@@ -11937,7 +12117,8 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
           this._rooms.push({ room: r, joinedAt: 0 });
         }
       }
-      cfg.signal?.addEventListener("abort", () => this.close(1e3, "AbortSignal aborted"), {
+      this._externalSignal = cfg.signal ?? null;
+      this._externalSignal?.addEventListener("abort", this._onExternalAbort, {
         once: true
       });
     }
@@ -12018,6 +12199,8 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
      */
     close(code = 1e3, reason = "Client closed") {
       this._aborted = true;
+      this._externalSignal?.removeEventListener("abort", this._onExternalAbort);
+      this._externalSignal = null;
       this._stopAll();
       for (const w of this._drainWaiters.splice(0))
         w();
@@ -12452,7 +12635,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
             data = evt.data;
             bytes = new TextEncoder().encode(data).byteLength;
             try {
-              json = JSON.parse(data);
+              json = sanitizeParsedJSON(JSON.parse(data));
             } catch {
             }
           } else if (evt.data instanceof ArrayBuffer) {
@@ -13157,27 +13340,33 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
       }, ms);
       const existing = ctx.request.signal;
       if (existing) {
-        existing.addEventListener("abort", () => {
+        const onExistingAbort = () => {
           clearTimeout(timer);
           controller.abort(existing.reason);
-        }, { once: true });
+        };
+        existing.addEventListener("abort", onExistingAbort, { once: true });
+        ctx.store.set(TIMEOUT_SIGNAL_KEY, { existing, onExistingAbort });
       }
       ctx.request = { ...ctx.request, signal: controller.signal };
       ctx.store.set(TIMEOUT_TIMER_KEY, timer);
     };
-    const responseInterceptor = (ctx) => {
+    const cleanupTimeout = (ctx) => {
       const timer = ctx.store.get(TIMEOUT_TIMER_KEY);
       if (timer) {
         clearTimeout(timer);
         ctx.store.delete(TIMEOUT_TIMER_KEY);
       }
+      const merged = ctx.store.get(TIMEOUT_SIGNAL_KEY);
+      if (merged) {
+        merged.existing.removeEventListener("abort", merged.onExistingAbort);
+        ctx.store.delete(TIMEOUT_SIGNAL_KEY);
+      }
+    };
+    const responseInterceptor = (ctx) => {
+      cleanupTimeout(ctx);
     };
     const errorInterceptor = (ctx) => {
-      const timer = ctx.store.get(TIMEOUT_TIMER_KEY);
-      if (timer) {
-        clearTimeout(timer);
-        ctx.store.delete(TIMEOUT_TIMER_KEY);
-      }
+      cleanupTimeout(ctx);
     };
     return {
       id: "timeout",
@@ -13187,6 +13376,7 @@ ${text}`, "ENETWORK", void 0, req, void 0, new Error(`HTTP ${response.status}`))
     };
   }
   var TIMEOUT_TIMER_KEY = /* @__PURE__ */ Symbol("timeoutTimer");
+  var TIMEOUT_SIGNAL_KEY = /* @__PURE__ */ Symbol("timeoutSignal");
   var TimeoutError2 = class extends Error {
     constructor(message, timeoutMs) {
       super(message);
@@ -14868,6 +15058,34 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
   function randomHex(len) {
     return randomBytes(len / 2);
   }
+  var HAR_REDACT_HEADERS = /* @__PURE__ */ new Set([
+    "authorization",
+    "proxy-authorization",
+    "cookie",
+    "set-cookie",
+    "x-api-key",
+    "x-auth-token",
+    "x-access-token",
+    "x-refresh-token",
+    "x-csrf-token",
+    "x-session-id",
+    "x-session-token",
+    "x-secret",
+    "x-secret-key",
+    "x-private-key",
+    "api-key",
+    "apikey",
+    "bearer",
+    "token",
+    "authentication",
+    "credentials",
+    "password",
+    "passwd",
+    "secret"
+  ]);
+  function redactHARHeader(name, value) {
+    return HAR_REDACT_HEADERS.has(name.toLowerCase()) ? { name, value: "***REDACTED***" } : { name, value };
+  }
   var HARRecorder = class {
     /**
      * @param maxEntries - Maximum number of entries before eviction (default 10000).
@@ -14919,7 +15137,7 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
           method: req.method,
           url: req.url,
           httpVersion: res.httpVersion,
-          headers: Object.entries(req.headers).map(([name, value]) => ({ name, value })),
+          headers: Object.entries(req.headers).map(([name, value]) => redactHARHeader(name, value)),
           queryString: (() => {
             try {
               return Array.from(new URL(req.url).searchParams.entries()).map(([name, value]) => ({
@@ -14946,7 +15164,7 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
           status: res.status,
           statusText: res.statusText,
           httpVersion: res.httpVersion,
-          headers: Object.entries(res.headers).map(([name, value]) => ({ name, value })),
+          headers: Object.entries(res.headers).map(([name, value]) => redactHARHeader(name, value)),
           content: {
             size: res.rawBody?.byteLength ?? 0,
             mimeType: res.headers["content-type"] ?? "application/octet-stream",
@@ -14994,7 +15212,11 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
     switch (auth.type) {
       case "bearer": {
         const token = typeof auth.token === "function" ? await auth.token() : auth.token;
-        headers["authorization"] = `Bearer ${token}`;
+        const headerValue = `Bearer ${token}`;
+        if (!isValidHeaderValue(headerValue)) {
+          throw new KinetexError("Invalid bearer token \u2014 contains forbidden characters (CRLF/CTL)", "EVALIDATION");
+        }
+        headers["authorization"] = headerValue;
         break;
       }
       case "basic": {
@@ -15015,7 +15237,13 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
       }
       case "apikey": {
         const key = typeof auth.key === "function" ? await auth.key() : auth.key;
-        headers[auth.header.toLowerCase()] = key;
+        if (!isValidHeaderName(auth.header)) {
+          throw new KinetexError(`Invalid apikey auth header name: "${auth.header}"`, "EVALIDATION");
+        }
+        if (!isValidHeaderValue(String(key))) {
+          throw new KinetexError(`Invalid apikey value for "${auth.header}" \u2014 contains forbidden characters`, "EVALIDATION");
+        }
+        headers[auth.header.toLowerCase()] = String(key);
         break;
       }
       case "digest": {
@@ -15034,6 +15262,37 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
     }
     return { ...req, headers };
   }
+  var CROSS_ORIGIN_STRIP_HEADERS = /* @__PURE__ */ new Set([
+    "authorization",
+    "cookie",
+    "proxy-authorization",
+    "x-api-key",
+    "x-auth-token",
+    "x-access-token",
+    "x-refresh-token",
+    "x-csrf-token",
+    "x-session-id",
+    "x-session-token",
+    "x-secret",
+    "x-secret-key",
+    "x-private-key",
+    "api-key",
+    "apikey",
+    "www-authenticate"
+  ]);
+  function redactUserInfo(url) {
+    try {
+      const u = new URL(url);
+      if (u.username || u.password) {
+        u.username = "";
+        u.password = "";
+        return u.toString();
+      }
+      return url;
+    } catch {
+      return url.replace(/\/\/[^/@]*@/, "//");
+    }
+  }
   function buildURL(base, url, params) {
     const MAX_QUERY_PARAM_COUNT = 100;
     const MAX_URL_LENGTH = 8192;
@@ -15054,7 +15313,7 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
     }
     if (!params || Object.keys(params).length === 0) {
       if (!isSafeURL(full)) {
-        throw new KinetexError(`URL "${full}" failed safety check \u2014 blocked private/loopback address or forbidden scheme`, "EVALIDATION");
+        throw new KinetexError(`URL "${redactUserInfo(full)}" failed safety check \u2014 blocked private/loopback address or forbidden scheme`, "EVALIDATION");
       }
       return full;
     }
@@ -15088,7 +15347,7 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
         throw new KinetexError(`URL length ${result.length} bytes exceeds limit of ${MAX_URL_LENGTH} bytes`, "EVALIDATION");
       }
       if (!isSafeURL(result)) {
-        throw new KinetexError(`URL "${result}" failed safety check \u2014 blocked private/loopback address or forbidden scheme`, "EVALIDATION");
+        throw new KinetexError(`URL "${redactUserInfo(result)}" failed safety check \u2014 blocked private/loopback address or forbidden scheme`, "EVALIDATION");
       }
       return result;
     } catch (err) {
@@ -15126,6 +15385,9 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
       if (result.length > MAX_URL_LENGTH) {
         throw new KinetexError(`URL length ${result.length} bytes exceeds limit of ${MAX_URL_LENGTH} bytes`, "EVALIDATION");
       }
+      if (!isSafeURL(result)) {
+        throw new KinetexError(`URL "${redactUserInfo(result)}" failed safety check \u2014 blocked private/loopback address or forbidden scheme`, "EVALIDATION");
+      }
       return result;
     }
   }
@@ -15873,6 +16135,10 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
         throw new KinetexError(`Invalid HTTP method '${method}'. Valid methods: ${VALID_METHODS.join(", ")}`, "EVALIDATION");
       }
       const fullUrl = buildURL(options.baseURL ?? this.cfg.baseURL, url, mergeParams(this.cfg.params, options.params));
+      const proxy = options.proxy ?? this.cfg.proxy;
+      if (proxy) {
+        throw new KinetexError("proxy is configured but kinetex's built-in transports cannot route through it: HTTP(S) proxies require a custom fetch with a proxy agent (e.g. undici ProxyAgent passed via the `fetch` option), and SOCKS5 requires createSocks5Tunnel() from kinetex/socks5. Set up one of those instead of relying on `proxy` silently doing nothing.", "EVALIDATION");
+      }
       if (this.cfg.httpsOnly) {
         try {
           const parsedUrl = new URL(fullUrl);
@@ -15896,9 +16162,25 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
           bodySize2 = options.body.byteLength;
         } else if (options.body instanceof Blob) {
           bodySize2 = options.body.size;
+        } else if (ArrayBuffer.isView(options.body)) {
+          bodySize2 = options.body.byteLength;
+        } else if (options.body instanceof URLSearchParams) {
+          bodySize2 = new TextEncoder().encode(options.body.toString()).byteLength;
         } else if (options.body instanceof FormData) {
+          const boundaryOverhead = 76;
+          for (const [name, value] of options.body) {
+            bodySize2 += new TextEncoder().encode(name).byteLength + boundaryOverhead;
+            if (typeof value === "string") {
+              bodySize2 += new TextEncoder().encode(value).byteLength;
+            } else {
+              bodySize2 += value.size;
+            }
+          }
+          bodySize2 += boundaryOverhead;
+        } else if (options.body instanceof ReadableStream) {
+          throw new KinetexError(`maxRequestSize cannot be enforced for ReadableStream bodies \u2014 pass maxRequestSize: 0 to opt out, or buffer the body first`, "EVALIDATION");
         } else if (options.body && typeof options.body === "object") {
-          bodySize2 = JSON.stringify(options.body).length;
+          bodySize2 = new TextEncoder().encode(JSON.stringify(options.body)).byteLength;
         }
         if (bodySize2 > maxRequestSize) {
           throw new KinetexError(`Request body size ${bodySize2} bytes exceeds limit of ${maxRequestSize} bytes`, "EVALIDATION");
@@ -16078,10 +16360,26 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
     async _sendFollowingRedirects(req, timeout, jar, appliedAuth) {
       const MAX_REDIRECTS = 20;
       let currentReq = { ...req, redirect: "manual" };
+      const origin0 = (() => {
+        try {
+          return new URL(req.url).origin;
+        } catch {
+          return null;
+        }
+      })();
       const visited = /* @__PURE__ */ new Set();
       for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
         if (hop > 0 && appliedAuth) {
-          currentReq = await applyAuth(currentReq, appliedAuth);
+          const sameOrigin = (() => {
+            try {
+              return new URL(currentReq.url).origin === origin0;
+            } catch {
+              return false;
+            }
+          })();
+          if (sameOrigin) {
+            currentReq = await applyAuth(currentReq, appliedAuth);
+          }
         }
         if (hop > 0 && this.cfg.hooks?.onBeforeRequest) {
           for (const fn of this.cfg.hooks.onBeforeRequest) {
@@ -16153,6 +16451,14 @@ ${errors.map((e) => `  - ${e.message}`).join("\n")}`);
           } else {
             delete nextHeaders["cookie"];
           }
+          try {
+            if (new URL(nextUrl).origin !== new URL(currentReq.url).origin) {
+              for (const h of CROSS_ORIGIN_STRIP_HEADERS) {
+                delete nextHeaders[h];
+              }
+            }
+          } catch {
+          }
           currentReq = {
             ...currentReq,
             url: nextUrl,