@patchstack/connect 0.5.12 → 0.5.16

package/dist/protect.edge.js

@@ -426,18 +426,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: "<",
@@ -445,7 +551,6 @@ var NAMED_ENTITIES = {
   amp: "&",
   quot: '"',
   apos: "'",
-  "#39": "'",
   nbsp: "\xA0",
   sol: "/",
   bsol: "\\",
@@ -464,7 +569,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);
@@ -478,74 +583,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 [];
   }
@@ -575,6 +965,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 {
@@ -595,11 +988,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":
@@ -618,16 +1007,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 ?? {};
@@ -640,8 +1043,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();
@@ -718,422 +1124,144 @@ var RequestResolver = class {
     if (body === void 0 || body === null) {
       return [];
     }
-    if (typeof body === "string") {
-      return [body];
-    }
-    try {
-      return [JSON.stringify(body)];
-    } catch {
-      return [String(body)];
-    }
-  }
-  #resolveAll() {
-    const parts = [];
-    const uri = this.#req.originalUrl ?? this.#req.url ?? "/";
-    parts.push(uri);
-    const queryString = uri.includes("?") ? uri.split("?")[1] : "";
-    if (queryString) {
-      parts.push(queryString);
-    }
-    const body = this.#req.body;
-    if (body) {
-      parts.push(typeof body === "string" ? body : JSON.stringify(body));
-    }
-    if (typeof this.#req._rawBody === "string" && this.#req._rawBody) {
-      parts.push(this.#req._rawBody);
-    }
-    const headers = this.#req.headers ?? {};
-    const excludedHeaders = /* @__PURE__ */ new Set([
-      "host",
-      "connection",
-      "cache-control",
-      "accept",
-      "accept-encoding",
-      "accept-language",
-      "priority",
-      "sec-ch-ua",
-      "sec-ch-ua-mobile",
-      "sec-ch-ua-platform",
-      "sec-fetch-dest",
-      "sec-fetch-mode",
-      "sec-fetch-site",
-      "sec-fetch-user",
-      "upgrade-insecure-requests"
-    ]);
-    for (const [name, value] of Object.entries(headers)) {
-      if (!excludedHeaders.has(name)) {
-        parts.push(`${name}: ${value}`);
-      }
-    }
-    const cookies = this.#parseCookies();
-    const cookieStr = Object.entries(cookies).map(([k, v]) => `${k}=${v}`).join("; ");
-    if (cookieStr) {
-      parts.push(cookieStr);
-    }
-    return [parts.join(" ")];
-  }
-  #resolveWildcard(obj, pattern) {
-    if (typeof obj !== "object" || obj === null) {
-      return [];
-    }
-    const prefix = pattern.slice(0, -1);
-    const values = [];
-    for (const [key, value] of Object.entries(obj)) {
-      if (key.startsWith(prefix)) {
-        values.push(value);
-      }
-    }
-    return values;
-  }
-  #getNestedValue(obj, key) {
-    if (typeof obj !== "object" || obj === null) {
-      return void 0;
-    }
-    const own = (o, k) => o !== null && typeof o === "object" && Object.prototype.hasOwnProperty.call(o, k);
-    if (own(obj, key)) {
-      return obj[key];
-    }
-    const parts = key.split(".");
-    let current = obj;
-    for (const part of parts) {
-      if (!own(current, part)) {
-        return void 0;
-      }
-      current = current[part];
-    }
-    return current;
-  }
-  #parseCookies() {
-    if (this.#cookies !== null) {
-      return this.#cookies;
-    }
-    if (this.#req.cookies) {
-      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;
-    return this.#cookies;
-  }
-};
-
-// src/protect/notify.js
-var reported = /* @__PURE__ */ new Set();
-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));
-      } 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 body === "string") {
+      return [body];
     }
-    if (typeof value === "string") {
-      append(task.root ? value.slice(0, MAX_RAW_CHARS) : boundedJsonString(value));
-      continue;
+    try {
+      return [JSON.stringify(body)];
+    } catch {
+      return [String(body)];
     }
-    if (typeof value !== "object") {
-      append(String(value).slice(0, MAX_RAW_CHARS));
-      continue;
+  }
+  #resolveAll() {
+    const parts = [];
+    const uri = this.#req.originalUrl ?? this.#req.url ?? "/";
+    parts.push(uri);
+    const queryString = uri.includes("?") ? uri.split("?")[1] : "";
+    if (queryString) {
+      parts.push(queryString);
     }
-    if (visited.has(value)) {
-      append("[Circular]");
-      continue;
+    const body = this.#req.body;
+    if (body) {
+      parts.push(typeof body === "string" ? body : JSON.stringify(body));
     }
-    if (task.depth >= MAX_RAW_DEPTH) {
-      append('"[DepthLimit]"');
-      continue;
+    if (typeof this.#req._rawBody === "string" && this.#req._rawBody) {
+      parts.push(this.#req._rawBody);
     }
-    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 });
+    const headers = this.#req.headers ?? {};
+    const excludedHeaders = /* @__PURE__ */ new Set([
+      "host",
+      "connection",
+      "cache-control",
+      "accept",
+      "accept-encoding",
+      "accept-language",
+      "priority",
+      "sec-ch-ua",
+      "sec-ch-ua-mobile",
+      "sec-ch-ua-platform",
+      "sec-fetch-dest",
+      "sec-fetch-mode",
+      "sec-fetch-site",
+      "sec-fetch-user",
+      "upgrade-insecure-requests"
+    ]);
+    for (const [name, value] of Object.entries(headers)) {
+      if (!excludedHeaders.has(name)) {
+        parts.push(`${name}: ${value}`);
       }
-      if (value.length > length2) {
-        if (length2 > 0) items.push({ kind: "text", text: "," });
-        items.push({ kind: "text", text: '"[EntryLimit]"' });
+    }
+    const cookies = this.#parseCookies();
+    const cookieStr = Object.entries(cookies).map(([k, v]) => `${k}=${v}`).join("; ");
+    if (cookieStr) {
+      parts.push(cookieStr);
+    }
+    return [parts.join(" ")];
+  }
+  #resolveWildcard(obj, pattern) {
+    if (typeof obj !== "object" || obj === null) {
+      return [];
+    }
+    const prefix = pattern.slice(0, -1);
+    const values = [];
+    for (const [key, value] of Object.entries(obj)) {
+      if (key.startsWith(prefix)) {
+        values.push(value);
       }
-      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;
+    return values;
+  }
+  #getNestedValue(obj, key) {
+    if (typeof obj !== "object" || obj === null) {
+      return void 0;
     }
-    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 });
+    const own = (o, k) => o !== null && typeof o === "object" && Object.prototype.hasOwnProperty.call(o, k);
+    if (own(obj, key)) {
+      return obj[key];
     }
-    if (keys.length > length) {
-      if (length > 0) entries.push({ kind: "text", text: "," });
-      entries.push({ kind: "text", text: '"[EntryLimit]":null' });
+    const parts = key.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (!own(current, part)) {
+        return void 0;
+      }
+      current = current[part];
     }
-    stack.push({ kind: "text", text: "}" });
-    for (let i = entries.length - 1; i >= 0; i--) stack.push(entries[i]);
-    stack.push({ kind: "text", text: "{" });
+    return current;
   }
