@patchstack/connect 0.5.6 → 0.5.7

package/dist/protect.js

@@ -1,9 +1,12 @@
 import {
   canonicalBuildId,
+  isSafeOrigin,
   pulseAuthHeader,
   pulseFetch,
-  readBuildStamp
-} from "./chunk-IOODP4ZB.js";
+  readBoundedJson,
+  readBuildStamp,
+  safeBaseUrl
+} from "./chunk-2K5SHFUM.js";
 
 // src/protect/client-ip.js
 var ZONE = /^[A-Za-z0-9._-]{1,64}$/;
@@ -219,27 +222,49 @@ function clientIpFields(resolved) {
   return established && address !== null ? { client_ip: address, client_ip_source: resolved.source } : { client_ip_source: "unavailable" };
 }
 
-// src/protect/safe-origin.js
-function isSafeOrigin(value) {
+// src/protect/engine/response-json.js
+var MAX_RULE_RESPONSE_BYTES = 5 * 1024 * 1024;
+async function readBoundedJson2(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 {
-    const u = new URL(value);
-    if (u.protocol === "https:") return true;
-    return u.protocol === "http:" && (u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]" || u.hostname === "::1");
-  } catch {
-    return false;
+    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();
   }
-}
-function safeBaseUrl(candidate, fallback, label) {
-  if (typeof candidate !== "string" || candidate === "") return fallback;
-  if (isSafeOrigin(candidate)) return candidate;
-  warnOnce(label, `[patchstack] ignoring unsafe ${label} override (${candidate}): must be https (or localhost). Using the default.`);
-  return fallback;
-}
-var warned = /* @__PURE__ */ new Set();
-function warnOnce(key, message) {
-  if (warned.has(key)) return;
-  warned.add(key);
-  console.warn(message);
+  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
@@ -298,7 +323,7 @@ var PatchstackRuleClient = class {
           whitelist_keys: {}
         };
       }
-      const data = await response.json();
+      const data = await readBoundedJson2(response);
       if (!data || !Array.isArray(data.firewall)) {
         return { success: false, error: "unexpected response shape (no firewall array)", firewall: [], whitelists: [], whitelist_keys: {} };
       }
@@ -335,6 +360,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;
@@ -453,8 +494,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 [];
   }
@@ -549,7 +590,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) {
@@ -557,8 +598,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;
@@ -734,7 +774,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;
@@ -749,17 +789,17 @@ function notify(fn, arg, label) {
     const result = fn(arg);
     if (result !== null && typeof result === "object" && typeof result.then === "function") {
       try {
-        result.then(void 0, (err) => warnOnce2(label, err));
+        result.then(void 0, (err) => warnOnce(label, err));
       } catch {
       }
     }
     return true;
   } catch (err) {
-    warnOnce2(label, err);
+    warnOnce(label, err);
     return false;
   }
 }
-function warnOnce2(label, err) {
+function warnOnce(label, err) {
   if (reported.has(label)) return;
   reported.add(label);
   try {
@@ -891,30 +931,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) {
@@ -956,7 +1079,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;
   }
@@ -973,6 +1096,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);
@@ -990,15 +1218,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 {
@@ -1069,7 +1296,7 @@ function collectLeafValues(root, nodeCap = 2e4, maxDepth = 1e3) {
   return out;
 }
 var warnedKeys = /* @__PURE__ */ new Set();
-function warnOnce3(key, message) {
+function warnOnce2(key, message) {
   if (warnedKeys.has(key)) return;
   warnedKeys.add(key);
   console.warn(message);
@@ -1451,13 +1678,13 @@ var RuleEngine = class {
     this.#whitelistKeys = whitelist_keys;
     this.#onError = onError;
     if (Array.isArray(whitelists) && whitelists.some((w) => w && Array.isArray(w.rule_v2) && !w.rule_id)) {
-      warnOnce3(
+      warnOnce2(
         "whitelist-no-rule-id",
         "[patchstack] a whitelist has no `rule_id` \u2014 it suppresses ALL rules when it matches. Scope each whitelist to a specific rule_id, and key it only on values an attacker cannot set."
       );
     }
     if (whitelist_keys && typeof whitelist_keys === "object" && Object.keys(whitelist_keys).length > 0) {
-      warnOnce3("whitelist-keys-unimplemented", "[patchstack] `whitelist_keys` is not implemented and has no effect.");
+      warnOnce2("whitelist-keys-unimplemented", "[patchstack] `whitelist_keys` is not implemented and has no effect.");
     }
   }
   // A mitigation engine must never take down the app it protects: any error while
@@ -1742,6 +1969,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";
@@ -1772,8 +2009,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";
@@ -1919,9 +2159,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) {
@@ -1948,6 +2195,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);
@@ -1956,6 +2206,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`;
   }
@@ -1991,6 +2244,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`;
@@ -2013,11 +2280,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`;
@@ -2037,10 +2313,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;
 }
@@ -2064,6 +2349,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) {
@@ -2093,46 +2383,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;
@@ -2143,9 +2463,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}`;
@@ -2153,10 +2473,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;
     }
@@ -2170,11 +2500,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;
     }
   }
@@ -2454,7 +2790,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 readBoundedJson2(response);
       if (!data || !Array.isArray(data.firewall)) {
         return { success: false, error: "unexpected response shape (no firewall array)", firewall: [], whitelists: [], whitelist_keys: {} };
       }
@@ -2515,19 +2851,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 = {};
@@ -2554,7 +2889,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) {
@@ -2562,7 +2898,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") {
@@ -2573,23 +2909,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 "";
   }
