@patchstack/connect 0.5.6 → 0.5.8

package/dist/protect.edge.js

@@ -272,6 +272,51 @@ function warnOnce(key, message) {
   console.warn(message);
 }
 
+// src/protect/engine/response-json.js
+var MAX_RULE_RESPONSE_BYTES = 5 * 1024 * 1024;
+async function readBoundedJson(response, maxBytes = MAX_RULE_RESPONSE_BYTES) {
+  const stated = Number(response.headers?.get?.("content-length"));
+  if (Number.isFinite(stated) && stated > maxBytes) {
+    throw new Error(`rule response exceeds ${maxBytes} bytes`);
+  }
+  const stream = response.body;
+  if (!stream || typeof stream.getReader !== "function") {
+    if (typeof response.text === "function") {
+      const text = await response.text();
+      if (new TextEncoder().encode(text).byteLength > maxBytes) {
+        throw new Error(`rule response exceeds ${maxBytes} bytes`);
+      }
+      return JSON.parse(text);
+    }
+    throw new Error("rule response body cannot be read with a size bound");
+  }
+  const reader = stream.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 Error(`rule response exceeds ${maxBytes} bytes`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+
 // src/protect/engine/client.js
 var DEFAULT_BASE_URL = "https://api.patchstack.com";
 var DEFAULT_CACHE_TTL = 3e5;
@@ -328,7 +373,7 @@ var PatchstackRuleClient = class {
           whitelist_keys: {}
         };
       }
-      const data = await response.json();
+      const data = await readBoundedJson(response);
       if (!data || !Array.isArray(data.firewall)) {
         return { success: false, error: "unexpected response shape (no firewall array)", firewall: [], whitelists: [], whitelist_keys: {} };
       }
@@ -365,6 +410,22 @@ var PatchstackRuleClient = class {
   }
 };
 
+// src/protect/engine/own.js
+function setOwn(target, key, value) {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value
+  });
+  return value;
+}
+function appendOwn(target, key, value) {
+  if (!Object.hasOwn(target, key)) return setOwn(target, key, value);
+  const previous = target[key];
+  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;
@@ -483,8 +544,8 @@ var RequestResolver = class {
     }
     if (key.startsWith("header.")) {
       const name = key.slice("header.".length).toLowerCase();
-      const value = (resp.headers ?? {})[name];
-      return value !== void 0 ? [value] : [];
+      const headers = resp.headers ?? {};
+      return Object.hasOwn(headers, name) ? [headers[name]] : [];
     }
     return [];
   }
@@ -579,7 +640,7 @@ var RequestResolver = class {
         ...this.#resolveWildcard(cookies, key)
       ];
     }
-    const value = this.#getNestedValue(query, key) ?? this.#getNestedValue(body, key) ?? 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] : [];
   }
   #resolveCookie(key) {
@@ -587,8 +648,7 @@ var RequestResolver = class {
     if (key.endsWith("*")) {
       return this.#resolveWildcard(cookies, key);
     }
-    const value = cookies[key];
-    return value !== void 0 ? [value] : [];
+    return Object.hasOwn(cookies, key) ? [cookies[key]] : [];
   }
   #resolveServer(key) {
     const req = this.#req;
@@ -764,7 +824,7 @@ var RequestResolver = class {
       }
       const name = pair.substring(0, eqIndex).trim();
       const value = pair.substring(eqIndex + 1).trim();
-      cookies[name] = value;
+      setOwn(cookies, name, value);
     }
     this.#cookies = cookies;
     return this.#cookies;
@@ -921,30 +981,113 @@ function normalizeWhitespace(value) {
   result = result.replace(/ {2,}/g, " ");
   return result;
 }