-  return output.join("");
-}
-function boundedJsonString(value) {
-  return JSON.stringify(String(value).slice(0, MAX_RAW_CHARS));
-}
-function readOwnValue(value, key) {
+  #parseCookies() {
+    if (this.#cookies !== null) {
+      return this.#cookies;
+    }
+    if (this.#req.cookies) {
+      this.#cookies = this.#req.cookies;
+      return this.#cookies;
+    }
+    this.#cookies = parseCookieHeader(this.#req.headers?.cookie);
+    return this.#cookies;
+  }
+};
+
+// src/protect/notify.js
+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 descriptor = Object.getOwnPropertyDescriptor(value, key);
-    return descriptor && Object.hasOwn(descriptor, "value") ? descriptor.value : "[Accessor]";
-  } catch {
-    return "[Unreadable]";
+    const result = fn(arg);
+    if (result !== null && typeof result === "object" && typeof result.then === "function") {
+      try {
+        result.then(void 0, (err) => warnOnce2(fn, label, err));
+      } catch {
+      }
+    }
+    return true;
+  } catch (err) {
+    warnOnce2(fn, label, err);
+    return false;
   }
 }
-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;
-  }
-  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
@@ -1235,6 +1363,184 @@ function hasAdjacentUnbounded(body, flags) {
   }
   return false;
 }