@@ -2616,7 +2959,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) {
@@ -2644,9 +2987,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 };
@@ -2661,7 +3004,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;
 }
@@ -2671,7 +3014,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;
@@ -2686,11 +3029,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 = {};
@@ -2731,7 +3070,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;
 }
@@ -2787,6 +3126,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 {
@@ -2812,20 +3212,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");
@@ -3136,7 +3559,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",
@@ -3269,9 +3692,18 @@ async function loadFs() {
   try {
     const [fs, path] = await Promise.all([import("fs"), import("path")]);
     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 {
@@ -3324,22 +3756,84 @@ 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;
   if (value.bundle && typeof value.bundle === "object") {
@@ -3364,7 +3858,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;
@@ -3535,7 +4033,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 }
   );
@@ -3555,7 +4054,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 } : {}
   };
 }
@@ -3599,18 +4098,23 @@ function startRefresh(tick, { refreshMs, onError } = {}) {
   };
 }
 function makeRefreshHandler(tick, secret) {
+  let inflight = null;
+  const runOnce = () => {
+    if (inflight) return inflight;
+    let current;
+    current = Promise.resolve().then(() => tick()).finally(() => {
+      if (inflight === current) inflight = null;
+    });
+    inflight = 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;
@@ -4359,8 +4863,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_MS = 6e4;
 function parseApiKey(apiKey) {
   if (typeof apiKey !== "string" || apiKey.length === 0) return null;
@@ -4382,14 +4888,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 {
     }
   }
@@ -4401,16 +4909,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;
@@ -4436,9 +4944,9 @@ function createFirewallLogReporter(opts) {
           })
         });
         if (!res || !res.ok) return null;
-        const body = await res.json();
+        const body = await readBoundedJson(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 };
@@ -4456,12 +4964,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");
@@ -4476,19 +4990,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 {
     /**
@@ -4504,6 +5023,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,
@@ -4535,9 +5055,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) => {
@@ -4549,8 +5070,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;
@@ -4574,10 +5095,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 });
@@ -4591,29 +5209,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;
   };
 }
@@ -4916,9 +5550,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)
+          );
         }
       }
     }
@@ -4968,7 +5606,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");
@@ -5058,7 +5702,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;
   };
@@ -5455,7 +6099,7 @@ async function createProtection(options = {}) {
   let reporter = null;
   if (refreshable && options.siteUuid && options.reportManifest !== false && cwd) {
     try {
-      ({ reportManifest: reporter } = await import("./refresh-manifest-2ALIJGZ3.js"));
+      ({ reportManifest: reporter } = await import("./refresh-manifest-3YWIYENU.js"));
     } catch (err) {
       notify(onError, err, "onError");
     }
@@ -5594,7 +6238,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 (; ; ) {
@@ -5603,20 +6246,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 {
@@ -5644,10 +6294,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) {
@@ -5816,7 +6466,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") {
@@ -5825,7 +6475,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;
   }