@patchstack/connect 0.5.6 → 0.5.8

package/dist/protect.cjs

@@ -35,6 +35,183 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/protect/safe-origin.js
+function isSafeOrigin(value) {
+  try {
+    const u = new URL(value);
+    if (u.protocol === "https:") return true;
+    return u.protocol === "http:" && (u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]" || u.hostname === "::1");
+  } catch {
+    return false;
+  }
+}
+function safeBaseUrl(candidate, fallback, label) {
+  if (typeof candidate !== "string" || candidate === "") return fallback;
+  if (isSafeOrigin(candidate)) return candidate;
+  warnOnce(label, `[patchstack] ignoring unsafe ${label} override (${candidate}): must be https (or localhost). Using the default.`);
+  return fallback;
+}
+function warnOnce(key, message) {
+  if (warned.has(key)) return;
+  warned.add(key);
+  console.warn(message);
+}
+var warned;
+var init_safe_origin = __esm({
+  "src/protect/safe-origin.js"() {
+    "use strict";
+    warned = /* @__PURE__ */ new Set();
+  }
+});
+
+// src/types.ts
+var PatchstackError;
+var init_types = __esm({
+  "src/types.ts"() {
+    "use strict";
+    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 safeDisplayString(value, maxLength = 512) {
+  if (typeof value !== "string") return null;
+  const clean = value.replace(/\u001b(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001b\\))/g, "").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim();
+  if (clean.length === 0) return null;
+  return clean.slice(0, maxLength);
+}
+function isCanonicalUuid(value) {
+  return typeof value === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function isCredential(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 4096) return false;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 33 || code > 126) return false;
+  }
+  const separator = value.lastIndexOf("-");
+  return separator > 0 && separator < value.length - 1 && /^\d+$/.test(value.slice(separator + 1));
+}
+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;
+}
+var init_endpoint_policy = __esm({
+  "src/endpoint-policy.ts"() {
+    "use strict";
+    init_types();
+    init_safe_origin();
+  }
+});
+
+// src/bounded-response.ts
+async function readBoundedText(response, maxBytes = MAX_CONTROL_RESPONSE_BYTES) {
+  const stated2 = Number(response.headers?.get?.("content-length"));
+  if (Number.isFinite(stated2) && stated2 > 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 (stated2 === 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);
+}
+var MAX_CONTROL_RESPONSE_BYTES;
+var init_bounded_response = __esm({
+  "src/bounded-response.ts"() {
+    "use strict";
+    MAX_CONTROL_RESPONSE_BYTES = 256 * 1024;
+  }
+});
+
 // src/pulse-token.ts
 function buildTokenUrl(manifestEndpoint) {
   const url = new URL(manifestEndpoint);
@@ -51,20 +228,46 @@ function parsePulseAuth(credential) {
   if (!/^\d+$/.test(clientId)) return null;
   return { clientId, clientSecret: credential.slice(0, index) };
 }
-function clearPulseToken() {
-  cached = null;
+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 (inflight !== null) return inflight;
+  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;
+  }
+  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",
@@ -79,25 +282,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, {
@@ -108,7 +313,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;
@@ -117,9 +322,12 @@ var TOKEN_SKEW_MS, cached, inflight;
 var init_pulse_token = __esm({
   "src/pulse-token.ts"() {
     "use strict";
+    init_safe_origin();
+    init_endpoint_policy();
+    init_bounded_response();
     TOKEN_SKEW_MS = 6e4;
-    cached = null;
-    inflight = null;
+    cached = /* @__PURE__ */ new Map();
+    inflight = /* @__PURE__ */ new Map();
   }
 });
 
@@ -144,30 +352,6 @@ var init_build_id = __esm({
   }
 });
 
-// src/types.ts
-var PatchstackError;
-var init_types = __esm({
-  "src/types.ts"() {
-    "use strict";
-    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/hosting.ts
 function detectHostingPlatform(env = process.env) {
   for (const rule of RULES) {
@@ -185,8 +369,8 @@ var init_hosting = __esm({
     RULES = [
       { platform: "netlify", any: ["NETLIFY", "NETLIFY_BUILD_BASE", "DEPLOY_PRIME_URL"] },
       { platform: "vercel", any: ["VERCEL", "VERCEL_ENV", "VERCEL_URL"] },
-      { platform: "cloudflare", any: ["CF_PAGES", "CF_PAGES_URL", "CLOUDFLARE_ACCOUNT_ID"] },
-      { platform: "aws", any: ["AWS_APP_ID", "AWS_LAMBDA_FUNCTION_NAME", "AWS_EXECUTION_ENV"] },
+      { platform: "cloudflare", any: ["CF_PAGES", "CF_PAGES_URL", "WORKERS_CI", "WORKERS_CI_BRANCH", "CLOUDFLARE_ACCOUNT_ID"] },
+      { platform: "aws", any: ["AWS_APP_ID", "AWS_BRANCH", "AWS_LAMBDA_FUNCTION_NAME", "AWS_EXECUTION_ENV"] },
       { platform: "render", any: ["RENDER", "RENDER_SERVICE_ID", "RENDER_EXTERNAL_URL"] },
       { platform: "railway", any: ["RAILWAY_ENVIRONMENT", "RAILWAY_ENVIRONMENT_NAME", "RAILWAY_PROJECT_ID"] },
       { platform: "fly", any: ["FLY_APP_NAME", "FLY_REGION", "FLY_ALLOC_ID"] },
@@ -204,7 +388,7 @@ var init_hosting = __esm({
 
 // src/client.ts
 function claimTokenHeader(config) {
-  return typeof config.claimToken === "string" && config.claimToken !== "" ? { [CLAIM_TOKEN_HEADER]: config.claimToken } : {};
+  return config.endpointTrusted !== false && isHeaderValue(config.claimToken) ? { [CLAIM_TOKEN_HEADER]: config.claimToken } : {};
 }
 function buildEndpointUrl(base, siteUuid) {
   const trimmed = base.replace(/\/$/, "");
@@ -239,9 +423,46 @@ function validationFields(body) {
   if (typeof errors !== "object" || errors === null || Array.isArray(errors)) return [];
   return Object.keys(errors);
 }
+function manifestResponse(body, provisioning) {
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return null;
+  const value = body;
+  if (typeof value.stored !== "boolean") return null;
+  const uuid = value.uuid === void 0 ? void 0 : isCanonicalUuid(value.uuid) ? value.uuid : null;
+  if (uuid === null || provisioning && uuid === void 0) return null;
+  if (value.api_key !== void 0 && !isCredential(value.api_key)) return null;
+  if (value.manifest_id !== void 0 && (!Number.isInteger(value.manifest_id) || Number(value.manifest_id) <= 0)) return null;
+  const claimValue = value.claim;
+  let claim2;
+  if (claimValue !== void 0) {
+    if (typeof claimValue !== "object" || claimValue === null || Array.isArray(claimValue)) return null;
+    const raw = claimValue;
+    if (!["claimed", "owned-by-you", "owned-by-other", "rejected"].includes(String(raw.state))) return null;
+    const dashboardUrl = raw.dashboard_url === void 0 || raw.dashboard_url === null ? null : safeRemoteUrl(raw.dashboard_url);
+    if (raw.dashboard_url !== void 0 && raw.dashboard_url !== null && dashboardUrl === null) return null;
+    claim2 = {
+      state: raw.state,
+      ...Number.isInteger(raw.site_id) ? { site_id: Number(raw.site_id) } : {},
+      ...dashboardUrl !== null ? { dashboard_url: dashboardUrl } : {},
+      ...raw.reason === "expired" || raw.reason === "invalid" ? { reason: raw.reason } : {}
+    };
+  }
+  const result = {
+    stored: value.stored,
+    ...uuid !== void 0 ? { uuid } : {},
+    ...typeof value.api_key === "string" ? { api_key: value.api_key } : {},
+    ...Number.isInteger(value.manifest_id) ? { manifest_id: Number(value.manifest_id) } : {},
+    ...safeDisplayString(value.checksum, 256) !== null ? { checksum: safeDisplayString(value.checksum, 256) } : {},
+    ...safeDisplayString(value.reason) !== null ? { reason: safeDisplayString(value.reason) } : {},
+    ...safeDisplayString(value.message) !== null ? { message: safeDisplayString(value.message) } : {},
+    ...safeDisplayString(value.error) !== null ? { error: safeDisplayString(value.error) } : {},
+    ...claim2 !== void 0 ? { claim: claim2 } : {}
+  };
+  return result;
+}
 async function postManifest(config, payload) {
   const url = buildEndpointUrl(config.endpoint, config.siteUuid);
   const timeoutMs = config.timeoutMs;
+  assertConnectableEndpoint(config, url);
   let response;
   try {
     response = await pulseFetch(config, url, {
@@ -269,25 +490,27 @@ async function postManifest(config, payload) {
       cause
     );
   }
-  const text = await response.text();
-  let body = null;
+  let text = "";
+  let parsed = null;
   try {
-    body = text.length > 0 ? JSON.parse(text) : null;
+    text = await readBoundedText(response);
+    parsed = text.length > 0 ? JSON.parse(text) : null;
   } catch {
-    body = null;
+    parsed = null;
   }
+  const body = manifestResponse(parsed, config.siteUuid === null);
   if (response.status === 404) {
     throw new PatchstackError(
-      body?.error ?? "Site not found. Check that your site UUID is correct and that the app is registered as a Pulse app in your Patchstack dashboard.",
+      safeDisplayString(parsed?.error) ?? "Site not found. Check that your site UUID is correct and that the app is registered as a Pulse app in your Patchstack dashboard.",
       "SITE_NOT_FOUND"
     );
   }
   if (response.status === 422) {
     const refused2 = new PatchstackError(
-      body?.message ?? "Patchstack rejected the manifest payload (validation failed).",
+      safeDisplayString(parsed?.message) ?? "Patchstack rejected the manifest payload (validation failed).",
       "VALIDATION_ERROR"
     );
-    refused2.fields = validationFields(body);
+    refused2.fields = validationFields(parsed);
     throw refused2;
   }
   const refused = authFailureMessage(response.status, config);
@@ -296,12 +519,12 @@ async function postManifest(config, payload) {
   }
   if (response.status < 200 || response.status >= 300) {
     throw new PatchstackError(
-      `Patchstack returned ${response.status}: ${text.slice(0, 200)}`,
+      `Patchstack returned ${response.status}: ${safeDisplayString(text, 200) ?? "no response details"}`,
       "SERVER_ERROR"
     );
   }
   if (body === null) {
-    throw new PatchstackError("Patchstack returned an empty response.", "SERVER_ERROR");
+    throw new PatchstackError("Patchstack returned an unexpected response.", "SERVER_ERROR");
   }
   return body;
 }
@@ -311,7 +534,7 @@ function isTimeoutError(cause) {
   }
   return false;
 }
-var DEFAULT_ENDPOINT, DEFAULT_TIMEOUT_MS, CLAIM_TOKEN_HEADER;
+var DEFAULT_ENDPOINT, DEFAULT_TIMEOUT_MS2, CLAIM_TOKEN_HEADER;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
@@ -319,13 +542,18 @@ var init_client = __esm({
     init_hosting();
     init_pulse_token();
     init_build_id();
+    init_bounded_response();
+    init_endpoint_policy();
     DEFAULT_ENDPOINT = "https://api.patchstack.com/monitor/pulse/manifest";
-    DEFAULT_TIMEOUT_MS = 3e4;
+    DEFAULT_TIMEOUT_MS2 = 3e4;
     CLAIM_TOKEN_HEADER = "X-Patchstack-Claim-Token";
   }
 });
 
 // src/environment.ts
+function environmentFromBranch(variable, branch) {
+  return PRODUCTION_BRANCHES.has(branch.toLowerCase()) ? { environment: "production", evidence: `${variable}=${branch} (a production branch by name)` } : { environment: "sandbox", evidence: `${variable}=${branch} (not a production branch by name)` };
+}
 function detectHostedBuilder(cwd) {
   let declared;
   try {
@@ -358,13 +586,21 @@ function inferEnvironment(env = process.env, builder = null) {
   }
   return { environment: "local", evidence: [] };
 }
-var import_node_fs, import_node_path, set, DISCRIMINATORS, HOSTED_BUILDER_PACKAGES;
+var import_node_fs, import_node_path, set, PRODUCTION_BRANCHES, DISCRIMINATORS, HOSTED_BUILDER_PACKAGES;
 var init_environment = __esm({
   "src/environment.ts"() {
     "use strict";
     import_node_fs = require("fs");
     import_node_path = __toESM(require("path"), 1);
     set = (value) => value !== void 0 && value !== "";
+    PRODUCTION_BRANCHES = /* @__PURE__ */ new Set([
+      "main",
+      "master",
+      "production",
+      "prod",
+      "release",
+      "live"
+    ]);
     DISCRIMINATORS = [
       {
         platform: "vercel",
@@ -393,6 +629,79 @@ var init_environment = __esm({
           if (!set(env.RAILWAY_ENVIRONMENT_NAME)) return null;
           return env.RAILWAY_ENVIRONMENT_NAME === "production" ? { environment: "production", evidence: "RAILWAY_ENVIRONMENT_NAME=production" } : { environment: "sandbox", evidence: `RAILWAY_ENVIRONMENT_NAME=${env.RAILWAY_ENVIRONMENT_NAME}` };
         }
+      },
+      {
+        // Pages and Workers Builds both name the branch and neither names the tier.
+        platform: "cloudflare",
+        read: (env) => {
+          if (set(env.CF_PAGES) && set(env.CF_PAGES_BRANCH)) {
+            return environmentFromBranch("CF_PAGES_BRANCH", env.CF_PAGES_BRANCH);
+          }
+          if (set(env.WORKERS_CI) && set(env.WORKERS_CI_BRANCH)) {
+            return environmentFromBranch("WORKERS_CI_BRANCH", env.WORKERS_CI_BRANCH);
+          }
+          return null;
+        }
+      },
+      {
+        // Amplify names the branch, and separately whether the build is a pull-request preview.
+        platform: "aws",
+        read: (env) => {
+          if (!set(env.AWS_APP_ID) || !set(env.AWS_BRANCH)) return null;
+          return set(env.AWS_PULL_REQUEST_ID) ? { environment: "sandbox", evidence: "AWS_PULL_REQUEST_ID set (a pull-request preview)" } : environmentFromBranch("AWS_BRANCH", env.AWS_BRANCH);
+        }
+      },
+      {
+        // A Deployment build carries `REPLIT_DEPLOYMENT`; the workspace carries `REPL_ID` alone. Read here,
+        // before the hosted-builder rule, so a workspace build in a Replit project is not its publish step.
+        platform: "replit",
+        read: (env) => {
+          if (set(env.REPLIT_DEPLOYMENT)) {
+            return { environment: "production", evidence: "REPLIT_DEPLOYMENT set (a Replit Deployment build)" };
+          }
+          if (set(env.REPL_ID)) {
+            return { environment: "sandbox", evidence: "REPL_ID set without REPLIT_DEPLOYMENT (the workspace)" };
+          }
+          return null;
+        }
+      },
+      {
+        // GitHub Pages deploys build here. A pull request checks out a merge ref whose name says nothing, so
+        // the event is read first; a tag is a release; otherwise the branch name decides.
+        platform: "github-actions",
+        read: (env) => {
+          if (env.GITHUB_ACTIONS !== "true") return null;
+          if (set(env.GITHUB_EVENT_NAME) && env.GITHUB_EVENT_NAME.startsWith("pull_request")) {
+            return { environment: "sandbox", evidence: `GITHUB_EVENT_NAME=${env.GITHUB_EVENT_NAME} (a pull-request build)` };
+          }
+          if (env.GITHUB_REF_TYPE === "tag") {
+            return { environment: "production", evidence: "GITHUB_REF_TYPE=tag (a tag build)" };
+          }
+          if (!set(env.GITHUB_REF_NAME)) return null;
+          return environmentFromBranch("GITHUB_REF_NAME", env.GITHUB_REF_NAME);
+        }
+      },
+      {
+        // The tier, when a job declares one, is GitLab's own word for it. Without one: a merge request is a
+        // check, a tag is a release, the default branch goes live, and any other branch name decides.
+        platform: "gitlab-ci",
+        read: (env) => {
+          if (env.GITLAB_CI !== "true") return null;
+          if (set(env.CI_ENVIRONMENT_TIER)) {
+            return env.CI_ENVIRONMENT_TIER === "production" ? { environment: "production", evidence: "CI_ENVIRONMENT_TIER=production" } : { environment: "sandbox", evidence: `CI_ENVIRONMENT_TIER=${env.CI_ENVIRONMENT_TIER}` };
+          }
+          if (set(env.CI_MERGE_REQUEST_IID)) {
+            return { environment: "sandbox", evidence: "CI_MERGE_REQUEST_IID set (a merge-request build)" };
+          }
+          if (set(env.CI_COMMIT_TAG)) {
+            return { environment: "production", evidence: "CI_COMMIT_TAG set (a tag build)" };
+          }
+          if (!set(env.CI_COMMIT_BRANCH)) return null;
+          if (set(env.CI_DEFAULT_BRANCH) && env.CI_COMMIT_BRANCH === env.CI_DEFAULT_BRANCH) {
+            return { environment: "production", evidence: `CI_COMMIT_BRANCH=${env.CI_COMMIT_BRANCH} (the default branch)` };
+          }
+          return environmentFromBranch("CI_COMMIT_BRANCH", env.CI_COMMIT_BRANCH);
+        }
       }
     ];
     HOSTED_BUILDER_PACKAGES = [
@@ -610,8 +919,16 @@ async function resolveConfig(options) {
   const fromSecretFile = await readSecretFile(options.cwd);
   const fromEnv = readEnv();
   const siteUuid = options.cliSiteUuid ?? fromEnv.siteUuid ?? fromFile.siteUuid ?? null;
-  const endpoint = options.cliEndpoint ?? fromEnv.endpoint ?? fromFile.endpoint ?? DEFAULT_ENDPOINT;
-  const timeoutMs = fromEnv.timeoutMs ?? fromFile.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const endpointRaw = options.cliEndpoint ?? fromEnv.endpoint ?? fromFile.endpoint ?? DEFAULT_ENDPOINT;
+  const endpointTrusted = endpointRaw === DEFAULT_ENDPOINT || options.cliEndpoint !== void 0 || fromEnv.endpoint !== void 0 || fromFile.endpoint === void 0;
+  const endpoint = safeRemoteUrl(endpointRaw);
+  if (endpoint === null) {
+    throw new PatchstackError(
+      "Patchstack endpoints must be valid HTTPS URLs, except for localhost development endpoints.",
+      "CONFIG_INVALID"
+    );
+  }
+  const timeoutMs = fromEnv.timeoutMs ?? fromFile.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
   const environmentRaw = fromEnv.environment ?? fromFile.environment;
   if (environmentRaw !== void 0 && !isEnvironment(environmentRaw)) {
     throw new PatchstackError(
@@ -622,7 +939,7 @@ async function resolveConfig(options) {
   const inferred = environmentRaw === void 0 ? inferEnvironment(process.env, detectHostedBuilder(options.cwd)) : null;
   const environment = environmentRaw ?? inferred.environment;
   const environmentEvidence = inferred?.evidence ?? [];
-  if (siteUuid !== null && siteUuid.length > 0 && !isUuid(siteUuid)) {
+  if (siteUuid !== null && siteUuid.length > 0 && !isCanonicalUuid(siteUuid)) {
     throw new PatchstackError(
       `Site UUID "${siteUuid}" does not look like a valid UUID.`,
       "CONFIG_INVALID"
@@ -645,6 +962,7 @@ async function resolveConfig(options) {
     siteUrl: identity.url,
     siteName: identity.name,
     endpoint,
+    endpointTrusted,
     timeoutMs,
     environment,
     environmentEvidence,
@@ -663,8 +981,15 @@ async function readJsonFile(cwd, filename) {
   const target = import_node_path3.default.join(cwd, filename);
   let raw;
   try {
+    if ((await (0, import_promises2.lstat)(target)).isSymbolicLink()) {
+      throw new PatchstackError(
+        `Could not read ${target}: configuration files must not be symbolic links.`,
+        "CONFIG_INVALID"
+      );
+    }
     raw = await (0, import_promises2.readFile)(target, "utf8");
   } catch (err) {
+    if (err instanceof PatchstackError) throw err;
     if (err.code === "ENOENT") {
       return {};
     }
@@ -709,23 +1034,22 @@ function readEnv() {
     environment: environmentRaw !== void 0 && environmentRaw.length > 0 ? environmentRaw : void 0
   };
 }
-function isUuid(value) {
-  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
-}
 function isEnvironment(value) {
   return value === "production" || value === "sandbox" || value === "local";
 }
-var import_promises2, import_node_path3, CONFIG_FILENAME, SECRET_FILENAME;
+var import_promises2, import_node_path3, import_node_crypto, CONFIG_FILENAME, SECRET_FILENAME;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     import_promises2 = require("fs/promises");
     import_node_path3 = __toESM(require("path"), 1);
+    import_node_crypto = require("crypto");
     init_types();
     init_client();
     init_environment();
     init_site_url();
     init_site_name();
+    init_endpoint_policy();
     CONFIG_FILENAME = ".patchstackrc.json";
     SECRET_FILENAME = ".patchstackrc.local.json";
   }
@@ -2222,27 +2546,52 @@ 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/client.js
+init_safe_origin();
+
+// src/protect/engine/response-json.js
+var MAX_RULE_RESPONSE_BYTES = 5 * 1024 * 1024;
+async function readBoundedJson(response, maxBytes = MAX_RULE_RESPONSE_BYTES) {
+  const stated2 = Number(response.headers?.get?.("content-length"));
+  if (Number.isFinite(stated2) && stated2 > 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
@@ -2301,7 +2650,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: {} };
       }
@@ -2338,6 +2687,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;
@@ -2456,8 +2821,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 [];
   }
@@ -2552,7 +2917,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) {
@@ -2560,8 +2925,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;
@@ -2737,7 +3101,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;
@@ -2894,30 +3258,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) {
@@ -2959,7 +3406,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;
   }
@@ -2976,6 +3423,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);
@@ -2993,15 +3545,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 {
@@ -3745,6 +4296,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";
@@ -3775,8 +4336,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";
@@ -3922,9 +4486,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) {
@@ -3951,6 +4522,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);
@@ -3959,6 +4533,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`;
   }
@@ -3994,6 +4571,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`;
@@ -4016,11 +4607,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((path9) => typeof path9 === "string" && path9.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`;
@@ -4040,10 +4640,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;
 }
@@ -4067,6 +4676,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) {
@@ -4096,46 +4710,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;
@@ -4146,9 +4790,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}`;
@@ -4156,10 +4800,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;
     }
@@ -4173,11 +4827,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;
     }
   }
@@ -4391,12 +5051,14 @@ function asText(value) {
 }
 
 // src/protect/engine/pulse-client.js
+init_safe_origin();
 init_pulse_token();
 init_build_id();
 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;
@@ -4441,6 +5103,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) {
@@ -4459,7 +5124,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: {} };
       }
@@ -4520,19 +5185,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 = {};
@@ -4559,7 +5223,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) {
@@ -4567,7 +5232,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") {
@@ -4578,23 +5243,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 "";
   }
@@ -4621,7 +5293,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) {
@@ -4649,9 +5321,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 };
@@ -4666,7 +5338,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;
 }
@@ -4676,7 +5348,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;
@@ -4691,11 +5363,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 = {};
@@ -4736,7 +5404,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;
 }
@@ -4792,6 +5460,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 {
@@ -4817,20 +5546,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");
@@ -5141,7 +5893,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",
@@ -5275,9 +6027,18 @@ async function loadFs() {
   try {
     const [fs, path9] = 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: path9.join
     };
   } catch {
@@ -5330,21 +6091,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;
@@ -5371,7 +6194,11 @@ init_build_id();
 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;
@@ -5542,7 +6369,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 }
   );
@@ -5562,7 +6390,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 } : {}
   };
 }
@@ -5606,18 +6434,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;
@@ -5628,6 +6461,7 @@ function makeRefreshHandler(tick, secret) {
 
 // src/protect/detections.js
 init_pulse_token();
+init_safe_origin();
 var DEFAULT_BASE_URL3 = "https://api.patchstack.com/monitor/pulse";
 var DEFAULT_FLUSH_MS = 5e3;
 var MAX_BATCH = 50;
@@ -6365,10 +7199,14 @@ function hardensWithoutBody(rule) {
 }
 
 // src/protect/firewall-log.js
+init_safe_origin();
+init_bounded_response();
 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;
@@ -6390,14 +7228,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 {
     }
   }
@@ -6409,16 +7249,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;
@@ -6444,9 +7284,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 };
@@ -6464,12 +7304,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");
@@ -6484,19 +7330,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 {
     /**
@@ -6512,6 +7363,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,
@@ -6543,9 +7395,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) => {
@@ -6557,8 +7410,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;
@@ -6582,10 +7435,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 stated2 = Number(request.headers.get("content-length"));
+  if (Number.isFinite(stated2) && stated2 > maxBytes) throw new BodyTooLargeError();
+  if (!request.body) return void 0;
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        void reader.cancel().catch(() => {
+        });
+        throw new BodyTooLargeError();
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return body;
+}
+function requestHeaders(input) {
+  const output = new Headers();
+  const connectionTokens = new Set(
+    (input.get("connection") ?? "").split(",").map((value) => value.trim().toLowerCase()).filter(Boolean)
+  );
+  input.forEach((value, key) => {
+    const lower = key.toLowerCase();
+    if (!REQUEST_HEADER_DENYLIST.has(lower) && !connectionTokens.has(lower)) output.append(key, value);
+  });
+  return output;
+}
+function responseHeaders(input) {
+  const output = new Headers();
+  const connectionTokens = new Set(
+    (input.get("connection") ?? "").split(",").map((value) => value.trim().toLowerCase()).filter(Boolean)
+  );
+  input.forEach((value, key) => {
+    const lower = key.toLowerCase();
+    if (!RESPONSE_HEADER_DENYLIST.has(lower) && !connectionTokens.has(lower)) output.append(key, value);
+  });
+  return output;
+}
+function createSupabaseGuard({
+  protection,
+  supabaseUrl,
+  fetchImpl = fetch,
+  maxBodyBytes = DEFAULT_MAX_BODY_BYTES,
+  timeoutMs = DEFAULT_TIMEOUT_MS
+}) {
   const guard = protection.fetchGuard();
   const allowedOrigin = supabaseUrl ? new URL(supabaseUrl).origin : null;
+  const bodyLimit = Number.isFinite(maxBodyBytes) && maxBodyBytes > 0 ? maxBodyBytes : DEFAULT_MAX_BODY_BYTES;
+  const upstreamTimeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_TIMEOUT_MS;
   return async function handleGuardRequest(request) {
     const target = request.headers.get("x-ps-target");
     if (!target) return new Response("patchstack: missing x-ps-target", { status: 400 });
@@ -6599,29 +7549,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;
   };
 }
@@ -6924,9 +7890,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)
+          );
         }
       }
     }
@@ -6976,7 +7946,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");
@@ -7066,7 +8042,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;
   };
@@ -7602,7 +8578,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 (; ; ) {
@@ -7611,20 +8586,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 {
@@ -7652,10 +8634,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) {
@@ -7824,7 +8806,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") {
@@ -7833,7 +8815,7 @@ function applyHeaderMutation(headers, rule) {
       const key = String(name).toLowerCase();
       const present2 = headers[key] != null && headers[key] !== "";
       if (ensure && present2) continue;
-      headers[key] = String(value);
+      setOwn(headers, key, String(value));
     }
     return;
   }