+function parseRepetition(body) {
+  let i = 0;
+  const parseAlternation = () => {
+    const branches = [parseSequence()];
+    while (body[i] === "|") {
+      i++;
+      branches.push(parseSequence());
+    }
+    return branches.length === 1 ? branches[0] : { type: "alt", branches };
+  };
+  const parseSequence = () => {
+    const items = [];
+    while (i < body.length && body[i] !== "|" && body[i] !== ")") {
+      const atom = parseAtom();
+      if (atom === null) return null;
+      const quantified = parseQuantifier(atom);
+      if (quantified === null) return null;
+      items.push(quantified);
+    }
+    return { type: "seq", items };
+  };
+  const parseAtom = () => {
+    const ch = body[i];
+    if (ch === "(") {
+      const start2 = i;
+      i++;
+      let kind = "capture";
+      if (body.startsWith("?:", i)) {
+        kind = "group";
+        i += 2;
+      } else if (body.startsWith("?=", i) || body.startsWith("?!", i)) {
+        kind = "look";
+        i += 2;
+      } else if (body.startsWith("?<=", i) || body.startsWith("?<!", i)) {
+        kind = "look";
+        i += 3;
+      } else if (body.startsWith("?<", i)) {
+        const close = body.indexOf(">", i + 2);
+        if (close === -1) return null;
+        i = close + 1;
+      } else if (body[i] === "?") {
+        return null;
+      }
+      const inner = parseAlternation();
+      if (inner === null || body[i] !== ")") return null;
+      i++;
+      return { type: "group", kind, body: inner, source: body.slice(start2, i) };
+    }
+    const start = i;
+    if (ch === "[") {
+      i++;
+      if (body[i] === "^") i++;
+      if (body[i] === "]") i++;
+      while (i < body.length && body[i] !== "]") i += body[i] === "\\" ? 2 : 1;
+      if (body[i] !== "]") return null;
+      i++;
+      return { type: "atom", source: body.slice(start, i) };
+    }
+    if (ch === "\\") {
+      const next = body[i + 1];
+      if (next === void 0) return null;
+      if ((next === "p" || next === "P" || next === "u") && body[i + 2] === "{") {
+        const close = body.indexOf("}", i + 3);
+        if (close === -1) return null;
+        i = close + 1;
+      } else if (next === "k" && body[i + 2] === "<") {
+        const close = body.indexOf(">", i + 3);
+        if (close === -1) return null;
+        i = close + 1;
+      } else {
+        i += 2;
+      }
+      return { type: /[bB]/.test(next) ? "assert" : "atom", source: body.slice(start, i) };
+    }
+    if (ch === "^" || ch === "$") {
+      i++;
+      return { type: "assert" };
+    }
+    if (ch === "*" || ch === "+" || ch === "?") return null;
+    i++;
+    return { type: "atom", source: body.slice(start, i) };
+  };
+  const parseQuantifier = (atom) => {
+    let min;
+    let max;
+    const ch = body[i];
+    if (ch === "*") [min, max, i] = [0, Infinity, i + 1];
+    else if (ch === "+") [min, max, i] = [1, Infinity, i + 1];
+    else if (ch === "?") [min, max, i] = [0, 1, i + 1];
+    else if (ch === "{") {
+      const bounds = /^\{(\d+)(,(\d*))?\}/.exec(body.slice(i));
+      if (!bounds) return atom;
+      min = Number(bounds[1]);
+      max = bounds[2] === void 0 ? min : bounds[3] === "" ? Infinity : Number(bounds[3]);
+      i += bounds[0].length;
+    } else {
+      return atom;
+    }
+    if (body[i] === "?") i++;
+    if (body[i] === "*" || body[i] === "+" || body[i] === "?" || body[i] === "{") return null;
+    return { type: "quant", min, max, body: atom };
+  };
+  const root = parseAlternation();
+  return root !== null && i === body.length ? root : null;
+}
+function* nodesOf(node) {
+  if (!node) return;
+  yield node;
+  if (node.type === "alt") for (const branch of node.branches) yield* nodesOf(branch);
+  else if (node.type === "seq") for (const item of node.items) yield* nodesOf(item);
+  else if (node.type === "group" || node.type === "quant") yield* nodesOf(node.body);
+}
+var BOUNDED_NESTING_LIMIT = 100;
+var BOUNDED_ALTERNATION_LIMIT = 16;
+var OPTIONAL_REPEAT_LIMIT = 8;
+function hasFencedRepetitions(quant, flags) {
+  let body = quant.body;
+  if (body.type === "group" && body.kind !== "look") body = body.body;
+  if (body.type !== "seq" || body.items.length < 2) return false;
+  const variable = [...nodesOf(body)].filter((n) => n.type === "quant" && (n.max > 1 || n.min < n.max));
+  if (variable.some((n) => n.body.type !== "atom" || n.body.source === void 0)) return false;
+  const atomFlags = flags.replace(/[^i]/g, "");
+  const unicode = /[uv]/.test(flags);
+  let insides;
+  try {
+    insides = variable.map((n) => new RegExp(`^(?:${n.body.source})$`, `${atomFlags}${unicode ? "u" : ""}`));
+  } catch {
+    return false;
+  }
+  const literalOf = (source) => {
+    if (source.length === 1 && !".[]()|^$\\".includes(source)) return source;
+    if (source.length === 2 && source[0] === "\\" && /[^\w\s]/.test(source[1])) return source[1];
+    return null;
+  };
+  const disjoint = (edge) => {
+    if (edge?.type !== "atom" || edge.source === void 0) return false;
+    const literal = literalOf(edge.source);
+    if (literal !== null) return insides.every((re) => !re.test(literal));
+    if (unicode) return false;
+    let fence;
+    try {
+      fence = new RegExp(`^(?:${edge.source})$`, atomFlags);
+    } catch {
+      return false;
+    }
+    for (let unit = 0; unit <= 65535; unit++) {
+      const ch = String.fromCharCode(unit);
+      if (fence.test(ch) && insides.some((re) => re.test(ch))) return false;
+    }
+    return true;
+  };
+  return disjoint(body.items[0]) || disjoint(body.items[body.items.length - 1]);
+}
+function hasCatastrophicShape(body, flags) {
+  const root = parseRepetition(body);
+  if (root === null) return null;
+  for (const node of nodesOf(root)) {
+    if (node.type === "group" && node.kind === "look" && hasAdjacentUnbounded(lookaroundBody(node.source), flags)) return true;
+    if (node.type !== "quant" || node.max <= 1) continue;
+    const fenced = hasFencedRepetitions(node, flags);
+    for (const inner of nodesOf(node.body)) {
+      if (inner === node.body && inner.type === "quant") continue;
+      if (inner.type === "quant" && inner.max > 1 && !fenced) {
+        if (node.max === Infinity || inner.max === Infinity || node.max * inner.max > BOUNDED_NESTING_LIMIT) return true;
+      }
+      if (inner.type === "quant" && inner.min === 0 && inner.max <= 1 && !fenced && (node.max === Infinity || node.max > OPTIONAL_REPEAT_LIMIT)) {
+        return true;
+      }
+      if (inner.type === "alt" && inner.branches.length > 1 && (node.max === Infinity || node.max > BOUNDED_ALTERNATION_LIMIT)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function lookaroundBody(source) {
+  return source.slice(source.startsWith("(?<") ? 4 : 3, -1);
+}
 function groupEnd(body, start) {
   let depth = 0;
   let inClass = false;
@@ -1261,6 +1567,8 @@ function warnRejectedPatternOnce(pattern) {
   );
 }
 var MAX_PATTERN_LENGTH = 1e3;
+var regexVerdicts = /* @__PURE__ */ new Map();
+var REGEX_VERDICT_LIMIT = 2048;
 function safeRegExp(pattern) {
   if (!pattern) {
     return null;
@@ -1272,16 +1580,32 @@ function safeRegExp(pattern) {
   if (!match) {
     return null;
   }
-  for (const dangerous of REDOS_PATTERNS) {
-    if (dangerous.test(match[1])) return null;
+  let safe = regexVerdicts.get(pattern);
+  if (safe === void 0) {
+    safe = isSafeBody(match[1], match[2]);
+    if (regexVerdicts.size >= REGEX_VERDICT_LIMIT) regexVerdicts.clear();
+    regexVerdicts.set(pattern, safe);
   }
-  if (hasAdjacentUnbounded(match[1], match[2])) return null;
+  if (!safe) return null;
   try {
     return new RegExp(match[1], match[2]);
   } catch {
     return null;
   }
 }
+function isSafeBody(body, flags) {
+  for (const dangerous of REDOS_PATTERNS) {
+    if (dangerous.test(body)) return false;
+  }
+  if (hasAdjacentUnbounded(body, flags)) return false;
+  if (hasCatastrophicShape(body, flags) === true) return false;
+  try {
+    new RegExp(body, flags);
+  } catch {
+    return false;
+  }
+  return true;
+}
 function ctypeResult(strValue, isClass, matchVal) {
   if (strValue === "") {
     return false;
@@ -1325,17 +1649,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]);
@@ -1343,7 +1671,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) {
@@ -1361,12 +1700,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;
     }
@@ -1394,10 +1743,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);
@@ -1407,6 +1764,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;
@@ -1755,8 +2116,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 };
@@ -1782,14 +2147,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);
@@ -1845,9 +2211,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;
       }
@@ -2234,6 +2606,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";
@@ -3176,7 +3551,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,
@@ -3238,7 +3613,7 @@ function concatChunks(chunks, total) {
 }
 function parseBody(rawBody, contentType) {
   const ct = String(contentType || "").toLowerCase();
-  const isJson = ct.includes("application/json") || /\+json\b/.test(ct);
+  const isJson2 = ct.includes("application/json") || /\+json\b/.test(ct);
   const isForm = ct.includes("application/x-www-form-urlencoded");
   const isMultipart = ct.includes("multipart/form-data");
   const isAmbiguous = ct === "" || ct.startsWith("text/plain") || ct.includes("csp-report") || ct.includes("/json");
@@ -3252,7 +3627,7 @@ function parseBody(rawBody, contentType) {
     for (const [k, v] of new URLSearchParams(rawBody)) appendOwn(body, k, v);
     return { body, files: void 0 };
   }
-  if (isJson || isAmbiguous) {
+  if (isJson2 || isAmbiguous) {
     try {
       const parsed = JSON.parse(rawBody);
       if (parsed && typeof parsed === "object") return { body: parsed, files: void 0 };
@@ -3268,38 +3643,115 @@ function parseMultipart(rawBody, boundary) {
     const sep = /\r?\n\r?\n/.exec(part);
     if (!sep) continue;
     const rawHeaders = part.slice(0, sep.index);
-    const disposition = /content-disposition:[^\r\n]*/i.exec(rawHeaders)?.[0];
-    if (!disposition) continue;
-    const name = /name="([^"]*)"/i.exec(disposition)?.[1];
-    if (name == null) continue;
+    const disposition = /content-disposition:([^\r\n]*)/i.exec(rawHeaders)?.[1];
+    if (disposition === void 0) continue;
+    const { names, filename } = dispositionFields(disposition);
+    if (names.length === 0) continue;
     const content = part.slice(sep.index + sep[0].length).replace(/\r?\n$/, "");
-    const filename = /filename="([^"]*)"/i.exec(disposition)?.[1];
-    if (filename !== void 0) {
-      const partType = /content-type:\s*([^\r\n;]+)/i.exec(rawHeaders)?.[1]?.trim() || "";
-      const file = { filename, type: partType, content };
-      appendOwn(files, name, file);
-    } else {
-      appendOwn(body, name, content);
+    const file = filename === void 0 ? void 0 : { filename, type: /content-type:\s*([^\r\n;]+)/i.exec(rawHeaders)?.[1]?.trim() || "", content };
+    for (const name of names) {
+      if (file) appendOwn(files, name, file);
+      else appendOwn(body, name, content);
     }
   }
   return { body, files };
 }
-function parseCookies(header) {
-  const cookies = {};
-  if (!header) {
-    return cookies;
-  }
-  for (const pair of header.split(";")) {
-    const idx = pair.indexOf("=");
-    if (idx === -1) {
-      continue;
+function dispositionFields(value) {
+  const text = String(value);
+  const names = /* @__PURE__ */ new Set();
+  let filename;
+  let extendedFilename;
+  let i = text.indexOf(";");
+  while (i !== -1 && i < text.length) {
+    i++;
+    while (text[i] === " " || text[i] === "	") i++;
+    let key = "";
+    while (i < text.length && text[i] !== "=" && text[i] !== ";") key += text[i++];
+    key = key.trim().toLowerCase();
+    let val = null;
+    if (text[i] === "=") {
+      i++;
+      while (text[i] === " " || text[i] === "	") i++;
+      if (text[i] === '"') {
+        i++;
+        val = "";
+        while (i < text.length && text[i] !== '"') {
+          if (text[i] === "\\" && i + 1 < text.length) i++;
+          val += text[i++];
+        }
+        i++;
+        while (i < text.length && text[i] !== ";") i++;
+      } else {
+        let bare = "";
+        while (i < text.length && text[i] !== ";") bare += text[i++];
+        val = bare.trim();
+      }
+    }
+    if (val !== null) {
+      if (key === "name") names.add(val);
+      else if (key === "filename") filename = val;
+      else if (key === "filename*") extendedFilename = decodeExtendedValue(val);
     }
-    setOwn(cookies, pair.slice(0, idx).trim(), pair.slice(idx + 1).trim());
+    i = i < text.length && text[i] === ";" ? i : -1;
+  }
+  return { names: [...names], filename: extendedFilename ?? filename };
+}
+function decodeExtendedValue(value) {
+  const match = /^([^']*)'[^']*'(.*)$/.exec(value);
+  if (!match) return value;
+  try {
+    return decodeURIComponent(match[2]);
+  } catch {
+    return match[2];
   }
-  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 = {};
@@ -3345,29 +3797,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()));
@@ -3412,6 +3876,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]);
@@ -3484,15 +3951,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";
@@ -3503,13 +3974,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;
@@ -3517,7 +3987,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) {
@@ -3550,43 +4020,84 @@ 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 = () => {
+  };
+  try {
+    const { syncBuiltinESMExports } = await Promise.resolve().then(() => __toESM(require_ps_edge_stub(), 1));
+    if (typeof syncBuiltinESMExports === "function") syncBuiltins = syncBuiltinESMExports;
+  } catch {
+  }
+  let patchedAny = false;
   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) restores.push(restore);
+      if (registry.surfaces.has(moduleName)) continue;
+      const release = patchHttpModule(mod.default ?? mod, registry);
+      if (release) {
+        patchedAny = true;
+        registry.surfaces.set(moduleName, {
+          release() {
+            if (!release()) return false;
+            syncBuiltins();
+            return true;
+          }
+        });
+      }
     } catch {
     }
   }
+  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 wrap = (original) => function(...args) {
+  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 {
-        args = withScreeningLookup(args, target, block, screen.lookup, skip);
+        return withScreeningLookup(args, target, block, resolving[0].dns.lookup, skip);
       } catch {
       }
     }
-    return original.apply(this, args);
+    return args;
+  };
+  const wrap = (original) => function(...args) {
+    return original.apply(this, guardArgs(args));
   };
   const guardedRequest = wrap(originalRequest);
   http.request = guardedRequest;
@@ -3595,11 +4106,26 @@ function patchHttpModule(http, block, screen, skip) {
     guardedGet = wrap(originalGet);
     http.get = guardedGet;
   }
+  let GuardedClientRequest;
+  if (OriginalClientRequest) {
+    GuardedClientRequest = function ClientRequest(...args) {
+      const screened = guardArgs(args);
+      return new.target ? Reflect.construct(OriginalClientRequest, screened, new.target) : Reflect.construct(OriginalClientRequest, screened);
+    };
+    GuardedClientRequest.prototype = OriginalClientRequest.prototype;
+    Object.setPrototypeOf(GuardedClientRequest, OriginalClientRequest);
+    http.ClientRequest = GuardedClientRequest;
+  }
   http.__patchstackGuarded = true;
   return () => {
-    if (http.request === guardedRequest) http.request = originalRequest;
-    if (guardedGet && http.get === guardedGet) http.get = originalGet;
+    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) {
@@ -3608,19 +4134,27 @@ function extractHttpTarget(args) {
     if (typeof first === "string" || first instanceof URL) {
       const url = new URL(String(first));
       const opts = args.find((a) => a && typeof a === "object" && !(a instanceof URL));
-      return { url: url.href, host: url.hostname, method: opts && opts.method || "GET" };
-    }
-    if (first && typeof first === "object") {
-      const host = normalizeHost(first.hostname || first.host) || "localhost";
-      const protocol = first.protocol || "http:";
-      const port = first.port ? `:${first.port}` : "";
-      const path = first.path || "/";
-      return { url: `${protocol}//${host}${port}${path}`, host, method: first.method || "GET" };
+      return targetOf({ ...optionsFromUrl(url), ...opts ?? {} });
     }
+    if (first && typeof first === "object") return targetOf(first);
   } catch {
   }
   return null;
 }
+function optionsFromUrl(url) {
+  const hostname = url.hostname.startsWith("[") ? url.hostname.slice(1, -1) : url.hostname;
+  const options = { protocol: url.protocol, hostname, path: `${url.pathname || "/"}${url.search}` };
+  if (url.port !== "") options.port = Number(url.port);
+  return options;
+}
+function targetOf(options) {
+  const host = normalizeHost(options.hostname || options.host) || "localhost";
+  const protocol = options.protocol || "http:";
+  const port = options.port ? `:${options.port}` : "";
+  const path = options.path || "/";
+  const authority = host.includes(":") ? `[${host}]` : host;
+  return { url: `${protocol}//${authority}${port}${path}`, host, method: options.method || "GET" };
+}
 function normalizeHost(raw) {
   const host = String(raw || "").trim();
   const bracketed = /^\[([^\]]+)\]/.exec(host);
@@ -4001,19 +4535,49 @@ async function loadFs() {
   }
   return fsMod;
 }
