@patchstack/connect 0.5.15 → 0.5.17

package/dist/protect.cjs

@@ -2033,7 +2033,7 @@ async function scanLockfile(cwd) {
     await detectLockfile(cwd);
   }
   const declared = await readDeclaredDependencyNames(cwd);
-  const warnings = [];
+  const warnings2 = [];
   let firstParsed = null;
   let walked = null;
   let walkWasCandidate = false;
@@ -2047,7 +2047,7 @@ async function scanLockfile(cwd) {
       continue;
     }
     const unreadable = unreadableWarning(candidate.filename, report);
-    if (unreadable !== null) warnings.push(unreadable);
+    if (unreadable !== null) warnings2.push(unreadable);
     if (candidate.strategy === "node-modules-walk") {
       walked = packages;
       walkWasCandidate = true;
@@ -2058,16 +2058,16 @@ async function scanLockfile(cwd) {
   for (const source of parsedSources) {
     const missing = missingDependencies(declared, source.packages);
     if (missing.length > 0) {
-      warnings.push(staleWarning(source.filename, missing));
+      warnings2.push(staleWarning(source.filename, missing));
       continue;
     }
     const conflicts = otherCompleteSources(parsedSources, source, declared).flatMap(
       (other) => disagreements(source.packages, other.packages).map((conflict) => ({ other: other.filename, conflict }))
     );
     if (conflicts.length === 0) {
-      return manifestWith(source.packages, warnings);
+      return manifestWith(source.packages, warnings2);
     }
-    warnings.push(conflictWarning(source.filename, conflicts));
+    warnings2.push(conflictWarning(source.filename, conflicts));
     break;
   }
   if (walked === null) {
@@ -2080,12 +2080,12 @@ async function scanLockfile(cwd) {
   if (walked !== null) {
     const missing = missingDependencies(declared, walked);
     if (missing.length > 0) {
-      warnings.push(staleWarning("node_modules/", missing));
+      warnings2.push(staleWarning("node_modules/", missing));
     }
-    warnings.push(
+    warnings2.push(
       walkWasCandidate ? "Checked the installed packages in node_modules/, which is what the build loads." : "Checked the installed packages in node_modules/ instead. Delete the out-of-date package list file to stop this warning."
     );
-    return manifestWith(walked, warnings);
+    return manifestWith(walked, warnings2);
   }
   if (firstParsed === null) {
     const expected = LOCKFILE_CANDIDATES.map((candidate) => candidate.filename).join(", ");
@@ -2094,13 +2094,13 @@ async function scanLockfile(cwd) {
       "LOCKFILE_NOT_FOUND"
     );
   }
-  warnings.push(
+  warnings2.push(
     `No package list matches package.json; checked ${firstParsed.filename}, so some packages may be missing. Reinstall your packages to fix this.`
   );
-  return manifestWith(firstParsed.packages, warnings);
+  return manifestWith(firstParsed.packages, warnings2);
 }
-function manifestWith(packages, warnings) {
-  return warnings.length > 0 ? { ecosystem: "npm", packages, warnings } : { ecosystem: "npm", packages };
+function manifestWith(packages, warnings2) {
+  return warnings2.length > 0 ? { ecosystem: "npm", packages, warnings: warnings2 } : { ecosystem: "npm", packages };
 }
 function otherCompleteSources(all, current, declared) {
   return all.filter(
@@ -2725,18 +2725,124 @@ function appendOwn(target, key, value) {
   return setOwn(target, key, Array.isArray(previous) ? [...previous, value] : [previous, value]);
 }
 
-// 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") {
-    return Buffer.from(str, "base64").toString("utf-8");
+// src/protect/engine/cookies.js
+function parseCookieHeader(header) {
+  const cookies = {};
+  if (typeof header !== "string" || header === "") return cookies;
+  const repeated = /* @__PURE__ */ new Map();
+  for (const pair of header.split(";")) {
+    const eq = pair.indexOf("=");
+    if (eq === -1) continue;
+    const name = pair.slice(0, eq).trim();
+    if (name === "") continue;
+    let value = pair.slice(eq + 1).trim();
+    if (value.length >= 2 && value[0] === '"' && value[value.length - 1] === '"') value = value.slice(1, -1);
+    if (!Object.hasOwn(cookies, name)) {
+      setOwn(cookies, name, value);
+    } else {
+      let values = repeated.get(name);
+      if (values === void 0) {
+        values = [cookies[name]];
+        repeated.set(name, values);
+        setOwn(cookies, name, values);
+      }
+      values.push(value);
+    }
   }
-  const binary = atob(str);
-  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
-  return new TextDecoder().decode(bytes);
+  return cookies;
+}
+
+// src/protect/engine/normalizer.js
+var HTML_ENTITIES = {
+  "&": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&apos;": "'",
+  "&nbsp;": " ",
+  "&#x27;": "'",
+  "&#x22;": '"',
+  "&#x3C;": "<",
+  "&#x3E;": ">",
+  "&#x26;": "&",
+  "&#34;": '"',
+  "&#60;": "<",
+  "&#62;": ">",
+  "&#38;": "&"
+};
+var MAX_DECODE_ITERATIONS = 5;
+function normalize(value, options = {}) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const opts = {
+    urlDecode: true,
+    htmlDecode: true,
+    sqlComments: true,
+    nullBytes: true,
+    whitespace: true,
+    ...options
+  };
+  let result = value;
+  if (opts.nullBytes) {
+    result = removeNullBytes(result);
+  }
+  if (opts.urlDecode) {
+    result = urlDecode(result);
+  }
+  if (opts.htmlDecode) {
+    result = htmlEntityDecode(result);
+  }
+  if (opts.sqlComments) {
+    result = removeSqlComments(result);
+  }
+  if (opts.whitespace) {
+    result = normalizeWhitespace(result);
+  }
+  return result;
+}
+function urlDecode(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  let result = value;
+  let previous = "";
+  let iterations = 0;
+  while (result !== previous && iterations < MAX_DECODE_ITERATIONS) {
+    previous = result;
+    iterations++;
+    result = safeUrlDecode(result);
+  }
+  return result;
+}
+var utf8 = new TextDecoder();
+function safeUrlDecode(value) {
+  return value.replace(/(?:%[0-9A-Fa-f]{2})+/g, (run) => {
+    try {
+      return decodeURIComponent(run);
+    } catch {
+      const bytes = new Uint8Array(run.length / 3);
+      for (let i = 0; i < bytes.length; i++) bytes[i] = parseInt(run.slice(i * 3 + 1, i * 3 + 3), 16);
+      return utf8.decode(bytes);
+    }
+  });
+}
+function decodeQueryPlus(target) {
+  if (typeof target !== "string") return target;
+  const query = target.indexOf("?");
+  if (query === -1) return target;
+  return target.slice(0, query + 1) + target.slice(query + 1).replace(/\+/g, " ");
+}
+function htmlEntityDecode(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  let result = value;
+  for (const [entity, char] of Object.entries(HTML_ENTITIES)) {
+    result = result.split(entity).join(char);
+  }
+  return decodeHtmlEntities(result);
 }
 var NAMED_ENTITIES = {
   lt: "<",
@@ -2744,7 +2850,6 @@ var NAMED_ENTITIES = {
   amp: "&",
   quot: '"',
   apos: "'",
-  "#39": "'",
   nbsp: "\xA0",
   sol: "/",
   bsol: "\\",
@@ -2763,7 +2868,7 @@ var NAMED_ENTITIES = {
   ast: "*"
 };
 function decodeHtmlEntities(input) {
-  return input.replace(/&(#[xX]?[0-9a-fA-F]+|[A-Za-z][A-Za-z0-9]*);?/g, (whole, body) => {
+  return input.replace(/&(#[xX][0-9a-fA-F]+|#\d+|[A-Za-z][A-Za-z0-9]*);?/g, (whole, body) => {
     if (body[0] === "#") {
       const hex = body[1] === "x" || body[1] === "X";
       const code = Number.parseInt(hex ? body.slice(2) : body.slice(1), hex ? 16 : 10);
@@ -2777,74 +2882,359 @@ function decodeHtmlEntities(input) {
     return Object.prototype.hasOwnProperty.call(NAMED_ENTITIES, body) ? NAMED_ENTITIES[body] : whole;
   });
 }
-var RequestResolver = class {
-  #req;
-  #cookies;
-  constructor(req) {
-    this.#req = req;
-    this.#cookies = null;
+function removeSqlComments(value) {
+  if (typeof value !== "string") {
+    return value;
   }
-  resolve(parameter) {
-    if (!parameter || parameter === "false") {
-      return [null];
+  let result = value;
+  result = result.replace(/\/\*[\s\S]*?\*\//g, " ");
+  result = result.replace(/\/\*![\s\S]*?\*\//g, " ");
+  return result;
+}
+function removeNullBytes(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  let result = value.replace(/\x00/g, "");
+  result = result.replace(/[\x01-\x08\x0B\x0C\x0E-\x1F]/g, "");
+  return result;
+}
+function normalizeWhitespace(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  let result = value.replace(/[\t\r\n\f\v]+/g, " ");
+  result = result.replace(/ {2,}/g, " ");
+  return result;
+}
+var MAX_RAW_CHARS = 1024 * 1024;
+var MAX_RAW_NODES = 25e3;
+var MAX_RAW_DEPTH = 200;
+var MAX_RAW_ENTRIES = 2e3;
+function serializeForRawDetection(body) {
+  if (body === null || body === void 0) return "";
+  if (typeof body === "string") return body.slice(0, MAX_RAW_CHARS);
+  const visited = /* @__PURE__ */ new Set();
+  const output = [];
+  const stack = [{ kind: "value", value: body, depth: 0, root: true }];
+  let chars = 0;
+  let nodes = 0;
+  const append = (text) => {
+    if (chars >= MAX_RAW_CHARS) return;
+    const piece = String(text).slice(0, MAX_RAW_CHARS - chars);
+    output.push(piece);
+    chars += piece.length;
+  };
+  while (stack.length > 0 && chars < MAX_RAW_CHARS) {
+    const task = stack.pop();
+    if (task.kind === "text") {
+      append(task.text);
+      continue;
     }
-    if (parameter === "rules") {
-      return [null];
+    if (task.kind === "key") {
+      append(boundedJsonString(task.value));
+      append(":");
+      continue;
     }
-    if (parameter === "raw") {
-      return this.#resolveRaw();
+    nodes++;
+    if (nodes > MAX_RAW_NODES) {
+      append('"[NodeLimit]"');
+      continue;
     }
-    if (parameter === "all") {
-      return this.#resolveAll();
+    const value = task.value;
+    if (value === null || value === void 0) {
+      append(task.root ? "" : "null");
+      continue;
     }
-    const dotIndex = parameter.indexOf(".");
-    if (dotIndex === -1) {
-      return [];
+    if (typeof value === "string") {
+      append(task.root ? value.slice(0, MAX_RAW_CHARS) : boundedJsonString(value));
+      continue;
     }
-    const source = parameter.substring(0, dotIndex);
-    const key = parameter.substring(dotIndex + 1);
-    switch (source) {
-      case "get":
-        return this.#resolveGet(key);
-      case "post":
-        return this.#resolvePost(key);
-      case "request":
-        return this.#resolveRequest(key);
-      case "cookie":
-        return this.#resolveCookie(key);
-      case "server":
-        return this.#resolveServer(key);
-      case "files":
-        return this.#resolveFiles(key);
-      case "response":
-        return this.#resolveResponse(key);
-      case "egress":
-        return this.#resolveEgress(key);
-      default:
-        return [];
+    if (typeof value !== "object") {
+      append(String(value).slice(0, MAX_RAW_CHARS));
+      continue;
     }
-  }
-  // Response-phase sources (req._response = { status, headers, body }). Lets rules inspect
-  // what the app is about to SEND — e.g. a leaked secret in the body — regardless of route.
-  #resolveResponse(key) {
-    const resp = this.#req._response;
-    if (!resp) {
-      return [];
+    if (visited.has(value)) {
+      append("[Circular]");
+      continue;
     }
-    if (key === "status") {
-      return resp.status !== void 0 ? [String(resp.status)] : [];
+    if (task.depth >= MAX_RAW_DEPTH) {
+      append('"[DepthLimit]"');
+      continue;
     }
-    if (key === "body") {
-      return resp.body != null && resp.body !== "" ? [resp.body] : [];
+    visited.add(value);
+    if (Array.isArray(value)) {
+      const length2 = Math.min(value.length, MAX_RAW_ENTRIES);
+      const items = [];
+      for (let i = 0; i < length2; i++) {
+        if (i > 0) items.push({ kind: "text", text: "," });
+        items.push({ kind: "value", value: readOwnValue(value, String(i)), depth: task.depth + 1, root: false });
+      }
+      if (value.length > length2) {
+        if (length2 > 0) items.push({ kind: "text", text: "," });
+        items.push({ kind: "text", text: '"[EntryLimit]"' });
+      }
+      stack.push({ kind: "text", text: "]" });
+      for (let i = items.length - 1; i >= 0; i--) stack.push(items[i]);
+      stack.push({ kind: "text", text: "[" });
+      continue;
     }
-    if (key === "headers") {
-      const headers = resp.headers ?? {};
-      return [Object.entries(headers).map(([k, v]) => `${k}: ${v}`).join("\n")];
+    let keys;
+    try {
+      keys = Object.getOwnPropertyNames(value);
+    } catch {
+      append('"[Unreadable]"');
+      continue;
     }
-    if (key.startsWith("header.")) {
-      const name = key.slice("header.".length).toLowerCase();
-      const headers = resp.headers ?? {};
-      return Object.hasOwn(headers, name) ? [headers[name]] : [];
+    const length = Math.min(keys.length, MAX_RAW_ENTRIES);
+    const entries = [];
+    for (let i = 0; i < length; i++) {
+      const key = keys[i];
+      if (i > 0) entries.push({ kind: "text", text: "," });
+      entries.push({ kind: "key", value: key });
+      entries.push({ kind: "value", value: readOwnValue(value, key), depth: task.depth + 1, root: false });
+    }
+    if (keys.length > length) {
+      if (length > 0) entries.push({ kind: "text", text: "," });
+      entries.push({ kind: "text", text: '"[EntryLimit]":null' });
+    }
+    stack.push({ kind: "text", text: "}" });
+    for (let i = entries.length - 1; i >= 0; i--) stack.push(entries[i]);
+    stack.push({ kind: "text", text: "{" });
+  }
+  return output.join("");
+}
+function boundedJsonString(value) {
+  return JSON.stringify(String(value).slice(0, MAX_RAW_CHARS));
+}
+function readOwnValue(value, key) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor && Object.hasOwn(descriptor, "value") ? descriptor.value : "[Accessor]";
+  } catch {
+    return "[Unreadable]";
+  }
+}
+var INHERITED_ACCESSORS = /* @__PURE__ */ new Set(["headers", "query"]);
+function requestField(req, key) {
+  if (req === null || typeof req !== "object") return void 0;
+  if (Object.hasOwn(req, key)) return req[key];
+  if (!INHERITED_ACCESSORS.has(key)) return void 0;
+  let holder = Object.getPrototypeOf(req);
+  while (holder !== null && !Object.hasOwn(holder, key)) holder = Object.getPrototypeOf(holder);
+  if (holder === null || holder === Object.prototype) return void 0;
+  const descriptor = Object.getOwnPropertyDescriptor(holder, key);
+  if (typeof descriptor?.get !== "function") return void 0;
+  return req[key];
+}
+function normalizeRequest(req, options = {}) {
+  const ownRaw = Object.hasOwn(req ?? {}, "_rawBody") && typeof req._rawBody === "string";
+  const body = requestField(req, "body");
+  const url = requestField(req, "url");
+  const rawBody = ownRaw ? req._rawBody : serializeForRawDetection(body ?? null);
+  const headers = requestField(req, "headers") || {};
+  return {
+    query: normalizeObject(requestField(req, "query") || {}, options),
+    body: normalizeObject(body || {}, options),
+    headers: normalizeObject(headers, options),
+    // Cookies are split into name/value pairs BEFORE their values are normalised, and normalised the
+    // same way whether a framework parsed them or they come from the header — so a rule on a cookie
+    // sees one value, independent of which cookie parser (if any) ran first.
+    cookies: normalizeObject(cookieValues(requestField(req, "cookies"), headers), options),
+    url: normalize(decodeQueryPlus(url || ""), options),
+    originalUrl: normalize(decodeQueryPlus(requestField(req, "originalUrl") || url || ""), options),
+    _rawBody: rawBody
+  };
+}
+function cookieValues(parsed, headers) {
+  if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  return parseCookieHeader(headers?.cookie);
+}
+var MAX_NORMALIZE_DEPTH = 1e3;
+function normalizeObject(value, options = {}, depth = 0) {
+  if (typeof value === "string") {
+    return normalize(value, options);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (depth >= MAX_NORMALIZE_DEPTH) {
+    options.onLimit?.();
+    return value;
+  }
+  const copies = /* @__PURE__ */ new Map();
+  const copyOf = (node) => {
+    const copy = Array.isArray(node) ? new Array(node.length) : {};
+    copies.set(node, copy);
+    return copy;
+  };
+  const top = copyOf(value);
+  const stack = [[value, top, depth]];
+  while (stack.length > 0) {
+    const [node, copy, level] = stack.pop();
+    for (const key of Object.keys(node)) {
+      const child = node[key];
+      if (typeof child === "string") {
+        setOwn(copy, key, normalize(child, options));
+      } else if (child === null || typeof child !== "object") {
+        setOwn(copy, key, child);
+      } else if (copies.has(child)) {
+        setOwn(copy, key, copies.get(child));
+      } else if (level + 1 >= MAX_NORMALIZE_DEPTH) {
+        setOwn(copy, key, child);
+        options.onLimit?.();
+      } else {
+        const childCopy = copyOf(child);
+        setOwn(copy, key, childCopy);
+        stack.push([child, childCopy, level + 1]);
+      }
+    }
+  }
+  return top;
+}
+
+// src/protect/engine/request.js
+var FILE_ATTRS = /* @__PURE__ */ new Set(["content", "filename", "type"]);
+var ownValue = (obj, key) => obj !== null && typeof obj === "object" && Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : void 0;
+function fieldSpellings(key) {
+  const spellings = [{ key, nested: true }];
+  if (key.includes("[")) {
+    const dotted = key.replace(/\[\]$/, "").replace(/\[([^\][]*)\]/g, ".$1");
+    if (dotted !== key && dotted !== "" && !dotted.includes("[") && !dotted.includes("]")) {
+      spellings.push({ key: dotted, nested: true });
+    }
+    return spellings;
+  }
+  const [head, ...rest] = key.split(".");
+  const bracketed = head + rest.map((part) => `[${part}]`).join("");
+  if (bracketed !== key) spellings.push({ key: bracketed, nested: false });
+  spellings.push({ key: `${bracketed}[]`, nested: false });
+  return spellings;
+}
+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") {
+    return Buffer.from(str, "base64").toString("utf-8");
+  }
+  const binary = atob(str);
+  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+var TEXT_MUTATIONS = /* @__PURE__ */ new Set(["base64_decode", "urldecode", "htmlentitydecode"]);
+var MAX_MAPPED_NODES = 2e4;
+var MAX_MAPPED_DEPTH = 1e3;
+function mapStringLeaves(root, fn, onLimit) {
+  const copies = /* @__PURE__ */ new Map();
+  const copyOf = (node) => {
+    const copy = Array.isArray(node) ? [] : {};
+    copies.set(node, copy);
+    return copy;
+  };
+  const top = copyOf(root);
+  const stack = [[root, top, 0]];
+  let visited = 0;
+  while (stack.length) {
+    const [node, copy, depth] = stack.pop();
+    visited++;
+    for (const key of Object.keys(node)) {
+      const child = node[key];
+      if (typeof child === "string") {
+        setOwn(copy, key, fn(child));
+      } else if (child === null || typeof child !== "object") {
+        setOwn(copy, key, child);
+      } else if (copies.has(child)) {
+        setOwn(copy, key, copies.get(child));
+      } else if (depth + 1 >= MAX_MAPPED_DEPTH || visited + stack.length >= MAX_MAPPED_NODES) {
+        setOwn(copy, key, child);
+        onLimit();
+      } else {
+        const childCopy = copyOf(child);
+        setOwn(copy, key, childCopy);
+        stack.push([child, childCopy, depth + 1]);
+      }
+    }
+  }
+  return top;
+}
+var RequestResolver = class {
+  #req;
+  #cookies;
+  #skips = /* @__PURE__ */ new Set();
+  constructor(req) {
+    this.#req = req;
+    this.#cookies = null;
+  }
+  /** Record an inspection limit this evaluation reached (reported once per reason). */
+  noteSkip(reason) {
+    this.#skips.add(reason);
+  }
+  /** The inspection limits recorded so far, in the order first reached. */
+  get skips() {
+    return [...this.#skips];
+  }
+  resolve(parameter) {
+    if (!parameter || parameter === "false") {
+      return [null];
+    }
+    if (parameter === "rules") {
+      return [null];
+    }
+    if (parameter === "raw") {
+      return this.#resolveRaw();
+    }
+    if (parameter === "all") {
+      return this.#resolveAll();
+    }
+    const dotIndex = parameter.indexOf(".");
+    if (dotIndex === -1) {
+      return [];
+    }
+    const source = parameter.substring(0, dotIndex);
+    const key = parameter.substring(dotIndex + 1);
+    switch (source) {
+      case "get":
+        return this.#resolveGet(key);
+      case "post":
+        return this.#resolvePost(key);
+      case "request":
+        return this.#resolveRequest(key);
+      case "cookie":
+        return this.#resolveCookie(key);
+      case "server":
+        return this.#resolveServer(key);
+      case "files":
+        return this.#resolveFiles(key);
+      case "response":
+        return this.#resolveResponse(key);
+      case "egress":
+        return this.#resolveEgress(key);
+      default:
+        return [];
+    }
+  }
+  // Response-phase sources (req._response = { status, headers, body }). Lets rules inspect
+  // what the app is about to SEND — e.g. a leaked secret in the body — regardless of route.
+  #resolveResponse(key) {
+    const resp = this.#req._response;
+    if (!resp) {
+      return [];
+    }
+    if (key === "status") {
+      return resp.status !== void 0 ? [String(resp.status)] : [];
+    }
+    if (key === "body") {
+      return resp.body != null && resp.body !== "" ? [resp.body] : [];
+    }
+    if (key === "headers") {
+      const headers = resp.headers ?? {};
+      return [Object.entries(headers).map(([k, v]) => `${k}: ${v}`).join("\n")];
+    }
+    if (key.startsWith("header.")) {
+      const name = key.slice("header.".length).toLowerCase();
+      const headers = resp.headers ?? {};
+      return Object.hasOwn(headers, name) ? [headers[name]] : [];
     }
     return [];
   }
@@ -2874,6 +3264,9 @@ var RequestResolver = class {
     if (value === null || value === void 0) {
       return value;
     }
+    if (typeof value === "object" && TEXT_MUTATIONS.has(mutation)) {
+      return mapStringLeaves(value, (leaf) => this.#applyMutation(mutation, leaf), () => this.noteSkip("container-cap"));
+    }
     switch (mutation) {
       case "base64_decode":
         try {
@@ -2894,11 +3287,7 @@ var RequestResolver = class {
           return value;
         }
       case "urldecode":
-        try {
-          return decodeURIComponent(String(value));
-        } catch {
-          return value;
-        }
+        return safeUrlDecode(String(value).replace(/\+/g, " "));
       case "htmlentitydecode":
         return decodeHtmlEntities(String(value));
       case "intval":
@@ -2917,16 +3306,30 @@ var RequestResolver = class {
     if (key.endsWith("*")) {
       return this.#resolveWildcard(query, key);
     }
-    const value = this.#getNestedValue(query, key);
-    return value !== void 0 ? [value] : [];
+    return this.#lookup(query, key);
   }
   #resolvePost(key) {
     const body = this.#req.body ?? {};
     if (key.endsWith("*")) {
       return this.#resolveWildcard(body, key);
     }
-    const value = this.#getNestedValue(body, key);
-    return value !== void 0 ? [value] : [];
+    return this.#lookup(body, key);
+  }
+  /**
+   * Every value a field path names in `obj`, in either spelling a form or query field can take.
+   *
+   * A parser that expands brackets (`qs`, as Express uses) turns `user[name]=x` into `{ user: { name } }`
+   * and `id[]=x` into `{ id: [x] }`; a flat parser (`URLSearchParams`, as the Fetch and Node adapters use)
+   * keeps `user[name]` and `id[]` as literal keys. The rule names the field once, so both shapes answer
+   * to both spellings: `user.name` and `user[name]`, `id` and `id[]`.
+   */
+  #lookup(obj, key) {
+    const values = [];
+    for (const candidate of fieldSpellings(key)) {
+      const value = candidate.nested ? this.#getNestedValue(obj, candidate.key) : ownValue(obj, candidate.key);
+      if (value !== void 0) values.push(value);
+    }
+    return values;
   }
   #resolveRequest(key) {
     const query = this.#req.query ?? {};
@@ -2939,8 +3342,11 @@ var RequestResolver = class {
         ...this.#resolveWildcard(cookies, key)
       ];
     }
-    const value = this.#getNestedValue(query, key) ?? this.#getNestedValue(body, key) ?? (Object.hasOwn(cookies, key) ? cookies[key] : void 0);
-    return value !== void 0 ? [value] : [];
+    const fromQuery = this.#lookup(query, key);
+    if (fromQuery.length > 0) return fromQuery;
+    const fromBody = this.#lookup(body, key);
+    if (fromBody.length > 0) return fromBody;
+    return Object.hasOwn(cookies, key) ? [cookies[key]] : [];
   }
   #resolveCookie(key) {
     const cookies = this.#parseCookies();
@@ -3110,329 +3516,51 @@ var RequestResolver = class {
       this.#cookies = this.#req.cookies;
       return this.#cookies;
     }
-    const header = this.#req.headers?.cookie;
-    if (!header) {
-      this.#cookies = {};
-      return this.#cookies;
-    }
-    const cookies = {};
-    for (const pair of header.split(";")) {
-      const eqIndex = pair.indexOf("=");
-      if (eqIndex === -1) {
-        continue;
-      }
-      const name = pair.substring(0, eqIndex).trim();
-      const value = pair.substring(eqIndex + 1).trim();
-      setOwn(cookies, name, value);
-    }
-    this.#cookies = cookies;
+    this.#cookies = parseCookieHeader(this.#req.headers?.cookie);
     return this.#cookies;
   }
 };
 
 // src/protect/notify.js
-var reported = /* @__PURE__ */ new Set();
+var reported = /* @__PURE__ */ new WeakMap();
+var warnings = 0;
+var MAX_WARNINGS = 20;
 function notify(fn, arg, label) {
   if (typeof fn !== "function") return false;
   try {
     const result = fn(arg);
     if (result !== null && typeof result === "object" && typeof result.then === "function") {
       try {
-        result.then(void 0, (err) => warnOnce2(label, err));
+        result.then(void 0, (err) => warnOnce2(fn, label, err));
       } catch {
-      }
-    }
-    return true;
-  } catch (err) {
-    warnOnce2(label, err);
-    return false;
-  }
-}
-function warnOnce2(label, err) {
-  if (reported.has(label)) return;
-  reported.add(label);
-  try {
-    console.warn(
-      `Patchstack: the ${label} callback passed to createProtection failed and was ignored. Protection is unaffected; this is reported once per process. Cause: ${err && err.message ? err.message : String(err)}`
-    );
-  } catch {
-  }
-}
-
-// src/protect/engine/normalizer.js
-var HTML_ENTITIES = {
-  "&amp;": "&",
-  "&lt;": "<",
-  "&gt;": ">",
-  "&quot;": '"',
-  "&#39;": "'",
-  "&apos;": "'",
-  "&nbsp;": " ",
-  "&#x27;": "'",
-  "&#x22;": '"',
-  "&#x3C;": "<",
-  "&#x3E;": ">",
-  "&#x26;": "&",
-  "&#34;": '"',
-  "&#60;": "<",
-  "&#62;": ">",
-  "&#38;": "&"
-};
-var MAX_DECODE_ITERATIONS = 5;
-function normalize(value, options = {}) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  const opts = {
-    urlDecode: true,
-    htmlDecode: true,
-    sqlComments: true,
-    nullBytes: true,
-    whitespace: true,
-    ...options
-  };
-  let result = value;
-  if (opts.nullBytes) {
-    result = removeNullBytes(result);
-  }
-  if (opts.urlDecode) {
-    result = urlDecode(result);
-  }
-  if (opts.htmlDecode) {
-    result = htmlEntityDecode(result);
-  }
-  if (opts.sqlComments) {
-    result = removeSqlComments(result);
-  }
-  if (opts.whitespace) {
-    result = normalizeWhitespace(result);
-  }
-  return result;
-}
-function urlDecode(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  let result = value;
-  let previous = "";
-  let iterations = 0;
-  while (result !== previous && iterations < MAX_DECODE_ITERATIONS) {
-    previous = result;
-    iterations++;
-    try {
-      result = decodeURIComponent(result);
-    } catch {
-      result = safeUrlDecode(result);
-      break;
-    }
-  }
-  return result;
-}
-function safeUrlDecode(value) {
-  return value.replace(/%([0-9A-Fa-f]{2})/g, (match, hex) => {
-    try {
-      return String.fromCharCode(parseInt(hex, 16));
-    } catch {
-      return match;
-    }
-  });
-}
-function htmlEntityDecode(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  let result = value;
-  for (const [entity, char] of Object.entries(HTML_ENTITIES)) {
-    result = result.split(entity).join(char);
-  }
-  result = result.replace(/&#(\d+);/g, (match, code) => {
-    const num = parseInt(code, 10);
-    return num > 0 && num < 65536 ? String.fromCharCode(num) : match;
-  });
-  result = result.replace(/&#x([0-9A-Fa-f]+);/g, (match, hex) => {
-    const num = parseInt(hex, 16);
-    return num > 0 && num < 65536 ? String.fromCharCode(num) : match;
-  });
-  return result;
-}
-function removeSqlComments(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  let result = value;
-  result = result.replace(/\/\*[\s\S]*?\*\//g, " ");
-  result = result.replace(/\/\*![\s\S]*?\*\//g, " ");
-  return result;
-}
-function removeNullBytes(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  let result = value.replace(/\x00/g, "");
-  result = result.replace(/[\x01-\x08\x0B\x0C\x0E-\x1F]/g, "");
-  return result;
-}
-function normalizeWhitespace(value) {
-  if (typeof value !== "string") {
-    return value;
-  }
-  let result = value.replace(/[\t\r\n\f\v]+/g, " ");
-  result = result.replace(/ {2,}/g, " ");
-  return result;
-}
-var MAX_RAW_CHARS = 1024 * 1024;
-var MAX_RAW_NODES = 25e3;
-var MAX_RAW_DEPTH = 200;
-var MAX_RAW_ENTRIES = 2e3;
-function serializeForRawDetection(body) {
-  if (body === null || body === void 0) return "";
-  if (typeof body === "string") return body.slice(0, MAX_RAW_CHARS);
-  const visited = /* @__PURE__ */ new Set();
-  const output = [];
-  const stack = [{ kind: "value", value: body, depth: 0, root: true }];
-  let chars = 0;
-  let nodes = 0;
-  const append = (text) => {
-    if (chars >= MAX_RAW_CHARS) return;
-    const piece = String(text).slice(0, MAX_RAW_CHARS - chars);
-    output.push(piece);
-    chars += piece.length;
-  };
-  while (stack.length > 0 && chars < MAX_RAW_CHARS) {
-    const task = stack.pop();
-    if (task.kind === "text") {
-      append(task.text);
-      continue;
-    }
-    if (task.kind === "key") {
-      append(boundedJsonString(task.value));
-      append(":");
-      continue;
-    }
-    nodes++;
-    if (nodes > MAX_RAW_NODES) {
-      append('"[NodeLimit]"');
-      continue;
-    }
-    const value = task.value;
-    if (value === null || value === void 0) {
-      append(task.root ? "" : "null");
-      continue;
-    }
-    if (typeof value === "string") {
-      append(task.root ? value.slice(0, MAX_RAW_CHARS) : boundedJsonString(value));
-      continue;
-    }
-    if (typeof value !== "object") {
-      append(String(value).slice(0, MAX_RAW_CHARS));
-      continue;
-    }
-    if (visited.has(value)) {
-      append("[Circular]");
-      continue;
-    }
-    if (task.depth >= MAX_RAW_DEPTH) {
-      append('"[DepthLimit]"');
-      continue;
-    }
-    visited.add(value);
-    if (Array.isArray(value)) {
-      const length2 = Math.min(value.length, MAX_RAW_ENTRIES);
-      const items = [];
-      for (let i = 0; i < length2; i++) {
-        if (i > 0) items.push({ kind: "text", text: "," });
-        items.push({ kind: "value", value: readOwnValue(value, String(i)), depth: task.depth + 1, root: false });
-      }
-      if (value.length > length2) {
-        if (length2 > 0) items.push({ kind: "text", text: "," });
-        items.push({ kind: "text", text: '"[EntryLimit]"' });
-      }
-      stack.push({ kind: "text", text: "]" });
-      for (let i = items.length - 1; i >= 0; i--) stack.push(items[i]);
-      stack.push({ kind: "text", text: "[" });
-      continue;
-    }
-    let keys;
-    try {
-      keys = Object.getOwnPropertyNames(value);
-    } catch {
-      append('"[Unreadable]"');
-      continue;
-    }
-    const length = Math.min(keys.length, MAX_RAW_ENTRIES);
-    const entries = [];
-    for (let i = 0; i < length; i++) {
-      const key = keys[i];
-      if (i > 0) entries.push({ kind: "text", text: "," });
-      entries.push({ kind: "key", value: key });
-      entries.push({ kind: "value", value: readOwnValue(value, key), depth: task.depth + 1, root: false });
-    }
-    if (keys.length > length) {
-      if (length > 0) entries.push({ kind: "text", text: "," });
-      entries.push({ kind: "text", text: '"[EntryLimit]":null' });
-    }
-    stack.push({ kind: "text", text: "}" });
-    for (let i = entries.length - 1; i >= 0; i--) stack.push(entries[i]);
-    stack.push({ kind: "text", text: "{" });
-  }
-  return output.join("");
-}
-function boundedJsonString(value) {
-  return JSON.stringify(String(value).slice(0, MAX_RAW_CHARS));
-}
-function readOwnValue(value, key) {
-  try {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    return descriptor && Object.hasOwn(descriptor, "value") ? descriptor.value : "[Accessor]";
-  } catch {
-    return "[Unreadable]";
-  }
-}
-var INHERITED_ACCESSORS = /* @__PURE__ */ new Set(["headers", "query"]);
-function requestField(req, key) {
-  if (req === null || typeof req !== "object") return void 0;
-  if (Object.hasOwn(req, key)) return req[key];
-  if (!INHERITED_ACCESSORS.has(key)) return void 0;
-  let holder = Object.getPrototypeOf(req);
-  while (holder !== null && !Object.hasOwn(holder, key)) holder = Object.getPrototypeOf(holder);
-  if (holder === null || holder === Object.prototype) return void 0;
-  const descriptor = Object.getOwnPropertyDescriptor(holder, key);
-  if (typeof descriptor?.get !== "function") return void 0;
-  return req[key];
-}
-function normalizeRequest(req, options = {}) {
-  const ownRaw = Object.hasOwn(req ?? {}, "_rawBody") && typeof req._rawBody === "string";
-  const body = requestField(req, "body");
-  const url = requestField(req, "url");
-  const rawBody = ownRaw ? req._rawBody : serializeForRawDetection(body ?? null);
-  return {
-    query: normalizeObject(requestField(req, "query") || {}, options),
-    body: normalizeObject(body || {}, options),
-    headers: normalizeObject(requestField(req, "headers") || {}, options),
-    url: normalize(url || "", options),
-    originalUrl: normalize(requestField(req, "originalUrl") || url || "", options),
-    _rawBody: rawBody
-  };
-}
-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;
+      }
+    }
+    return true;
+  } catch (err) {
+    warnOnce2(fn, label, err);
+    return false;
   }
-  if (Array.isArray(value)) {
-    return value.map((item) => normalizeObject(item, options, depth + 1));
+}
+function warnOnce2(fn, label, err) {
+  let labels = reported.get(fn);
+  if (labels?.has(label)) return;
+  if (!labels) {
+    labels = /* @__PURE__ */ new Set();
+    reported.set(fn, labels);
   }
-  if (typeof value === "object" && value !== null) {
-    const result = {};
-    for (const [key, val] of Object.entries(value)) {
-      setOwn(result, key, normalizeObject(val, options, depth + 1));
+  labels.add(label);
+  if (warnings > MAX_WARNINGS) return;
+  warnings++;
+  try {
+    if (warnings > MAX_WARNINGS) {
+      console.warn("Patchstack: further failing callbacks passed to createProtection are not reported in this process.");
+      return;
     }
-    return result;
+    console.warn(
+      `Patchstack: the ${label} callback passed to createProtection failed and was ignored. Protection is unaffected; this callback's failures are reported once. Cause: ${err && err.message ? err.message : String(err)}`
+    );
+  } catch {
   }
-  return value;
 }
 
 // src/protect/engine/engine.js
@@ -3820,17 +3948,21 @@ function arrayKeyValue(value, matchObj) {
 }
 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 leaves = [];
   const stack = [[root, 0]];
   let visited = 0;
+  let truncated = false;
   while (stack.length) {
     const [node, depth] = stack.pop();
     if (node === null || node === void 0) continue;
     if (typeof node !== "object") {
-      out.push(node);
+      leaves.push(node);
+      continue;
+    }
+    if (depth >= maxDepth || visited >= nodeCap) {
+      truncated = true;
       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]);
@@ -3838,7 +3970,18 @@ function collectLeafValues(root, nodeCap = 2e4, maxDepth = 1e3) {
       for (const k of Object.keys(node)) stack.push([node[k], depth + 1]);
     }
   }
-  return out;
+  return { leaves, truncated };
+}
+function skipsOf(resolver) {
+  const skips = resolver?.skips;
+  return skips && skips.length > 0 ? { skips } : {};
+}
+function serialisedValue(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return void 0;
+  }
 }
 var warnedKeys = /* @__PURE__ */ new Set();
 function warnOnce3(key, message) {
@@ -3856,12 +3999,22 @@ function warnUnsupportedMatchType(type) {
     `[patchstack] Unsupported rule_v2 match type "${type}" \u2014 condition treated as no-match. Rules relying on it are not enforced by this engine.`
   );
 }
+var SPECIAL_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "ws", "wss", "ftp", "file"]);
+function trimControls(text) {
+  let start = 0;
+  let end = text.length;
+  while (start < end && text.charCodeAt(start) <= 32) start++;
+  while (end > start && text.charCodeAt(end - 1) <= 32) end--;
+  return text.slice(start, end);
+}
 function hostFromValue(value) {
-  const raw = String(value ?? "").trim();
+  const raw = trimControls(String(value ?? "").replace(/[\t\n\r]/g, "")).trim();
   if (raw === "") return "";
-  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw) || raw.startsWith("//")) {
+  const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(raw)?.[1]?.toLowerCase();
+  const relative = /^[\\/]{2}/.test(raw);
+  if (relative || /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) || scheme !== void 0 && SPECIAL_SCHEMES.has(scheme)) {
     try {
-      return new URL(raw.startsWith("//") ? `http:${raw}` : raw).hostname;
+      return new URL(relative ? `http:${raw}` : raw).hostname;
     } catch {
       return raw;
     }
@@ -3889,10 +4042,18 @@ function isInternalHost(hostname) {
     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] & 65472) === 65216) return true;
     if ((g[0] & 65024) === 64512) return true;
+    if ((g[0] & 65280) === 65280) return true;
+    const low32 = (g[6] << 16 >>> 0 | g[7]) >>> 0;
     if (allZeroHi && (g[5] === 65535 || g[5] === 0)) {
-      return isPrivateV4Int((g[6] << 16 >>> 0 | g[7]) >>> 0);
+      return isPrivateV4Int(low32);
+    }
+    if (g[0] === 100 && g[1] === 65435 && g[2] === 0 && g[3] === 0 && g[4] === 0 && g[5] === 0) {
+      return isPrivateV4Int(low32);
     }
+    if (g[0] === 100 && g[1] === 65435 && g[2] === 1) return true;
+    if (g[0] === 8194) return isPrivateV4Int((g[1] << 16 >>> 0 | g[2]) >>> 0);
     return false;
   }
   const v4 = parseIPv4ToInt(host);
@@ -3902,6 +4063,10 @@ function isInternalHost(hostname) {
 function isPrivateV4Int(n) {
   const a = n >>> 24 & 255;
   const b = n >>> 16 & 255;
+  const c = n >>> 8 & 255;
+  if (a >= 224) return true;
+  if (a === 192 && b === 0 && c === 0) return true;
+  if (a === 198 && (b === 18 || b === 19)) return true;
   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;
@@ -4250,8 +4415,12 @@ var RuleEngine = class {
     let normalizedReq;
     let resolver;
     try {
-      normalizedReq = { ...req, ...normalizeRequest(req) };
+      let limited = false;
+      normalizedReq = { ...req, ...normalizeRequest(req, { onLimit: () => {
+        limited = true;
+      } }) };
       resolver = new RequestResolver(normalizedReq);
+      if (limited) resolver.noteSkip("container-cap");
     } catch (err) {
       this.#reportError(err);
       return { blocked: false, rule: null, message: null };
@@ -4277,14 +4446,15 @@ var RuleEngine = class {
             // that re-read the request instead would be reading it a second time: a getter, a stream or
             // anything else that answers once can give a different value, and evidence that disagrees
             // with the match it belongs to is worse than none.
-            resolver
+            resolver,
+            ...skipsOf(resolver)
           };
         }
       } catch (err) {
         this.#reportError(err);
       }
     }
-    return { blocked: false, rule: null, message: null };
+    return { blocked: false, rule: null, message: null, ...skipsOf(resolver) };
   }
   #evaluateRule(conditions, resolver) {
     const inclusiveConditions = conditions.filter((c) => c.inclusive);
@@ -4340,9 +4510,15 @@ var RuleEngine = class {
         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)) {
+          const { leaves, truncated } = collectLeafValues(value);
+          for (const leaf of leaves) {
             if (matchValue(match.type, leaf, match.value, match)) return true;
           }
+          if (truncated) {
+            resolver.noteSkip("container-cap");
+            const text = serialisedValue(value);
+            if (text !== void 0 && matchValue(match.type, text, match.value, match)) return true;
+          }
         }
         continue;
       }
@@ -4729,6 +4905,9 @@ function conditionShapeProblem(condition) {
   if (nested && !named) {
     return `condition carries nested rules but its parameter is ${JSON.stringify(condition.parameter)}; a group must be {"parameter":"${GROUP_PARAMETER}"}`;
   }
+  if (condition.inclusive !== void 0 && typeof condition.inclusive !== "boolean") {
+    return "inclusive must be true or false";
+  }
   if (named && nested) {
     if (condition.match !== void 0) return "a group carries no match of its own; the engine ignores it";
     if (condition.mutations !== void 0) return "a group carries no mutations of its own; the engine ignores them";
@@ -5438,7 +5617,7 @@ async function fromFetchRequest(request, options = {}) {
     // that guessed differently would attribute one request to two addresses.
     ip: client.ip ?? "",
     _clientIp: client,
-    cookies: parseCookies(headers.cookie),
+    cookies: parseCookieHeader(headers.cookie),
     // Verbatim body text: preserves literal keys (e.g. `__proto__`) that JSON.stringify
     // drops, so prototype-pollution rules on `raw` are robust.
     _rawBody: rawBody,
@@ -5592,22 +5771,53 @@ function decodeExtendedValue(value) {
     return match[2];
   }
 }
-function parseCookies(header) {
-  const cookies = {};
-  if (!header) {
-    return cookies;
-  }
-  for (const pair of header.split(";")) {
-    const idx = pair.indexOf("=");
-    if (idx === -1) {
-      continue;
-    }
-    setOwn(cookies, pair.slice(0, idx).trim(), pair.slice(idx + 1).trim());
-  }
-  return cookies;
-}
 
 // src/protect/engine/node.js
+function readBodyPrefix(req, maxBytes, done) {
+  const chunks = [];
+  let retained = 0;
+  let size = 0;
+  let failed = false;
+  let finished = false;
+  const finish = (error, read) => {
+    if (finished) return;
+    finished = true;
+    done(error, read);
+  };
+  req.on("data", (chunk) => {
+    if (failed) return;
+    try {
+      const bytes = typeof chunk === "string" ? Buffer.from(chunk, req.readableEncoding || "utf8") : chunk;
+      size += bytes.length;
+      const take = Math.min(bytes.length, maxBytes - retained);
+      if (take <= 0) return;
+      chunks.push(take === bytes.length ? bytes : bytes.subarray(0, take));
+      retained += take;
+    } catch {
+      failed = true;
+      chunks.length = 0;
+    }
+  });
+  req.on("error", (error) => finish(error));
+  req.on("end", () => {
+    if (failed) {
+      finish(null, { text: "", overflow: false, size, failed: true });
+      return;
+    }
+    const prefix = Buffer.concat(chunks);
+    const overflow = size > maxBytes;
+    const text = (overflow ? prefix.subarray(0, completeUtf8Length(prefix)) : prefix).toString("utf8");
+    finish(null, { text, overflow, size, failed: false });
+  });
+}
+function completeUtf8Length(bytes) {
+  let start = bytes.length - 1;
+  while (start >= 0 && bytes.length - start <= 3 && (bytes[start] & 192) === 128) start--;
+  if (start < 0) return bytes.length;
+  const lead = bytes[start];
+  const needed = lead >= 240 ? 4 : lead >= 224 ? 3 : lead >= 192 ? 2 : 1;
+  return bytes.length - start < needed ? start : bytes.length;
+}
 function fromNodeRequest(req, rawBody = "", options = {}) {
   const method = (req.method || "GET").toUpperCase();
   const headers = {};
@@ -5653,29 +5863,41 @@ function fromNodeRequest(req, rawBody = "", options = {}) {
     headers,
     ip: client.ip ?? "",
     _clientIp: client,
-    cookies: parseCookies2(headers.cookie),
+    cookies: parseCookieHeader(headers.cookie),
     // Verbatim body text: preserves literal keys (e.g. `__proto__`) that JSON.stringify drops.
     _rawBody: rawBody
   };
 }
-function parseCookies2(header) {
-  const cookies = {};
-  if (!header) {
-    return cookies;
+
+// src/protect/egress.js
+var REGISTRY = /* @__PURE__ */ Symbol.for("patchstack.connect.egress-guard");
+function egressRegistry() {
+  const existing = globalThis[REGISTRY];
+  if (existing && existing.screens instanceof Set && existing.surfaces instanceof Map) return existing;
+  const created = { screens: /* @__PURE__ */ new Set(), surfaces: /* @__PURE__ */ new Map() };
+  Object.defineProperty(globalThis, REGISTRY, { value: created, configurable: true, writable: true });
+  return created;
+}
+var refusal = (host) => new Error(`Patchstack blocked an outbound request to a disallowed address: ${host}`);
+function readableDestination(input, init) {
+  try {
+    const raw = typeof input === "string" || input instanceof URL ? String(input) : input?.url ?? input?.href;
+    if (typeof raw !== "string" && !(raw instanceof URL)) return null;
+    const url = new URL(String(raw)).href;
+    const method = String(init?.method ?? input?.method ?? "GET").toUpperCase();
+    return { url, method };
+  } catch {
+    return null;
   }
-  for (const pair of header.split(";")) {
-    const idx = pair.indexOf("=");
-    if (idx === -1) {
-      continue;
-    }
-    setOwn(cookies, pair.slice(0, idx).trim(), pair.slice(idx + 1).trim());
+}
+function anyRefuses(screens, url, host, method) {
+  let refused = false;
+  for (const screen of screens) {
+    if (screen.block(url, host, method)) refused = true;
   }
-  return cookies;
+  return refused;
 }
-
-// src/protect/egress.js
 async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = true, lookup, allowHosts } = {}) {
-  const restores = [];
   if (typeof shouldBlock !== "function") return () => {
   };
   const exempt = new Set((allowHosts ?? []).map((h) => String(h).toLowerCase()));
@@ -5720,6 +5942,9 @@ async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = tr
       resolve(false);
     }
   });
+  const registry = egressRegistry();
+  const own = { block, prescreen: resolvesToDisallowed, dns: screen, skip };
+  registry.screens.add(own);
   const originalFetch = globalThis.fetch;
   if (typeof originalFetch === "function" && !originalFetch.__patchstackGuarded) {
     const REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
@@ -5792,15 +6017,19 @@ async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = tr
       } catch {
         host = null;
       }
-      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 screens = [...registry.screens];
+      if (anyRefuses(screens, u, host, method)) throw refusal(host ?? u);
+      const resolved = await Promise.all(screens.map((each) => each.prescreen(u, host, method)));
+      if (resolved.includes(true)) throw refusal(host ?? u);
     };
     const guarded = async (input, init) => {
       let cur;
       try {
         cur = new Request(input, { ...init || {}, redirect: "manual" });
       } catch {
+        const destination = readableDestination(input, init);
+        if (destination) await screenUrl(destination.url, destination.method);
+        else for (const each of registry.screens) each.skip("unrecognised-request", {});
         return originalFetch(input, init);
       }
       const callerRedirect = init && init.redirect || input && input.redirect || "follow";
@@ -5811,13 +6040,12 @@ async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = tr
       const headers = new Headers(cur.headers);
       const signal = cur.signal;
       const replay = captureReplayBody(cur);
+      const { body: _callerBody, ...callerOptions } = init || {};
       let body;
       for (let hop = 0; ; hop++) {
         let resp;
         try {
-          resp = await originalFetch(
-            hop === 0 ? cur : new Request(url, { method, headers, body, redirect: "manual", signal })
-          );
+          resp = hop === 0 ? await originalFetch(cur, { ...callerOptions, redirect: "manual" }) : await originalFetch(url, { ...callerOptions, method, headers, body, redirect: "manual", signal });
         } catch (error) {
           replay.cancel();
           throw error;
@@ -5825,7 +6053,7 @@ async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = tr
         const location = REDIRECT_STATUSES.has(resp.status) ? resp.headers.get("location") : null;
         if (!location) {
           replay.cancel();
-          return resp;
+          return hop === 0 ? resp : markRedirected(resp);
         }
         await discardResponseBody(resp);
         if (hop >= MAX_REDIRECTS) {
@@ -5858,8 +6086,12 @@ async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = tr
     };
     guarded.__patchstackGuarded = true;
     globalThis.fetch = guarded;
-    restores.push(() => {
-      if (globalThis.fetch === guarded) globalThis.fetch = originalFetch;
+    registry.surfaces.set(guarded, {
+      release() {
+        if (globalThis.fetch !== guarded) return false;
+        globalThis.fetch = originalFetch;
+        return true;
+      }
     });
   }
   let syncBuiltins = () => {
@@ -5873,12 +6105,16 @@ async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = tr
   for (const moduleName of ["node:http", "node:https"]) {
     try {
       const mod = await import(moduleName);
-      const restore = patchHttpModule(mod.default ?? mod, block, screen, skip);
-      if (restore) {
+      if (registry.surfaces.has(moduleName)) continue;
+      const release = patchHttpModule(mod.default ?? mod, registry);
+      if (release) {
         patchedAny = true;
-        restores.push(() => {
-          restore();
-          syncBuiltins();
+        registry.surfaces.set(moduleName, {
+          release() {
+            if (!release()) return false;
+            syncBuiltins();
+            return true;
+          }
         });
       }
     } catch {
@@ -5886,27 +6122,41 @@ async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = tr
   }
   if (patchedAny) syncBuiltins();
   return () => {
-    for (const restore of restores) {
+    registry.screens.delete(own);
+    if (registry.screens.size > 0) return;
+    for (const [name, surface] of registry.surfaces) {
       try {
-        restore();
+        if (surface.release()) registry.surfaces.delete(name);
       } catch {
       }
     }
   };
 }
-function patchHttpModule(http, block, screen, skip) {
+function markRedirected(response) {
+  try {
+    Object.defineProperty(response, "redirected", { value: true, configurable: true });
+  } catch {
+  }
+  return response;
+}
+function patchHttpModule(http, registry) {
   if (!http || typeof http.request !== "function" || http.__patchstackGuarded) return null;
   const originalRequest = http.request;
   const originalGet = http.get;
   const OriginalClientRequest = typeof http.ClientRequest === "function" ? http.ClientRequest : null;
   const guardArgs = (args) => {
     const target = extractHttpTarget(args);
-    if (target && block(target.url, target.host, target.method)) {
-      throw new Error(`Patchstack blocked an outbound request to a disallowed address: ${target.host ?? target.url}`);
-    }
-    if (target && screen && target.host && screen.isIP(target.host) === 0 && !screen.isExempt(target.host)) {
+    if (!target) return args;
+    const screens = [...registry.screens];
+    if (anyRefuses(screens, target.url, target.host, target.method)) throw refusal(target.host ?? target.url);
+    const resolving = target.host ? screens.filter((each) => each.dns && each.dns.isIP(target.host) === 0 && !each.dns.isExempt(target.host)) : [];
+    if (resolving.length > 0) {
+      const block = (url, host, method) => anyRefuses(resolving, url, host, method);
+      const skip = (reason, detail) => {
+        for (const each of resolving) each.skip(reason, detail);
+      };
       try {
-        return withScreeningLookup(args, target, block, screen.lookup, skip);
+        return withScreeningLookup(args, target, block, resolving[0].dns.lookup, skip);
       } catch {
       }
     }
@@ -5934,10 +6184,14 @@ function patchHttpModule(http, block, screen, skip) {
   }
   http.__patchstackGuarded = true;
   return () => {
-    if (http.request === guardedRequest) http.request = originalRequest;
-    if (guardedGet && http.get === guardedGet) http.get = originalGet;
-    if (GuardedClientRequest && http.ClientRequest === GuardedClientRequest) http.ClientRequest = OriginalClientRequest;
+    if (http.request !== guardedRequest) return false;
+    if (guardedGet && http.get !== guardedGet) return false;
+    if (GuardedClientRequest && http.ClientRequest !== GuardedClientRequest) return false;
+    http.request = originalRequest;
+    if (guardedGet) http.get = originalGet;
+    if (GuardedClientRequest) http.ClientRequest = OriginalClientRequest;
     delete http.__patchstackGuarded;
+    return true;
   };
 }
 function extractHttpTarget(args) {
@@ -6206,7 +6460,10 @@ var DEFAULT_RESPONSE_RULES = [
     // the constraint name, the column and the offending value discloses the schema anyway.
     action: "block",
     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" } }]
+    // Case-sensitive, because every signature is emitted in one fixed case. `ER_` is the one that needs
+    // it: MySQL error codes are whole upper-case words (`ER_DUP_ENTRY`), and matched without case or a
+    // word boundary it finds the end of ordinary identifiers such as a `cover__background` class name.
+    rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/(SQLSTATE\\[[0-9A-Z]+\\]|SequelizeDatabaseError|\\bER_[A-Z][A-Z0-9_]*|ORA-\\d{5}|PG::[A-Za-z]+Error|SQLITE_ERROR|You have an error in your SQL syntax)/" } }]
   },
   {
     id: "resp-exception-trace",
@@ -6838,7 +7095,7 @@ function makeRefreshHandler(tick, secret) {
   return async (request) => {
     if (!secret) return new Response("not found", { status: 404 });
     const provided = request?.headers?.get?.("x-patchstack-refresh") ?? null;
-    if (provided !== secret) return new Response("forbidden", { status: 403 });
+    if (!await sameSecret(provided, secret)) return new Response("forbidden", { status: 403 });
     let refreshed = true;
     try {
       const status = await runOnce();
@@ -6849,6 +7106,33 @@ function makeRefreshHandler(tick, secret) {
     return new Response(JSON.stringify({ refreshed }), { status: 200, headers: { "content-type": "application/json" } });
   };
 }
+async function sameSecret(provided, secret) {
+  if (typeof provided !== "string" || typeof secret !== "string") return false;
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle && typeof TextEncoder === "function") {
+    try {
+      const encoder2 = new TextEncoder();
+      const [a, b] = await Promise.all([
+        subtle.digest("SHA-256", encoder2.encode(provided)),
+        subtle.digest("SHA-256", encoder2.encode(secret))
+      ]);
+      return equalBytes(new Uint8Array(a), new Uint8Array(b));
+    } catch {
+    }
+  }
+  let diff = provided.length ^ secret.length;
+  const length = Math.max(provided.length, secret.length);
+  for (let i = 0; i < length; i++) {
+    diff |= (provided.charCodeAt(i) || 0) ^ (secret.charCodeAt(i) || 0);
+  }
+  return diff === 0;
+}
+function equalBytes(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
 
 // src/protect/detections.js
 init_pulse_token();
@@ -7584,9 +7868,180 @@ function hardensWithoutBody(rule) {
   if (!rule || !HEADER_ACTIONS.includes(rule.action)) return false;
   const { parameters, complete } = readRuleParameters(rule);
   if (!complete) return false;
-  return parameters.every(
-    (parameter) => BODY_INDEPENDENT.includes(parameter) || parameter.startsWith(BODY_INDEPENDENT_PREFIX)
+  return parameters.every(bodyIndependent);
+}
+function readsOnlyResponseHeaders(rule) {
+  if (!rule) return false;
+  const { parameters, complete } = readRuleParameters(rule);
+  if (!complete || !parameters.some(isHeaderParameter)) return false;
+  return parameters.every(bodyIndependent);
+}
+function isHeaderParameter(parameter) {
+  return parameter === "response.headers" || parameter.startsWith(BODY_INDEPENDENT_PREFIX);
+}
+function bodyIndependent(parameter) {
+  return BODY_INDEPENDENT.includes(parameter) || parameter.startsWith(BODY_INDEPENDENT_PREFIX);
+}
+
+// src/protect/supabase-guard.js
+var GUARD_PATH = "/_patchstack/guard";
+var DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var REQUEST_HEADER_DENYLIST = /* @__PURE__ */ new Set([
+  "connection",
+  "cookie",
+  "cookie2",
+  "forwarded",
+  "host",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-port",
+  "x-forwarded-proto",
+  "x-ps-target",
+  "x-real-ip"
+]);
+var RESPONSE_HEADER_DENYLIST = /* @__PURE__ */ new Set([
+  "connection",
+  "content-encoding",
+  "content-length",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "set-cookie",
+  "set-cookie2",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var BodyTooLargeError = class extends Error {
+};
+async function boundedBody(request, maxBytes) {
+  const stated2 = Number(request.headers.get("content-length"));
+  if (Number.isFinite(stated2) && stated2 > maxBytes) throw new BodyTooLargeError();
+  if (!request.body) return void 0;
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        void reader.cancel().catch(() => {
+        });
+        throw new BodyTooLargeError();
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+function requestHeaders(input) {
+  const output = new Headers();
+  const connectionTokens = new Set(
+    (input.get("connection") ?? "").split(",").map((value) => value.trim().toLowerCase()).filter(Boolean)
   );
+  input.forEach((value, key) => {
+    const lower = key.toLowerCase();
+    if (!REQUEST_HEADER_DENYLIST.has(lower) && !connectionTokens.has(lower)) output.append(key, value);
+  });
+  return output;
+}
+function responseHeaders(input) {
+  const output = new Headers();
+  const connectionTokens = new Set(
+    (input.get("connection") ?? "").split(",").map((value) => value.trim().toLowerCase()).filter(Boolean)
+  );
+  input.forEach((value, key) => {
+    const lower = key.toLowerCase();
+    if (!RESPONSE_HEADER_DENYLIST.has(lower) && !connectionTokens.has(lower)) output.append(key, value);
+  });
+  return output;
+}
+var SOURCE_REQUEST = /* @__PURE__ */ Symbol.for("@patchstack/connect.sourceRequest");
+function createSupabaseGuard({
+  protection,
+  supabaseUrl,
+  fetchImpl = fetch,
+  maxBodyBytes = DEFAULT_MAX_BODY_BYTES,
+  timeoutMs = DEFAULT_TIMEOUT_MS
+}) {
+  const guard = protection.fetchGuard();
+  const allowedOrigin = supabaseUrl ? new URL(supabaseUrl).origin : null;
+  const bodyLimit = Number.isFinite(maxBodyBytes) && maxBodyBytes > 0 ? maxBodyBytes : DEFAULT_MAX_BODY_BYTES;
+  const upstreamTimeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS;
+  return async function handleGuardRequest(request, ...hostArgs) {
+    const target = request.headers.get("x-ps-target");
+    if (!target) return new Response("patchstack: missing x-ps-target", { status: 400 });
+    let targetUrl;
+    try {
+      targetUrl = new URL(target);
+    } catch {
+      return new Response("patchstack: invalid target", { status: 400 });
+    }
+    if (!allowedOrigin || targetUrl.protocol !== "https:" || targetUrl.origin !== allowedOrigin) {
+      return new Response("patchstack: target not allowed", { status: 403 });
+    }
+    const hasBody = request.method !== "GET" && request.method !== "HEAD";
+    let body;
+    try {
+      body = hasBody ? await boundedBody(request, bodyLimit) : void 0;
+    } catch (error) {
+      if (error instanceof BodyTooLargeError) {
+        return new Response("patchstack: request body too large", { status: 413 });
+      }
+      throw error;
+    }
+    const forwardHeaders = requestHeaders(request.headers);
+    const evalReq = new Request(targetUrl.toString(), {
+      method: request.method,
+      // Inspect what the browser sent, including app-origin cookies; only the forwarded copy is
+      // sanitized at the cross-origin boundary below.
+      headers: request.headers,
+      body
+    });
+    Object.defineProperty(evalReq, SOURCE_REQUEST, { value: request });
+    const blocked = await guard(evalReq, ...hostArgs);
+    if (blocked) return blocked;
+    let upstream;
+    try {
+      upstream = await fetchImpl(targetUrl.toString(), {
+        method: request.method,
+        headers: forwardHeaders,
+        body,
+        redirect: "manual",
+        signal: AbortSignal.timeout(upstreamTimeout)
+      });
+    } catch (error) {
+      if (error?.name === "TimeoutError" || error?.name === "AbortError") {
+        return new Response("patchstack: upstream timed out", { status: 504 });
+      }
+      throw error;
+    }
+    const forwarded = new Response(upstream.body, {
+      status: upstream.status,
+      statusText: upstream.statusText,
+      headers: responseHeaders(upstream.headers)
+    });
+    return protection.screenResponse ? protection.screenResponse(forwarded, evalReq) : forwarded;
+  };
 }
 
 // src/protect/firewall-log.js
@@ -7637,8 +8092,13 @@ function resolveApiBase(pulseOrManifestUrl) {
 function createFirewallLogReporter(opts) {
   const creds = parseApiKey(opts.apiKey);
   if (!creds) {
-    return { record() {
-    }, flush: () => Promise.resolve(), stop: () => Promise.resolve() };
+    return {
+      record() {
+      },
+      flush: () => Promise.resolve(),
+      stop: () => Promise.resolve(),
+      health: () => ({ recorded: 0, delivered: 0, failed: 0, dropped: 0, queued: 0 })
+    };
   }
   const apiBase = safeBaseUrl(opts.apiBase, DEFAULT_API_BASE, "block-log API").replace(/\/$/, "");
   const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
@@ -7651,6 +8111,19 @@ function createFirewallLogReporter(opts) {
   let drainPromise = null;
   let activeController = null;
   let ended = false;
+  let recorded = 0;
+  let delivered = 0;
+  let failed = 0;
+  let dropped = 0;
+  let activeBatch = null;
+  const settle = (sent, outcome) => {
+    if (sent.counted) return;
+    sent.counted = true;
+    if (outcome === "delivered") delivered += sent.size;
+    else if (outcome === "failed") failed += sent.size;
+    else dropped += sent.size;
+    if (activeBatch === sent) activeBatch = null;
+  };
   let cachedToken = null;
   let tokenInflight = null;
   const fetchAccessToken = async (signal) => {
@@ -7704,10 +8177,16 @@ function createFirewallLogReporter(opts) {
     const attemptTimer = setTimeout(() => controller?.abort(), ATTEMPT_TIMEOUT_MS2);
     attemptTimer?.unref?.();
     let entry;
+    const sent = { size: batch.length, counted: false };
+    activeBatch = sent;
     entry = (async () => {
       try {
         const token = await fetchAccessToken(controller?.signal);
-        if (!token || ended) return;
+        if (ended) return;
+        if (!token) {
+          settle(sent, "failed");
+          return;
+        }
         const body = new URLSearchParams();
         body.set("type", "firewall");
         body.set("logs", JSON.stringify(batch));
@@ -7724,10 +8203,11 @@ function createFirewallLogReporter(opts) {
           // Both phases carry the attempt controller, so slow transports cannot accumulate work.
           ...controller ? { signal: controller.signal } : {}
         });
-        if (p && typeof p.then === "function") await p.catch(() => {
-        });
+        const res = p && typeof p.then === "function" ? await p.catch(() => null) : p;
+        settle(sent, res && res.ok ? "delivered" : "failed");
       } catch {
       } finally {
+        settle(sent, "failed");
         clearTimeout(attemptTimer);
         if (activeController === controller) activeController = null;
         if (inFlight === entry) inFlight = null;
@@ -7754,7 +8234,11 @@ function createFirewallLogReporter(opts) {
       if (stopped) return;
       const fid = event?.rule?.id;
       if (fid === void 0 || fid === null || fid === "") return;
-      if (queue.length >= MAX_QUEUE2) return;
+      if (queue.length >= MAX_QUEUE2) {
+        dropped++;
+        return;
+      }
+      recorded++;
       queue.push({
         fid,
         method: event.method ?? null,
@@ -7770,6 +8254,10 @@ function createFirewallLogReporter(opts) {
       if (!timer) timer = setTimeout(flush, flushMs);
     },
     flush,
+    /** Where the records went so far; see the counters above. `queued` is what is waiting now. */
+    health() {
+      return { recorded, delivered, failed, dropped, queued: queue.length };
+    },
     /**
      * Stop, and hand back a wait for what was outstanding.
      *
@@ -7788,6 +8276,8 @@ function createFirewallLogReporter(opts) {
         ended = true;
         activeController?.abort();
         activeController = null;
+        if (activeBatch) settle(activeBatch, "dropped");
+        dropped += queue.length;
         queue = [];
         inFlight = null;
       };
@@ -7824,165 +8314,6 @@ function telemetryEnabled() {
   return !/^(0|false|off|no)$/i.test(String(v));
 }
 
-// src/protect/supabase-guard.js
-var GUARD_PATH = "/_patchstack/guard";
-var DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
-var DEFAULT_TIMEOUT_MS = 3e4;
-var REQUEST_HEADER_DENYLIST = /* @__PURE__ */ new Set([
-  "connection",
-  "cookie",
-  "cookie2",
-  "forwarded",
-  "host",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade",
-  "x-forwarded-for",
-  "x-forwarded-host",
-  "x-forwarded-port",
-  "x-forwarded-proto",
-  "x-ps-target",
-  "x-real-ip"
-]);
-var RESPONSE_HEADER_DENYLIST = /* @__PURE__ */ new Set([
-  "connection",
-  "content-encoding",
-  "content-length",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "set-cookie",
-  "set-cookie2",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade"
-]);
-var BodyTooLargeError = class extends Error {
-};
-async function boundedBody(request, maxBytes) {
-  const stated2 = Number(request.headers.get("content-length"));
-  if (Number.isFinite(stated2) && stated2 > maxBytes) throw new BodyTooLargeError();
-  if (!request.body) return void 0;
-  const reader = request.body.getReader();
-  const chunks = [];
-  let total = 0;
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      total += value.byteLength;
-      if (total > maxBytes) {
-        void reader.cancel().catch(() => {
-        });
-        throw new BodyTooLargeError();
-      }
-      chunks.push(value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const body = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return body;
-}
-function requestHeaders(input) {
-  const output = new Headers();
-  const connectionTokens = new Set(
-    (input.get("connection") ?? "").split(",").map((value) => value.trim().toLowerCase()).filter(Boolean)
-  );
-  input.forEach((value, key) => {
-    const lower = key.toLowerCase();
-    if (!REQUEST_HEADER_DENYLIST.has(lower) && !connectionTokens.has(lower)) output.append(key, value);
-  });
-  return output;
-}
-function responseHeaders(input) {
-  const output = new Headers();
-  const connectionTokens = new Set(
-    (input.get("connection") ?? "").split(",").map((value) => value.trim().toLowerCase()).filter(Boolean)
-  );
-  input.forEach((value, key) => {
-    const lower = key.toLowerCase();
-    if (!RESPONSE_HEADER_DENYLIST.has(lower) && !connectionTokens.has(lower)) output.append(key, value);
-  });
-  return output;
-}
-function createSupabaseGuard({
-  protection,
-  supabaseUrl,
-  fetchImpl = fetch,
-  maxBodyBytes = DEFAULT_MAX_BODY_BYTES,
-  timeoutMs = DEFAULT_TIMEOUT_MS
-}) {
-  const guard = protection.fetchGuard();
-  const allowedOrigin = supabaseUrl ? new URL(supabaseUrl).origin : null;
-  const bodyLimit = Number.isFinite(maxBodyBytes) && maxBodyBytes > 0 ? maxBodyBytes : DEFAULT_MAX_BODY_BYTES;
-  const upstreamTimeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS;
-  return async function handleGuardRequest(request) {
-    const target = request.headers.get("x-ps-target");
-    if (!target) return new Response("patchstack: missing x-ps-target", { status: 400 });
-    let targetUrl;
-    try {
-      targetUrl = new URL(target);
-    } catch {
-      return new Response("patchstack: invalid target", { status: 400 });
-    }
-    if (!allowedOrigin || targetUrl.protocol !== "https:" || targetUrl.origin !== allowedOrigin) {
-      return new Response("patchstack: target not allowed", { status: 403 });
-    }
-    const hasBody = request.method !== "GET" && request.method !== "HEAD";
-    let body;
-    try {
-      body = hasBody ? await boundedBody(request, bodyLimit) : void 0;
-    } catch (error) {
-      if (error instanceof BodyTooLargeError) {
-        return new Response("patchstack: request body too large", { status: 413 });
-      }
-      throw error;
-    }
-    const forwardHeaders = requestHeaders(request.headers);
-    const evalReq = new Request(targetUrl.toString(), {
-      method: request.method,
-      // Inspect what the browser sent, including app-origin cookies; only the forwarded copy is
-      // sanitized at the cross-origin boundary below.
-      headers: request.headers,
-      body
-    });
-    const blocked = await guard(evalReq);
-    if (blocked) return blocked;
-    let upstream;
-    try {
-      upstream = await fetchImpl(targetUrl.toString(), {
-        method: request.method,
-        headers: forwardHeaders,
-        body,
-        redirect: "manual",
-        signal: AbortSignal.timeout(upstreamTimeout)
-      });
-    } catch (error) {
-      if (error?.name === "TimeoutError" || error?.name === "AbortError") {
-        return new Response("patchstack: upstream timed out", { status: 504 });
-      }
-      throw error;
-    }
-    const forwarded = new Response(upstream.body, {
-      status: upstream.status,
-      statusText: upstream.statusText,
-      headers: responseHeaders(upstream.headers)
-    });
-    return protection.screenResponse ? protection.screenResponse(forwarded, evalReq) : forwarded;
-  };
-}
-
 // src/protect/verify-sentinel.js
 var VERIFY_HEADER = "x-patchstack-verify";
 var CHALLENGE = "PATCHSTACK_VERIFY_CHALLENGE";
@@ -8169,20 +8500,47 @@ async function createProtection(options = {}) {
       whitelist_keys: delivered.whitelist_keys,
       onError
     });
-    responseRuleSet = responseRules.map((rule) => ({
-      rule,
-      engine: new RuleEngine({ firewall: [rule], onError }),
-      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
-    }));
+    responseRuleSet = responseRules.map((rule) => {
+      const unscoped = [];
+      const rewrites = rule.action === "redact" || rule.action === "encode";
+      let derived;
+      try {
+        const redactors = rewrites ? extractRedactors(rule, (parameter) => unscoped.push(parameter)) : null;
+        const mutatedSpan = rewrites && hasSpanMutations(rule);
+        derived = {
+          redactors,
+          mutatedSpan,
+          // A redaction that reads response headers only, and masks spans in them, and an explicit block
+          // that reads response headers only, are decided and carried out without the body — so they
+          // still apply to a response whose body was not screened.
+          redactsHeaders: rule.action === "redact" && !mutatedSpan && (redactors ?? []).some((r) => !r.jsonPath) && readsOnlyResponseHeaders(rule),
+          blocksOnHeaders: rule.action === "block" && readsOnlyResponseHeaders(rule)
+        };
+      } catch (err) {
+        notify(onError, err, "onError");
+        derived = { redactors: null, mutatedSpan: false, redactsHeaders: false, blocksOnHeaders: false };
+      }
+      if (unscoped.length) {
+        notify(
+          onError,
+          new Error(
+            `Patchstack: response rule ${JSON.stringify(rule.id ?? null)} has a condition whose parameter names no place in the response to mask (${unscoped.map((p) => JSON.stringify(p ?? null)).join(", ")}); its matches are not masked`
+          ),
+          "onError"
+        );
+      }
+      return {
+        rule,
+        engine: new RuleEngine({ firewall: [rule], onError }),
+        ...derived,
+        // 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 responses with no candidate
+        // — the common case — cutting CPU/latency and shrinking the regex/ReDoS surface.
+        // Case-insensitive, and checked against the header values as well as the body, since a rule may
+        // read either.
+        prefilter: Array.isArray(rule.prefilter) && rule.prefilter.length ? rule.prefilter.map((s) => String(s).toLowerCase()) : null
+      };
+    });
     egressRuleSet = egressRules.map((rule) => ({
       rule,
       engine: new RuleEngine({ firewall: [rule], onError })
@@ -8196,6 +8554,9 @@ async function createProtection(options = {}) {
     skipCounts[key] = (skipCounts[key] ?? 0) + 1;
     notify(onSkip, { phase, reason, detail, count: skipCounts[key] }, "onSkip");
   };
+  const recordEvaluationSkips = (result) => {
+    for (const reason of result?.skips ?? []) recordSkip("request", reason);
+  };
   const maskFn = typeof options.maskWith === "function" ? options.maskWith : () => typeof options.maskWith === "string" ? options.maskWith : "[REDACTED]";
   const ruleMode = (rule) => rule?.enforcement === "dry-run" ? "dry-run" : mode;
   const planCache = createPlanCache();
@@ -8238,15 +8599,19 @@ async function createProtection(options = {}) {
     });
     return effectiveMode === "block" ? block() : allow2();
   };
+  const decidedByHeaders = (_rule, entry) => Boolean(entry?.redactsHeaders || entry?.blocksOnHeaders);
+  const decidedWithoutBody = (rule, entry) => hardensWithoutBody(rule) || decidedByHeaders(rule, entry);
   const screenText = (text, meta, reqCtx, only) => {
     let blockRule = null;
     const redactions = [];
     const headerMutations = [];
     let lowerText = null;
-    for (const { rule, engine: re, redactors, prefilter, mutatedSpan } of responseRuleSet) {
-      if (only && !only(rule)) continue;
+    const responseSkips = /* @__PURE__ */ new Set();
+    for (const entry of responseRuleSet) {
+      const { rule, engine: re, redactors, prefilter, mutatedSpan } = entry;
+      if (only && !only(rule, entry)) continue;
       if (prefilter) {
-        if (lowerText === null) lowerText = text.toLowerCase();
+        if (lowerText === null) lowerText = prefilterText(text, meta.headers);
         if (!prefilter.some((p) => lowerText.includes(p))) continue;
       }
       let result;
@@ -8256,6 +8621,11 @@ async function createProtection(options = {}) {
         notify(onError, err, "onError");
         continue;
       }
+      for (const reason of result.skips ?? []) {
+        if (responseSkips.has(reason)) continue;
+        responseSkips.add(reason);
+        recordSkip("response", reason);
+      }
       if (!result.blocked) continue;
       const responseMode = ruleMode(rule);
       onDetect({
@@ -8285,6 +8655,8 @@ async function createProtection(options = {}) {
     if (blockRule) return { verdict: "block" };
     let body = text;
     const headers = { ...meta.headers || {} };
+    let responseIsJson;
+    let structure;
     for (const { rule, redactors } of redactions) {
       const mask = maskFn(rule.category);
       const transform = rule.action === "encode" ? htmlEscape : null;
@@ -8293,23 +8665,32 @@ async function createProtection(options = {}) {
       if (pathRedactors.length) body = applyPathRedactors(body, pathRedactors, mask, screenCap, transform);
       if (!spanRedactors.length) continue;
       const beforeSpan = body;
-      body = applyRedactors(body, spanRedactors, mask, transform);
-      if (body !== beforeSpan && !preservesJsonStructure(beforeSpan, body)) return { verdict: "block" };
+      const bodySpans = spanRedactors.filter((r) => r.scope.body === true);
+      if (bodySpans.length) body = applyRedactors(body, bodySpans, mask, transform);
+      if (body !== beforeSpan) {
+        responseIsJson ??= isJson(text);
+        if (responseIsJson) {
+          if (structure?.text !== beforeSpan) structure = { text: beforeSpan, tokens: lexJson(beforeSpan) };
+          const tokens = lexJson(body);
+          if (!sameJsonStructure(structure.text, structure.tokens, body, tokens)) return { verdict: "block" };
+          structure = { text: body, tokens };
+        }
+      }
       if (transform) continue;
       for (const name of Object.keys(headers)) {
         const value = headers[name];
+        const headerSpans = spanRedactors.filter((r) => masksHeader(r, name));
         if (typeof value === "string") {
-          setOwn(headers, name, applyRedactors(value, spanRedactors, mask));
+          setOwn(headers, name, applyRedactors(value, headerSpans, mask));
         } else if (Array.isArray(value)) {
           setOwn(
             headers,
             name,
-            value.map((item) => typeof item === "string" ? applyRedactors(item, spanRedactors, mask) : item)
+            value.map((item) => typeof item === "string" ? applyRedactors(item, headerSpans, mask) : item)
           );
         }
       }
     }
-    if (body !== text && isJson(text) && !isJson(body)) return { verdict: "block" };
     for (const rule of headerMutations) applyHeaderMutation(headers, rule);
     return { verdict: "redact", body, headers };
   };
@@ -8352,18 +8733,53 @@ async function createProtection(options = {}) {
       }
     };
   };
-  const screenFetchRequest = async (request) => {
+  const peerOf = (request, hostArgs) => {
+    if (typeof options.peerAddress !== "function") return void 0;
+    try {
+      return options.peerAddress(request?.[SOURCE_REQUEST] ?? request, ...hostArgs);
+    } catch (err) {
+      notify(onError, err, "onError");
+      return void 0;
+    }
+  };
+  let warnedNoPeer = false;
+  const warnNoPeer = () => {
+    if (warnedNoPeer) return;
+    warnedNoPeer = true;
+    const message = "[patchstack] trustedProxy is set, but this Fetch runtime supplied no peer address, so forwarded headers are not used and client addresses read as unavailable. Pass { peerAddress } to supply one.";
+    if (typeof onError === "function") notify(onError, new Error(message), "onError");
+    else console.warn(message);
+  };
+  const clientByRequest = /* @__PURE__ */ new WeakMap();
+  const clientForResponse = (request, hostArgs) => {
+    const known = clientByRequest.get(request);
+    if (known) return known;
+    const client = resolveClientIp({
+      peer: peerOf(request, hostArgs),
+      headers: headerObject(request.headers),
+      trustedProxy: options.trustedProxy
+    });
+    if (options.trustedProxy !== void 0 && client.source === "unavailable") warnNoPeer();
+    return client;
+  };
+  const screenFetchRequest = async (request, hostArgs = []) => {
     let result;
     let shaped;
     try {
       shaped = await fromFetchRequest(request, {
+        peer: peerOf(request, hostArgs),
         trustedProxy: options.trustedProxy,
         maxBodyBytes: options.maxBodyBytes
       });
+      if (shaped?._clientIp) {
+        clientByRequest.set(request, shaped._clientIp);
+        if (options.trustedProxy !== void 0 && shaped._clientIp.source === "unavailable") warnNoPeer();
+      }
       if (shaped?._bodyInspectionSkip) {
         recordSkip("request", shaped._bodyInspectionSkip, { limit: options.maxBodyBytes ?? 1024 * 1024 });
       }
       result = engine.evaluate(shaped);
+      recordEvaluationSkips(result);
     } catch (err) {
       notify(onError, err, "onError");
       return { blocked: null, client: void 0 };
@@ -8413,15 +8829,19 @@ async function createProtection(options = {}) {
     const read = await readTextResponse(response, screenCap);
     if (read.skip) {
       if (read.skip !== "not-a-response") {
-        recordSkip("response", read.skip, { status: response?.status, ...read.encoding ? { encoding: read.encoding } : {} });
+        recordSkip("response", read.skip, {
+          status: response?.status,
+          ...read.encoding ? { encoding: read.encoding } : {},
+          ...read.charset ? { charset: read.charset } : {}
+        });
       }
       if (read.skip === "not-a-response") return response;
       return hardenHeadersOnly(response, reqCtx);
     }
-    const text = read.text;
+    const text = readJsonEscapes(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);
+    if (r.verdict === "block" || r.verdict === "redact" && outgrowsCharset(read.ascii, r.body)) return leakResponse();
+    if (r.verdict === "redact") return rebuildResponse(response, withBom(read.bom, r.body), r.headers);
     return response;
   };
   const headerValueChanged = (was, value) => {
@@ -8483,7 +8903,8 @@ async function createProtection(options = {}) {
   const hardenHeadersOnly = (response, reqCtx) => {
     try {
       const meta = { status: response.status, headers: headerObject(response.headers) };
-      const r = screenText("", meta, reqCtx, hardensWithoutBody);
+      const r = screenText("", meta, reqCtx, decidedWithoutBody);
+      if (r.verdict === "block") return leakResponse();
       if (r.verdict !== "redact" || !r.headers) return response;
       if (!headersChanged(meta.headers, r.headers)) return response;
       return rebuildResponse(response, response.body, r.headers);
@@ -8503,6 +8924,8 @@ async function createProtection(options = {}) {
     const chunks = [];
     let size = 0;
     let overflow = false;
+    let withheld = false;
+    let headScreened = false;
     const MAX = screenCap;
     let hardened = false;
     let answeredWithoutBody = false;
@@ -8534,6 +8957,7 @@ async function createProtection(options = {}) {
       }
     };
     const stillToAnswer = (rule) => !hardensWithoutBody(rule);
+    const notYetAnswered = (rule, entry) => (!answeredWithoutBody || stillToAnswer(rule)) && !(headScreened && decidedByHeaders(rule, entry));
     let pendingHead = null;
     let sending = false;
     const origWriteHead = typeof res.writeHead === "function" ? res.writeHead.bind(res) : null;
@@ -8595,7 +9019,12 @@ async function createProtection(options = {}) {
     if (typeof res.flushHeaders === "function") {
       const origFlushHeaders = res.flushHeaders.bind(res);
       res.flushHeaders = function() {
-        sendHead();
+        const unread = screenUnreadHead();
+        if (unread?.withhold) {
+          sendWithheld();
+          return void 0;
+        }
+        sendHead(unread);
         return origFlushHeaders();
       };
     }
@@ -8630,6 +9059,32 @@ async function createProtection(options = {}) {
         headers: at === -1 ? set2 : { ...set2, ...writeHeadHeaderObject(pendingHead[at]) }
       };
     };
+    const screenUnreadHead = () => {
+      if (headScreened) return void 0;
+      headScreened = true;
+      try {
+        const head = effectiveHead();
+        const r = screenText("", head, reqCtx, decidedByHeaders);
+        if (r.verdict === "block") {
+          if (!reallySent()) return { withhold: true };
+          recordSkip("response", "headers-sent", { action: "block" });
+          return void 0;
+        }
+        if (r.verdict !== "redact" || !r.headers) return void 0;
+        const changed = /* @__PURE__ */ new Map();
+        for (const [name, value] of Object.entries(r.headers)) {
+          if (headerValueChanged(head.headers[name], value)) changed.set(name.toLowerCase(), value);
+        }
+        if (changed.size && reallySent()) {
+          recordSkip("response", "headers-sent", { headers: [...changed.keys()] });
+          return void 0;
+        }
+        return changed.size ? { headers: changed } : void 0;
+      } catch (err) {
+        notify(onError, err, "onError");
+        return void 0;
+      }
+    };
     const sendHead = (changes) => {
       if (sending) return;
       const hardened2 = hardenOnce();
@@ -8651,6 +9106,17 @@ async function createProtection(options = {}) {
       applyToResponse({ headers: merged });
       origWriteHead(...args);
     };
+    const sendWithheld = (cb) => {
+      const body = JSON.stringify({ error: "Response withheld by Patchstack (sensitive data detected)" });
+      const headers = /* @__PURE__ */ new Map();
+      for (const name of Object.keys(effectiveHead().headers)) headers.set(name.toLowerCase(), null);
+      headers.set("content-type", "application/json");
+      headers.set("content-length", String(Buffer.byteLength(body)));
+      headers.set("transfer-encoding", null);
+      withheld = true;
+      sendHead({ status: 500, headers });
+      return origEnd(body, cb);
+    };
     const applyToResponse = (changes) => {
       if (changes.status !== void 0) res.statusCode = changes.status;
       for (const [name, value] of changes.headers ?? []) {
@@ -8666,7 +9132,12 @@ async function createProtection(options = {}) {
       const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, typeof enc === "string" ? enc : "utf8");
       size += buf.length;
       if (size > MAX) {
-        sendHead();
+        const unread = screenUnreadHead();
+        if (unread?.withhold) {
+          sendWithheld();
+          return;
+        }
+        sendHead(unread);
         for (const c of chunks) origWrite(c);
         chunks.length = 0;
         origWrite(buf);
@@ -8677,6 +9148,11 @@ async function createProtection(options = {}) {
       chunks.push(buf);
     };
     res.write = function(chunk, enc, cb) {
+      if (withheld) {
+        if (typeof enc === "function") enc();
+        else if (typeof cb === "function") cb();
+        return true;
+      }
       if (overflow) return origWrite(chunk, enc, cb);
       collect(chunk, enc);
       if (typeof enc === "function") enc();
@@ -8692,15 +9168,24 @@ async function createProtection(options = {}) {
         cb = enc;
         enc = void 0;
       }
+      if (withheld) {
+        if (typeof cb === "function") cb();
+        return res;
+      }
       if (overflow) {
         if (chunk != null) origWrite(chunk, enc);
         return origEnd(cb);
       }
       collect(chunk, enc);
+      if (withheld) {
+        if (typeof cb === "function") cb();
+        return res;
+      }
       if (overflow) return origEnd(cb);
       hardenOnce();
-      const passThrough = () => {
-        sendHead();
+      const passThrough = (changes) => {
+        if (changes?.withhold) return sendWithheld(cb);
+        sendHead(changes);
         for (const c of chunks) origWrite(c);
         return origEnd(cb);
       };
@@ -8711,21 +9196,28 @@ async function createProtection(options = {}) {
       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");
-        return passThrough();
+        return passThrough(screenUnreadHead());
       }
       const codings = declaredCodings(head.headers["content-encoding"]);
       if (codings.length > 0 && stillEncoded(buffer)) {
         recordSkip("response", "encoded-body", { encoding: codings.join(", ") });
-        return passThrough();
+        return passThrough(screenUnreadHead());
+      }
+      const reading = charsetReading(ct, buffer);
+      if (reading.skip) {
+        recordSkip("response", "unsupported-charset", { charset: reading.skip });
+        return passThrough(screenUnreadHead());
       }
-      const text = buffer.toString("utf8");
+      const text = readJsonEscapes(buffer.toString("utf8", reading.bom ? 3 : 0));
       let r;
       try {
-        r = screenText(text, head, reqCtx, answeredWithoutBody ? stillToAnswer : void 0);
+        r = screenText(text, head, reqCtx, notYetAnswered);
       } catch (err) {
         notify(onError, err, "onError");
         return passThrough();
       }
+      if (r.verdict === "redact" && outgrowsCharset(reading.ascii, r.body)) r = { verdict: "block" };
+      if (r.verdict === "redact") r = { ...r, body: withBom(reading.bom, r.body) };
       if (r.verdict !== "block" && r.verdict !== "redact") return passThrough();
       if (reallySent() && res.chunkedEncoding !== true) {
         notify(onError, new Error("Patchstack: response withheld \u2014 its headers were sent before the body could be screened"), "onError");
@@ -8733,20 +9225,11 @@ async function createProtection(options = {}) {
         return res;
       }
       if (r.verdict === "block") {
-        const body = JSON.stringify({ error: "Response withheld by Patchstack (sensitive data detected)" });
         if (reallySent()) {
           res.destroy?.();
           return res;
         }
-        sendHead({
-          status: 500,
-          headers: /* @__PURE__ */ new Map([
-            ["content-type", "application/json"],
-            ["content-length", String(Buffer.byteLength(body))],
-            ["transfer-encoding", null]
-          ])
-        });
-        return origEnd(body, cb);
+        return sendWithheld(cb);
       }
       const changed = /* @__PURE__ */ new Map();
       if (r.headers) {
@@ -8842,21 +9325,15 @@ async function createProtection(options = {}) {
     // .fetch(), and by the Supabase guard on its forwarded upstream response.
     // A standalone response screen with no request phase of its own — the Supabase guard's forwarded
     // upstream response. It resolves once here, which is the only resolution for this call.
-    screenResponse: (response, request) => screenResp(
-      response,
-      request ? reqContextFromFetch(
-        request,
-        resolveClientIp({ headers: headerObject(request.headers), trustedProxy: options.trustedProxy })
-      ) : void 0
-    ),
+    screenResponse: (response, request, ...hostArgs) => screenResp(response, request ? reqContextFromFetch(request, clientForResponse(request, hostArgs)) : void 0),
     // (request) => Response | null   (null = allow, caller proceeds). Request phase only.
     fetchGuard() {
-      return async (request) => (await screenFetchRequest(request)).blocked;
+      return async (request, ...hostArgs) => (await screenFetchRequest(request, hostArgs)).blocked;
     },
     // Wrap a fetch handler: screens the request, then the response (redact/block).
     fetch(handler) {
       return async (request, ...rest) => {
-        const { blocked, client } = await screenFetchRequest(request);
+        const { blocked, client } = await screenFetchRequest(request, rest);
         if (blocked) return blocked;
         const response = await handler(request, ...rest);
         return screenResp(response, reqContextFromFetch(request, client));
@@ -8870,6 +9347,7 @@ async function createProtection(options = {}) {
         const { shaped, client } = shapeExpressRequest(req);
         try {
           result = engine.evaluate(shaped);
+          recordEvaluationSkips(result);
         } catch (err) {
           notify(onError, err, "onError");
           if (exprOptions.screenResponses) wrapNodeResponse(res, reqContextFromNode(req, client));
@@ -8904,33 +9382,25 @@ async function createProtection(options = {}) {
           screenNodeRequest(req, res, next, "", req.body);
           return;
         }
-        const chunks = [];
-        let size = 0;
-        let overflow = false;
-        req.on("data", (chunk) => {
-          size += chunk.length;
-          if (size > maxBytes) {
-            overflow = true;
+        readBodyPrefix(req, maxBytes, (err, read) => {
+          if (err) {
+            notify(onError, err, "onError");
+            next();
             return;
           }
-          chunks.push(chunk);
-        });
-        req.on("error", (err) => {
-          notify(onError, err, "onError");
-          next();
-        });
-        req.on("end", () => {
-          if (overflow) recordSkip("request", "body-cap", { bytes: size, limit: maxBytes });
-          screenNodeRequest(req, res, next, overflow ? "" : Buffer.concat(chunks).toString("utf8"));
+          if (read.overflow) recordSkip("request", "body-cap", { bytes: read.size, limit: maxBytes });
+          if (read.failed) recordSkip("request", "read-failed", { bytes: read.size });
+          screenNodeRequest(req, res, next, read.text, void 0, read.overflow || read.failed);
         });
       };
-      function screenNodeRequest(req, res, next, rawBody, parsedBody) {
+      function screenNodeRequest(req, res, next, rawBody, parsedBody, truncated = false) {
         let shaped;
         let result;
         try {
           shaped = fromNodeRequest(req, rawBody, { trustedProxy: options.trustedProxy });
           if (parsedBody !== void 0 && parsedBody !== null) shaped.body = parsedBody;
           result = engine.evaluate(shaped);
+          recordEvaluationSkips(result);
         } catch (err) {
           notify(onError, err, "onError");
           return next();
@@ -8949,7 +9419,7 @@ async function createProtection(options = {}) {
             }
           },
           () => {
-            if (req.body === void 0) req.body = shaped.body;
+            if (req.body === void 0 && !truncated) req.body = shaped.body;
             if (nodeOptions.screenResponses) wrapNodeResponse(res, reqContextFromNode(req, shaped?._clientIp));
             next();
           },
@@ -9015,12 +9485,17 @@ async function createProtection(options = {}) {
   protection.stop = () => {
     loop?.stop();
     recovery?.stop();
+    protection.uninstallEgress?.();
     const outstanding = [firewallLog?.stop(), detections?.stop()].filter(
       (wait) => wait && typeof wait.then === "function"
     );
     return Promise.all(outstanding).then(() => void 0);
   };
-  protection.stopRefresh = protection.stop;
+  protection.stopRefresh = () => {
+    loop?.stop();
+    recovery?.stop();
+    return Promise.resolve();
+  };
   Object.defineProperty(protection, "ruleSource", {
     get: () => ({ ...ruleSource }),
     enumerable: true
@@ -9033,6 +9508,10 @@ async function createProtection(options = {}) {
     get: () => detections ? () => detections.health() : void 0,
     enumerable: true
   });
+  Object.defineProperty(protection, "blockLogHealth", {
+    get: () => firewallLog ? () => firewallLog.health() : void 0,
+    enumerable: true
+  });
   return protection;
 }
 function accessorOf(obj, name) {
@@ -9107,6 +9586,14 @@ function screenableContentType(ct) {
   if (base === "application/octet-stream") return "sniff";
   return "skip";
 }
+function prefilterText(body, headers) {
+  const values = [];
+  for (const value of Object.values(headers ?? {})) {
+    if (Array.isArray(value)) values.push(...value.map(String));
+    else if (value !== void 0 && value !== null) values.push(String(value));
+  }
+  return [body, ...values].join("\n").toLowerCase();
+}
 function looksBinary(bytes) {
   const n = Math.min(bytes.length, 512);
   let ctrl = 0;
@@ -9130,6 +9617,52 @@ function stillEncoded(bytes) {
     return true;
   }
 }
+var UTF8_CHARSETS = /* @__PURE__ */ new Set(["utf-8", "utf8", "unicode-1-1-utf-8", "us-ascii", "ascii"]);
+var WIDE_CHARSET = /^(?:utf-?(?:16|32)|ucs-?[24]|unicode|iso-10646)/;
+function declaredCharset(ct) {
+  const m = /;\s*charset\s*=\s*(?:"([^"]*)"|([^;\s]*))/i.exec(String(ct ?? ""));
+  const label = m ? (m[1] ?? m[2] ?? "").trim().toLowerCase() : "";
+  return label || null;
+}
+function charsetReading(ct, bytes) {
+  if (bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) return { ascii: false, bom: true };
+  if (bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 254) return { skip: "utf-16le" };
+  if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) return { skip: "utf-16be" };
+  const charset = declaredCharset(ct);
+  if (!charset || UTF8_CHARSETS.has(charset)) return { ascii: false };
+  if (WIDE_CHARSET.test(charset)) return { skip: charset };
+  for (let i = 0; i < bytes.length; i++) {
+    const b = bytes[i];
+    if (b >= 128 || b === 0 || b === 27) return { skip: charset };
+  }
+  return { ascii: true };
+}
+function decodeForScreening(ct, bytes) {
+  const reading = charsetReading(ct, bytes);
+  if (reading.skip) return { skip: "unsupported-charset", charset: reading.skip };
+  return { text: new TextDecoder().decode(bytes), ascii: reading.ascii, bom: reading.bom === true };
+}
+function withBom(bom, body) {
+  return bom ? "\uFEFF" + body : body;
+}
+function outgrowsCharset(ascii, body) {
+  return ascii === true && /[^\x00-\x7f]/.test(body);
+}
+var KEPT_ESCAPES = /* @__PURE__ */ new Set([34, 92, 60, 62, 38, 39]);
+function readJsonEscapes(text) {
+  if (!text.includes("\\u") && !text.includes("\\/")) return text;
+  try {
+    JSON.parse(text);
+  } catch {
+    return text;
+  }
+  return text.replace(/\\(?:u([0-9a-fA-F]{4})|([\s\S]))/g, (whole, hex, ch, offset) => {
+    if (hex === void 0) return ch === "/" && text[offset - 1] !== "<" ? "/" : whole;
+    const code = parseInt(hex, 16);
+    if (code < 32 || code > 126 || KEPT_ESCAPES.has(code)) return whole;
+    return String.fromCharCode(code);
+  });
+}
 async function readTextResponse(response, cap = DEFAULT_SCREEN_CAP) {
   if (!response || typeof response.clone !== "function") return { skip: "not-a-response" };
   const ct = response.headers?.get?.("content-type") || "";
@@ -9183,17 +9716,18 @@ async function readTextResponse(response, cap = DEFAULT_SCREEN_CAP) {
     const bytes = concatBytes(chunks, size);
     if (codings.length > 0 && stillEncoded(bytes)) return encodedSkip();
     try {
-      return { text: new TextDecoder().decode(bytes) };
+      return decodeForScreening(ct, bytes);
     } catch {
       return { skip: "decode-failed" };
     }
   }
   try {
-    if (codings.length > 0) {
+    if (codings.length > 0 || typeof clone.arrayBuffer === "function") {
       const bytes = new Uint8Array(await clone.arrayBuffer());
       if (bytes.byteLength > cap) return { skip: "body-cap" };
-      if (stillEncoded(bytes)) return encodedSkip();
-      return { text: new TextDecoder().decode(bytes) };
+      if (codings.length > 0 && stillEncoded(bytes)) return encodedSkip();
+      if (codings.length === 0 && sniff && looksBinary(bytes)) return { skip: "binary-body" };
+      return decodeForScreening(ct, bytes);
     }
     const text = await clone.text();
     if (text.length > cap) return { skip: "body-cap" };
@@ -9224,8 +9758,9 @@ function headerObject(headers) {
 function hasSpanMutations(rule) {
   let found = false;
   const walk2 = (conds) => {
-    for (const c of conds ?? []) {
+    for (const c of Array.isArray(conds) ? conds : []) {
       if (found) return;
+      if (!c || typeof c !== "object") continue;
       if (Array.isArray(c.rules)) walk2(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;
@@ -9234,10 +9769,34 @@ function hasSpanMutations(rule) {
   walk2(rule.rule_v2);
   return found;
 }
-function extractRedactors(rule) {
+function redactorScope(parameter) {
+  if (parameter === void 0 || parameter === null || parameterProblem(parameter) !== null) return null;
+  const scope = { body: false, allHeaders: false, headers: /* @__PURE__ */ new Set() };
+  for (const name of Array.isArray(parameter) ? parameter : [parameter]) {
+    if (typeof name !== "string" || name === "") return null;
+    if (name.startsWith("response.header.")) scope.headers.add(name.slice("response.header.".length).toLowerCase());
+    else if (name === "response.headers") scope.allHeaders = true;
+    else if (name === "response.body" || name === "response.status" || BROAD_SCOPE_SOURCES.has(name.split(".")[0])) {
+      scope.body = true;
+      scope.allHeaders = true;
+    } else return null;
+  }
+  return scope;
+}
+var BROAD_SCOPE_SOURCES = /* @__PURE__ */ new Set(["get", "post", "request", "cookie", "files", "server", "raw", "all"]);
+function masksHeader(redactor, name) {
+  return redactor.scope.allHeaders || redactor.scope.headers.has(name);
+}
+function extractRedactors(rule, onUnscoped) {
   const out = [];
+  const scoped = (c) => {
+    const scope = redactorScope(c.parameter);
+    if (scope === null) onUnscoped?.(c.parameter);
+    return scope;
+  };
   const walk2 = (conds) => {
-    for (const c of conds ?? []) {
+    for (const c of Array.isArray(conds) ? conds : []) {
+      if (!c || typeof c !== "object") continue;
       if (Array.isArray(c.rules)) walk2(c.rules);
       const m = c.match;
       if (!m) continue;
@@ -9245,16 +9804,21 @@ function extractRedactors(rule) {
         const safe = safeRegExp(m.value);
         if (safe) {
           const flags = safe.flags.includes("g") ? safe.flags : safe.flags + "g";
+          const scope = scoped(c);
           try {
-            out.push({ re: new RegExp(safe.source, flags) });
+            if (scope) out.push({ re: new RegExp(safe.source, flags), scope });
           } catch {
           }
         }
       } else if ((m.type === "contains" || m.type === "stripos") && m.value != null) {
-        out.push({ literal: String(m.value) });
+        const scope = scoped(c);
+        if (scope) out.push({ literal: String(m.value), scope });
       } else if (m.type === "jwt_claim_equals" && typeof m.claim === "string") {
-        out.push({ jwtClaim: { claim: m.claim, value: String(m.value ?? "") } });
-      } else if (m.type === "array_key_value" && m.match && isBodyParam(c.parameter)) {
+        const scope = scoped(c);
+        if (scope) out.push({ jwtClaim: { claim: m.claim, value: String(m.value ?? "") }, scope });
+      } else if (m.type === "array_key_value" && m.match && Array.isArray(c.parameter) && !readsBody(c.parameter) && redactorScope(c.parameter) === null) {
+        onUnscoped?.(c.parameter);
+      } else if (m.type === "array_key_value" && m.match && readsBody(c.parameter)) {
         const keys = Array.isArray(m.key) ? m.key : [m.key];
         for (const key of keys) {
           out.push({ jsonPath: String(key).split("."), condition: m.match });
@@ -9276,30 +9840,101 @@ function isJson(text) {
     return false;
   }
 }
-function preservesJsonStructure(before, after) {
-  if (!isJson(before)) return true;
-  if (!isJson(after)) return false;
-  const expected = jsonStructure(before);
-  const actual = jsonStructure(after);
-  for (; ; ) {
-    const left = expected.next();
-    const right = actual.next();
-    if (left.done || right.done) return left.done === right.done;
-    if (left.value !== right.value) return false;
-  }
+var JSON_STRING = 1;
+var JSON_NUMBER = 2;
+var JSON_LITERAL = 3;
+var JSON_NUMBER_TOKEN = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+function isHexCode(c) {
+  return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
 }
-function* jsonStructure(text) {
-  const tokens = /"(?:[^"\\]|\\[\s\S])*"|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?|[^\s]/g;
-  for (const match of text.matchAll(tokens)) {
-    const token = match[0];
-    if (token[0] !== '"') {
-      yield "token:" + token;
+var PLAIN_STRING_SEGMENT = /^[^"\\\u0000-\u001f]*$/;
+function lexJson(text) {
+  let kinds = new Int32Array(1024);
+  let spans = new Int32Array(2048);
+  let count = 0;
+  const n = text.length;
+  let i = 0;
+  while (i < n) {
+    const c = text.charCodeAt(i);
+    if (c === 32 || c === 9 || c === 10 || c === 13) {
+      i++;
       continue;
     }
-    let next = match.index + token.length;
-    while (text[next] === " " || text[next] === "	" || text[next] === "\r" || text[next] === "\n") next++;
-    yield text[next] === ":" ? "key:" + JSON.parse(token) : "string";
+    const start = i;
+    let kind;
+    if (c === 34) {
+      i++;
+      const close = text.indexOf('"', i);
+      if (close === -1) return null;
+      if (PLAIN_STRING_SEGMENT.test(text.slice(i, close))) {
+        i = close;
+      } else {
+        for (; ; ) {
+          if (i >= n) return null;
+          const d = text.charCodeAt(i);
+          if (d === 34) break;
+          if (d < 32) return null;
+          if (d !== 92) {
+            i++;
+            continue;
+          }
+          const e = text.charCodeAt(i + 1);
+          if (e === 117) {
+            for (let k = 2; k < 6; k++) if (!isHexCode(text.charCodeAt(i + k))) return null;
+            i += 6;
+          } else if (e === 34 || e === 92 || e === 47 || e === 98 || e === 102 || e === 110 || e === 114 || e === 116) {
+            i += 2;
+          } else {
+            return null;
+          }
+        }
+      }
+      i++;
+      kind = JSON_STRING;
+    } else if (c === 123 || c === 125 || c === 91 || c === 93 || c === 58 || c === 44) {
+      i++;
+      kind = c;
+    } else if (text.startsWith("true", i) || text.startsWith("null", i)) {
+      i += 4;
+      kind = JSON_LITERAL;
+    } else if (text.startsWith("false", i)) {
+      i += 5;
+      kind = JSON_LITERAL;
+    } else {
+      JSON_NUMBER_TOKEN.lastIndex = i;
+      if (!JSON_NUMBER_TOKEN.test(text)) return null;
+      i = JSON_NUMBER_TOKEN.lastIndex;
+      kind = JSON_NUMBER;
+    }
+    if (count === kinds.length) {
+      const grownKinds = new Int32Array(count * 2);
+      grownKinds.set(kinds);
+      kinds = grownKinds;
+      const grownSpans = new Int32Array(count * 4);
+      grownSpans.set(spans);
+      spans = grownSpans;
+    }
+    kinds[count] = kind;
+    spans[2 * count] = start;
+    spans[2 * count + 1] = i;
+    count++;
+  }
+  return { kinds, spans, count };
+}
+function sameJsonStructure(beforeText, before, afterText, after) {
+  if (!before || !after || before.count !== after.count) return false;
+  const { kinds, spans, count } = before;
+  for (let k = 0; k < count; k++) {
+    const kind = kinds[k];
+    if (after.kinds[k] !== kind) return false;
+    if (kind > JSON_LITERAL) continue;
+    if (kind === JSON_STRING && kinds[k + 1] !== 58) continue;
+    const was = beforeText.slice(spans[2 * k], spans[2 * k + 1]);
+    const now = afterText.slice(after.spans[2 * k], after.spans[2 * k + 1]);
+    if (was === now) continue;
+    if (kind !== JSON_STRING || JSON.parse(was) !== JSON.parse(now)) return false;
   }
+  return true;
 }
 function applyRedactors(body, redactors, mask, transform) {
   let out = body;
@@ -9316,6 +9951,11 @@ function applyRedactors(body, redactors, mask, transform) {
   }
   return out;
 }
+function readsBody(parameter) {
+  if (!Array.isArray(parameter)) return isBodyParam(parameter);
+  const names = parameter.every((member) => typeof member === "string" && member !== "");
+  return names && parameterProblem(parameter) === null && parameter.some((member) => isBodyParam(member));
+}
 function isBodyParam(parameter) {
   return parameter == null || parameter === "response.body" || parameter === "raw" || parameter === "response.raw";
 }
@@ -9347,7 +9987,7 @@ function applyPathRedactors(text, pathRedactors, mask, cap, transform) {
   let obj;
   try {
     JSON.parse(text);
-    preserved = preserveBigInts(text, mask);
+    preserved = preserveNumbers(text, mask);
     obj = JSON.parse(preserved.text);
   } catch {
     return text;
@@ -9366,22 +10006,22 @@ function applyPathRedactors(text, pathRedactors, mask, cap, transform) {
       }
     });
   }
-  return changed ? restoreBigInts(JSON.stringify(obj), preserved.numbers) : text;
+  return changed ? restoreNumbers(JSON.stringify(obj), preserved.numbers) : text;
 }
-function preserveBigInts(text, mask) {
+function preserveNumbers(text, mask) {
   const occupied = /* @__PURE__ */ new Set([mask]);
-  const integers = [];
+  const found = [];
   const tokens = /"(?:[^"\\]|\\[\s\S])*"|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/g;
   for (const match of text.matchAll(tokens)) {
     const token = match[0];
     if (token[0] === '"') occupied.add(JSON.parse(token));
-    else if (/^-?\d{16,}$/.test(token)) integers.push({ start: match.index, token });
+    else found.push({ start: match.index, token });
   }
   const numbers = /* @__PURE__ */ new Map();
   const chunks = [];
   let offset = 0;
   let index = 0;
-  for (const { start, token } of integers) {
+  for (const { start, token } of found) {
     let marker;
     do {
       marker = "__PSNUMBER_" + index++ + "__";
@@ -9393,7 +10033,7 @@ function preserveBigInts(text, mask) {
   chunks.push(text.slice(offset));
   return { text: chunks.join(""), numbers };
 }
-function restoreBigInts(text, numbers) {
+function restoreNumbers(text, numbers) {
   return text.replace(/"(__PSNUMBER_\d+__)"/g, (token, marker) => numbers.get(marker) ?? token);
 }
 function isHeaderMutation(action) {