-function serializeForRawDetection(body, visited = /* @__PURE__ */ new Set(), isRoot = true) {
-  if (body === null || body === void 0) {
-    return isRoot ? "" : "null";
-  }
-  if (typeof body === "string") {
-    return isRoot ? body : JSON.stringify(body);
-  }
-  if (typeof body !== "object") {
-    return String(body);
-  }
-  if (visited.has(body)) {
-    return "[Circular]";
+var MAX_RAW_CHARS = 1024 * 1024;
+var MAX_RAW_NODES = 25e3;
+var MAX_RAW_DEPTH = 200;
+var MAX_RAW_ENTRIES = 2e3;
+function serializeForRawDetection(body) {
+  if (body === null || body === void 0) return "";
+  if (typeof body === "string") return body.slice(0, MAX_RAW_CHARS);
+  const visited = /* @__PURE__ */ new Set();
+  const output = [];
+  const stack = [{ kind: "value", value: body, depth: 0, root: true }];
+  let chars = 0;
+  let nodes = 0;
+  const append = (text) => {
+    if (chars >= MAX_RAW_CHARS) return;
+    const piece = String(text).slice(0, MAX_RAW_CHARS - chars);
+    output.push(piece);
+    chars += piece.length;
+  };
+  while (stack.length > 0 && chars < MAX_RAW_CHARS) {
+    const task = stack.pop();
+    if (task.kind === "text") {
+      append(task.text);
+      continue;
+    }
+    if (task.kind === "key") {
+      append(boundedJsonString(task.value));
+      append(":");
+      continue;
+    }
+    nodes++;
+    if (nodes > MAX_RAW_NODES) {
+      append('"[NodeLimit]"');
+      continue;
+    }
+    const value = task.value;
+    if (value === null || value === void 0) {
+      append(task.root ? "" : "null");
+      continue;
+    }
+    if (typeof value === "string") {
+      append(task.root ? value.slice(0, MAX_RAW_CHARS) : boundedJsonString(value));
+      continue;
+    }
+    if (typeof value !== "object") {
+      append(String(value).slice(0, MAX_RAW_CHARS));
+      continue;
+    }
+    if (visited.has(value)) {
+      append("[Circular]");
+      continue;
+    }
+    if (task.depth >= MAX_RAW_DEPTH) {
+      append('"[DepthLimit]"');
+      continue;
+    }
+    visited.add(value);
+    if (Array.isArray(value)) {
+      const length2 = Math.min(value.length, MAX_RAW_ENTRIES);
+      const items = [];
+      for (let i = 0; i < length2; i++) {
+        if (i > 0) items.push({ kind: "text", text: "," });
+        items.push({ kind: "value", value: readOwnValue(value, String(i)), depth: task.depth + 1, root: false });
+      }
+      if (value.length > length2) {
+        if (length2 > 0) items.push({ kind: "text", text: "," });
+        items.push({ kind: "text", text: '"[EntryLimit]"' });
+      }
+      stack.push({ kind: "text", text: "]" });
+      for (let i = items.length - 1; i >= 0; i--) stack.push(items[i]);
+      stack.push({ kind: "text", text: "[" });
+      continue;
+    }
+    let keys;
+    try {
+      keys = Object.getOwnPropertyNames(value);
+    } catch {
+      append('"[Unreadable]"');
+      continue;
+    }
+    const length = Math.min(keys.length, MAX_RAW_ENTRIES);
+    const entries = [];
+    for (let i = 0; i < length; i++) {
+      const key = keys[i];
+      if (i > 0) entries.push({ kind: "text", text: "," });
+      entries.push({ kind: "key", value: key });
+      entries.push({ kind: "value", value: readOwnValue(value, key), depth: task.depth + 1, root: false });
+    }
+    if (keys.length > length) {
+      if (length > 0) entries.push({ kind: "text", text: "," });
+      entries.push({ kind: "text", text: '"[EntryLimit]":null' });
+    }
+    stack.push({ kind: "text", text: "}" });
+    for (let i = entries.length - 1; i >= 0; i--) stack.push(entries[i]);
+    stack.push({ kind: "text", text: "{" });
   }
-  visited.add(body);
-  if (Array.isArray(body)) {
-    const items = body.map((item) => serializeForRawDetection(item, visited, false));
-    return "[" + items.join(",") + "]";
+  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]";
   }
-  const keys = Object.getOwnPropertyNames(body);
-  const parts = keys.map((key) => {
-    const val = serializeForRawDetection(body[key], visited, false);
-    return JSON.stringify(key) + ":" + val;
-  });
-  return "{" + parts.join(",") + "}";
 }
 var INHERITED_ACCESSORS = /* @__PURE__ */ new Set(["headers", "query"]);
 function requestField(req, key) {
@@ -986,7 +1129,7 @@ function normalizeObject(value, options = {}, depth = 0) {
   if (typeof value === "object" && value !== null) {
     const result = {};
     for (const [key, val] of Object.entries(value)) {
-      result[key] = normalizeObject(val, options, depth + 1);
+      setOwn(result, key, normalizeObject(val, options, depth + 1));
     }
     return result;
   }
@@ -1003,6 +1146,111 @@ var REDOS_PATTERNS = [
   new RegExp("\\(" + GRP + "\\|" + GRP + "\\)\\s*[+*]")
   // nested alternation under a quantifier
 ];
+function hasAdjacentUnbounded(body, flags) {
+  let previousUnboundedAtom = null;
+  for (let i = 0; i < body.length; ) {
+    const start = i;
+    const ch = body[i];
+    let assertion = false;
+    let literal = null;
+    let atom = ch;
+    if (ch === "\\") {
+      const escaped = body[i + 1] ?? "";
+      assertion = /[bBAZz]/.test(escaped);
+      if (!/[bBAZzdswDSWnrtvf0-9pPkKxuc]/.test(escaped)) literal = escaped;
+      i += Math.min(2, body.length - i);
+      atom = body.slice(start, i);
+    } else if (ch === "[") {
+      i++;
+      while (i < body.length) {
+        if (body[i] === "\\") i += 2;
+        else if (body[i++] === "]") break;
+      }
+      atom = body.slice(start, i);
+    } else if (ch === ")") {
+      i++;
+      atom = ".";
+    } else if (ch === "(") {
+      const lookaround = body.startsWith("(?=", i) || body.startsWith("(?!", i) || body.startsWith("(?<=", i) || body.startsWith("(?<!", i);
+      if (lookaround) {
+        i = groupEnd(body, i);
+        continue;
+      }
+      i++;
+      if (body.startsWith("?:", i)) i += 2;
+      else if (body.startsWith("?<", i)) {
+        const nameEnd = body.indexOf(">", i + 2);
+        if (nameEnd !== -1) i = nameEnd + 1;
+      }
+      continue;
+    } else if (ch === "|") {
+      previousUnboundedAtom = null;
+      i++;
+      continue;
+    } else if ("^$".includes(ch)) {
+      i++;
+      continue;
+    } else if ("?*+{}".includes(ch)) {
+      previousUnboundedAtom = null;
+      i++;
+      continue;
+    } else {
+      if (ch !== ".") literal = ch;
+      i++;
+    }
+    if (assertion) continue;
+    let unbounded = false;
+    let mayBeEmpty = false;
+    if (body[i] === "*" || body[i] === "+") {
+      unbounded = true;
+      mayBeEmpty = body[i] === "*";
+      i++;
+    } else if (body[i] === "{") {
+      const quantifier = /^\{(\d+)(?:,(\d*))?\}/.exec(body.slice(i));
+      if (quantifier) {
+        unbounded = quantifier[2] === "";
+        mayBeEmpty = Number(quantifier[1]) === 0;
+        i += quantifier[0].length;
+      }
+    } else if (body[i] === "?") {
+      mayBeEmpty = true;
+      i++;
+    }
+    if (unbounded && (body[i] === "?" || body[i] === "+")) i++;
+    if (unbounded && previousUnboundedAtom !== null) return true;
+    if (unbounded) {
+      previousUnboundedAtom = atom;
+    } else if (previousUnboundedAtom !== null && !mayBeEmpty) {
+      try {
+        const atomFlags = flags.replace(/[^iu]/g, "");
+        const complementaryClass = previousUnboundedAtom === "\\s" && atom === "\\S" || previousUnboundedAtom === "\\S" && atom === "\\s" || previousUnboundedAtom === "\\d" && atom === "\\D" || previousUnboundedAtom === "\\D" && atom === "\\d" || previousUnboundedAtom === "\\w" && atom === "\\W" || previousUnboundedAtom === "\\W" && atom === "\\w";
+        const excludedLiteral = literal !== null && !new RegExp(`^(?:${previousUnboundedAtom})$`, atomFlags).test(literal);
+        if (complementaryClass || excludedLiteral) {
+          previousUnboundedAtom = null;
+        }
+      } catch {
+      }
+    }
+    if (i === start) i++;
+  }
+  return false;
+}
+function groupEnd(body, start) {
+  let depth = 0;
+  let inClass = false;
+  for (let i = start; i < body.length; i++) {
+    const ch = body[i];
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === "[") inClass = true;
+    else if (ch === "]") inClass = false;
+    else if (!inClass && ch === "(") depth++;
+    else if (!inClass && ch === ")" && --depth === 0) return i + 1;
+  }
+  return body.length;
+}
 var warnedRejectedPatterns = /* @__PURE__ */ new Set();
 function warnRejectedPatternOnce(pattern) {
   const key = String(pattern);
@@ -1020,15 +1268,14 @@ function safeRegExp(pattern) {
   if (typeof pattern !== "string" || pattern.length > MAX_PATTERN_LENGTH) {
     return null;
   }
-  for (const dangerous of REDOS_PATTERNS) {
-    if (dangerous.test(pattern)) {
-      return null;
-    }
-  }
   const match = pattern.match(/^\/(.+?)\/([gimsuy]*)$/s);
   if (!match) {
     return null;
   }
+  for (const dangerous of REDOS_PATTERNS) {
+    if (dangerous.test(match[1])) return null;
+  }
+  if (hasAdjacentUnbounded(match[1], match[2])) return null;
   try {
     return new RegExp(match[1], match[2]);
   } catch {
@@ -1772,6 +2019,16 @@ function operandShapeProblem(shape, value) {
   const isFilledString = (v) => typeof v === "string" && v.trim() !== "";
   const isScalar = (v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean";
   const isHeaderName = (v) => typeof v === "string" && HEADER_NAME.test(v);
+  const stringLimit = (v) => typeof v === "string" && v.length > LIMITS.maxValueLength ? `must not be longer than ${LIMITS.maxValueLength} chars` : null;
+  const listLimit = (v) => Array.isArray(v) && v.length > LIMITS.maxOperandItems ? `must not have more than ${LIMITS.maxOperandItems} entries` : null;
+  const tooLong = stringLimit(value);
+  if (tooLong) return tooLong;
+  const tooMany = listLimit(value);
+  if (tooMany) return tooMany;
+  if (Array.isArray(value)) {
+    const longMember = value.find((member) => stringLimit(member) !== null);
+    if (longMember !== void 0) return `contains a string longer than ${LIMITS.maxValueLength} chars`;
+  }
   switch (shape) {
     case "positive-number":
       return typeof value === "number" && Number.isFinite(value) && value > 0 ? null : "must be a finite positive number";
@@ -1802,8 +2059,11 @@ function operandShapeProblem(shape, value) {
       if (value === null || typeof value !== "object" || Array.isArray(value)) return "must be an object";
       const names = Object.keys(value);
       if (names.length === 0) return "must be an object with at least one entry";
+      if (names.length > LIMITS.maxMapEntries) return `must not have more than ${LIMITS.maxMapEntries} entries`;
       const bad = names.find((name) => !isHeaderName(name));
-      return bad === void 0 ? null : `names an invalid HTTP header, ${JSON.stringify(bad)}`;
+      if (bad !== void 0) return `names an invalid HTTP header, ${JSON.stringify(bad)}`;
+      const badValue = Object.values(value).find((entry) => typeof entry !== "string" || entry.length > LIMITS.maxValueLength);
+      return badValue === void 0 ? null : `values must be strings no longer than ${LIMITS.maxValueLength} chars`;
     }
     case "header-name-list": {
       if (!Array.isArray(value) || value.length === 0) return "must be a non-empty list of HTTP header names";
@@ -1949,9 +2209,16 @@ var LIMITS = Object.freeze({
   maxRules: 5e3,
   maxWhitelists: 2e3,
   maxConditionsPerRule: 250,
+  maxConditionNodesPerRule: 1e3,
+  maxConditionNodesPerBundle: 25e3,
   maxNestingDepth: 12,
   maxRegexLength: 1e3,
-  maxValueLength: 8192
+  maxValueLength: 8192,
+  maxParameterLength: 512,
+  maxParameterItems: 64,
+  maxOperandItems: 256,
+  maxMapEntries: 128,
+  maxPathSegments: 64
 });
 var GROUP_PARAMETER = "rules";
 function isGroup(condition) {
@@ -1978,6 +2245,9 @@ function parameterProblem(parameter) {
   if (parameter === void 0 || parameter === null) return null;
   if (Array.isArray(parameter)) {
     if (parameter.length === 0) return "parameter list is empty";
+    if (parameter.length > LIMITS.maxParameterItems) {
+      return `parameter list has more than ${LIMITS.maxParameterItems} entries`;
+    }
     for (const member of parameter) {
       if (Array.isArray(member)) return "a parameter list holds parameters, not more lists";
       const problem = parameterProblem(member);
@@ -1986,6 +2256,9 @@ function parameterProblem(parameter) {
     return null;
   }
   if (typeof parameter !== "string" || parameter === "") return "parameter must be a non-empty string";
+  if (parameter.length > LIMITS.maxParameterLength) {
+    return `parameter is longer than ${LIMITS.maxParameterLength} chars`;
+  }
   if (parameter === GROUP_PARAMETER) {
     return `"${GROUP_PARAMETER}" is the group source and is only valid as a whole group, not as a parameter`;
   }
@@ -2021,6 +2294,20 @@ function matchProblem(match, parameter) {
   if (!match || typeof match !== "object") return "condition has no match object";
   if (typeof match.type !== "string" || match.type === "") return "match.type must be a non-empty string";
   if (!MATCH_TYPES.includes(match.type)) return `unknown match type "${match.type}"`;
+  for (const operand of ["value", "key", "claim"]) {
+    const value = match[operand];
+    if (typeof value === "string" && value.length > LIMITS.maxValueLength) {
+      return `match operand "${operand}" is longer than ${LIMITS.maxValueLength} chars`;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > LIMITS.maxOperandItems) {
+        return `match operand "${operand}" has more than ${LIMITS.maxOperandItems} entries`;
+      }
+      if (value.some((entry) => typeof entry === "string" && entry.length > LIMITS.maxValueLength)) {
+        return `match operand "${operand}" contains a string longer than ${LIMITS.maxValueLength} chars`;
+      }
+    }
+  }
   const parameterless = PARAMETERLESS_MATCH_TYPES.includes(match.type);
   if (!parameterless && (parameter === void 0 || parameter === null)) {
     return `match type "${match.type}" needs a parameter`;
@@ -2043,11 +2330,20 @@ function matchProblem(match, parameter) {
   } else if (!OPERANDLESS_MATCH_TYPES.includes(match.type) && match.value === void 0) {
     return `match type "${match.type}" needs a value`;
   }
+  if (match.type === "array_key_value") {
+    const paths = Array.isArray(match.key) ? match.key : [match.key];
+    if (paths.some((path) => typeof path === "string" && path.split(".").length > LIMITS.maxPathSegments)) {
+      return `match type "array_key_value" key has more than ${LIMITS.maxPathSegments} path segments`;
+    }
+  }
   return null;
 }
 function mutationsProblem(mutations) {
   if (mutations === void 0 || mutations === null) return null;
   if (!Array.isArray(mutations)) return "mutations must be an array";
+  if (mutations.length > LIMITS.maxOperandItems) {
+    return `mutations has more than ${LIMITS.maxOperandItems} entries`;
+  }
   for (const mutation of mutations) {
     if (typeof mutation !== "string" || !MUTATIONS.includes(mutation)) {
       return `unknown mutation "${String(mutation)}" \u2014 applied as a no-op, so the condition would test the untransformed value`;
@@ -2067,10 +2363,19 @@ function whenProblem(when) {
   if ("path" in when && !isNonEmptyString(when.path)) {
     return "when.path must be a non-empty string";
   }
+  if (typeof when.path === "string" && when.path.length > LIMITS.maxValueLength) {
+    return `when.path is longer than ${LIMITS.maxValueLength} chars`;
+  }
   if ("method" in when) {
     const methods = Array.isArray(when.method) ? when.method : [when.method];
     if (methods.length === 0) return "when.method is an empty list, so the rule would match no method";
+    if (methods.length > LIMITS.maxParameterItems) {
+      return `when.method has more than ${LIMITS.maxParameterItems} entries`;
+    }
     if (!methods.every(isNonEmptyString)) return "when.method must be a non-empty string, or a list of them";
+    if (methods.some((method) => method.length > LIMITS.maxParameterLength)) {
+      return `when.method entries must not be longer than ${LIMITS.maxParameterLength} chars`;
+    }
   }
   return null;
 }
@@ -2094,6 +2399,11 @@ function rulePropertyProblem(rule) {
     const problem = operandShapeProblem(shape, rule[property]);
     if (problem) return `"${property}" ${problem}`;
   }
+  for (const property of ["id", "rule_id", "title", "category", "message", "source_revision"]) {
+    if (typeof rule[property] === "string" && rule[property].length > LIMITS.maxValueLength) {
+      return `"${property}" is longer than ${LIMITS.maxValueLength} chars`;
+    }
+  }
   return null;
 }
 function actionProblem(action, rule) {
@@ -2123,46 +2433,76 @@ var PHASES2 = new Set(PHASES);
 var ACTIONS2 = new Set(ACTIONS);
 function validateBundle(bundle, opts = {}) {
   const rejected = [];
+  let omittedRejections = 0;
+  const reject = (entry) => {
+    if (rejected.length < 100) rejected.push(entry);
+    else omittedRejections++;
+  };
   const inFirewall = Array.isArray(bundle?.firewall) ? bundle.firewall : [];
   const inWhitelists = Array.isArray(bundle?.whitelists) ? bundle.whitelists : [];
+  const bundleBudget = { count: 0 };
   const firewall = [];
-  for (const rule of inFirewall) {
-    if (firewall.length >= LIMITS2.maxRules) {
-      rejected.push({ id: idOf(rule), reason: `bundle exceeds maxRules (${LIMITS2.maxRules})` });
-      continue;
-    }
-    const reason = enforceableRuleProblem(rule);
-    if (reason) rejected.push({ id: idOf(rule), reason });
+  for (const rule of inFirewall.slice(0, LIMITS2.maxRules)) {
+    const reason = enforceableRuleProblem(rule, bundleBudget);
+    if (reason) reject({ id: idOf(rule), reason });
     else firewall.push(rule);
   }
+  if (inFirewall.length > LIMITS2.maxRules) {
+    reject({ id: "(bundle)", reason: `bundle exceeds maxRules (${LIMITS2.maxRules})` });
+  }
   const whitelists = [];
-  for (const wl of inWhitelists) {
-    if (whitelists.length >= LIMITS2.maxWhitelists) {
-      rejected.push({ id: idOf(wl), reason: `bundle exceeds maxWhitelists (${LIMITS2.maxWhitelists})` });
-      continue;
-    }
+  for (const wl of inWhitelists.slice(0, LIMITS2.maxWhitelists)) {
     if (!opts.allowGlobalWhitelists && wl && Array.isArray(wl.rule_v2) && !wl.rule_id) {
-      rejected.push({ id: idOf(wl), reason: "whitelist has no rule_id (would suppress every rule); set allowGlobalWhitelists to permit" });
+      reject({ id: idOf(wl), reason: "whitelist has no rule_id (would suppress every rule); set allowGlobalWhitelists to permit" });
       continue;
     }
     if (wl && typeof wl === "object" && BUILD_SCOPE_PROPERTY in wl) {
-      rejected.push({ id: idOf(wl), reason: `whitelist may not carry ${BUILD_SCOPE_PROPERTY}` });
+      reject({ id: idOf(wl), reason: `whitelist may not carry ${BUILD_SCOPE_PROPERTY}` });
       continue;
     }
-    const reason = conditionsProblem(wl?.rule_v2);
-    if (reason) rejected.push({ id: idOf(wl), reason: `whitelist: ${reason}` });
+    const reason = conditionsProblem(wl?.rule_v2, 0, { count: 0 }, bundleBudget);
+    if (reason) reject({ id: idOf(wl), reason: `whitelist: ${reason}` });
     else whitelists.push(wl);
   }
+  if (inWhitelists.length > LIMITS2.maxWhitelists) {
+    reject({ id: "(bundle)", reason: `bundle exceeds maxWhitelists (${LIMITS2.maxWhitelists})` });
+  }
+  let whitelistKeys = {};
+  if (bundle?.whitelist_keys !== void 0) {
+    if (!bundle.whitelist_keys || typeof bundle.whitelist_keys !== "object" || Array.isArray(bundle.whitelist_keys)) {
+      reject({ id: "(bundle)", reason: "whitelist_keys must be an object" });
+    } else {
+      const entries = Object.entries(bundle.whitelist_keys);
+      if (entries.length > LIMITS2.maxMapEntries) {
+        reject({ id: "(bundle)", reason: `whitelist_keys has more than ${LIMITS2.maxMapEntries} entries` });
+      } else {
+        const invalid = entries.find(([key, value]) => key.length > LIMITS2.maxParameterLength || !Array.isArray(value) || value.length > LIMITS2.maxOperandItems || value.some((entry) => typeof entry !== "string" || entry.length > LIMITS2.maxValueLength));
+        if (invalid) {
+          reject({ id: "(bundle)", reason: `whitelist_keys entry "${invalid[0].slice(0, 64)}" has an unsupported shape` });
+        } else {
+          whitelistKeys = bundle.whitelist_keys;
+        }
+      }
+    }
+  }
+  if (omittedRejections > 0) {
+    rejected.push({ id: "(bundle)", reason: `${omittedRejections} additional rejected entries omitted` });
+  }
   return {
-    bundle: { ...bundle, firewall, whitelists },
+    bundle: { ...bundle, firewall, whitelists, whitelist_keys: whitelistKeys },
     rejected
   };
 }
 function idOf(rule) {
   const id = rule?.id ?? rule?.rule_id;
-  return id === void 0 || id === null ? "(unidentified)" : String(id);
+  if (id === void 0 || id === null) return "(unidentified)";
+  try {
+    return String(id).slice(0, 128);
+  } catch {
+    return "(unidentified)";
+  }
 }
-function enforceableRuleProblem(rule) {
+function enforceableRuleProblem(rule, bundleBudget = null) {
   if (!rule || typeof rule !== "object") return "not an object";
   const nullReason = nullPropertyProblem(rule);
   if (nullReason) return nullReason;
@@ -2173,9 +2513,9 @@ function enforceableRuleProblem(rule) {
   if (scopeReason) return scopeReason;
   const propertyReason = rulePropertyProblem(rule);
   if (propertyReason) return propertyReason;
-  return conditionsProblem(rule.rule_v2);
+  return conditionsProblem(rule.rule_v2, 0, { count: 0 }, bundleBudget);
 }
-function conditionsProblem(conditions, depth = 0) {
+function conditionsProblem(conditions, depth = 0, ruleBudget = { count: 0 }, bundleBudget = null) {
   if (!Array.isArray(conditions)) return "rule_v2 must be an array of conditions";
   if (conditions.length === 0) return "rule_v2 is empty (would never match)";
   if (depth > LIMITS2.maxNestingDepth) return `nesting deeper than ${LIMITS2.maxNestingDepth}`;
@@ -2183,10 +2523,20 @@ function conditionsProblem(conditions, depth = 0) {
     return `more than ${LIMITS2.maxConditionsPerRule} conditions`;
   }
   for (const c of conditions) {
+    ruleBudget.count++;
+    if (ruleBudget.count > LIMITS2.maxConditionNodesPerRule) {
+      return `more than ${LIMITS2.maxConditionNodesPerRule} total condition nodes`;
+    }
+    if (bundleBudget) {
+      bundleBudget.count++;
+      if (bundleBudget.count > LIMITS2.maxConditionNodesPerBundle) {
+        return `bundle exceeds ${LIMITS2.maxConditionNodesPerBundle} total condition nodes`;
+      }
+    }
     const shapeReason = conditionShapeProblem(c);
     if (shapeReason) return shapeReason;
     if (isGroup(c)) {
-      const nested = conditionsProblem(c.rules, depth + 1);
+      const nested = conditionsProblem(c.rules, depth + 1, ruleBudget, bundleBudget);
       if (nested) return nested;
       continue;
     }
@@ -2200,11 +2550,17 @@ function conditionsProblem(conditions, depth = 0) {
     if (m.type === "regex") {
       if (typeof m.value !== "string") return "regex match.value must be a string";
       if (m.value.length > LIMITS2.maxRegexLength) return `regex longer than ${LIMITS2.maxRegexLength} chars`;
+      if (safeRegExp(m.value) === null) return "regex is invalid or has an unsafe repetition shape";
     } else if (typeof m.value === "string" && m.value.length > LIMITS2.maxValueLength) {
       return `match.value longer than ${LIMITS2.maxValueLength} chars`;
     }
     if (m.match) {
-      const nested = conditionsProblem([{ parameter: c.parameter, match: m.match }], depth + 1);
+      const nested = conditionsProblem(
+        [{ parameter: c.parameter, match: m.match }],
+        depth + 1,
+        ruleBudget,
+        bundleBudget
+      );
       if (nested) return nested;
     }
   }
@@ -2417,6 +2773,117 @@ function asText(value) {
   return null;
 }
 
+// src/types.ts
+var PatchstackError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "PatchstackError";
+  }
+  code;
+  cause;
+  /**
+   * For a `VALIDATION_ERROR`, the request fields the server refused, as it named them. Read from the
+   * structured `errors` object a validation response carries, so a caller deciding what to do about a
+   * refusal keys on the field rather than on the wording of a sentence.
+   */
+  fields = [];
+};
+
+// src/endpoint-policy.ts
+function assertConnectableEndpoint(config, target = config.endpoint) {
+  if (config.endpointTrusted === false) {
+    throw new PatchstackError(
+      "The custom endpoint in .patchstackrc.json must be confirmed with --endpoint or PATCHSTACK_ENDPOINT before it can be used.",
+      "CONFIG_INVALID"
+    );
+  }
+  if (safeRemoteUrl(config.endpoint) === null) {
+    throw new PatchstackError(
+      "Patchstack endpoints must use HTTPS, except for localhost development endpoints.",
+      "CONFIG_INVALID"
+    );
+  }
+  let endpointOrigin;
+  let targetOrigin;
+  try {
+    endpointOrigin = new URL(config.endpoint).origin;
+    targetOrigin = new URL(target).origin;
+  } catch (cause) {
+    throw new PatchstackError("The configured Patchstack endpoint is not a valid URL.", "CONFIG_INVALID", cause);
+  }
+  if (safeRemoteUrl(target) === null || targetOrigin !== endpointOrigin) {
+    throw new PatchstackError(
+      "A Patchstack request resolved outside the configured endpoint origin.",
+      "CONFIG_INVALID"
+    );
+  }
+}
+function safeRemoteUrl(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 2048) return null;
+  try {
+    const parsed = new URL(value);
+    if (!isSafeOrigin(parsed.toString()) || parsed.username !== "" || parsed.password !== "") return null;
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+}
+function isHeaderValue(value, maxLength = 8192) {
+  if (typeof value !== "string" || value.length === 0 || value.length > maxLength) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 33 || code > 126) return false;
+  }
+  return true;
+}
+
+// src/bounded-response.ts
+var MAX_CONTROL_RESPONSE_BYTES = 256 * 1024;
+async function readBoundedText(response, maxBytes = MAX_CONTROL_RESPONSE_BYTES) {
+  const stated = Number(response.headers?.get?.("content-length"));
+  if (Number.isFinite(stated) && stated > maxBytes) {
+    void response.body?.cancel().catch(() => {
+    });
+    throw new Error(`response exceeds ${maxBytes} bytes`);
+  }
+  const stream = response.body;
+  if (stream === null || typeof stream.getReader !== "function") {
+    if (stated === 0) return "";
+    throw new Error("response body cannot be read with a size bound");
+  }
+  const reader = stream.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 Error(`response exceeds ${maxBytes} bytes`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+async function readBoundedJson2(response, maxBytes = MAX_CONTROL_RESPONSE_BYTES) {
+  const text = await readBoundedText(response, maxBytes);
+  return JSON.parse(text);
+}
+
 // src/pulse-token.ts
 var TOKEN_SKEW_MS = 6e4;
 function buildTokenUrl(manifestEndpoint) {
@@ -2434,22 +2901,48 @@ function parsePulseAuth(credential) {
   if (!/^\d+$/.test(clientId)) return null;
   return { clientId, clientSecret: credential.slice(0, index) };
 }
-var cached = null;
-var inflight = null;
-function clearPulseToken() {
-  cached = null;
+var cached = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+function cacheKey(tokenUrl, credential) {
+  return `${tokenUrl}
+${credential}`;
+}
+function clearPulseToken(config) {
+  if (!config || typeof config.pulseAuth !== "string") {
+    cached.clear();
+    inflight.clear();
+    return;
+  }
+  try {
+    const key = cacheKey(buildTokenUrl(config.endpoint), config.pulseAuth);
+    cached.delete(key);
+    inflight.delete(key);
+  } catch {
+  }
 }
 async function getPulseToken(config, fetchImpl = fetch) {
   if (typeof config.pulseAuth !== "string" || config.pulseAuth.length === 0) return null;
-  if (cached !== null && Date.now() < cached.expiresAt - TOKEN_SKEW_MS) {
-    return cached.token;
+  if (config.endpointTrusted === false) return null;
+  let tokenUrl;
+  try {
+    tokenUrl = buildTokenUrl(config.endpoint);
+  } catch {
+    return null;
+  }
+  if (!isSafeOrigin(tokenUrl)) return null;
+  const key = cacheKey(tokenUrl, config.pulseAuth);
+  const existing = cached.get(key);
+  if (existing !== void 0 && Date.now() < existing.expiresAt - TOKEN_SKEW_MS) {
+    return existing.token;
   }
-  if (inflight !== null) return inflight;
+  const pending = inflight.get(key);
+  if (pending !== void 0) return pending;
   const credentials = parsePulseAuth(config.pulseAuth);
   if (credentials === null) return null;
-  inflight = (async () => {
+  let exchange;
+  exchange = (async () => {
     try {
-      const response = await fetchImpl(buildTokenUrl(config.endpoint), {
+      const response = await fetchImpl(tokenUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -2464,25 +2957,27 @@ async function getPulseToken(config, fetchImpl = fetch) {
         signal: AbortSignal.timeout(config.timeoutMs)
       });
       if (!response.ok) return null;
-      const body = await response.json();
-      if (typeof body.access_token !== "string" || body.access_token.length === 0) return null;
+      const body = await readBoundedJson2(response);
+      if (!isHeaderValue(body.access_token)) return null;
       const expiresIn = Number(body.expires_in);
       const ttlMs = Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn * 1e3 : 36e5;
-      cached = { token: body.access_token, expiresAt: Date.now() + ttlMs };
+      cached.set(key, { token: body.access_token, expiresAt: Date.now() + ttlMs });
       return body.access_token;
     } catch {
       return null;
     } finally {
-      inflight = null;
+      if (inflight.get(key) === exchange) inflight.delete(key);
     }
   })();
-  return inflight;
+  inflight.set(key, exchange);
+  return exchange;
 }
 async function pulseAuthHeader(config, fetchImpl = fetch) {
   const token = await getPulseToken(config, fetchImpl);
   return token === null ? {} : { Authorization: `Bearer ${token}` };
 }
 async function pulseFetch(config, url, init, fetchImpl = fetch) {
+  assertConnectableEndpoint(config, url);
   const send = async () => {
     const auth = await pulseAuthHeader(config, fetchImpl);
     const response = await fetchImpl(url, {
@@ -2493,7 +2988,7 @@ async function pulseFetch(config, url, init, fetchImpl = fetch) {
   };
   const first = await send();
   if (first.response.status === 401 && first.authenticated) {
-    clearPulseToken();
+    clearPulseToken(config);
     return (await send()).response;
   }
   return first.response;
@@ -2519,6 +3014,7 @@ var DEFAULT_BASE_URL2 = "https://api.patchstack.com/monitor/pulse";
 var DEFAULT_CACHE_TTL2 = 3e5;
 var BUILD_VERDICT_HEADER = "X-Patchstack-Build-Match";
 var BUILD_IDENTITY_HEADER = "X-Patchstack-Build-ID";
+var PER_RULE_DRY_RUN_HEADER = "X-Patchstack-Per-Rule-Dry-Run";
 var JITTER_FRACTION2 = 0.1;
 var PulseRuleClient = class {
   #siteUuid;
@@ -2563,6 +3059,9 @@ var PulseRuleClient = class {
       if (this.#buildId !== null && typeof auth.Authorization === "string") {
         headers["X-Patchstack-Build"] = this.#buildId;
       }
+      if (typeof auth.Authorization === "string") {
+        headers[PER_RULE_DRY_RUN_HEADER] = "1";
+      }
       if (this.#etag) headers["If-None-Match"] = this.#etag;
       const response = await fetch(url, { method: "GET", headers, signal: AbortSignal.timeout(this.#timeoutMs) });
       if (response.status === 304) {
@@ -2581,7 +3080,7 @@ var PulseRuleClient = class {
       if (!response.ok) {
         return { success: false, error: `API returned ${response.status}`, firewall: [], whitelists: [], whitelist_keys: {} };
       }
-      const data = await response.json();
+      const data = await readBoundedJson(response);
       if (!data || !Array.isArray(data.firewall)) {
         return { success: false, error: "unexpected response shape (no firewall array)", firewall: [], whitelists: [], whitelist_keys: {} };
       }
@@ -2642,19 +3141,18 @@ async function fromFetchRequest(request, options = {}) {
   const method = (request.method || "GET").toUpperCase();
   const headers = {};
   request.headers.forEach((value, key) => {
-    headers[key.toLowerCase()] = value;
+    setOwn(headers, key.toLowerCase(), value);
   });
   const query = {};
   for (const [key, value] of url.searchParams) {
-    if (key in query) {
-      query[key] = Array.isArray(query[key]) ? [...query[key], value] : [query[key], value];
-    } else {
-      query[key] = value;
-    }
+    appendOwn(query, key, value);
   }
   let rawBody = "";
+  let bodyInspectionSkip = null;
   if (method !== "GET" && method !== "HEAD") {
-    rawBody = await readCappedText(request, maxBodyBytes);
+    const read = await readCappedText(request, maxBodyBytes);
+    rawBody = read.text;
+    bodyInspectionSkip = read.skip;
   }
   const contentType = headers["content-type"] || "";
   let body = {};
@@ -2681,7 +3179,8 @@ async function fromFetchRequest(request, options = {}) {
     cookies: parseCookies(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
+    _rawBody: rawBody,
+    ...bodyInspectionSkip === null ? {} : { _bodyInspectionSkip: bodyInspectionSkip }
   };
 }
 async function readCappedText(request, max) {
@@ -2689,7 +3188,7 @@ async function readCappedText(request, max) {
   try {
     clone = request.clone();
   } catch {
-    return "";
+    return { text: "", skip: "clone-failed" };
   }
   const body = clone.body;
   if (body && typeof body.getReader === "function") {
@@ -2700,23 +3199,30 @@ async function readCappedText(request, max) {
       for (; ; ) {
         const { done, value } = await reader.read();
         if (done) break;
-        if (!value || buffered >= max) continue;
+        if (!value) continue;
         const take = Math.min(value.byteLength, max - buffered);
-        chunks.push(take === value.byteLength ? value : value.subarray(0, take));
+        if (take > 0) chunks.push(take === value.byteLength ? value : value.subarray(0, take));
         buffered += take;
+        if (buffered >= max) {
+          void reader.cancel().catch(() => {
+          });
+          return { text: decodeChunks(chunks, buffered), skip: "body-cap" };
+        }
       }
     } catch {
-      return "";
-    }
-    try {
-      return new TextDecoder().decode(concatChunks(chunks, buffered));
-    } catch {
-      return "";
+      void reader.cancel().catch(() => {
+      });
+      return { text: "", skip: "read-failed" };
+    } finally {
+      reader.releaseLock();
     }
+    return { text: decodeChunks(chunks, buffered), skip: null };
   }
+  return { text: "", skip: "unreadable-body" };
+}
+function decodeChunks(chunks, total) {
   try {
-    const text = await clone.text();
-    return text.length > max ? text.slice(0, max) : text;
+    return new TextDecoder().decode(concatChunks(chunks, total));
   } catch {
     return "";
   }
@@ -2743,7 +3249,7 @@ function parseBody(rawBody, contentType) {
   }
   if (isForm) {
     const body = {};
-    for (const [k, v] of new URLSearchParams(rawBody)) body[k] = k in body ? [].concat(body[k], v) : v;
+    for (const [k, v] of new URLSearchParams(rawBody)) appendOwn(body, k, v);
     return { body, files: void 0 };
   }
   if (isJson || isAmbiguous) {
@@ -2771,9 +3277,9 @@ function parseMultipart(rawBody, boundary) {
     if (filename !== void 0) {
       const partType = /content-type:\s*([^\r\n;]+)/i.exec(rawHeaders)?.[1]?.trim() || "";
       const file = { filename, type: partType, content };
-      files[name] = name in files ? [].concat(files[name], file) : file;
+      appendOwn(files, name, file);
     } else {
-      body[name] = name in body ? [].concat(body[name], content) : content;
+      appendOwn(body, name, content);
     }
   }
   return { body, files };
@@ -2788,7 +3294,7 @@ function parseCookies(header) {
     if (idx === -1) {
       continue;
     }
-    cookies[pair.slice(0, idx).trim()] = pair.slice(idx + 1).trim();
+    setOwn(cookies, pair.slice(0, idx).trim(), pair.slice(idx + 1).trim());
   }
   return cookies;
 }
@@ -2798,7 +3304,7 @@ function fromNodeRequest(req, rawBody = "", options = {}) {
   const method = (req.method || "GET").toUpperCase();
   const headers = {};
   for (const [key, value] of Object.entries(req.headers || {})) {
-    headers[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+    setOwn(headers, key.toLowerCase(), Array.isArray(value) ? value.join(", ") : value);
   }
   const host = headers.host || "localhost";
   let url;
@@ -2813,11 +3319,7 @@ function fromNodeRequest(req, rawBody = "", options = {}) {
   }
   const query = {};
   for (const [key, value] of url.searchParams) {
-    if (key in query) {
-      query[key] = Array.isArray(query[key]) ? [...query[key], value] : [query[key], value];
-    } else {
-      query[key] = value;
-    }
+    appendOwn(query, key, value);
   }
   const contentType = headers["content-type"] || "";
   let body = {};
@@ -2858,7 +3360,7 @@ function parseCookies2(header) {
     if (idx === -1) {
       continue;
     }
-    cookies[pair.slice(0, idx).trim()] = pair.slice(idx + 1).trim();
+    setOwn(cookies, pair.slice(0, idx).trim(), pair.slice(idx + 1).trim());
   }
   return cookies;
 }
@@ -2914,6 +3416,67 @@ async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = tr
   if (typeof originalFetch === "function" && !originalFetch.__patchstackGuarded) {
     const REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
     const MAX_REDIRECTS = 20;
+    const MAX_REPLAY_BODY_BYTES = 1024 * 1024;
+    const captureReplayBody = (request) => {
+      if (request.method === "GET" || request.method === "HEAD" || !request.body) {
+        return { result: Promise.resolve({ body: void 0, tooLarge: false }), cancel() {
+        } };
+      }
+      let reader;
+      try {
+        reader = request.clone().body?.getReader();
+      } catch {
+        reader = null;
+      }
+      if (!reader) {
+        return { result: Promise.resolve({ body: void 0, tooLarge: true }), cancel() {
+        } };
+      }
+      let cancelled = false;
+      const result = (async () => {
+        const chunks = [];
+        let total = 0;
+        try {
+          for (; ; ) {
+            const { done, value } = await reader.read();
+            if (done || cancelled) break;
+            total += value.byteLength;
+            if (total > MAX_REPLAY_BODY_BYTES) {
+              void reader.cancel().catch(() => {
+              });
+              return { body: void 0, tooLarge: true };
+            }
+            chunks.push(value);
+          }
+          if (cancelled) return { body: void 0, tooLarge: false };
+          const body = new Uint8Array(total);
+          let offset = 0;
+          for (const chunk of chunks) {
+            body.set(chunk, offset);
+            offset += chunk.byteLength;
+          }
+          return { body, tooLarge: false };
+        } catch {
+          return { body: void 0, tooLarge: true };
+        } finally {
+          reader.releaseLock();
+        }
+      })();
+      return {
+        result,
+        cancel() {
+          cancelled = true;
+          void reader.cancel().catch(() => {
+          });
+        }
+      };
+    };
+    const discardResponseBody = async (response) => {
+      try {
+        await response?.body?.cancel?.();
+      } catch {
+      }
+    };
     const screenUrl = async (u, method) => {
       let host = null;
       try {
@@ -2939,20 +3502,43 @@ async function installEgressGuard({ shouldBlock, onBlock, onSkip, dnsScreen = tr
       if (callerRedirect !== "follow") return originalFetch(input, init);
       const headers = new Headers(cur.headers);
       const signal = cur.signal;
-      let body = method === "GET" || method === "HEAD" ? void 0 : await cur.clone().arrayBuffer();
+      const replay = captureReplayBody(cur);
+      let body;
       for (let hop = 0; ; hop++) {
-        const resp = await originalFetch(
-          hop === 0 ? cur : new Request(url, { method, headers, body, redirect: "manual", signal })
-        );
+        let resp;
+        try {
+          resp = await originalFetch(
+            hop === 0 ? cur : new Request(url, { method, headers, body, redirect: "manual", signal })
+          );
+        } catch (error) {
+          replay.cancel();
+          throw error;
+        }
         const location = REDIRECT_STATUSES.has(resp.status) ? resp.headers.get("location") : null;
-        if (!location) return resp;
-        if (hop >= MAX_REDIRECTS) throw new Error("Patchstack blocked an outbound request: too many redirects");
+        if (!location) {
+          replay.cancel();
+          return resp;
+        }
+        await discardResponseBody(resp);
+        if (hop >= MAX_REDIRECTS) {
+          replay.cancel();
+          throw new Error("Patchstack blocked an outbound request: too many redirects");
+        }
         const next = new URL(location, url).href;
         if (resp.status === 303 || (resp.status === 301 || resp.status === 302) && method === "POST") {
           method = "GET";
           body = void 0;
+          replay.cancel();
           headers.delete("content-type");
           headers.delete("content-length");
+        } else if (body === void 0 && method !== "GET" && method !== "HEAD") {
+          const captured = await replay.result;
+          if (captured.tooLarge) {
+            throw new Error(
+              `Patchstack blocked a redirect that required replaying more than ${MAX_REPLAY_BODY_BYTES} bytes`
+            );
+          }
+          body = captured.body;
         }
         if (new URL(next).origin !== new URL(url).origin) {
           headers.delete("authorization");
@@ -3263,7 +3849,7 @@ var DEFAULT_RESPONSE_RULES = [
     //
     // Accepts a real newline and a JSON-escaped one. Most traces reach a client inside a JSON error
     // body, where the newline is the two characters `\` and `n`.
-    rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/(?:\\n|\\\\n)\\s*at\\s+.+\\(.+:\\d+:\\d+\\)/" } }]
+    rule_v2: [{ parameter: "response.body", match: { type: "regex", value: "/(?:\\n|\\\\n)\\s*at\\s+\\S[^\\r\\n(]*\\((?:node:|[A-Za-z]:[\\\\/])?[^:\\r\\n]+:\\d+:\\d+\\)/" } }]
   },
   {
     id: "resp-sql-error",
@@ -3396,9 +3982,18 @@ async function loadFs() {
   try {
     const [fs, path] = await Promise.all([Promise.resolve().then(() => __toESM(require_ps_edge_stub(), 1)), Promise.resolve().then(() => __toESM(require_ps_edge_stub(), 1))]);
     fsMod = {
+      chmodSync: fs.chmodSync,
+      closeSync: fs.closeSync,
+      constants: fs.constants,
+      fstatSync: fs.fstatSync,
+      fsyncSync: fs.fsyncSync,
+      lstatSync: fs.lstatSync,
+      openSync: fs.openSync,
       readFileSync: fs.readFileSync,
-      writeFileSync: fs.writeFileSync,
       mkdirSync: fs.mkdirSync,
+      renameSync: fs.renameSync,
+      unlinkSync: fs.unlinkSync,
+      writeFileSync: fs.writeFileSync,
       join: path.join
     };
   } catch {
@@ -3451,21 +4046,83 @@ async function cacheWrite(dir, env) {
   if (!dir) return;
   const fs = await loadFs();
   if (!fs) return;
+  const target = fs.join(dir, "patchstack-rules.json");
+  const temporary = fs.join(dir, `.patchstack-rules-${randomSuffix()}.tmp`);
+  let descriptor = null;
   try {
     fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(fs.join(dir, "patchstack-rules.json"), JSON.stringify(env));
+    const directory = fs.lstatSync(dir);
+    if (directory.isSymbolicLink() || !directory.isDirectory()) return;
+    let mode;
+    try {
+      const current = fs.lstatSync(target);
+      if (current.isSymbolicLink() || !current.isFile()) return;
+      mode = current.mode & 4095;
+    } catch (error) {
+      if (error?.code !== "ENOENT") return;
+    }
+    descriptor = fs.openSync(temporary, "wx", mode ?? 384);
+    fs.writeFileSync(descriptor, JSON.stringify(env), "utf8");
+    fs.fsyncSync(descriptor);
+    fs.closeSync(descriptor);
+    descriptor = null;
+    if (mode !== void 0) fs.chmodSync(temporary, mode);
+    try {
+      fs.renameSync(temporary, target);
+    } catch (error) {
+      if (typeof process === "undefined" || process.platform !== "win32" || error?.code !== "EEXIST" && error?.code !== "EPERM") throw error;
+      try {
+        fs.unlinkSync(target);
+      } catch (unlinkError) {
+        if (unlinkError?.code !== "ENOENT") throw unlinkError;
+      }
+      fs.renameSync(temporary, target);
+    }
   } catch {
+  } finally {
+    if (descriptor !== null) {
+      try {
+        fs.closeSync(descriptor);
+      } catch {
+      }
+    }
+    try {
+      fs.unlinkSync(temporary);
+    } catch {
+    }
   }
 }
 async function cacheRead(dir) {
   if (!dir) return null;
   const fs = await loadFs();
   if (!fs) return null;
+  const target = fs.join(dir, "patchstack-rules.json");
+  let descriptor = null;
   try {
-    return toEnvelope(JSON.parse(fs.readFileSync(fs.join(dir, "patchstack-rules.json"), "utf8")));
+    const entry = fs.lstatSync(target);
+    if (entry.isSymbolicLink() || !entry.isFile() || entry.size > 16 * 1024 * 1024) return null;
+    const flags = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0);
+    descriptor = fs.openSync(target, flags);
+    const opened = fs.fstatSync(descriptor);
+    if (!opened.isFile() || opened.size > 16 * 1024 * 1024) return null;
+    return toEnvelope(JSON.parse(fs.readFileSync(descriptor, "utf8")));
   } catch {
     return null;
+  } finally {
+    if (descriptor !== null) {
+      try {
+        fs.closeSync(descriptor);
+      } catch {
+      }
+    }
+  }
+}
+function randomSuffix() {
+  try {
+    if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+  } catch {
   }
+  return `${Date.now()}-${Math.random().toString(36).slice(2)}`;
 }
 function toEnvelope(value) {
   if (!value || typeof value !== "object") return null;
@@ -3491,7 +4148,11 @@ function toEnvelope(value) {
 function liveUpdateRejections(res, options) {
   if (options.acceptPartialBundle) return [];
   const { rejected } = validateBundle(
-    { firewall: Array.isArray(res.firewall) ? res.firewall : [], whitelists: Array.isArray(res.whitelists) ? res.whitelists : [] },
+    {
+      firewall: Array.isArray(res.firewall) ? res.firewall : [],
+      whitelists: Array.isArray(res.whitelists) ? res.whitelists : [],
+      whitelist_keys: res.whitelist_keys
+    },
     { allowGlobalWhitelists: options.allowGlobalWhitelists }
   );
   return rejected;
@@ -3662,7 +4323,8 @@ function normalizeBundle(b, options = {}) {
   const { bundle: checked, rejected } = validateBundle(
     {
       firewall: Array.isArray(b.firewall) ? b.firewall : [],
-      whitelists: Array.isArray(b.whitelists) ? b.whitelists : []
+      whitelists: Array.isArray(b.whitelists) ? b.whitelists : [],
+      whitelist_keys: b.whitelist_keys
     },
     { allowGlobalWhitelists: options.allowGlobalWhitelists }
   );
@@ -3682,7 +4344,7 @@ function normalizeBundle(b, options = {}) {
   return {
     firewall: checked.firewall,
     whitelists: checked.whitelists,
-    whitelist_keys: b.whitelist_keys ?? {},
+    whitelist_keys: checked.whitelist_keys,
     ...enforcement === "block" || enforcement === "dry-run" ? { enforcement } : {}
   };
 }
@@ -3726,18 +4388,23 @@ function startRefresh(tick, { refreshMs, onError } = {}) {
   };
 }
 function makeRefreshHandler(tick, secret) {
+  let inflight2 = null;
+  const runOnce = () => {
+    if (inflight2) return inflight2;
+    let current;
+    current = Promise.resolve().then(() => tick()).finally(() => {
+      if (inflight2 === current) inflight2 = null;
+    });
+    inflight2 = current;
+    return current;
+  };
   return async (request) => {
     if (!secret) return new Response("not found", { status: 404 });
-    let provided = null;
-    try {
-      provided = request?.headers?.get?.("x-patchstack-refresh") ?? new URL(request.url).searchParams.get("token");
-    } catch {
-      provided = null;
-    }
+    const provided = request?.headers?.get?.("x-patchstack-refresh") ?? null;
     if (provided !== secret) return new Response("forbidden", { status: 403 });
     let refreshed = true;
     try {
-      const status = await tick();
+      const status = await runOnce();
       if (status && status.ok === false) refreshed = false;
     } catch {
       refreshed = false;
@@ -4486,8 +5153,10 @@ function hardensWithoutBody(rule) {
 // src/protect/firewall-log.js
 var DEFAULT_API_BASE = "https://api.patchstack.com";
 var STOP_BUDGET_MS2 = 5e3;
+var ATTEMPT_TIMEOUT_MS2 = 1e4;
 var DEFAULT_FLUSH_MS2 = 1e3;
 var MAX_BATCH2 = 50;
+var MAX_QUEUE2 = 500;
 var TOKEN_SKEW_MS2 = 6e4;
 function parseApiKey(apiKey) {
   if (typeof apiKey !== "string" || apiKey.length === 0) return null;
@@ -4509,14 +5178,16 @@ function resolveApiBase(pulseOrManifestUrl) {
   }
   if (typeof pulseOrManifestUrl === "string" && pulseOrManifestUrl.length > 0) {
     try {
-      return new URL(pulseOrManifestUrl).origin;
+      const candidate = new URL(pulseOrManifestUrl).origin;
+      if (isSafeOrigin(candidate)) return candidate;
     } catch {
     }
   }
   const endpoint = typeof process !== "undefined" ? process.env?.PATCHSTACK_ENDPOINT : void 0;
   if (typeof endpoint === "string" && endpoint.length > 0) {
     try {
-      return new URL(endpoint).origin;
+      const candidate = new URL(endpoint).origin;
+      if (isSafeOrigin(candidate)) return candidate;
     } catch {
     }
   }
@@ -4528,16 +5199,16 @@ function createFirewallLogReporter(opts) {
     return { record() {
     }, flush: () => Promise.resolve(), stop: () => Promise.resolve() };
   }
-  const apiBase = (opts.apiBase ?? DEFAULT_API_BASE).replace(/\/$/, "");
+  const apiBase = safeBaseUrl(opts.apiBase, DEFAULT_API_BASE, "block-log API").replace(/\/$/, "");
   const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
   const flushMs = Number.isFinite(opts.flushMs) ? opts.flushMs : DEFAULT_FLUSH_MS2;
   const sourceHost = typeof opts.sourceHost === "string" ? opts.sourceHost : "";
   let queue = [];
   let timer = null;
   let stopped = false;
-  const outstanding = /* @__PURE__ */ new Set();
+  let inFlight = null;
   let drainPromise = null;
-  const lifetime = typeof AbortController === "function" ? new AbortController() : null;
+  let activeController = null;
   let ended = false;
   let cachedToken = null;
   let tokenInflight = null;
@@ -4563,9 +5234,9 @@ function createFirewallLogReporter(opts) {
           })
         });
         if (!res || !res.ok) return null;
-        const body = await res.json();
+        const body = await readBoundedJson2(res);
         const token = body?.access_token;
-        if (typeof token !== "string" || token.length === 0) return null;
+        if (typeof token !== "string" || token.length === 0 || token.length > 8192 || /[\u0000-\u0020\u007f-\u009f]/.test(token)) return null;
         const expiresIn = Number(body?.expires_in);
         const ttlMs = Number.isFinite(expiresIn) && expiresIn > 0 ? expiresIn * 1e3 : 36e5;
         cachedToken = { token, expiresAt: Date.now() + ttlMs };
@@ -4583,12 +5254,18 @@ function createFirewallLogReporter(opts) {
       clearTimeout(timer);
       timer = null;
     }
-    if (ended || queue.length === 0 || typeof fetchImpl !== "function") return Promise.resolve();
+    if (ended || typeof fetchImpl !== "function") return Promise.resolve();
+    if (inFlight) return inFlight;
+    if (queue.length === 0) return Promise.resolve();
     const batch = queue.splice(0, MAX_BATCH2);
+    const controller = typeof AbortController === "function" ? new AbortController() : null;
+    activeController = controller;
+    const attemptTimer = setTimeout(() => controller?.abort(), ATTEMPT_TIMEOUT_MS2);
+    attemptTimer?.unref?.();
     let entry;
-    const send = (async () => {
+    entry = (async () => {
       try {
-        const token = await fetchAccessToken(lifetime?.signal);
+        const token = await fetchAccessToken(controller?.signal);
         if (!token || ended) return;
         const body = new URLSearchParams();
         body.set("type", "firewall");
@@ -4603,19 +5280,24 @@ function createFirewallLogReporter(opts) {
             ...sourceHost ? { "Source-Host": sourceHost } : {}
           },
           body,
-          // Both phases carry it, so a shutdown that runs out of time can end either one.
-          ...lifetime ? { signal: lifetime.signal } : {}
+          // 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(() => {
         });
       } catch {
       } finally {
-        outstanding.delete(entry);
+        clearTimeout(attemptTimer);
+        if (activeController === controller) activeController = null;
+        if (inFlight === entry) inFlight = null;
+        if (!stopped && !ended && queue.length > 0 && !timer) {
+          timer = setTimeout(flush, queue.length >= MAX_BATCH2 ? 0 : flushMs);
+          timer?.unref?.();
+        }
       }
     })();
-    entry = send;
-    outstanding.add(send);
-    return send;
+    inFlight = entry;
+    return entry;
   };
   return {
     /**
@@ -4631,6 +5313,7 @@ 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,
@@ -4662,9 +5345,10 @@ function createFirewallLogReporter(opts) {
       }
       const terminate = () => {
         ended = true;
-        lifetime?.abort();
+        activeController?.abort();
+        activeController = null;
         queue = [];
-        outstanding.clear();
+        inFlight = null;
       };
       let budget = null;
       const spent = new Promise((resolve) => {
@@ -4676,8 +5360,8 @@ function createFirewallLogReporter(opts) {
       });
       const work = (async () => {
         while (!ended) {
-          if (outstanding.size > 0) {
-            await Promise.all([...outstanding]);
+          if (inFlight) {
+            await inFlight;
             continue;
           }
           if (queue.length === 0) break;
@@ -4701,10 +5385,107 @@ function telemetryEnabled() {
 
 // src/protect/supabase-guard.js
 var GUARD_PATH = "/_patchstack/guard";
-var HOP_BY_HOP = /* @__PURE__ */ new Set(["content-encoding", "content-length", "transfer-encoding", "connection"]);
-function createSupabaseGuard({ protection, supabaseUrl, fetchImpl = fetch }) {
+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 });
@@ -4718,29 +5499,45 @@ function createSupabaseGuard({ protection, supabaseUrl, fetchImpl = fetch }) {
       return new Response("patchstack: target not allowed", { status: 403 });
     }
     const hasBody = request.method !== "GET" && request.method !== "HEAD";
-    const bodyText = hasBody ? await request.text() : "";
+    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: hasBody ? bodyText : void 0
+      body
     });
     const blocked = await guard(evalReq);
     if (blocked) return blocked;
-    const forwardHeaders = new Headers(request.headers);
-    forwardHeaders.delete("x-ps-target");
-    forwardHeaders.delete("host");
-    const upstream = await fetchImpl(targetUrl.toString(), {
-      method: request.method,
-      headers: forwardHeaders,
-      body: hasBody ? bodyText : void 0,
-      redirect: "manual"
-    });
-    const outHeaders = new Headers();
-    upstream.headers.forEach((value, key) => {
-      if (!HOP_BY_HOP.has(key.toLowerCase())) outHeaders.set(key, value);
+    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)
     });
-    const buf = await upstream.arrayBuffer();
-    const forwarded = new Response(buf, { status: upstream.status, statusText: upstream.statusText, headers: outHeaders });
     return protection.screenResponse ? protection.screenResponse(forwarded) : forwarded;
   };
 }
@@ -5043,9 +5840,13 @@ async function createProtection(options = {}) {
       for (const name of Object.keys(headers)) {
         const value = headers[name];
         if (typeof value === "string") {
-          headers[name] = applyRedactors(value, spanRedactors, mask);
+          setOwn(headers, name, applyRedactors(value, spanRedactors, mask));
         } else if (Array.isArray(value)) {
-          headers[name] = value.map((item) => typeof item === "string" ? applyRedactors(item, spanRedactors, mask) : item);
+          setOwn(
+            headers,
+            name,
+            value.map((item) => typeof item === "string" ? applyRedactors(item, spanRedactors, mask) : item)
+          );
         }
       }
     }
@@ -5095,7 +5896,13 @@ async function createProtection(options = {}) {
     let result;
     let shaped;
     try {
-      shaped = await fromFetchRequest(request, { trustedProxy: options.trustedProxy });
+      shaped = await fromFetchRequest(request, {
+        trustedProxy: options.trustedProxy,
+        maxBodyBytes: options.maxBodyBytes
+      });
+      if (shaped?._bodyInspectionSkip) {
+        recordSkip("request", shaped._bodyInspectionSkip, { limit: options.maxBodyBytes ?? 1024 * 1024 });
+      }
       result = engine.evaluate(shaped);
     } catch (err) {
       notify(onError, err, "onError");
@@ -5185,7 +5992,7 @@ async function createProtection(options = {}) {
     const out = {};
     for (const [name, value] of writeHeadEntries(headers)) {
       const key = name.toLowerCase();
-      out[key] = Object.hasOwn(out, key) ? [].concat(out[key], value) : value;
+      appendOwn(out, key, value);
     }
     return out;
   };
@@ -5721,7 +6528,6 @@ async function readTextResponse(response, cap = DEFAULT_SCREEN_CAP) {
     const reader = body.getReader();
     const chunks = [];
     let size = 0;
-    let over = false;
     let sniffed = !sniff;
     try {
       for (; ; ) {
@@ -5730,20 +6536,27 @@ async function readTextResponse(response, cap = DEFAULT_SCREEN_CAP) {
         if (!value) continue;
         if (!sniffed) {
           sniffed = true;
-          if (looksBinary(value)) return { skip: "binary-body" };
+          if (looksBinary(value)) {
+            void reader.cancel().catch(() => {
+            });
+            return { skip: "binary-body" };
+          }
         }
         size += value.byteLength;
-        if (over) continue;
-        if (size > cap) {
-          over = true;
-          continue;
+        if (size >= cap) {
+          void reader.cancel().catch(() => {
+          });
+          return { skip: "body-cap" };
         }
         chunks.push(value);
       }
     } catch {
+      void reader.cancel().catch(() => {
+      });
       return { skip: "read-failed" };
+    } finally {
+      reader.releaseLock();
     }
-    if (over) return { skip: "body-cap" };
     try {
       return { text: new TextDecoder().decode(concatBytes(chunks, size)) };
     } catch {
@@ -5771,10 +6584,10 @@ function concatBytes(chunks, total) {
 function headerObject(headers) {
   const out = {};
   headers?.forEach?.((v, k) => {
-    out[k.toLowerCase()] = v;
+    setOwn(out, k.toLowerCase(), v);
   });
   const setCookies = headers?.getSetCookie?.();
-  if (setCookies && setCookies.length) out["set-cookie"] = setCookies;
+  if (setCookies && setCookies.length) setOwn(out, "set-cookie", setCookies);
   return out;
 }
 function hasSpanMutations(rule) {
@@ -5943,7 +6756,7 @@ function isHeaderMutation(action) {
 }
 function applyHeaderMutation(headers, rule) {
   if (rule.action === "remove-header") {
-    for (const name of rule.remove_headers ?? []) headers[String(name).toLowerCase()] = null;
+    for (const name of rule.remove_headers ?? []) setOwn(headers, String(name).toLowerCase(), null);
     return;
   }
   if (rule.action === "set-header") {
@@ -5952,7 +6765,7 @@ function applyHeaderMutation(headers, rule) {
       const key = String(name).toLowerCase();
       const present = headers[key] != null && headers[key] !== "";
       if (ensure && present) continue;
-      headers[key] = String(value);
+      setOwn(headers, key, String(value));
     }
     return;
   }