+async function sourceIdentity(options = {}) {
+  if (typeof options.siteUuid === "string" && options.siteUuid.trim() !== "") {
+    const endpoint = typeof options.pulseRulesUrl === "string" ? options.pulseRulesUrl : "";
+    return `site:${options.siteUuid.trim().toLowerCase()}@${endpoint}`;
+  }
+  if (typeof options.token === "string" && options.token !== "") {
+    const digest = await sha256Hex(options.token);
+    if (digest === null) return null;
+    const endpoint = typeof options.baseUrl === "string" ? options.baseUrl : "";
+    return `token:${digest}@${endpoint}`;
+  }
+  return null;
+}
+async function sha256Hex(text) {
+  try {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle || typeof TextEncoder === "undefined") return null;
+    const digest = await subtle.digest("SHA-256", new TextEncoder().encode(text));
+    return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+  } catch {
+    return null;
+  }
+}
 function makeStore(options = {}) {
   let mem = null;
   const durable = durableTier(options);
+  let identity;
+  const identityOf = () => identity ??= sourceIdentity(options);
   return {
     async read() {
       if (mem) return mem;
+      const source = await identityOf();
+      if (source === null) return null;
       const env = await durable.read();
-      if (env) mem = env;
+      if (!env || env.source !== source) return null;
+      mem = env;
       return env;
     },
     async write(env) {
-      if (env) mem = env;
-      await durable.write(env);
+      if (!env) return;
+      const stamped = { ...env, source: await identityOf() };
+      mem = stamped;
+      await durable.write(stamped);
     }
   };
 }
@@ -4135,11 +4699,12 @@ function toEnvelope(value) {
       buildId,
       // A confirmation belongs to the presentation stored beside it. A crossed or partially written
       // envelope confirms nothing, even when one of its fields happens to name the current map.
-      matchedBuildId: buildId !== null && matched === buildId ? matched : null
+      matchedBuildId: buildId !== null && matched === buildId ? matched : null,
+      source: typeof value.source === "string" ? value.source : null
     };
   }
   if (Array.isArray(value.firewall) || Array.isArray(value.whitelists)) {
-    return { bundle: value, etag: null, buildId: null, matchedBuildId: null };
+    return { bundle: value, etag: null, buildId: null, matchedBuildId: null, source: null };
   }
   return null;
 }
@@ -4206,13 +4771,17 @@ function withScopedDryRun(bundle, confirmed, reason, options = {}) {
     ...unusable > 0 ? [`${unusable} rule(s) carry an unusable ${BUILD_SCOPE_PROPERTY}`] : [],
     ...held > unusable ? [reason] : []
   ];
-  notify(
-    options.onError,
-    new Error(`${held} build-scoped rule(s) are detecting only, not blocking: ${explanations.join("; ")}`),
-    "onError"
-  );
+  const message = `${held} build-scoped rule(s) are detecting only, not blocking: ${explanations.join("; ")}`;
+  if (typeof options.onError === "function") notify(options.onError, new Error(message), "onError");
+  else warnHeldOnce(message);
   return { ...bundle, firewall };
 }
+var warnedHeld = /* @__PURE__ */ new Set();
+function warnHeldOnce(message) {
+  if (warnedHeld.has(message)) return;
+  warnedHeld.add(message);
+  console.warn(`[patchstack] ${message}. Pass { onError } to handle this yourself.`);
+}
 function confirmedBy(res, presented) {
   if (presented === null) return null;
   const verdict = res?.build;
@@ -4387,6 +4956,60 @@ function startRefresh(tick, { refreshMs, onError } = {}) {
     }
   };
 }
