@patchstack/connect 0.3.22 → 0.3.24

package/dist/protect.js

@@ -1,3 +1,30 @@
+import {
+  pulseAuthHeader
+} from "./chunk-MJOTFUDE.js";
+
+// src/protect/safe-origin.js
+function isSafeOrigin(value) {
+  try {
+    const u = new URL(value);
+    if (u.protocol === "https:") return true;
+    return u.protocol === "http:" && (u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]" || u.hostname === "::1");
+  } catch {
+    return false;
+  }
+}
+function safeBaseUrl(candidate, fallback, label) {
+  if (typeof candidate !== "string" || candidate === "") return fallback;
+  if (isSafeOrigin(candidate)) return candidate;
+  warnOnce(label, `[patchstack] ignoring unsafe ${label} override (${candidate}): must be https (or localhost). Using the default.`);
+  return fallback;
+}
+var warned = /* @__PURE__ */ new Set();
+function warnOnce(key, message) {
+  if (warned.has(key)) return;
+  warned.add(key);
+  console.warn(message);
+}
+
 // src/protect/engine/client.js
 var DEFAULT_BASE_URL = "https://api.patchstack.com";
 var DEFAULT_CACHE_TTL = 3e5;
@@ -10,9 +37,11 @@ var PatchstackRuleClient = class {
   #cacheTime = null;
   #ttlEffective = 0;
   #etag;
-  constructor({ token, baseUrl, cacheTtl, etag } = {}) {
+  #timeoutMs;
+  constructor({ token, baseUrl, cacheTtl, etag, timeoutMs } = {}) {
+    this.#timeoutMs = Number(timeoutMs) > 0 ? Number(timeoutMs) : 3e4;
     this.#token = token ?? process.env.PATCHSTACK_WAF_TOKEN;
-    this.#baseUrl = baseUrl ?? process.env.PATCHSTACK_WAF_API_URL ?? DEFAULT_BASE_URL;
+    this.#baseUrl = safeBaseUrl(baseUrl ?? process.env.PATCHSTACK_WAF_API_URL, DEFAULT_BASE_URL, "rule endpoint");
     this.#cacheTtl = Number.isFinite(cacheTtl) && cacheTtl > 0 ? cacheTtl : DEFAULT_CACHE_TTL;
     this.#etag = etag ?? null;
     if (!this.#token) {
@@ -37,7 +66,7 @@ var PatchstackRuleClient = class {
         method: "POST",
         headers,
         body: JSON.stringify({}),
-        signal: AbortSignal.timeout(3e4)
+        signal: AbortSignal.timeout(this.#timeoutMs)
       });
       if (response.status === 304) {
         this.#touch(now);
@@ -90,6 +119,9 @@ var PatchstackRuleClient = class {
 };
 
 // src/protect/engine/request.js
+var FILE_ATTRS = /* @__PURE__ */ new Set(["content", "filename", "type"]);
+var fileFilename = (f) => f && typeof f === "object" ? f.filename : f;
+var fileAttribute = (f, attr) => f && typeof f === "object" ? f[attr] : attr === "filename" ? f : void 0;
 function base64DecodeUtf8(value) {
   const str = String(value);
   if (typeof Buffer !== "undefined") {
@@ -293,7 +325,9 @@ var RequestResolver = class {
       default: {
         if (key.startsWith("HTTP_")) {
           const headerName = key.substring(5).toLowerCase().replace(/_/g, "-");
-          return req.headers?.[headerName] ? [req.headers[headerName]] : [];
+          const headers = req.headers;
+          if (headers === null || typeof headers !== "object") return [];
+          return Object.prototype.hasOwnProperty.call(headers, headerName) ? [headers[headerName]] : [];
         }
         return [];
       }
@@ -301,14 +335,32 @@ var RequestResolver = class {
   }
   #resolveFiles(key) {
     const files = this.#req.files;
-    if (!files) {
+    if (!files || typeof files !== "object") {
       return [];
     }
+    const dot = key.lastIndexOf(".");
+    if (dot !== -1 && FILE_ATTRS.has(key.slice(dot + 1)) && Object.prototype.hasOwnProperty.call(files, key.slice(0, dot))) {
+      const attr = key.slice(dot + 1);
+      const entry = files[key.slice(0, dot)];
+      const list = Array.isArray(entry) ? entry : [entry];
+      const out = [];
+      for (const f of list) {
+        const v = fileAttribute(f, attr);
+        if (v !== void 0 && v !== "") out.push(v);
+      }
+      return out;
+    }
+    const filenamesOf = (entry) => Array.isArray(entry) ? entry.map(fileFilename) : [fileFilename(entry)];
     if (key.endsWith("*")) {
-      return this.#resolveWildcard(files, key);
+      const prefix = key.slice(0, -1);
+      const out = [];
+      for (const [k, entry] of Object.entries(files)) {
+        if (k.startsWith(prefix)) out.push(...filenamesOf(entry));
+      }
+      return out.filter((v) => v !== void 0);
     }
-    const value = files[key];
-    return value !== void 0 ? [value] : [];
+    if (!Object.prototype.hasOwnProperty.call(files, key)) return [];
+    return filenamesOf(files[key]).filter((v) => v !== void 0);
   }
   #resolveRaw() {
     if (typeof this.#req._rawBody === "string") {
@@ -339,6 +391,9 @@ var RequestResolver = class {
     if (body) {
       parts.push(typeof body === "string" ? body : JSON.stringify(body));
     }
+    if (typeof this.#req._rawBody === "string" && this.#req._rawBody) {
+      parts.push(this.#req._rawBody);
+    }
     const headers = this.#req.headers ?? {};
     const excludedHeaders = /* @__PURE__ */ new Set([
       "host",
@@ -531,8 +586,6 @@ function removeSqlComments(value) {
   let result = value;
   result = result.replace(/\/\*[\s\S]*?\*\//g, " ");
   result = result.replace(/\/\*![\s\S]*?\*\//g, " ");
-  result = result.replace(/--[^\r\n]*/g, "");
-  result = result.replace(/#[^\r\n]*/g, "");
   return result;
 }
 function removeNullBytes(value) {
@@ -587,17 +640,21 @@ function normalizeRequest(req, options = {}) {
     _rawBody: rawBody
   };
 }
-function normalizeObject(value, options = {}) {
+var MAX_NORMALIZE_DEPTH = 200;
+function normalizeObject(value, options = {}, depth = 0) {
   if (typeof value === "string") {
     return normalize(value, options);
   }
+  if (depth >= MAX_NORMALIZE_DEPTH) {
+    return value;
+  }
   if (Array.isArray(value)) {
-    return value.map((item) => normalizeObject(item, options));
+    return value.map((item) => normalizeObject(item, options, depth + 1));
   }
   if (typeof value === "object" && value !== null) {
     const result = {};
     for (const [key, val] of Object.entries(value)) {
-      result[key] = normalizeObject(val, options);
+      result[key] = normalizeObject(val, options, depth + 1);
     }
     return result;
   }
@@ -605,14 +662,32 @@ function normalizeObject(value, options = {}) {
 }
 
 // src/protect/engine/engine.js
+var GRP = "(?:[^()]|\\([^()]*\\))*";
 var REDOS_PATTERNS = [
   /\([^)]*[+*}][^)]*\)\s*[+*]/,
-  /\([^)]*\|[^)]*\)\s*[+*]/
+  /\([^)]*\|[^)]*\)\s*[+*]/,
+  new RegExp("\\(" + GRP + "[+*}]" + GRP + "\\)\\s*[+*]"),
+  // nested quantified subgroup
+  new RegExp("\\(" + GRP + "\\|" + GRP + "\\)\\s*[+*]")
+  // nested alternation under a quantifier
 ];
+var warnedRejectedPatterns = /* @__PURE__ */ new Set();
+function warnRejectedPatternOnce(pattern) {
+  const key = String(pattern);
+  if (warnedRejectedPatterns.has(key)) return;
+  warnedRejectedPatterns.add(key);
+  console.warn(
+    `[patchstack] rule_v2 regex pattern rejected (unsafe or invalid) \u2014 condition treated as no-match. The rule relying on it is NOT enforced: ${key}`
+  );
+}
+var MAX_PATTERN_LENGTH = 1e3;
 function safeRegExp(pattern) {
   if (!pattern) {
     return null;
   }
+  if (typeof pattern !== "string" || pattern.length > MAX_PATTERN_LENGTH) {
+    return null;
+  }
   for (const dangerous of REDOS_PATTERNS) {
     if (dangerous.test(pattern)) {
       return null;
@@ -669,6 +744,34 @@ function arrayKeyValue(value, matchObj) {
   }
   return false;
 }
+var WHOLE_VALUE_MATCH_TYPES = /* @__PURE__ */ new Set(["isset", "array_in_array", "array_key_value"]);
+function collectLeafValues(root, nodeCap = 2e4, maxDepth = 1e3) {
+  const out = [];
+  const stack = [[root, 0]];
+  let visited = 0;
+  while (stack.length) {
+    const [node, depth] = stack.pop();
+    if (node === null || node === void 0) continue;
+    if (typeof node !== "object") {
+      out.push(node);
+      continue;
+    }
+    if (depth >= maxDepth || visited >= nodeCap) continue;
+    visited++;
+    if (Array.isArray(node)) {
+      for (let i = node.length - 1; i >= 0; i--) stack.push([node[i], depth + 1]);
+    } else {
+      for (const k of Object.keys(node)) stack.push([node[k], depth + 1]);
+    }
+  }
+  return out;
+}
+var warnedKeys = /* @__PURE__ */ new Set();
+function warnOnce2(key, message) {
+  if (warnedKeys.has(key)) return;
+  warnedKeys.add(key);
+  console.warn(message);
+}
 var warnedMatchTypes = /* @__PURE__ */ new Set();
 function warnUnsupportedMatchType(type) {
   if (type == null || warnedMatchTypes.has(type)) {
@@ -681,28 +784,93 @@ function warnUnsupportedMatchType(type) {
 }
 function isInternalHost(hostname) {
   if (!hostname) return false;
-  const host = String(hostname).toLowerCase().replace(/^\[|\]$/g, "");
+  let host = String(hostname).toLowerCase().replace(/^\[|\]$/g, "");
+  host = host.replace(/%[^\]]*$/, "");
+  host = host.replace(/\.$/, "");
   if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")) return true;
   if (host === "metadata.google.internal") return true;
-  if (host === "::1" || host === "::") return true;
-  if (host.startsWith("fe80:") || host.startsWith("fc") || host.startsWith("fd")) return true;
-  const v4 = host.match(/(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
-  if (v4 && isPrivateV4(Number(v4[1]), Number(v4[2]))) return true;
-  const mapped = host.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
-  if (mapped) {
-    const g1 = parseInt(mapped[1], 16);
-    const g2 = parseInt(mapped[2], 16);
-    if (isPrivateV4(g1 >> 8 & 255, g1 & 255)) return true;
+  if (host.includes(":")) {
+    const g = expandIPv6(host);
+    if (!g) return false;
+    const allZeroHi = g[0] === 0 && g[1] === 0 && g[2] === 0 && g[3] === 0 && g[4] === 0;
+    if (allZeroHi && g[5] === 0 && g[6] === 0 && (g[7] === 0 || g[7] === 1)) return true;
+    if ((g[0] & 65472) === 65152) return true;
+    if ((g[0] & 65024) === 64512) return true;
+    if (allZeroHi && (g[5] === 65535 || g[5] === 0)) {
+      return isPrivateV4Int((g[6] << 16 >>> 0 | g[7]) >>> 0);
+    }
+    return false;
   }
+  const v4 = parseIPv4ToInt(host);
+  if (v4 !== null) return isPrivateV4Int(v4);
   return false;
 }
-function isPrivateV4(a, b) {
+function isPrivateV4Int(n) {
+  const a = n >>> 24 & 255;
+  const b = n >>> 16 & 255;
   if (a === 127 || a === 10 || a === 0) return true;
   if (a === 169 && b === 254) return true;
   if (a === 172 && b >= 16 && b <= 31) return true;
   if (a === 192 && b === 168) return true;
+  if (a === 100 && b >= 64 && b <= 127) return true;
   return false;
 }
+function parseIPv4ToInt(host) {
+  if (!/^[0-9a-fx]+(\.[0-9a-fx]+)*$/i.test(host)) return null;
+  const parts = host.split(".");
+  if (parts.length > 4) return null;
+  const nums = [];
+  for (const p of parts) {
+    let n;
+    if (/^0x[0-9a-f]+$/i.test(p)) n = parseInt(p, 16);
+    else if (/^0[0-7]+$/.test(p)) n = parseInt(p, 8);
+    else if (/^[0-9]+$/.test(p)) n = parseInt(p, 10);
+    else return null;
+    if (!Number.isInteger(n) || n < 0) return null;
+    nums.push(n);
+  }
+  const last = nums.length - 1;
+  let value = 0;
+  for (let i = 0; i < last; i++) {
+    if (nums[i] > 255) return null;
+    value += nums[i] * 2 ** (8 * (3 - i));
+  }
+  const maxLast = 2 ** (8 * (5 - nums.length)) - 1;
+  if (nums[last] > maxLast) return null;
+  value += nums[last];
+  if (value < 0 || value > 4294967295) return null;
+  return value >>> 0;
+}
+function expandIPv6(host) {
+  if (!host.includes(":")) return null;
+  let s = host;
+  const lastColon = s.lastIndexOf(":");
+  const tail = s.slice(lastColon + 1);
+  if (tail.includes(".")) {
+    const v4 = parseIPv4ToInt(tail);
+    if (v4 === null) return null;
+    s = s.slice(0, lastColon + 1) + (v4 >>> 16 & 65535).toString(16) + ":" + (v4 & 65535).toString(16);
+  }
+  const halves = s.split("::");
+  if (halves.length > 2) return null;
+  const head = halves[0] ? halves[0].split(":") : [];
+  const back = halves.length === 2 ? halves[1] ? halves[1].split(":") : [] : null;
+  let groups;
+  if (back === null) {
+    groups = head;
+  } else {
+    const fill = 8 - head.length - back.length;
+    if (fill < 0) return null;
+    groups = [...head, ...Array(fill).fill("0"), ...back];
+  }
+  if (groups.length !== 8) return null;
+  const out = [];
+  for (const g of groups) {
+    if (!/^[0-9a-f]{1,4}$/i.test(g)) return null;
+    out.push(parseInt(g, 16));
+  }
+  return out;
+}
 function ruleAppliesTo(when, resolver) {
   try {
     if (when.method) {
@@ -730,14 +898,22 @@ function pathMatches(pattern, path) {
   }
   return path === pattern;
 }
+function normalizeDefaultPort(host) {
+  return String(host).toLowerCase().replace(/:(?:80|443)$/, "");
+}
 function isCrossOrigin(resolver) {
   try {
-    const host = String(resolver.resolve("server.HTTP_HOST")[0] ?? "").toLowerCase();
+    const host = normalizeDefaultPort(String(resolver.resolve("server.HTTP_HOST")[0] ?? ""));
     if (!host) return false;
-    const src = resolver.resolve("server.HTTP_ORIGIN")[0] ?? resolver.resolve("server.HTTP_REFERER")[0];
-    if (!src) return false;
-    const srcHost = hostFromUrl(String(src));
-    return srcHost !== null && srcHost !== host;
+    const originRaw = resolver.resolve("server.HTTP_ORIGIN")[0];
+    const hasOrigin = originRaw !== void 0 && originRaw !== null;
+    const src = hasOrigin ? originRaw : resolver.resolve("server.HTTP_REFERER")[0];
+    if (src === void 0 || src === null) return false;
+    const s = String(src).trim();
+    if (hasOrigin && (s === "" || s.toLowerCase() === "null")) return true;
+    const srcHost = hostFromUrl(s);
+    if (srcHost === null) return hasOrigin;
+    return normalizeDefaultPort(srcHost) !== host;
   } catch {
     return false;
   }
@@ -749,6 +925,41 @@ function hostFromUrl(value) {
     return null;
   }
 }
+function isOffOriginRedirect(resolver) {
+  try {
+    const status = Number(resolver.resolve("response.status")[0] ?? 0);
+    if (status < 300 || status >= 400) return false;
+    const location = resolver.resolve("response.header.location")[0];
+    if (!location) return false;
+    const host = String(resolver.resolve("server.HTTP_HOST")[0] ?? "").toLowerCase();
+    if (!host) return false;
+    const loc = String(location).replace(/[\t\r\n]/g, "").replace(/\\/g, "/");
+    let target;
+    try {
+      target = new URL(loc, "http://" + host).host.toLowerCase();
+    } catch {
+      return false;
+    }
+    return normalizeDefaultPort(target) !== normalizeDefaultPort(host);
+  } catch {
+    return false;
+  }
+}
+function isReflectedCorsWithCredentials(resolver) {
+  try {
+    const acac = String(resolver.resolve("response.header.access-control-allow-credentials")[0] ?? "").toLowerCase();
+    if (acac !== "true") return false;
+    const acao = String(resolver.resolve("response.header.access-control-allow-origin")[0] ?? "");
+    if (!acao) return false;
+    if (acao === "*") return true;
+    if (acao.toLowerCase() === "null") return true;
+    const origin = String(resolver.resolve("server.HTTP_ORIGIN")[0] ?? "");
+    if (!origin) return false;
+    return acao === origin;
+  } catch {
+    return false;
+  }
+}
 function matchValue(type, value, matchVal, matchObj) {
   if (value === null || value === void 0) {
     if (type === "isset") {
@@ -756,7 +967,16 @@ function matchValue(type, value, matchVal, matchObj) {
     }
     return false;
   }
-  const strValue = typeof value === "string" ? value : String(value);
+  let strValue;
+  if (typeof value === "string") {
+    strValue = value;
+  } else {
+    try {
+      strValue = String(value);
+    } catch {
+      strValue = "";
+    }
+  }
   switch (type) {
     case "equals":
       return strValue == matchVal;
@@ -777,6 +997,7 @@ function matchValue(type, value, matchVal, matchObj) {
     case "regex": {
       const regex = safeRegExp(matchVal);
       if (!regex) {
+        warnRejectedPatternOnce(matchVal);
         return false;
       }
       return regex.test(strValue);
@@ -855,6 +1076,15 @@ var RuleEngine = class {
     this.#whitelists = whitelists;
     this.#whitelistKeys = whitelist_keys;
     this.#onError = onError;
+    if (Array.isArray(whitelists) && whitelists.some((w) => w && Array.isArray(w.rule_v2) && !w.rule_id)) {
+      warnOnce2(
+        "whitelist-no-rule-id",
+        "[patchstack] a whitelist has no `rule_id` \u2014 it suppresses ALL rules when it matches. Scope each whitelist to a specific rule_id, and key it only on values an attacker cannot set."
+      );
+    }
+    if (whitelist_keys && typeof whitelist_keys === "object" && Object.keys(whitelist_keys).length > 0) {
+      warnOnce2("whitelist-keys-unimplemented", "[patchstack] `whitelist_keys` is not implemented and has no effect.");
+    }
   }
   // A mitigation engine must never take down the app it protects: any error while
   // evaluating a rule is reported and the request is allowed through (fail open). A
@@ -935,6 +1165,12 @@ var RuleEngine = class {
     if (match && match.type === "cross_origin") {
       return isCrossOrigin(resolver);
     }
+    if (match && match.type === "off_origin") {
+      return isOffOriginRedirect(resolver);
+    }
+    if (match && match.type === "cors_reflected") {
+      return isReflectedCorsWithCredentials(resolver);
+    }
     const params = Array.isArray(parameter) ? parameter : [parameter];
     const values = params.flatMap((p) => resolver.resolve(p));
     if (values.length === 0) {
@@ -950,10 +1186,12 @@ var RuleEngine = class {
         }
         continue;
       }
-      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        for (const v of Object.values(value)) {
-          if (matchValue(match.type, v, match.value, match)) {
-            return true;
+      if (typeof value === "object" && value !== null) {
+        if (WHOLE_VALUE_MATCH_TYPES.has(match.type)) {
+          if (matchValue(match.type, value, match.value, match)) return true;
+        } else {
+          for (const leaf of collectLeafValues(value)) {
+            if (matchValue(match.type, leaf, match.value, match)) return true;
           }
         }
         continue;
@@ -990,17 +1228,21 @@ var DEFAULT_CACHE_TTL2 = 3e5;
 var JITTER_FRACTION2 = 0.1;
 var PulseRuleClient = class {
   #siteUuid;
+  #timeoutMs;
   #baseUrl;
   #cacheTtl;
   #cache = null;
   #cacheTime = null;
   #ttlEffective = 0;
   #etag;
-  constructor({ siteUuid, baseUrl, cacheTtl, etag } = {}) {
+  #pulseAuth;
+  constructor({ siteUuid, baseUrl, cacheTtl, etag, timeoutMs, pulseAuth } = {}) {
+    this.#timeoutMs = Number(timeoutMs) > 0 ? Number(timeoutMs) : 3e4;
     this.#siteUuid = siteUuid ?? process.env.PATCHSTACK_SITE_UUID;
-    this.#baseUrl = baseUrl ?? process.env.PATCHSTACK_PULSE_RULES_URL ?? DEFAULT_BASE_URL2;
+    this.#baseUrl = safeBaseUrl(baseUrl ?? process.env.PATCHSTACK_PULSE_RULES_URL, DEFAULT_BASE_URL2, "rule endpoint");
     this.#cacheTtl = Number.isFinite(cacheTtl) && cacheTtl > 0 ? cacheTtl : DEFAULT_CACHE_TTL2;
     this.#etag = etag ?? null;
+    this.#pulseAuth = pulseAuth ?? null;
     if (!this.#siteUuid) {
       throw new Error("Patchstack site UUID is required. Pass { siteUuid } or set PATCHSTACK_SITE_UUID.");
     }
@@ -1012,9 +1254,15 @@ var PulseRuleClient = class {
     }
     const url = `${this.#baseUrl}/rules/${encodeURIComponent(this.#siteUuid)}`;
     try {
-      const headers = { Accept: "application/json" };
+      const headers = {
+        Accept: "application/json",
+        ...await pulseAuthHeader(
+          { pulseAuth: this.#pulseAuth, endpoint: this.#baseUrl, timeoutMs: this.#timeoutMs },
+          fetch
+        )
+      };
       if (this.#etag) headers["If-None-Match"] = this.#etag;
-      const response = await fetch(url, { method: "GET", headers, signal: AbortSignal.timeout(3e4) });
+      const response = await fetch(url, { method: "GET", headers, signal: AbortSignal.timeout(this.#timeoutMs) });
       if (response.status === 304) {
         this.#touch(now);
         return this.#cache ?? { success: true, notModified: true, etag: this.#etag, firewall: [], whitelists: [], whitelist_keys: {} };
@@ -1091,25 +1339,9 @@ async function fromFetchRequest(request, options = {}) {
   let body = {};
   let files;
   if (rawBody) {
-    if (contentType.includes("application/json")) {
-      try {
-        body = JSON.parse(rawBody);
-      } catch {
-        body = {};
-      }
-    } else if (contentType.includes("application/x-www-form-urlencoded")) {
-      body = {};
-      for (const [k, v] of new URLSearchParams(rawBody)) {
-        body[k] = k in body ? [].concat(body[k], v) : v;
-      }
-    } else if (contentType.includes("multipart/form-data")) {
-      const boundary = /boundary=("?)([^";]+)\1/i.exec(contentType)?.[2];
-      if (boundary) {
-        const parsed = parseMultipart(rawBody, boundary);
-        body = parsed.body;
-        files = parsed.files;
-      }
-    }
+    const parsed = parseBody(rawBody, contentType);
+    body = parsed.body;
+    files = parsed.files;
   }
   const uri = url.pathname + url.search;
   const forwarded = headers["cf-connecting-ip"] || headers["x-forwarded-for"] || headers["x-real-ip"] || "";
@@ -1129,9 +1361,6 @@ async function fromFetchRequest(request, options = {}) {
   };
 }
 async function readCappedText(request, max) {
-  const ceiling = Math.max(max, max * 4);
-  const declared = Number(request.headers?.get?.("content-length") || 0);
-  if (declared && declared > ceiling) return "";
   let clone;
   try {
     clone = request.clone();
@@ -1177,6 +1406,31 @@ function concatChunks(chunks, total) {
   }
   return out;
 }
+function parseBody(rawBody, contentType) {
+  const ct = String(contentType || "").toLowerCase();
+  const isJson = ct.includes("application/json") || /\+json\b/.test(ct);
+  const isForm = ct.includes("application/x-www-form-urlencoded");
+  const isMultipart = ct.includes("multipart/form-data");
+  const isAmbiguous = ct === "" || ct.startsWith("text/plain") || ct.includes("csp-report") || ct.includes("/json");
+  if (isMultipart) {
+    const boundary = /boundary=("?)([^";]+)\1/i.exec(contentType)?.[2];
+    if (boundary) return parseMultipart(rawBody, boundary);
+    return { body: {}, files: void 0 };
+  }
+  if (isForm) {
+    const body = {};
+    for (const [k, v] of new URLSearchParams(rawBody)) body[k] = k in body ? [].concat(body[k], v) : v;
+    return { body, files: void 0 };
+  }
+  if (isJson || isAmbiguous) {
+    try {
+      const parsed = JSON.parse(rawBody);
+      if (parsed && typeof parsed === "object") return { body: parsed, files: void 0 };
+    } catch {
+    }
+  }
+  return { body: {}, files: void 0 };
+}
 function parseMultipart(rawBody, boundary) {
   const body = {};
   const files = {};
@@ -1191,7 +1445,9 @@ function parseMultipart(rawBody, boundary) {
     const content = part.slice(sep.index + sep[0].length).replace(/\r?\n$/, "");
     const filename = /filename="([^"]*)"/i.exec(disposition)?.[1];
     if (filename !== void 0) {
-      files[name] = name in files ? [].concat(files[name], filename) : filename;
+      const partType = /content-type:\s*([^\r\n;]+)/i.exec(rawHeaders)?.[1]?.trim() || "";
+      const file = { filename, type: partType, content };
+      files[name] = name in files ? [].concat(files[name], file) : file;
     } else {
       body[name] = name in body ? [].concat(body[name], content) : content;
     }
@@ -1243,25 +1499,9 @@ function fromNodeRequest(req, rawBody = "") {
   let body = {};
   let files;
   if (rawBody) {
-    if (contentType.includes("application/json")) {
-      try {
-        body = JSON.parse(rawBody);
-      } catch {
-        body = {};
-      }
-    } else if (contentType.includes("application/x-www-form-urlencoded")) {
-      body = {};
-      for (const [k, v] of new URLSearchParams(rawBody)) {
-        body[k] = k in body ? [].concat(body[k], v) : v;
-      }
-    } else if (contentType.includes("multipart/form-data")) {
-      const boundary = /boundary=("?)([^";]+)\1/i.exec(contentType)?.[2];
-      if (boundary) {
-        const parsed = parseMultipart(rawBody, boundary);
-        body = parsed.body;
-        files = parsed.files;
-      }
-    }
+    const parsed = parseBody(rawBody, contentType);
+    body = parsed.body;
+    files = parsed.files;
   }
   const uri = url.pathname + url.search;
   const forwarded = headers["cf-connecting-ip"] || headers["x-forwarded-for"] || headers["x-real-ip"] || "";
@@ -1295,7 +1535,7 @@ function parseCookies2(header) {
 }
 
 // src/protect/egress.js
-async function installEgressGuard({ shouldBlock, onBlock, dnsScreen = true, lookup, allowHosts } = {}) {
+async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = true, lookup, allowHosts } = {}) {
   const restores = [];
   if (typeof shouldBlock !== "function") return () => {
   };
@@ -1317,11 +1557,24 @@ async function installEgressGuard({ shouldBlock, onBlock, dnsScreen = true, look
       screen = null;
     }
   }
+  const skip = (reason, detail) => {
+    try {
+      onSkip?.({ phase: "egress", reason, detail });
+    } catch {
+    }
+  };
   const resolvesToDisallowed = (url, host, method) => new Promise((resolve) => {
-    if (!screen || !host || screen.isIP(host) !== 0 || screen.isExempt(host)) return resolve(false);
+    if (!screen) {
+      if (host && dnsScreen) skip("resolver-unavailable", { host });
+      return resolve(false);
+    }
+    if (!host || screen.isIP(host) !== 0 || screen.isExempt(host)) return resolve(false);
     try {
       screen.lookup(host, { all: true }, (err, addresses) => {
-        if (err || !Array.isArray(addresses)) return resolve(false);
+        if (err || !Array.isArray(addresses)) {
+          skip("resolver-failed", { host });
+          return resolve(false);
+        }
         for (const a of addresses) {
           const ip = a && typeof a === "object" ? a.address : a;
           if (ip && block(url, ip, method)) return resolve(true);
@@ -1329,24 +1582,61 @@ async function installEgressGuard({ shouldBlock, onBlock, dnsScreen = true, look
         resolve(false);
       });
     } catch {
+      skip("resolver-failed", { host });
       resolve(false);
     }
   });
   const originalFetch = globalThis.fetch;
   if (typeof originalFetch === "function" && !originalFetch.__patchstackGuarded) {
-    const guarded = async (input, init) => {
-      const url = typeof input === "string" ? input : input && input.url || String(input);
+    const REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+    const MAX_REDIRECTS = 20;
+    const screenUrl = async (u, method) => {
       let host = null;
       try {
-        host = new URL(url).hostname;
+        host = new URL(u).hostname;
       } catch {
         host = null;
       }
-      const method = init && init.method || input && input.method || "GET";
-      if (block(url, host, method) || await resolvesToDisallowed(url, host, method)) {
-        throw new Error(`Patchstack blocked an outbound request to a disallowed address: ${host ?? url}`);
+      if (block(u, host, method) || await resolvesToDisallowed(u, host, method)) {
+        throw new Error(`Patchstack blocked an outbound request to a disallowed address: ${host ?? u}`);
+      }
+    };
+    const guarded = async (input, init) => {
+      let cur;
+      try {
+        cur = new Request(input, { ...init || {}, redirect: "manual" });
+      } catch {
+        return originalFetch(input, init);
+      }
+      const callerRedirect = init && init.redirect || input && input.redirect || "follow";
+      let url = cur.url;
+      let method = cur.method;
+      await screenUrl(url, method);
+      if (callerRedirect !== "follow") return originalFetch(input, init);
+      const headers = new Headers(cur.headers);
+      const signal = cur.signal;
+      let body = method === "GET" || method === "HEAD" ? void 0 : await cur.clone().arrayBuffer();
+      for (let hop = 0; ; hop++) {
+        const resp = await originalFetch(
+          hop === 0 ? cur : new Request(url, { method, headers, body, redirect: "manual", signal })
+        );
+        const location = REDIRECT_STATUSES.has(resp.status) ? resp.headers.get("location") : null;
+        if (!location) return resp;
+        if (hop >= MAX_REDIRECTS) throw new Error("Patchstack blocked an outbound request: too many redirects");
+        const next = new URL(location, url).href;
+        if (resp.status === 303 || (resp.status === 301 || resp.status === 302) && method === "POST") {
+          method = "GET";
+          body = void 0;
+          headers.delete("content-type");
+          headers.delete("content-length");
+        }
+        if (new URL(next).origin !== new URL(url).origin) {
+          headers.delete("authorization");
+          headers.delete("cookie");
+        }
+        await screenUrl(next, method);
+        url = next;
       }
-      return originalFetch(input, init);
     };
     guarded.__patchstackGuarded = true;
     globalThis.fetch = guarded;
@@ -1362,30 +1652,6 @@ async function installEgressGuard({ shouldBlock, onBlock, dnsScreen = true, look
     } catch {
     }
   }
-  const OriginalWS = globalThis.WebSocket;
-  if (typeof OriginalWS === "function" && !OriginalWS.__patchstackGuarded) {
-    const GuardedWS = new Proxy(OriginalWS, {
-      construct(target, args, newTarget) {
-        const url = String(args?.[0] ?? "");
-        let host = null;
-        try {
-          host = new URL(url).hostname;
-        } catch {
-          host = null;
-        }
-        if (block(url, host, "WEBSOCKET")) {
-          throw new Error(`Patchstack blocked an outbound WebSocket to a disallowed address: ${host ?? url}`);
-        }
-        return Reflect.construct(target, args, newTarget);
-      }
-    });
-    OriginalWS.__patchstackGuarded = true;
-    globalThis.WebSocket = GuardedWS;
-    restores.push(() => {
-      if (globalThis.WebSocket === GuardedWS) globalThis.WebSocket = OriginalWS;
-      delete OriginalWS.__patchstackGuarded;
-    });
-  }
   return () => {
     for (const restore of restores) {
       try {
@@ -1516,6 +1782,7 @@ var DEFAULT_RESPONSE_RULES = [
     phase: "response",
     category: "secret-exposure",
     action: "redact",
+    prefilter: ["PRIVATE KEY"],
     rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/" } }]
   },
   {
@@ -1524,6 +1791,7 @@ var DEFAULT_RESPONSE_RULES = [
     phase: "response",
     category: "secret-exposure",
     action: "redact",
+    prefilter: ["AKIA", "ASIA"],
     rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\b(?:AKIA|ASIA)[0-9A-Z]{16}\\b/" } }]
   },
   {
@@ -1532,14 +1800,29 @@ var DEFAULT_RESPONSE_RULES = [
     phase: "response",
     category: "secret-exposure",
     action: "redact",
+    prefilter: ["AIza"],
     rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\bAIza[0-9A-Za-z_-]{35}\\b/" } }]
   },
+  {
+    id: "resp-vendor-api-key",
+    title: "Vendor API key / token in response body",
+    phase: "response",
+    category: "secret-exposure",
+    action: "redact",
+    // High-signal, prefix-anchored provider tokens that never legitimately appear in a response
+    // body: Stripe (sk_live_/rk_live_), GitHub (gh[opsu]_ / github_pat_), GitLab (glpat-),
+    // Slack (xox[baprs]-), Anthropic (sk-ant-), Google OAuth (ya29.), npm (npm_). Trailing
+    // (?![0-9A-Za-z]) instead of \\b since some tokens end in - / _ .
+    prefilter: ["sk_live_", "rk_live_", "ghp_", "gho_", "ghs_", "ghu_", "github_pat_", "glpat-", "xox", "sk-ant-", "ya29.", "npm_"],
+    rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\b(?:sk_live_[0-9A-Za-z]{16,}|rk_live_[0-9A-Za-z]{16,}|gh[opsu]_[0-9A-Za-z]{36}|github_pat_[0-9A-Za-z_]{60,}|glpat-[0-9A-Za-z_-]{20,}|xox[baprs]-[0-9A-Za-z-]{10,}|sk-ant-[0-9A-Za-z_-]{20,}|ya29\\.[0-9A-Za-z_-]{20,}|npm_[0-9A-Za-z]{36})(?![0-9A-Za-z])/" } }]
+  },
   {
     id: "resp-jwt",
     title: "JWT in response body",
     phase: "response",
     category: "secret-exposure",
     action: "redact",
+    prefilter: ["eyJ"],
     rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\beyJ[A-Za-z0-9_-]{8,}\\.eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\b/" } }]
   },
   {
@@ -1548,6 +1831,7 @@ var DEFAULT_RESPONSE_RULES = [
     phase: "response",
     category: "secret-exposure",
     action: "redact",
+    prefilter: ["mongodb", "postgres", "mysql", "redis", "amqp"],
     rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\b(?:mongodb(?:\\+srv)?|postgres(?:ql)?|mysql|redis|amqps?):\\/\\/[^\\s:@\\/]+:[^\\s:@\\/]+@/i" } }]
   },
   {
@@ -1556,6 +1840,8 @@ var DEFAULT_RESPONSE_RULES = [
     phase: "response",
     category: "info-exposure",
     action: "redact",
+    // No prefilter: a Node stack frame has no single distinctive literal (` at ` is too common to
+    // gate on). The pattern is linearly bounded per line, so it runs on every screened body.
     rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/\\n\\s+at\\s+.+\\(.+:\\d+:\\d+\\)/" } }]
   },
   {
@@ -1564,6 +1850,7 @@ var DEFAULT_RESPONSE_RULES = [
     phase: "response",
     category: "info-exposure",
     action: "redact",
+    prefilter: ["SQLSTATE", "Sequelize", "ER_", "ORA-", "PG::", "SQLITE_ERROR", "SQL syntax"],
     rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/(SQLSTATE\\[[0-9A-Z]+\\]|SequelizeDatabaseError|ER_[A-Z_]+|ORA-\\d{5}|PG::[A-Za-z]+Error|SQLITE_ERROR|You have an error in your SQL syntax)/i" } }]
   },
   {
@@ -1575,6 +1862,7 @@ var DEFAULT_RESPONSE_RULES = [
     // Multi-language exception/traceback signatures a normal API response never carries:
     // Python traceback, Java "Exception in thread", .NET System.*Exception, JVM stack frames,
     // Go goroutine dumps. (Node `at fn (file:line:col)` frames are handled by resp-stack-trace.)
+    prefilter: ["Traceback", "Exception in thread", "System.", "goroutine ", ".java:", ".kt:", ".scala:", ".rb:", ".py:", ".cs:"],
     rule_v2: [{ parameter: "response.body", match: { type: "regex", value: '/(Traceback \\(most recent call last\\)|Exception in thread "|System\\.[A-Za-z.]+Exception|\\bat [\\w.$]+\\([\\w]+\\.(?:java|kt|scala|rb|py|cs):\\d+\\)|goroutine \\d+ \\[)/' } }]
   }
 ];
@@ -1672,8 +1960,22 @@ function renderBlockPage({ url = "", code = "patchstack" } = {}) {
 }
 
 // src/protect/rules/store.js
-import { readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join } from "path";
+var fsMod;
+async function loadFs() {
+  if (fsMod !== void 0) return fsMod;
+  try {
+    const [fs, path] = await Promise.all([import("fs"), import("path")]);
+    fsMod = {
+      readFileSync: fs.readFileSync,
+      writeFileSync: fs.writeFileSync,
+      mkdirSync: fs.mkdirSync,
+      join: path.join
+    };
+  } catch {
+    fsMod = null;
+  }
+  return fsMod;
+}
 function makeStore(options = {}) {
   let mem = null;
   const durable = durableTier(options);
@@ -1715,21 +2017,22 @@ function durableTier(options) {
     write: async (env) => cacheWrite(dir, env)
   };
 }
-function cachePath(dir) {
-  return join(dir, "patchstack-rules.json");
-}
-function cacheWrite(dir, env) {
+async function cacheWrite(dir, env) {
   if (!dir) return;
+  const fs = await loadFs();
+  if (!fs) return;
   try {
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(cachePath(dir), JSON.stringify(env));
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(fs.join(dir, "patchstack-rules.json"), JSON.stringify(env));
   } catch {
   }
 }
-function cacheRead(dir) {
+async function cacheRead(dir) {
   if (!dir) return null;
+  const fs = await loadFs();
+  if (!fs) return null;
   try {
-    return toEnvelope(JSON.parse(readFileSync(cachePath(dir), "utf8")));
+    return toEnvelope(JSON.parse(fs.readFileSync(fs.join(dir, "patchstack-rules.json"), "utf8")));
   } catch {
     return null;
   }
@@ -1745,56 +2048,204 @@ function toEnvelope(value) {
   return null;
 }
 
+// src/protect/rules/validate.js
+var LIMITS = {
+  maxRules: 5e3,
+  maxWhitelists: 2e3,
+  maxConditionsPerRule: 250,
+  maxNestingDepth: 12,
+  maxRegexLength: 1e3,
+  maxValueLength: 8192
+};
+var PHASES = /* @__PURE__ */ new Set(["request", "response", "egress"]);
+var ACTIONS = /* @__PURE__ */ new Set(["block", "redact", "encode", "set-header", "remove-header", "harden-cookie"]);
+function validateBundle(bundle, opts = {}) {
+  const rejected = [];
+  const inFirewall = Array.isArray(bundle?.firewall) ? bundle.firewall : [];
+  const inWhitelists = Array.isArray(bundle?.whitelists) ? bundle.whitelists : [];
+  const firewall = [];
+  for (const rule of inFirewall) {
+    if (firewall.length >= LIMITS.maxRules) {
+      rejected.push({ id: idOf(rule), reason: `bundle exceeds maxRules (${LIMITS.maxRules})` });
+      continue;
+    }
+    const reason = ruleProblem(rule);
+    if (reason) rejected.push({ id: idOf(rule), reason });
+    else firewall.push(rule);
+  }
+  const whitelists = [];
+  for (const wl of inWhitelists) {
+    if (whitelists.length >= LIMITS.maxWhitelists) {
+      rejected.push({ id: idOf(wl), reason: `bundle exceeds maxWhitelists (${LIMITS.maxWhitelists})` });
+      continue;
+    }
+    if (!opts.allowGlobalWhitelists && wl && Array.isArray(wl.rule_v2) && !wl.rule_id) {
+      rejected.push({ id: idOf(wl), reason: "whitelist has no rule_id (would suppress every rule); set allowGlobalWhitelists to permit" });
+      continue;
+    }
+    const reason = conditionsProblem(wl?.rule_v2);
+    if (reason) rejected.push({ id: idOf(wl), reason: `whitelist: ${reason}` });
+    else whitelists.push(wl);
+  }
+  return {
+    bundle: { ...bundle, firewall, whitelists },
+    rejected
+  };
+}
+function idOf(rule) {
+  const id = rule?.id ?? rule?.rule_id;
+  return id === void 0 || id === null ? "(unidentified)" : String(id);
+}
+function ruleProblem(rule) {
+  if (!rule || typeof rule !== "object") return "not an object";
+  if (rule.phase !== void 0 && !PHASES.has(rule.phase)) return `unknown phase "${rule.phase}"`;
+  if (rule.action !== void 0 && !ACTIONS.has(rule.action)) return `unknown action "${rule.action}"`;
+  const capOverride = rule.max_bytes;
+  if (capOverride !== void 0 && !(Number(capOverride) > 0)) return "max_bytes must be a positive number";
+  return conditionsProblem(rule.rule_v2);
+}
+function conditionsProblem(conditions, depth = 0) {
+  if (!Array.isArray(conditions)) return "rule_v2 must be an array of conditions";
+  if (conditions.length === 0) return "rule_v2 is empty (would never match)";
+  if (depth > LIMITS.maxNestingDepth) return `nesting deeper than ${LIMITS.maxNestingDepth}`;
+  if (conditions.length > LIMITS.maxConditionsPerRule) {
+    return `more than ${LIMITS.maxConditionsPerRule} conditions`;
+  }
+  for (const c of conditions) {
+    if (!c || typeof c !== "object") return "condition is not an object";
+    if (Array.isArray(c.rules)) {
+      const nested = conditionsProblem(c.rules, depth + 1);
+      if (nested) return nested;
+      continue;
+    }
+    const m = c.match;
+    if (!m || typeof m !== "object") return "condition has no match object";
+    if (typeof m.type !== "string" || m.type === "") return "match.type must be a non-empty string";
+    if (m.type === "regex") {
+      if (typeof m.value !== "string") return "regex match.value must be a string";
+      if (m.value.length > LIMITS.maxRegexLength) return `regex longer than ${LIMITS.maxRegexLength} chars`;
+    } else if (typeof m.value === "string" && m.value.length > LIMITS.maxValueLength) {
+      return `match.value longer than ${LIMITS.maxValueLength} chars`;
+    }
+    if (m.match) {
+      const nested = conditionsProblem([{ match: m.match }], depth + 1);
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
 // src/protect/rules/source.js
-async function resolveRules(options, store) {
+function liveUpdateRejections(res, options) {
+  if (options.acceptPartialBundle) return [];
+  const { rejected } = validateBundle(
+    { firewall: Array.isArray(res.firewall) ? res.firewall : [], whitelists: Array.isArray(res.whitelists) ? res.whitelists : [] },
+    { allowGlobalWhitelists: options.allowGlobalWhitelists }
+  );
+  return rejected;
+}
+function reportRejections(rejected, options, label) {
+  const report = options.onRuleRejected;
+  for (const r of rejected) {
+    if (typeof report === "function") {
+      try {
+        report({ ...r, accepted: false });
+      } catch {
+      }
+    }
+  }
+  const sample = rejected.slice(0, 3).map((r) => `${r.id} (${r.reason})`).join("; ");
+  options.onError?.(new Error(
+    `${label}: rejected the entire update because ${rejected.length} rule(s) failed validation \u2014 keeping the previous ruleset and NOT caching this response: ${sample}${rejected.length > 3 ? ", \u2026" : ""}`
+  ));
+}
+async function resolveRules(options, store, ctx = {}) {
+  const timeoutMs = ctx.timeoutMs;
   if (options.siteUuid) {
     const prior = await store.read();
-    const client = new PulseRuleClient({ siteUuid: options.siteUuid, baseUrl: options.pulseRulesUrl, etag: prior?.etag });
+    const client = new PulseRuleClient({ siteUuid: options.siteUuid, baseUrl: options.pulseRulesUrl, etag: prior?.etag, timeoutMs, pulseAuth: ctx.pulseAuth });
     const res = await client.getRules();
-    if (res.success && res.notModified && prior?.bundle) return normalizeBundle(prior.bundle);
+    if (res.success && res.notModified && prior?.bundle) return normalizeBundle(prior.bundle, options);
     if (res.success && !res.notModified) {
-      const bundle = normalizeBundle(res);
+      const rejected = liveUpdateRejections(res, options);
+      if (rejected.length > 0) {
+        reportRejections(rejected, options, "rule update rejected");
+        if (prior?.bundle) return normalizeBundle(prior.bundle, options);
+        if (options.rules) return normalizeBundle(options.rules, options);
+        return emptyBundle();
+      }
+      const bundle = normalizeBundle(res, options);
       await store.write({ bundle, etag: res.etag ?? null });
       return bundle;
     }
     if (prior?.bundle) {
       options.onError?.(new Error(`pulse rule fetch failed (${res.error ?? "no usable response"}); using cached bundle`));
-      return normalizeBundle(prior.bundle);
+      return normalizeBundle(prior.bundle, options);
     }
     if (options.rules) {
       options.onError?.(new Error(`pulse rule fetch failed (${res.error ?? "no usable response"}); using bundled fallback`));
-      return normalizeBundle(options.rules);
+      return normalizeBundle(options.rules, options);
     }
     options.onError?.(new Error(`pulse rule fetch failed (${res.error ?? "no usable response"}); no cache \u2014 running with no rules`));
     return emptyBundle();
   }
   if (options.token) {
     const prior = await store.read();
-    const client = new PatchstackRuleClient({ token: options.token, baseUrl: options.baseUrl, etag: prior?.etag });
+    const client = new PatchstackRuleClient({ token: options.token, baseUrl: options.baseUrl, etag: prior?.etag, timeoutMs });
     const res = await client.getRules();
-    if (res.success && res.notModified && prior?.bundle) return normalizeBundle(prior.bundle);
+    if (res.success && res.notModified && prior?.bundle) return normalizeBundle(prior.bundle, options);
     if (res.success && !res.notModified) {
-      const bundle = normalizeBundle(res);
+      const rejected = liveUpdateRejections(res, options);
+      if (rejected.length > 0) {
+        reportRejections(rejected, options, "rule update rejected");
+        if (prior?.bundle) return normalizeBundle(prior.bundle, options);
+        if (options.rules) return normalizeBundle(options.rules, options);
+        return emptyBundle();
+      }
+      const bundle = normalizeBundle(res, options);
       await store.write({ bundle, etag: res.etag ?? null });
       return bundle;
     }
     if (prior?.bundle) {
       options.onError?.(new Error(`rule fetch failed (${res.error ?? "no usable response"}); using cached bundle`));
-      return normalizeBundle(prior.bundle);
+      return normalizeBundle(prior.bundle, options);
     }
     options.onError?.(new Error(`rule fetch failed (${res.error ?? "no usable response"}); no cache \u2014 running with no rules`));
     return emptyBundle();
   }
   if (options.rules) {
-    return normalizeBundle(options.rules);
+    return normalizeBundle(options.rules, options);
   }
   return emptyBundle();
 }
-function normalizeBundle(b) {
+function normalizeBundle(b, options = {}) {
   const enforcement = b?.enforcement ?? b?.mode;
+  const { bundle: checked, rejected } = validateBundle(
+    {
+      firewall: Array.isArray(b.firewall) ? b.firewall : [],
+      whitelists: Array.isArray(b.whitelists) ? b.whitelists : []
+    },
+    { allowGlobalWhitelists: options.allowGlobalWhitelists }
+  );
+  if (rejected.length > 0) {
+    const report = options.onRuleRejected;
+    if (typeof report === "function") {
+      for (const r of rejected) {
+        try {
+          report(r);
+        } catch {
+        }
+      }
+    } else {
+      const sample = rejected.slice(0, 3).map((r) => `${r.id} (${r.reason})`).join("; ");
+      console.warn(
+        `[patchstack] ${rejected.length} delivered rule(s) rejected as invalid/oversized and are NOT enforced: ${sample}` + (rejected.length > 3 ? ", \u2026" : "")
+      );
+    }
+  }
   return {
-    firewall: Array.isArray(b.firewall) ? b.firewall : [],
-    whitelists: Array.isArray(b.whitelists) ? b.whitelists : [],
+    firewall: checked.firewall,
+    whitelists: checked.whitelists,
     whitelist_keys: b.whitelist_keys ?? {},
     ...enforcement === "block" || enforcement === "dry-run" ? { enforcement } : {}
   };
@@ -1857,6 +2308,169 @@ function makeRefreshHandler(tick, secret) {
   };
 }
 
+// src/protect/firewall-log.js
+var DEFAULT_API_BASE = "https://api.patchstack.com";
+var DEFAULT_FLUSH_MS = 1e3;
+var MAX_BATCH = 50;
+var TOKEN_SKEW_MS = 6e4;
+function parseApiKey(apiKey) {
+  if (typeof apiKey !== "string" || apiKey.length === 0) return null;
+  const idx = apiKey.lastIndexOf("-");
+  if (idx <= 0 || idx === apiKey.length - 1) return null;
+  const clientSecret = apiKey.slice(0, idx);
+  const clientId = apiKey.slice(idx + 1);
+  if (!/^\d+$/.test(clientId) || clientSecret.length === 0) return null;
+  return { clientId, clientSecret };
+}
+function resolveApiBase(pulseOrManifestUrl) {
+  const fromEnv = typeof process !== "undefined" ? process.env?.PATCHSTACK_API_BASE : void 0;
+  if (typeof fromEnv === "string" && fromEnv.length > 0) {
+    const candidate = fromEnv.replace(/\/$/, "");
+    if (isSafeOrigin(candidate)) return candidate;
+    console.warn(
+      "[patchstack] ignoring PATCHSTACK_API_BASE: block-log reporting requires an https origin (or localhost). Falling back to the default API origin."
+    );
+  }
+  if (typeof pulseOrManifestUrl === "string" && pulseOrManifestUrl.length > 0) {
+    try {
+      return new URL(pulseOrManifestUrl).origin;
+    } catch {
+    }
+  }
+  const endpoint = typeof process !== "undefined" ? process.env?.PATCHSTACK_ENDPOINT : void 0;
+  if (typeof endpoint === "string" && endpoint.length > 0) {
+    try {
+      return new URL(endpoint).origin;
+    } catch {
+    }
+  }
+  return DEFAULT_API_BASE;
+}
+function createFirewallLogReporter(opts) {
+  const creds = parseApiKey(opts.apiKey);
+  if (!creds) {
+    return { record() {
+    }, flush() {
+    }, stop() {
+    } };
+  }
+  const apiBase = (opts.apiBase ?? DEFAULT_API_BASE).replace(/\/$/, "");
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  const flushMs = Number.isFinite(opts.flushMs) ? opts.flushMs : DEFAULT_FLUSH_MS;
+  const sourceHost = typeof opts.sourceHost === "string" ? opts.sourceHost : "";
+  let queue = [];
+  let timer = null;
+  let stopped = false;
+  let cachedToken = null;
+  let tokenInflight = null;
+  const fetchAccessToken = async () => {
+    if (cachedToken && Date.now() < cachedToken.expiresAt - TOKEN_SKEW_MS) {
+      return cachedToken.token;
+    }
+    if (tokenInflight) return tokenInflight;
+    tokenInflight = (async () => {
+      try {
+        const res = await fetchImpl(`${apiBase}/oauth/token`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "User-Agent": "@patchstack/connect"
+          },
+          body: JSON.stringify({
+            grant_type: "client_credentials",
+            client_id: creds.clientId,
+            client_secret: creds.clientSecret
+          })
+        });
+        if (!res || !res.ok) return null;
+        const body = await res.json();
+        const token = body?.access_token;
+        if (typeof token !== "string" || token.length === 0) return null;
+        const expiresIn = Number(body?.expires_in);
+        const ttlMs = Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn * 1e3 : 36e5;
+        cachedToken = { token, expiresAt: Date.now() + ttlMs };
+        return token;
+      } catch {
+        return null;
+      } finally {
+        tokenInflight = null;
+      }
+    })();
+    return tokenInflight;
+  };
+  const flush = () => {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    if (queue.length === 0 || typeof fetchImpl !== "function") return;
+    const batch = queue.splice(0, MAX_BATCH);
+    void (async () => {
+      const token = await fetchAccessToken();
+      if (!token) return;
+      const body = new URLSearchParams();
+      body.set("type", "firewall");
+      body.set("logs", JSON.stringify(batch));
+      try {
+        const p = fetchImpl(`${apiBase}/api/logs/log`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json",
+            "Content-Type": "application/x-www-form-urlencoded",
+            "User-Agent": "@patchstack/connect",
+            ...sourceHost ? { "Source-Host": sourceHost } : {}
+          },
+          body
+        });
+        if (p && typeof p.then === "function") p.catch(() => {
+        });
+      } catch {
+      }
+    })();
+  };
+  return {
+    /**
+     * @param {{
+     *   rule?: { id?: string | number },
+     *   method?: string | null,
+     *   path?: string | null,
+     *   ip?: string | null,
+     *   userAgent?: string | null,
+     * }} event
+     */
+    record(event) {
+      if (stopped) return;
+      const fid = event?.rule?.id;
+      if (fid === void 0 || fid === null || fid === "") return;
+      queue.push({
+        fid,
+        method: event.method ?? null,
+        request_uri: event.path ?? null,
+        ip: event.ip ?? null,
+        user_agent: event.userAgent ?? null,
+        log_date: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      if (queue.length >= MAX_BATCH) {
+        flush();
+        return;
+      }
+      if (!timer) timer = setTimeout(flush, flushMs);
+    },
+    flush,
+    stop() {
+      stopped = true;
+      flush();
+    }
+  };
+}
+function telemetryEnabled() {
+  const v = typeof process !== "undefined" ? process.env?.PATCHSTACK_TELEMETRY : void 0;
+  if (v === void 0 || v === "") return true;
+  return !/^(0|false|off|no)$/i.test(String(v));
+}
+
 // src/protect/supabase-guard.js
 var GUARD_PATH = "/_patchstack/guard";
 var HOP_BY_HOP = /* @__PURE__ */ new Set(["content-encoding", "content-length", "transfer-encoding", "connection"]);
@@ -1929,9 +2543,30 @@ function createServerFnGuard({ protection }) {
 }
 async function createProtection(options = {}) {
   const onError = options.onError;
-  const onDetect = options.onDetect ?? defaultOnDetect;
+  const userOnDetect = options.onDetect ?? defaultOnDetect;
+  const apiKey = await resolveApiKey(options);
+  const firewallLog = apiKey && telemetryEnabled() && options.reportFirewallLog !== false ? createFirewallLogReporter({
+    apiKey,
+    apiBase: resolveApiBase(options.pulseRulesUrl ?? options.baseUrl),
+    sourceHost: options.sourceHost,
+    fetchImpl: options.fetchImpl
+  }) : null;
+  const onDetect = (detection) => {
+    userOnDetect(detection);
+    if (firewallLog && detection?.mode === "block") {
+      firewallLog.record({
+        rule: detection.rule,
+        method: detection.method,
+        path: detection.path,
+        ip: detection.ip,
+        userAgent: detection.userAgent
+      });
+    }
+  };
   const store = makeStore(options);
-  const bundle = await resolveRules(options, store);
+  const bootTimeoutMs = Number(options.bootTimeoutMs) > 0 ? Number(options.bootTimeoutMs) : 5e3;
+  const pulseAuth = await resolvePulseAuth(options);
+  const bundle = await resolveRules(options, store, { timeoutMs: bootTimeoutMs, pulseAuth });
   let mode = resolveMode(options, bundle);
   let requestRules;
   let responseRules;
@@ -1955,39 +2590,84 @@ async function createProtection(options = {}) {
     responseRuleSet = responseRules.map((rule) => ({
       rule,
       engine: new RuleEngine({ firewall: [rule], onError }),
-      redactors: rule.action === "redact" || rule.action === "encode" ? extractRedactors(rule) : null
+      redactors: rule.action === "redact" || rule.action === "encode" ? extractRedactors(rule) : null,
+      // A redact/encode condition that carries body-transforming mutations (base64_decode, urldecode,
+      // json_decode, …) detects on the DECODED body but the span redactors run on the RAW body — so
+      // they mask nothing and the secret is served while the log says "redacted". Flag it so screenText
+      // fails such a rule CLOSED (block) instead of serving a no-op redaction.
+      mutatedSpan: (rule.action === "redact" || rule.action === "encode") && hasSpanMutations(rule),
+      // Optional cheap pre-filter: literal anchor(s) that MUST appear for the (expensive) regex to
+      // have any chance of matching. Lets screenText skip the full scan on bodies with no candidate —
+      // the common case — cutting CPU/latency and shrinking the regex/ReDoS surface. Case-insensitive.
+      prefilter: Array.isArray(rule.prefilter) && rule.prefilter.length ? rule.prefilter.map((s) => String(s).toLowerCase()) : null
     }));
     egressEngine = new RuleEngine({ firewall: egressRules, onError });
   };
   applyBundle(bundle);
+  const skipCounts = /* @__PURE__ */ Object.create(null);
+  const onSkip = typeof options.onSkip === "function" ? options.onSkip : null;
+  const recordSkip = (phase, reason, detail) => {
+    const key = `${phase}:${reason}`;
+    skipCounts[key] = (skipCounts[key] ?? 0) + 1;
+    if (onSkip) {
+      try {
+        onSkip({ phase, reason, detail, count: skipCounts[key] });
+      } catch {
+      }
+    }
+  };
   const maskFn = typeof options.maskWith === "function" ? options.maskWith : () => typeof options.maskWith === "string" ? options.maskWith : "[REDACTED]";
-  const decide = (phase, result, block, allow2) => {
+  const ruleMode = (rule) => rule?.enforcement === "dry-run" ? "dry-run" : mode;
+  const decide = (phase, result, block, allow2, ctx = {}) => {
     if (!result || !result.blocked) return allow2();
-    onDetect({ phase, mode, category: result.rule?.category, rule: result.rule, message: result.message });
-    return mode === "block" ? block() : allow2();
-  };
-  const isTextCT = (ct) => {
-    ct = (ct || "").toLowerCase();
-    return ct === "" || /(json|text|xml|html|javascript|csv|yaml|x-www-form-urlencoded)/.test(ct);
+    const effectiveMode = ruleMode(result.rule);
+    onDetect({
+      phase,
+      // The mode this detection was actually handled under, not the site's: a consumer counting blocks
+      // would otherwise over-report, and the whole point of a dry-run rule is that it did not block.
+      mode: effectiveMode,
+      category: result.rule?.category,
+      rule: result.rule,
+      message: result.message,
+      method: ctx.method,
+      path: ctx.path,
+      ip: ctx.ip,
+      userAgent: ctx.userAgent
+    });
+    return effectiveMode === "block" ? block() : allow2();
   };
-  const screenText = (text, meta) => {
+  const screenText = (text, meta, reqCtx) => {
     let blockRule = null;
     const redactions = [];
-    for (const { rule, engine: re, redactors } of responseRuleSet) {
+    const headerMutations = [];
+    let lowerText = null;
+    for (const { rule, engine: re, redactors, prefilter, mutatedSpan } of responseRuleSet) {
+      if (prefilter) {
+        if (lowerText === null) lowerText = text.toLowerCase();
+        if (!prefilter.some((p) => lowerText.includes(p))) continue;
+      }
       let result;
       try {
-        result = re.evaluate({ _response: { ...meta, body: text } });
+        result = re.evaluate({ ...reqCtx || {}, _response: { ...meta, body: text } });
       } catch (err) {
         onError?.(err);
         continue;
       }
       if (!result.blocked) continue;
-      onDetect({ phase: "response", mode, category: rule.category, rule, message: result.message });
-      if (mode !== "block") continue;
-      if (redactors && redactors.length) redactions.push({ rule, redactors });
+      const responseMode = ruleMode(rule);
+      onDetect({ phase: "response", mode: responseMode, category: rule.category, rule, message: result.message });
+      if (responseMode !== "block") continue;
+      if (redactors && redactors.length) {
+        const spanRedactors = redactors.filter((r) => !r.jsonPath);
+        if (mutatedSpan && spanRedactors.length) {
+          if (!blockRule) blockRule = rule;
+        } else {
+          redactions.push({ rule, redactors });
+        }
+      } else if (isHeaderMutation(rule.action)) headerMutations.push(rule);
       else if (!blockRule) blockRule = rule;
     }
-    if (mode !== "block" || !blockRule && !redactions.length) return { verdict: "pass" };
+    if (mode !== "block" || !blockRule && !redactions.length && !headerMutations.length) return { verdict: "pass" };
     if (blockRule) return { verdict: "block" };
     let body = text;
     const headers = { ...meta.headers || {} };
@@ -2009,17 +2689,33 @@ async function createProtection(options = {}) {
         }
       }
     }
+    for (const rule of headerMutations) applyHeaderMutation(headers, rule);
     return { verdict: "redact", body, headers };
   };
-  const screenResp = async (response) => {
-    const text = await readTextResponse(response, screenCap);
-    if (text == null) return response;
-    const r = screenText(text, { status: response.status, headers: headerObject(response.headers) });
+  const reqContextFromFetch = (request) => {
+    try {
+      const u = new URL(request.url);
+      const headers = headerObject(request.headers);
+      if (!headers.host) headers.host = u.host;
+      return { method: request.method, originalUrl: u.pathname + u.search, headers };
+    } catch {
+      return void 0;
+    }
+  };
+  const reqContextFromNode = (req) => req ? { method: req.method, originalUrl: req.url, headers: req.headers || {} } : void 0;
+  const screenResp = async (response, reqCtx) => {
+    const read = await readTextResponse(response, screenCap);
+    if (read.skip) {
+      if (read.skip !== "not-a-response") recordSkip("response", read.skip, { status: response?.status });
+      return response;
+    }
+    const text = read.text;
+    const r = screenText(text, { status: response.status, headers: headerObject(response.headers) }, reqCtx);
     if (r.verdict === "block") return leakResponse();
     if (r.verdict === "redact") return rebuildResponse(response, r.body, r.headers);
     return response;
   };
-  const wrapNodeResponse = (res) => {
+  const wrapNodeResponse = (res, reqCtx) => {
     const origWrite = res.write.bind(res);
     const origEnd = res.end.bind(res);
     const chunks = [];
@@ -2035,6 +2731,7 @@ async function createProtection(options = {}) {
         chunks.length = 0;
         origWrite(buf);
         overflow = true;
+        recordSkip("response", "body-cap", { bytes: size });
         return;
       }
       chunks.push(buf);
@@ -2061,16 +2758,19 @@ async function createProtection(options = {}) {
       }
       collect(chunk, enc);
       if (overflow) return origEnd(cb);
-      const text = Buffer.concat(chunks).toString("utf8");
+      const buffer = Buffer.concat(chunks);
       let ct = res.getHeader ? res.getHeader("content-type") : void 0;
       if (Array.isArray(ct)) ct = ct[0];
-      if (!isTextCT(ct)) {
+      const kind = screenableContentType(ct);
+      if (kind === "skip" || kind === "sniff" && looksBinary(buffer)) {
+        recordSkip("response", kind === "skip" ? baseContentType(ct) === "text/event-stream" ? "live-stream" : "non-text-content-type" : "binary-body");
         for (const c of chunks) origWrite(c);
         return origEnd(cb);
       }
+      const text = buffer.toString("utf8");
       let r;
       try {
-        r = screenText(text, { status: res.statusCode, headers: res.getHeaders ? res.getHeaders() : {} });
+        r = screenText(text, { status: res.statusCode, headers: res.getHeaders ? res.getHeaders() : {} }, reqCtx);
       } catch (err) {
         onError?.(err);
         for (const c of chunks) origWrite(c);
@@ -2093,7 +2793,12 @@ async function createProtection(options = {}) {
           const current = res.getHeaders ? res.getHeaders() : {};
           for (const [name, value] of Object.entries(r.headers)) {
             if (name.toLowerCase() === "content-length") continue;
-            if (Array.isArray(value)) {
+            if (value === null || value === void 0) {
+              try {
+                res.removeHeader && res.removeHeader(name);
+              } catch {
+              }
+            } else if (Array.isArray(value)) {
               try {
                 res.setHeader(name, value);
               } catch {
@@ -2123,8 +2828,9 @@ async function createProtection(options = {}) {
       return false;
     }
     if (!result.blocked) return false;
-    onDetect({ phase: "egress", mode, category: result.rule?.category, rule: result.rule, message: result.message });
-    return mode === "block";
+    const egressMode = ruleMode(result.rule);
+    onDetect({ phase: "egress", mode: egressMode, category: result.rule?.category, rule: result.rule, message: result.message });
+    return egressMode === "block";
   };
   const protection = {
     get mode() {
@@ -2133,9 +2839,18 @@ async function createProtection(options = {}) {
     get rules() {
       return { request: requestRules, response: responseRules, egress: egressRules };
     },
+    /**
+     * Enforcement coverage: how often the guard FAILED OPEN rather than inspecting, keyed
+     * `<phase>:<reason>` (e.g. `response:body-cap`, `request:body-cap`, `response:live-stream`,
+     * `egress:resolver-failed`). "Always-on" is not "always inspected" — surface this (or pass
+     * `onSkip`) so an unscreened path is visible and alertable rather than silent.
+     */
+    coverage() {
+      return { skipped: { ...skipCounts } };
+    },
     // Screen a fetch Response through the response-phase rules (redact/block). Used by
     // .fetch(), and by the Supabase guard on its forwarded upstream response.
-    screenResponse: (response) => screenResp(response),
+    screenResponse: (response, request) => screenResp(response, request ? reqContextFromFetch(request) : void 0),
     // (request) => Response | null   (null = allow, caller proceeds). Request phase only.
     fetchGuard() {
       return async (request) => {
@@ -2146,7 +2861,7 @@ async function createProtection(options = {}) {
           onError?.(err);
           return null;
         }
-        return decide("request", result, () => blockResponse(result, request), () => null);
+        return decide("request", result, () => blockResponse(result, request), () => null, fetchRequestMeta(request));
       };
     },
     // Wrap a fetch handler: screens the request, then the response (redact/block).
@@ -2156,7 +2871,7 @@ async function createProtection(options = {}) {
         const blocked = await guard(request);
         if (blocked) return blocked;
         const response = await handler(request, ...rest);
-        return screenResp(response);
+        return screenResp(response, reqContextFromFetch(request));
       };
     },
     // Express middleware (request phase; expects express-parsed req.query/req.body).
@@ -2168,7 +2883,7 @@ async function createProtection(options = {}) {
           result = engine.evaluate(req);
         } catch (err) {
           onError?.(err);
-          if (exprOptions.screenResponses) wrapNodeResponse(res);
+          if (exprOptions.screenResponses) wrapNodeResponse(res, reqContextFromNode(req));
           return next();
         }
         decide(
@@ -2182,9 +2897,10 @@ async function createProtection(options = {}) {
             }
           },
           () => {
-            if (exprOptions.screenResponses) wrapNodeResponse(res);
+            if (exprOptions.screenResponses) wrapNodeResponse(res, reqContextFromNode(req));
             next();
-          }
+          },
+          nodeRequestMeta(req)
         );
       };
     },
@@ -2209,6 +2925,7 @@ async function createProtection(options = {}) {
           next();
         });
         req.on("end", () => {
+          if (overflow) recordSkip("request", "body-cap", { bytes: size, limit: maxBytes });
           const rawBody = overflow ? "" : Buffer.concat(chunks).toString("utf8");
           let shaped;
           let result;
@@ -2234,9 +2951,10 @@ async function createProtection(options = {}) {
             },
             () => {
               if (req.body === void 0) req.body = shaped.body;
-              if (nodeOptions.screenResponses) wrapNodeResponse(res);
+              if (nodeOptions.screenResponses) wrapNodeResponse(res, reqContextFromNode(req));
               next();
-            }
+            },
+            nodeRequestMeta(req)
           );
         });
       };
@@ -2246,6 +2964,9 @@ async function createProtection(options = {}) {
     protection.uninstallEgress = await installEgressGuard({
       shouldBlock: egressShouldBlock,
       onBlock: options.onEgressBlock,
+      // Route egress coverage gaps (a DNS resolver failure / no resolver on this runtime) into the
+      // same skip accounting as the request/response phases.
+      onSkip: ({ reason, detail }) => recordSkip("egress", reason, detail),
       dnsScreen: options.screenDns !== false,
       allowHosts: options.allowHosts
     });
@@ -2257,7 +2978,7 @@ async function createProtection(options = {}) {
   let reporter = null;
   if (refreshable && options.siteUuid && options.reportManifest !== false && cwd) {
     try {
-      ({ reportManifest: reporter } = await import("./refresh-manifest-OW7WT5A6.js"));
+      ({ reportManifest: reporter } = await import("./refresh-manifest-MUWVIPFR.js"));
     } catch (err) {
       onError?.(err);
     }
@@ -2270,7 +2991,7 @@ async function createProtection(options = {}) {
         onError?.(err);
       }
     }
-    const next = await resolveRules(options, store);
+    const next = await resolveRules(options, store, { timeoutMs: options.refreshTimeoutMs, pulseAuth });
     mode = resolveMode(options, next);
     applyBundle(next);
   };
@@ -2280,7 +3001,12 @@ async function createProtection(options = {}) {
   }
   if (options.refreshMs > 0 && live) {
     const loop = startRefresh(runRefreshTick, { refreshMs: options.refreshMs, onError });
-    protection.stopRefresh = loop.stop;
+    protection.stopRefresh = () => {
+      loop.stop();
+      firewallLog?.stop();
+    };
+  } else if (firewallLog) {
+    protection.stopRefresh = () => firewallLog.stop();
   }
   return protection;
 }
@@ -2292,21 +3018,77 @@ function resolveMode(options, bundle) {
   if (options?.mode === "dry-run") return "dry-run";
   return "dry-run";
 }
+async function resolveApiKey(options) {
+  if (typeof options?.apiKey === "string" && options.apiKey.length > 0) return options.apiKey;
+  if (typeof process !== "undefined") {
+    const fromEnv = process.env?.PATCHSTACK_API_KEY;
+    if (typeof fromEnv === "string" && fromEnv.length > 0) return fromEnv;
+  }
+  try {
+    if (typeof process === "undefined" || typeof process.cwd !== "function") return void 0;
+    const [{ readFileSync }, { join }] = await Promise.all([import("fs"), import("path")]);
+    const cwd = options?.cwd ?? process.cwd();
+    const raw = readFileSync(join(cwd, ".patchstackrc.json"), "utf8");
+    const key = JSON.parse(raw)?.apiKey;
+    if (typeof key === "string" && key.length > 0) return key;
+  } catch {
+  }
+  return void 0;
+}
+async function resolvePulseAuth(options) {
+  if (typeof options?.pulseAuth === "string" && options.pulseAuth.length > 0) return options.pulseAuth;
+  if (typeof process !== "undefined") {
+    const fromEnv = process.env?.PATCHSTACK_PULSE_AUTH;
+    if (typeof fromEnv === "string" && fromEnv.length > 0) return fromEnv;
+  }
+  try {
+    if (typeof process === "undefined" || typeof process.cwd !== "function") return resolveApiKey(options);
+    const [{ readFileSync }, { join }] = await Promise.all([import("fs"), import("path")]);
+    const cwd = options?.cwd ?? process.cwd();
+    const raw = readFileSync(join(cwd, ".patchstackrc.json"), "utf8");
+    const key = JSON.parse(raw)?.pulseAuth;
+    if (typeof key === "string" && key.length > 0) return key;
+  } catch {
+  }
+  return resolveApiKey(options);
+}
 function byPhase(rules, phase) {
   return (rules ?? []).filter((r) => (r.phase ?? "request") === phase);
 }
+function baseContentType(ct) {
+  return String(ct || "").toLowerCase().split(";")[0].trim();
+}
+function screenableContentType(ct) {
+  const base = baseContentType(ct);
+  if (base === "text/event-stream") return "skip";
+  if (base === "") return "text";
+  if (/(json|text|xml|html|javascript|csv|yaml|x-www-form-urlencoded)/.test(base)) return "text";
+  if (base === "application/octet-stream") return "sniff";
+  return "skip";
+}
+function looksBinary(bytes) {
+  const n = Math.min(bytes.length, 512);
+  let ctrl = 0;
+  for (let i = 0; i < n; i++) {
+    const b = bytes[i];
+    if (b === 0) return true;
+    if (b < 9 || b > 13 && b < 32) ctrl++;
+  }
+  return n > 0 && ctrl / n > 0.1;
+}
 async function readTextResponse(response, cap = DEFAULT_SCREEN_CAP) {
-  if (!response || typeof response.clone !== "function") return null;
-  const ct = (response.headers?.get?.("content-type") || "").toLowerCase();
-  const isText = ct === "" || /(json|text|xml|html|javascript|csv|yaml|x-www-form-urlencoded)/.test(ct);
-  if (!isText) return null;
+  if (!response || typeof response.clone !== "function") return { skip: "not-a-response" };
+  const ct = response.headers?.get?.("content-type") || "";
+  const kind = screenableContentType(ct);
+  if (kind === "skip") return { skip: baseContentType(ct) === "text/event-stream" ? "live-stream" : "non-text-content-type" };
+  const sniff = kind === "sniff";
   const len = Number(response.headers?.get?.("content-length") || 0);
-  if (len && len > cap) return null;
+  if (len && len > cap) return { skip: "body-cap" };
   let clone;
   try {
     clone = response.clone();
   } catch {
-    return null;
+    return { skip: "clone-failed" };
   }
   const body = clone.body;
   if (body && typeof body.getReader === "function") {
@@ -2314,11 +3096,16 @@ async function readTextResponse(response, cap = DEFAULT_SCREEN_CAP) {
     const chunks = [];
     let size = 0;
     let over = false;
+    let sniffed = !sniff;
     try {
       for (; ; ) {
         const { done, value } = await reader.read();
         if (done) break;
         if (!value) continue;
+        if (!sniffed) {
+          sniffed = true;
+          if (looksBinary(value)) return { skip: "binary-body" };
+        }
         size += value.byteLength;
         if (over) continue;
         if (size > cap) {
@@ -2328,20 +3115,22 @@ async function readTextResponse(response, cap = DEFAULT_SCREEN_CAP) {
         chunks.push(value);
       }
     } catch {
-      return null;
+      return { skip: "read-failed" };
     }
-    if (over) return null;
+    if (over) return { skip: "body-cap" };
     try {
-      return new TextDecoder().decode(concatBytes(chunks, size));
+      return { text: new TextDecoder().decode(concatBytes(chunks, size)) };
     } catch {
-      return null;
+      return { skip: "decode-failed" };
     }
   }
   try {
     const text = await clone.text();
-    return text.length > cap ? null : text;
+    if (text.length > cap) return { skip: "body-cap" };
+    if (sniff && looksBinary(new TextEncoder().encode(text.slice(0, 512)))) return { skip: "binary-body" };
+    return { text };
   } catch {
-    return null;
+    return { skip: "read-failed" };
   }
 }
 function concatBytes(chunks, total) {
@@ -2362,6 +3151,19 @@ function headerObject(headers) {
   if (setCookies && setCookies.length) out["set-cookie"] = setCookies;
   return out;
 }
+function hasSpanMutations(rule) {
+  let found = false;
+  const walk = (conds) => {
+    for (const c of conds ?? []) {
+      if (found) return;
+      if (Array.isArray(c.rules)) walk(c.rules);
+      const isSpan = c.match && (c.match.type === "regex" || c.match.type === "contains" || c.match.type === "stripos");
+      if (isSpan && Array.isArray(c.mutations) && c.mutations.length) found = true;
+    }
+  };
+  walk(rule.rule_v2);
+  return found;
+}
 function extractRedactors(rule) {
   const out = [];
   const walk = (conds) => {
@@ -2398,7 +3200,10 @@ function applyRedactors(body, redactors, mask, transform) {
   let out = body;
   for (const r of redactors) {
     if (r.re) out = out.replace(r.re, transform ? (m) => transform(m) : mask);
-    else if (r.literal) out = out.split(r.literal).join(transform ? transform(r.literal) : mask);
+    else if (r.literal) {
+      const re = new RegExp(r.literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
+      out = out.replace(re, (m) => transform ? transform(m) : mask);
+    }
   }
   return out;
 }
@@ -2501,12 +3306,52 @@ function restoreBigInts(text) {
   if (!text.includes(BIGINT_OPEN)) return text;
   return text.replace(new RegExp(`"${BIGINT_OPEN}(-?\\d+)${BIGINT_CLOSE}"`, "g"), "$1");
 }
+function isHeaderMutation(action) {
+  return action === "set-header" || action === "remove-header" || action === "harden-cookie";
+}
+function applyHeaderMutation(headers, rule) {
+  if (rule.action === "remove-header") {
+    for (const name of rule.remove_headers ?? []) headers[String(name).toLowerCase()] = null;
+    return;
+  }
+  if (rule.action === "set-header") {
+    const ensure = rule.ensure === true;
+    for (const [name, value] of Object.entries(rule.set_headers ?? {})) {
+      const key = String(name).toLowerCase();
+      const present = headers[key] != null && headers[key] !== "";
+      if (ensure && present) continue;
+      headers[key] = String(value);
+    }
+    return;
+  }
+  if (rule.action === "harden-cookie") {
+    const cookie = headers["set-cookie"];
+    const flags = rule.cookie_flags ?? {};
+    if (Array.isArray(cookie)) {
+      headers["set-cookie"] = cookie.map((c) => typeof c === "string" ? hardenCookie(c, flags) : c);
+    } else if (typeof cookie === "string") {
+      headers["set-cookie"] = hardenCookie(cookie, flags);
+    }
+  }
+}
+function hardenCookie(cookie, { httpOnly = true, secure = true, sameSite = "Lax" } = {}) {
+  let out = String(cookie);
+  if (httpOnly && !/;\s*httponly/i.test(out)) out += "; HttpOnly";
+  if (secure && !/;\s*secure/i.test(out)) out += "; Secure";
+  if (sameSite && !/;\s*samesite\s*=/i.test(out)) out += `; SameSite=${sameSite}`;
+  return out;
+}
 function rebuildResponse(response, body, redactedHeaders) {
   const headers = new Headers(response.headers);
   headers.delete("content-length");
   if (redactedHeaders) {
     for (const [name, value] of Object.entries(redactedHeaders)) {
-      if (typeof value === "string") {
+      if (value === null || value === void 0) {
+        try {
+          headers.delete(name);
+        } catch {
+        }
+      } else if (typeof value === "string") {
         if (headers.get(name) !== value) {
           try {
             headers.set(name, value);
@@ -2522,7 +3367,8 @@ function rebuildResponse(response, body, redactedHeaders) {
       }
     }
   }
-  return new Response(body, { status: response.status, statusText: response.statusText, headers });
+  const nullBody = response.status === 101 || response.status === 204 || response.status === 205 || response.status === 304;
+  return new Response(nullBody ? null : body, { status: response.status, statusText: response.statusText, headers });
 }
 function leakResponse() {
   return new Response(JSON.stringify({ error: "Response withheld by Patchstack (sensitive data detected)" }), {
@@ -2555,6 +3401,33 @@ function defaultOnDetect({ phase, mode, category, rule, message }) {
   const tag = mode === "block" ? "BLOCK" : "DETECT (dry-run)";
   console.warn(`[patchstack] ${tag} phase=${phase ?? "request"} category=${category ?? "?"} rule=${rule?.id ?? "?"} ${message ?? ""}`.trim());
 }
+function fetchRequestMeta(request) {
+  if (!request) return {};
+  let path = null;
+  try {
+    path = new URL(request.url).pathname;
+  } catch {
+    path = typeof request.url === "string" ? request.url : null;
+  }
+  return {
+    method: request.method ?? null,
+    path,
+    ip: request.headers?.get?.("x-forwarded-for") ?? null,
+    userAgent: request.headers?.get?.("user-agent") ?? null
+  };
+}
+function nodeRequestMeta(req) {
+  if (!req) return {};
+  const headers = req.headers ?? {};
+  const ua = headers["user-agent"] ?? headers["User-Agent"];
+  const fwd = headers["x-forwarded-for"] ?? headers["X-Forwarded-For"];
+  return {
+    method: req.method ?? null,
+    path: req.originalUrl || req.url || null,
+    ip: req.ip ?? (typeof fwd === "string" ? fwd : null),
+    userAgent: typeof ua === "string" ? ua : Array.isArray(ua) ? ua[0] : null
+  };
+}
 export {
   GUARD_PATH,
   PulseRuleClient,