+var RECOVERY_DELAYS_MS = [5e3, 15e3, 45e3, 12e4, 3e5, 6e5];
+function startRecovery(tick, { onError } = {}) {
+  let stopped = false;
+  let attempt = 0;
+  let timer = null;
+  const schedule = () => {
+    if (stopped) return;
+    const delay = RECOVERY_DELAYS_MS[Math.min(attempt, RECOVERY_DELAYS_MS.length - 1)];
+    timer = setTimeout(run, delay * (1 - Math.random() * JITTER_FRACTION3));
+    timer?.unref?.();
+  };
+  const run = async () => {
+    if (stopped) return;
+    attempt++;
+    try {
+      const status = await tick();
+      if (!status || status.ok !== false) {
+        stopped = true;
+        return;
+      }
+    } catch (err) {
+      notify(onError, err, "onError");
+    }
+    schedule();
+  };
+  schedule();
+  return {
+    stop() {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    }
+  };
+}
+function serialise(tick) {
+  let running = null;
+  let next = null;
+  const run = () => {
+    if (!running) {
+      running = Promise.resolve().then(() => tick()).finally(() => {
+        running = null;
+      });
+      return running;
+    }
+    if (!next) {
+      next = running.catch(() => {
+      }).then(() => {
+        next = null;
+        return run();
+      });
+    }
+    return next;
+  };
+  return run;
+}
 function makeRefreshHandler(tick, secret) {
   let inflight2 = null;
   const runOnce = () => {
@@ -4401,7 +5024,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();
@@ -4412,6 +5035,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
 var DEFAULT_BASE_URL3 = "https://api.patchstack.com/monitor/pulse";
@@ -5145,9 +5795,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 stated = Number(request.headers.get("content-length"));
+  if (Number.isFinite(stated) && stated > 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
@@ -5196,8 +6017,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;
@@ -5210,6 +6036,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) => {
@@ -5263,10 +6102,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));
@@ -5283,10 +6128,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;
@@ -5313,234 +6159,85 @@ 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;
-      queue.push({
-        fid,
-        method: event.method ?? null,
-        request_uri: event.path ?? null,
-        ip: event.ip ?? null,
-        user_agent: event.userAgent ?? null,
-        log_date: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      if (queue.length >= MAX_BATCH2) {
-        flush();
+      if (queue.length >= MAX_QUEUE2) {
+        dropped++;
         return;
       }
-      if (!timer) timer = setTimeout(flush, flushMs);
-    },
-    flush,
-    /**
-     * Stop, and hand back a wait for what was outstanding.
-     *
-     * One flush sends at most a batch, so the queue is drained a batch at a time. The loop stops as soon
-     * as a pass cannot shrink the queue — with no usable transport there is nothing to wait for, and
-     * spinning would be worse than leaving the records where they are.
-     */
-    stop() {
-      if (drainPromise) return drainPromise;
-      stopped = true;
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      const terminate = () => {
-        ended = true;
-        activeController?.abort();
-        activeController = null;
-        queue = [];
-        inFlight = null;
-      };
-      let budget = null;
-      const spent = new Promise((resolve) => {
-        budget = setTimeout(() => {
-          terminate();
-          resolve();
-        }, STOP_BUDGET_MS2);
-        if (typeof budget.unref === "function") budget.unref();
-      });
-      const work = (async () => {
-        while (!ended) {
-          if (inFlight) {
-            await inFlight;
-            continue;
-          }
-          if (queue.length === 0) break;
-          const before = queue.length;
-          await flush();
-          if (queue.length >= before) break;
-        }
-      })();
-      drainPromise = Promise.race([work, spent]).then(() => {
-        if (budget) clearTimeout(budget);
-      });
-      return drainPromise;
-    }
-  };
-}
-function telemetryEnabled() {
-  const v = typeof process !== "undefined" ? process.env?.PATCHSTACK_TELEMETRY : void 0;
-  if (v === void 0 || v === "") return true;
-  return !/^(0|false|off|no)$/i.test(String(v));
-}
-
-// src/protect/supabase-guard.js
-var GUARD_PATH = "/_patchstack/guard";
-var 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 stated = Number(request.headers.get("content-length"));
-  if (Number.isFinite(stated) && stated > 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)
+      recorded++;
+      queue.push({
+        fid,
+        method: event.method ?? null,
+        request_uri: event.path ?? null,
+        ip: event.ip ?? null,
+        user_agent: event.userAgent ?? null,
+        log_date: (/* @__PURE__ */ new Date()).toISOString()
       });
-    } catch (error) {
-      if (error?.name === "TimeoutError" || error?.name === "AbortError") {
-        return new Response("patchstack: upstream timed out", { status: 504 });
+      if (queue.length >= MAX_BATCH2) {
+        flush();
+        return;
       }
-      throw error;
+      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.
+     *
+     * One flush sends at most a batch, so the queue is drained a batch at a time. The loop stops as soon
+     * as a pass cannot shrink the queue — with no usable transport there is nothing to wait for, and
+     * spinning would be worse than leaving the records where they are.
+     */
+    stop() {
+      if (drainPromise) return drainPromise;
+      stopped = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      const terminate = () => {
+        ended = true;
+        activeController?.abort();
+        activeController = null;
+        if (activeBatch) settle(activeBatch, "dropped");
+        dropped += queue.length;
+        queue = [];
+        inFlight = null;
+      };
+      let budget = null;
+      const spent = new Promise((resolve) => {
+        budget = setTimeout(() => {
+          terminate();
+          resolve();
+        }, STOP_BUDGET_MS2);
+        if (typeof budget.unref === "function") budget.unref();
+      });
+      const work = (async () => {
+        while (!ended) {
+          if (inFlight) {
+            await inFlight;
+            continue;
+          }
+          if (queue.length === 0) break;
+          const before = queue.length;
+          await flush();
+          if (queue.length >= before) break;
+        }
+      })();
+      drainPromise = Promise.race([work, spent]).then(() => {
+        if (budget) clearTimeout(budget);
+      });
+      return drainPromise;
     }
-    const forwarded = new Response(upstream.body, {
-      status: upstream.status,
-      statusText: upstream.statusText,
-      headers: responseHeaders(upstream.headers)
-    });
-    return protection.screenResponse ? protection.screenResponse(forwarded) : forwarded;
   };
 }
+function telemetryEnabled() {
+  const v = typeof process !== "undefined" ? process.env?.PATCHSTACK_TELEMETRY : void 0;
+  if (v === void 0 || v === "") return true;
+  return !/^(0|false|off|no)$/i.test(String(v));
+}
 
 // src/protect/verify-sentinel.js
 var VERIFY_HEADER = "x-patchstack-verify";
@@ -5632,6 +6329,7 @@ async function createProtection(options = {}) {
       "onDetect"
     );
   };
+  const nodeHttp = await Promise.resolve().then(() => __toESM(require_ps_edge_stub(), 1)).then((m) => m.default ?? m, () => null);
   const store = makeStore(options);
   const bootTimeoutMs = Number(options.bootTimeoutMs) > 0 ? Number(options.bootTimeoutMs) : 5e3;
   const pulseAuth = await resolvePulseAuth(options);
@@ -5657,6 +6355,21 @@ async function createProtection(options = {}) {
     pulseAuth,
     detectionState: preFetchState
   });
+  let ruleSource = { ...bundle.source ?? { ok: true, origin: "empty" } };
+  const warnedSources = /* @__PURE__ */ new Set();
+  const hasLiveSource = Boolean(options.siteUuid || options.token);
+  const noteRuleSource = (source) => {
+    ruleSource = { ...source ?? { ok: true, origin: ruleSource.origin } };
+    if (!hasLiveSource || typeof onError === "function" || ruleSource.ok !== false) return;
+    const cause = `${ruleSource.origin}:${ruleSource.reason ?? ""}`;
+    if (warnedSources.has(cause)) return;
+    warnedSources.add(cause);
+    const running = ruleSource.origin === "cache" ? "the last rules it received" : ruleSource.origin === "bundled" ? "its bundled fallback rules" : "no rules at all";
+    console.warn(
+      `[patchstack] the guard's rules are not current (${ruleSource.reason ?? "the rules source did not answer"}); it is running on ${running}. Pass { onError } to handle this yourself.`
+    );
+  };
+  noteRuleSource(bundle.source);
   let detectionReporting = "not-enrolled";
   let currentOrigin;
   const applyReportingState = async (origin) => {
@@ -5712,20 +6425,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 })
@@ -5739,6 +6479,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();
@@ -5781,15 +6524,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;
@@ -5799,6 +6546,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({
@@ -5828,6 +6580,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;
@@ -5835,17 +6589,29 @@ async function createProtection(options = {}) {
       const spanRedactors = redactors.filter((r) => !r.jsonPath);
       if (pathRedactors.length) body = applyPathRedactors(body, pathRedactors, mask, screenCap, transform);
       if (!spanRedactors.length) continue;
-      body = applyRedactors(body, spanRedactors, mask, transform);
+      const beforeSpan = body;
+      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)
           );
         }
       }
@@ -5892,18 +6658,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 };
@@ -5952,14 +6753,20 @@ async function createProtection(options = {}) {
   const screenResp = async (response, reqCtx) => {
     const read = await readTextResponse(response, screenCap);
     if (read.skip) {
-      if (read.skip !== "not-a-response") recordSkip("response", read.skip, { status: response?.status });
+      if (read.skip !== "not-a-response") {
+        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) => {
@@ -6021,7 +6828,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);
@@ -6033,9 +6841,16 @@ async function createProtection(options = {}) {
   const wrapNodeResponse = (res, reqCtx) => {
     const origWrite = res.write.bind(res);
     const origEnd = res.end.bind(res);
+    const setHeaderNow = typeof res.setHeader === "function" ? res.setHeader.bind(res) : null;
+    const removeHeaderNow = typeof res.removeHeader === "function" ? res.removeHeader.bind(res) : null;
+    const sentAccessor = accessorOf(res, "headersSent");
+    let sentValue = sentAccessor ? void 0 : res.headersSent;
+    const reallySent = () => Boolean(sentAccessor ? sentAccessor.call(res) : sentValue);
     const chunks = [];
     let size = 0;
     let overflow = false;
+    let withheld = false;
+    let headScreened = false;
     const MAX = screenCap;
     let hardened = false;
     let answeredWithoutBody = false;
@@ -6043,7 +6858,7 @@ async function createProtection(options = {}) {
       if (hardened) return null;
       hardened = true;
       try {
-        if (res.headersSent || typeof res.setHeader !== "function") return null;
+        if (reallySent() || !setHeaderNow) return null;
         const set = typeof res.getHeaders === "function" ? res.getHeaders() : {};
         const headers = effective && effective.headers ? { ...set, ...effective.headers } : set;
         const status = effective && effective.status !== void 0 ? effective.status : res.statusCode;
@@ -6055,8 +6870,8 @@ async function createProtection(options = {}) {
           if (!headerValueChanged(headers[name], value)) continue;
           changed.set(name.toLowerCase(), value);
           try {
-            if (value === null || value === void 0) res.removeHeader?.(name);
-            else res.setHeader(name, value);
+            if (value === null || value === void 0) removeHeaderNow?.(name);
+            else setHeaderNow(name, value);
           } catch {
           }
         }
@@ -6067,26 +6882,187 @@ async function createProtection(options = {}) {
       }
     };
     const stillToAnswer = (rule) => !hardensWithoutBody(rule);
-    if (typeof res.writeHead === "function") {
-      const origWriteHead = res.writeHead.bind(res);
+    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;
+    if (origWriteHead) {
       res.writeHead = function(...args) {
-        const at = writeHeadHeaderIndex(args);
-        const given = at === -1 ? null : args[at];
-        const changed = hardenBeforeFlush({
-          status: typeof args[0] === "number" ? args[0] : void 0,
-          headers: given ? writeHeadHeaderObject(given) : null
-        });
-        if (!changed || !given) return origWriteHead(...args);
-        const rewritten = [...args];
-        rewritten[at] = rewriteWriteHeadHeaders(given, changed);
-        return origWriteHead(...rewritten);
+        if (sending || reallySent()) return origWriteHead(...args);
+        if (pendingHead) throw headersSentError("write");
+        const judged = judgeWriteHead(args);
+        if (judged) {
+          res.statusCode = judged.statusCode;
+          res.statusMessage = judged.statusMessage;
+          mirrorHeaders(judged.headers);
+          pendingHead = args;
+        } else {
+          pendingHead = args;
+          if (typeof args[0] === "number") res.statusCode = args[0];
+          if (typeof args[1] === "string") res.statusMessage = args[1];
+        }
+        return res;
+      };
+    }
+    function judgeWriteHead(args) {
+      const ServerResponse = nodeHttp?.ServerResponse;
+      if (typeof ServerResponse !== "function") return null;
+      const detached = new ServerResponse({ method: res.req?.method ?? "GET", httpVersionMajor: 1, httpVersionMinor: 1, headers: {} });
+      if (res.statusMessage !== void 0) detached.statusMessage = res.statusMessage;
+      for (const [name, value] of headerEntries(res)) detached.setHeader(name, value);
+      detached.writeHead(...args);
+      return { statusCode: detached.statusCode, statusMessage: detached.statusMessage, headers: headerEntries(detached) };
+    }
+    function headerEntries(target) {
+      const names = typeof target.getRawHeaderNames === "function" ? target.getRawHeaderNames() : typeof target.getHeaderNames === "function" ? target.getHeaderNames() : [];
+      return names.map((name) => [name, target.getHeader(name)]);
+    }
+    function mirrorHeaders(entries) {
+      if (!setHeaderNow) return;
+      for (const [name, value] of entries) {
+        const current = res.getHeader?.(name);
+        if (current === void 0 || headerValueChanged(current, value)) setHeaderNow(name, value);
+      }
+    }
+    Object.defineProperty(res, "headersSent", {
+      configurable: true,
+      enumerable: true,
+      get: () => pendingHead !== null || reallySent(),
+      // A response-like object that tracks the flag itself keeps doing so.
+      set: (value) => {
+        if (!sentAccessor) sentValue = value;
+      }
+    });
+    for (const [method, verb] of [["setHeader", "set"], ["removeHeader", "remove"], ["appendHeader", "append"]]) {
+      const original = typeof res[method] === "function" ? res[method].bind(res) : null;
+      if (!original) continue;
+      res[method] = function(...args) {
+        if (pendingHead) throw headersSentError(verb);
+        return original(...args);
+      };
+    }
+    if (typeof res.flushHeaders === "function") {
+      const origFlushHeaders = res.flushHeaders.bind(res);
+      res.flushHeaders = function() {
+        const unread = screenUnreadHead();
+        if (unread?.withhold) {
+          sendWithheld();
+          return void 0;
+        }
+        sendHead(unread);
+        return origFlushHeaders();
       };
     }
+    let hardenDone = false;
+    let hardenedValues = null;
+    const hardenOnce = () => {
+      if (hardenDone) return hardenedValues;
+      hardenDone = true;
+      if (!pendingHead) {
+        hardenedValues = hardenBeforeFlush();
+        return hardenedValues;
+      }
+      const at = writeHeadHeaderIndex(pendingHead);
+      hardenedValues = hardenBeforeFlush({
+        status: typeof pendingHead[0] === "number" ? pendingHead[0] : void 0,
+        headers: at === -1 ? null : writeHeadHeaderObject(pendingHead[at])
+      });
+      return hardenedValues;
+    };
+    const effectiveHead = () => {
+      const set = typeof res.getHeaders === "function" ? { ...res.getHeaders() } : {};
+      if (typeof res.getHeaders !== "function" && typeof res.getHeader === "function") {
+        for (const name of ["content-type", "content-length"]) {
+          const value = res.getHeader(name);
+          if (value !== void 0) set[name] = value;
+        }
+      }
+      if (!pendingHead) return { status: res.statusCode, headers: set };
+      const at = writeHeadHeaderIndex(pendingHead);
+      return {
+        status: typeof pendingHead[0] === "number" ? pendingHead[0] : res.statusCode,
+        headers: at === -1 ? set : { ...set, ...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();
+      sending = true;
+      if (!pendingHead) {
+        if (changes) applyToResponse(changes);
+        return;
+      }
+      const args = [...pendingHead];
+      pendingHead = null;
+      const merged = new Map(hardened2 ?? []);
+      for (const [name, value] of changes?.headers ?? []) merged.set(name, value);
+      if (changes?.status !== void 0) {
+        args[0] = changes.status;
+        if (typeof args[1] === "string") args.splice(1, 1);
+      }
+      const headerAt = writeHeadHeaderIndex(args);
+      if (headerAt !== -1 && merged.size) args[headerAt] = rewriteWriteHeadHeaders(args[headerAt], merged);
+      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 ?? []) {
+        try {
+          if (value === null || value === void 0) removeHeaderNow?.(name);
+          else setHeaderNow?.(name, value);
+        } catch {
+        }
+      }
+    };
     const collect = (chunk, enc) => {
       if (chunk == null) return;
       const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, typeof enc === "string" ? enc : "utf8");
       size += buf.length;
       if (size > MAX) {
+        const unread = screenUnreadHead();
+        if (unread?.withhold) {
+          sendWithheld();
+          return;
+        }
+        sendHead(unread);
         for (const c of chunks) origWrite(c);
         chunks.length = 0;
         origWrite(buf);
@@ -6097,7 +7073,11 @@ async function createProtection(options = {}) {
       chunks.push(buf);
     };
     res.write = function(chunk, enc, cb) {
-      hardenBeforeFlush();
+      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();
@@ -6105,7 +7085,6 @@ async function createProtection(options = {}) {
       return true;
     };
     res.end = function(chunk, enc, cb) {
-      hardenBeforeFlush();
       if (typeof chunk === "function") {
         cb = chunk;
         chunk = void 0;
@@ -6114,74 +7093,90 @@ 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 = (changes) => {
+        if (changes?.withhold) return sendWithheld(cb);
+        sendHead(changes);
+        for (const c of chunks) origWrite(c);
+        return origEnd(cb);
+      };
       const buffer = Buffer.concat(chunks);
-      let ct = res.getHeader ? res.getHeader("content-type") : void 0;
+      const head = effectiveHead();
+      let ct = head.headers["content-type"];
       if (Array.isArray(ct)) ct = ct[0];
       const kind = screenableContentType(ct);
       if (kind === "skip" || kind === "sniff" && looksBinary(buffer)) {
         recordSkip("response", kind === "skip" ? baseContentType(ct) === "text/event-stream" ? "live-stream" : "non-text-content-type" : "binary-body");
-        for (const c of chunks) origWrite(c);
-        return origEnd(cb);
+        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(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,
-          { status: res.statusCode, headers: res.getHeaders ? res.getHeaders() : {} },
-          reqCtx,
-          answeredWithoutBody ? stillToAnswer : void 0
-        );
+        r = screenText(text, head, reqCtx, notYetAnswered);
       } catch (err) {
         notify(onError, err, "onError");
-        for (const c of chunks) origWrite(c);
-        return origEnd(cb);
+        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");
+        res.destroy?.();
+        return res;
       }
       if (r.verdict === "block") {
-        res.statusCode = 500;
-        try {
-          res.setHeader("content-type", "application/json");
-        } catch {
+        if (reallySent()) {
+          res.destroy?.();
+          return res;
         }
-        return origEnd(JSON.stringify({ error: "Response withheld by Patchstack (sensitive data detected)" }), cb);
+        return sendWithheld(cb);
       }
-      if (r.verdict === "redact") {
-        try {
-          res.removeHeader && res.removeHeader("content-length");
-        } catch {
+      const changed = /* @__PURE__ */ new Map();
+      if (r.headers) {
+        for (const [name, value] of Object.entries(r.headers)) {
+          if (name.toLowerCase() === "content-length") continue;
+          if (!headerValueChanged(head.headers[name], value)) continue;
+          changed.set(name.toLowerCase(), value);
         }
-        if (r.headers && res.setHeader) {
-          const current = res.getHeaders ? res.getHeaders() : {};
-          for (const [name, value] of Object.entries(r.headers)) {
-            if (name.toLowerCase() === "content-length") continue;
-            if (value === null || value === void 0) {
-              try {
-                res.removeHeader && res.removeHeader(name);
-              } catch {
-              }
-            } else if (Array.isArray(value)) {
-              try {
-                res.setHeader(name, value);
-              } catch {
-              }
-            } else if (typeof value === "string" && current[name] !== value) {
-              try {
-                res.setHeader(name, value);
-              } catch {
-              }
-            }
-          }
+      }
+      if (!reallySent()) {
+        const declared = head.headers["content-length"];
+        if (declared === void 0) {
+          changed.set("content-length", null);
+        } else {
+          changed.set("content-length", String(Buffer.byteLength(r.body)));
+          changed.set("transfer-encoding", null);
         }
-        return origEnd(r.body, cb);
+        sendHead({ headers: changed });
+      } else if (changed.size) {
+        recordSkip("response", "headers-sent", { headers: [...changed.keys()] });
       }
-      for (const c of chunks) origWrite(c);
-      return origEnd(cb);
+      return origEnd(r.body, cb);
     };
   };
   const allow = new Set(allowHosts.map((h) => String(h).toLowerCase()));
@@ -6255,21 +7250,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));
@@ -6283,6 +7272,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));
@@ -6317,33 +7307,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();
@@ -6362,7 +7344,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();
           },
@@ -6394,6 +7376,7 @@ async function createProtection(options = {}) {
       notify(onError, err, "onError");
     }
   }
+  let recovery = null;
   const runRefreshTick = async () => {
     if (reporter) {
       try {
@@ -6410,23 +7393,38 @@ async function createProtection(options = {}) {
     });
     mode = resolveMode(options, next);
     applyBundle(next);
+    noteRuleSource(next.source);
+    if (next.source?.ok !== false) recovery?.stop();
     await applyAndAcknowledge(next.source?.origin, declaredState);
     if (detections) detections.setRulesEtag((await store.read())?.etag ?? null);
     return next.source ?? { ok: true };
   };
+  const refreshTick = serialise(runRefreshTick);
   if (live) {
-    protection.refresh = () => runRefreshTick();
-    protection.refreshHandler = () => makeRefreshHandler(runRefreshTick, refreshSecret);
+    protection.refresh = () => refreshTick();
+    protection.refreshHandler = () => makeRefreshHandler(refreshTick, refreshSecret);
   }
-  const loop = options.refreshMs > 0 && live ? startRefresh(runRefreshTick, { refreshMs: options.refreshMs, onError }) : null;
+  const loop = options.refreshMs > 0 && live ? startRefresh(refreshTick, { refreshMs: options.refreshMs, onError }) : null;
+  const canAsk = Boolean(options.token || pulseAuth);
+  recovery = live && canAsk && !loop && ruleSource.ok === false ? startRecovery(refreshTick, { onError }) : null;
   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
+  });
   Object.defineProperty(protection, "detectionReporting", {
     get: () => detectionReporting,
     enumerable: true
@@ -6435,8 +7433,22 @@ 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) {
+  for (let o = obj; o; o = Object.getPrototypeOf(o)) {
+    const d = Object.getOwnPropertyDescriptor(o, name);
+    if (d) return typeof d.get === "function" ? d.get : null;
+  }
+  return null;
+}
+function headersSentError(verb) {
+  return Object.assign(new Error(`Cannot ${verb} headers after they are sent to the client`), { code: "ERR_HTTP_HEADERS_SENT" });
+}
 function resolveMode(options, bundle) {
   const env = typeof process !== "undefined" ? process.env?.PATCHSTACK_MODE : void 0;
   if (env === "block" || env === "dry-run") return env;
@@ -6499,6 +7511,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;
@@ -6509,11 +7529,72 @@ function looksBinary(bytes) {
   }
   return n > 0 && ctrl / n > 0.1;
 }
+function declaredCodings(value) {
+  const raw = Array.isArray(value) ? value.join(",") : String(value ?? "");
+  return raw.toLowerCase().split(",").map((c) => c.trim()).filter((c) => c !== "" && c !== "identity");
+}
+function stillEncoded(bytes) {
+  if (looksBinary(bytes)) return true;
+  try {
+    new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    return false;
+  } catch {
+    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") || "";
   const kind = screenableContentType(ct);
   if (kind === "skip") return { skip: baseContentType(ct) === "text/event-stream" ? "live-stream" : "non-text-content-type" };
+  const codings = declaredCodings(response.headers?.get?.("content-encoding"));
+  const encodedSkip = () => ({ skip: "encoded-body", encoding: codings.join(", ") });
   const sniff = kind === "sniff";
   const len = Number(response.headers?.get?.("content-length") || 0);
   if (len && len > cap) return { skip: "body-cap" };
@@ -6557,13 +7638,22 @@ async function readTextResponse(response, cap = DEFAULT_SCREEN_CAP) {
     } finally {
       reader.releaseLock();
     }
+    const bytes = concatBytes(chunks, size);
+    if (codings.length > 0 && stillEncoded(bytes)) return encodedSkip();
     try {
-      return { text: new TextDecoder().decode(concatBytes(chunks, size)) };
+      return decodeForScreening(ct, bytes);
     } catch {
       return { skip: "decode-failed" };
     }
   }
   try {
+    if (codings.length > 0 || typeof clone.arrayBuffer === "function") {
+      const bytes = new Uint8Array(await clone.arrayBuffer());
+      if (bytes.byteLength > cap) return { skip: "body-cap" };
+      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" };
     if (sniff && looksBinary(new TextEncoder().encode(text.slice(0, 512)))) return { skip: "binary-body" };
@@ -6593,8 +7683,9 @@ function headerObject(headers) {
 function hasSpanMutations(rule) {
   let found = false;
   const walk = (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)) walk(c.rules);
       const isSpan = c.match && (c.match.type === "regex" || c.match.type === "contains" || c.match.type === "stripos");
       if (isSpan && Array.isArray(c.mutations) && c.mutations.length) found = true;
@@ -6603,10 +7694,34 @@ function hasSpanMutations(rule) {
   walk(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 walk = (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)) walk(c.rules);
       const m = c.match;
       if (!m) continue;
@@ -6614,16 +7729,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 });
@@ -6637,6 +7757,110 @@ function extractRedactors(rule) {
 function htmlEscape(str) {
   return String(str).replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
 }
+function isJson(text) {
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    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;
+}
+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;
+    }
+    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;
   for (const r of redactors) {
@@ -6652,6 +7876,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";
 }
@@ -6679,10 +7908,12 @@ function applyPathRedactors(text, pathRedactors, mask, cap, transform) {
   if (!pathRedactors.length || typeof text !== "string" || text.length > cap) return text;
   const head = text.trimStart()[0];
   if (head !== "{" && head !== "[") return text;
-  const preserved = preserveBigInts(text);
+  let preserved;
   let obj;
   try {
-    obj = JSON.parse(preserved);
+    JSON.parse(text);
+    preserved = preserveNumbers(text, mask);
+    obj = JSON.parse(preserved.text);
   } catch {
     return text;
   }
@@ -6691,65 +7922,44 @@ function applyPathRedactors(text, pathRedactors, mask, cap, transform) {
     const pred = conditionPredicate(r.condition);
     walkLeaves(obj, r.jsonPath, (loc) => {
       try {
-        if (pred(loc.value)) {
-          loc.parent[loc.key] = transform ? transform(String(loc.value)) : mask;
+        const number = preserved.numbers.get(loc.value);
+        if (pred(number === void 0 ? loc.value : Number(number))) {
+          setOwn(loc.parent, loc.key, transform ? transform(number ?? String(loc.value)) : mask);
           changed = true;
         }
       } catch {
       }
     });
   }
-  return changed ? restoreBigInts(JSON.stringify(obj)) : text;
-}
-var BIGINT_OPEN = "__PSBIGINT_9c2f__";
-var BIGINT_CLOSE = "__DNEGIB__";
-function preserveBigInts(text) {
-  let out = "";
-  let inStr = false;
-  for (let i = 0; i < text.length; ) {
-    const ch = text[i];
-    if (inStr) {
-      out += ch;
-      if (ch === "\\") {
-        out += text[i + 1] ?? "";
-        i += 2;
-        continue;
-      }
-      if (ch === '"') inStr = false;
-      i++;
-      continue;
-    }
-    if (ch === '"') {
-      inStr = true;
-      out += ch;
-      i++;
-      continue;
-    }
-    if (ch === "-" || ch >= "0" && ch <= "9") {
-      let j = ch === "-" ? i + 1 : i;
-      let digits = 0;
-      while (j < text.length && text[j] >= "0" && text[j] <= "9") {
-        digits++;
-        j++;
-      }
-      const next = text[j];
-      const isIntToken = digits > 0 && next !== "." && next !== "e" && next !== "E";
-      if (isIntToken && digits >= 16) {
-        out += `"${BIGINT_OPEN}${text.slice(i, j)}${BIGINT_CLOSE}"`;
-      } else {
-        out += text.slice(i, j || i + 1);
-      }
-      i = j > i ? j : i + 1;
-      continue;
-    }
-    out += ch;
-    i++;
-  }
-  return out;
+  return changed ? restoreNumbers(JSON.stringify(obj), preserved.numbers) : text;
 }
-function restoreBigInts(text) {
-  if (!text.includes(BIGINT_OPEN)) return text;
-  return text.replace(new RegExp(`"${BIGINT_OPEN}(-?\\d+)${BIGINT_CLOSE}"`, "g"), "$1");
+function preserveNumbers(text, mask) {
+  const occupied = /* @__PURE__ */ new Set([mask]);
+  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 found.push({ start: match.index, token });
+  }
+  const numbers = /* @__PURE__ */ new Map();
+  const chunks = [];
+  let offset = 0;
+  let index = 0;
+  for (const { start, token } of found) {
+    let marker;
+    do {
+      marker = "__PSNUMBER_" + index++ + "__";
+    } while (occupied.has(marker));
+    numbers.set(marker, token);
+    chunks.push(text.slice(offset, start), JSON.stringify(marker));
+    offset = start + token.length;
+  }
+  chunks.push(text.slice(offset));
+  return { text: chunks.join(""), numbers };
+}
+function restoreNumbers(text, numbers) {
+  return text.replace(/"(__PSNUMBER_\d+__)"/g, (token, marker) => numbers.get(marker) ?? token);
 }
 function isHeaderMutation(action) {
   return action === "set-header" || action === "remove-header" || action === "harden-cookie";