@patchstack/connect 0.5.26 → 0.5.30

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { readFileSync as readFileSync19 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 import path16 from "path";
-import { createRequire as createRequire3 } from "module";
+import { createRequire as createRequire6 } from "module";
 
 // src/safe-file.ts
 import {
@@ -1073,7 +1073,7 @@ async function scanLockfile(cwd) {
     await detectLockfile(cwd);
   }
   const declared = await readDeclaredDependencyNames(cwd);
-  const warnings = [];
+  const warnings2 = [];
   let firstParsed = null;
   let walked = null;
   let walkWasCandidate = false;
@@ -1087,7 +1087,7 @@ async function scanLockfile(cwd) {
       continue;
     }
     const unreadable = unreadableWarning(candidate.filename, report);
-    if (unreadable !== null) warnings.push(unreadable);
+    if (unreadable !== null) warnings2.push(unreadable);
     if (candidate.strategy === "node-modules-walk") {
       walked = packages;
       walkWasCandidate = true;
@@ -1098,16 +1098,16 @@ async function scanLockfile(cwd) {
   for (const source of parsedSources) {
     const missing = missingDependencies(declared, source.packages);
     if (missing.length > 0) {
-      warnings.push(staleWarning(source.filename, missing));
+      warnings2.push(staleWarning(source.filename, missing));
       continue;
     }
     const conflicts = otherCompleteSources(parsedSources, source, declared).flatMap(
       (other) => disagreements(source.packages, other.packages).map((conflict) => ({ other: other.filename, conflict }))
     );
     if (conflicts.length === 0) {
-      return manifestWith(source.packages, warnings);
+      return manifestWith(source.packages, warnings2);
     }
-    warnings.push(conflictWarning(source.filename, conflicts));
+    warnings2.push(conflictWarning(source.filename, conflicts));
     break;
   }
   if (walked === null) {
@@ -1120,12 +1120,12 @@ async function scanLockfile(cwd) {
   if (walked !== null) {
     const missing = missingDependencies(declared, walked);
     if (missing.length > 0) {
-      warnings.push(staleWarning("node_modules/", missing));
+      warnings2.push(staleWarning("node_modules/", missing));
     }
-    warnings.push(
+    warnings2.push(
       walkWasCandidate ? "Checked the installed packages in node_modules/, which is what the build loads." : "Checked the installed packages in node_modules/ instead. Delete the out-of-date package list file to stop this warning."
     );
-    return manifestWith(walked, warnings);
+    return manifestWith(walked, warnings2);
   }
   if (firstParsed === null) {
     const expected = LOCKFILE_CANDIDATES.map((candidate) => candidate.filename).join(", ");
@@ -1134,13 +1134,13 @@ async function scanLockfile(cwd) {
       "LOCKFILE_NOT_FOUND"
     );
   }
-  warnings.push(
+  warnings2.push(
     `No package list matches package.json; checked ${firstParsed.filename}, so some packages may be missing. Reinstall your packages to fix this.`
   );
-  return manifestWith(firstParsed.packages, warnings);
+  return manifestWith(firstParsed.packages, warnings2);
 }
-function manifestWith(packages, warnings) {
-  return warnings.length > 0 ? { ecosystem: "npm", packages, warnings } : { ecosystem: "npm", packages };
+function manifestWith(packages, warnings2) {
+  return warnings2.length > 0 ? { ecosystem: "npm", packages, warnings: warnings2 } : { ecosystem: "npm", packages };
 }
 function otherCompleteSources(all, current, declared) {
   return all.filter(
@@ -1205,10 +1205,10 @@ function buildWirePayload(manifest, options = {}) {
   const byIdentity = /* @__PURE__ */ new Map();
   let entriesWithoutPath = 0;
   for (const entry of manifest.packages) {
-    const identity = `${entry.name}@${entry.version}`;
+    const identity2 = `${entry.name}@${entry.version}`;
     const location = withPaths && entry.path !== void 0 && entry.path !== "" ? entry.path : void 0;
     if (location === void 0) entriesWithoutPath++;
-    const existing = byIdentity.get(identity);
+    const existing = byIdentity.get(identity2);
     if (existing) {
       if (location !== void 0) addPath(existing, location);
       continue;
@@ -1221,7 +1221,7 @@ function buildWirePayload(manifest, options = {}) {
     }
     const wire6 = { name: entry.name, version: entry.version };
     if (location !== void 0) addPath(wire6, location);
-    byIdentity.set(identity, wire6);
+    byIdentity.set(identity2, wire6);
     wirePackages.push(wire6);
   }
   for (const wire6 of wirePackages) wire6.paths?.sort();
@@ -1329,7 +1329,7 @@ function compareSegments(a, b) {
 // src/checksum.ts
 import { createHash } from "crypto";
 function computeManifestChecksum(packages) {
-  const canonical = packages.map((pkg) => ({ name: pkg.name, version: pkg.version })).sort((a, b) => {
+  const canonical2 = packages.map((pkg) => ({ name: pkg.name, version: pkg.version })).sort((a, b) => {
     if (a.name !== b.name) {
       return a.name < b.name ? -1 : 1;
     }
@@ -1338,13 +1338,13 @@ function computeManifestChecksum(packages) {
     }
     return 0;
   });
-  return createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 12);
+  return createHash("sha256").update(JSON.stringify(canonical2)).digest("hex").slice(0, 12);
 }
 
 // src/hosting.ts
 var RULES = [
-  { platform: "netlify", any: ["NETLIFY", "NETLIFY_BUILD_BASE", "DEPLOY_PRIME_URL"] },
-  { platform: "vercel", any: ["VERCEL", "VERCEL_ENV", "VERCEL_URL"] },
+  { platform: "netlify", any: ["NETLIFY", "NETLIFY_PREVIEW_SERVER", "NETLIFY_DEV", "NETLIFY_BUILD_BASE", "DEPLOY_PRIME_URL"] },
+  { platform: "vercel", any: ["VERCEL", "VERCEL_TARGET_ENV", "VERCEL_ENV", "VERCEL_URL"] },
   { 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"] },
@@ -1379,6 +1379,18 @@ function isSafeOrigin(value) {
     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;
+}
+var warned = /* @__PURE__ */ new Set();
+function warnOnce(key, message) {
+  if (warned.has(key)) return;
+  warned.add(key);
+  console.warn(message);
+}
 
 // src/endpoint-policy.ts
 function assertConnectableEndpoint(config, target = config.endpoint) {
@@ -1707,7 +1719,7 @@ async function postInputMap(config, map, buildId) {
   }
   const url = buildInputMapUrl(config.endpoint, config.siteUuid);
   try {
-    const canonical = canonicalBuildId(buildId);
+    const canonical2 = canonicalBuildId(buildId);
     const response = await pulseFetch(config, url, {
       method: "POST",
       headers: {
@@ -1720,7 +1732,7 @@ async function postInputMap(config, map, buildId) {
       // to one of them as enforceable only to a guard carrying that same map. Omitted entirely when this
       // run could not bind the map into a pre-bundle guard — an absent field is a question the server
       // answers by withholding enforceability, which is the safe direction.
-      body: JSON.stringify(canonical === null ? map : { ...map, build_id: canonical }),
+      body: JSON.stringify(canonical2 === null ? map : { ...map, build_id: canonical2 }),
       signal: AbortSignal.timeout(config.timeoutMs)
     });
     if (response.status === 404) {
@@ -2237,7 +2249,7 @@ import { randomUUID as randomUUID2 } from "crypto";
 // src/environment.ts
 import { readFileSync as readFileSync2 } from "fs";
 import path6 from "path";
-var set = (value) => value !== void 0 && value !== "";
+var set = (value) => value !== void 0 && value.trim() !== "";
 var PRODUCTION_BRANCHES = /* @__PURE__ */ new Set([
   "main",
   "master",
@@ -2253,14 +2265,31 @@ var DISCRIMINATORS = [
   {
     platform: "vercel",
     read: (env) => {
-      if (!set(env.VERCEL) || !set(env.VERCEL_ENV)) return null;
-      return env.VERCEL_ENV === "production" ? { environment: "production", evidence: "VERCEL_ENV=production" } : { environment: "sandbox", evidence: `VERCEL_ENV=${env.VERCEL_ENV}` };
+      const variable = set(env.VERCEL_TARGET_ENV) ? "VERCEL_TARGET_ENV" : "VERCEL_ENV";
+      const tier = env[variable];
+      if (set(tier)) {
+        return {
+          environment: tier === "production" ? "production" : "sandbox",
+          evidence: `${variable}=${tier}`
+        };
+      }
+      if (env.VERCEL !== "1") return null;
+      return { environment: "local", evidence: "VERCEL=1 without a deployment tier; set PATCHSTACK_ENVIRONMENT" };
     }
   },
   {
     platform: "netlify",
     read: (env) => {
-      if (env.NETLIFY !== "true" || !set(env.CONTEXT)) return null;
+      if (env.NETLIFY_PREVIEW_SERVER === "true") {
+        return { environment: "sandbox", evidence: "NETLIFY_PREVIEW_SERVER=true" };
+      }
+      if (env.NETLIFY_DEV === "true") {
+        return { environment: "local", evidence: "NETLIFY_DEV=true (the local development server)" };
+      }
+      if (env.NETLIFY !== "true") return null;
+      if (!set(env.CONTEXT)) {
+        return { environment: "local", evidence: "NETLIFY=true without CONTEXT; set PATCHSTACK_ENVIRONMENT" };
+      }
       return env.CONTEXT === "production" ? { environment: "production", evidence: "CONTEXT=production" } : { environment: "sandbox", evidence: `CONTEXT=${env.CONTEXT}` };
     }
   },
@@ -2610,10 +2639,13 @@ async function resolveConfig(options) {
       "CONFIG_INVALID"
     );
   }
-  const inferred = environmentRaw === void 0 ? inferEnvironment(process.env, detectHostedBuilder(options.cwd)) : null;
-  const environment = environmentRaw ?? inferred.environment;
-  const environmentEvidence = inferred?.evidence ?? [];
-  const environmentSource = environmentRaw !== void 0 ? "override" : inferred.source;
+  const inferred = fromEnv.environment === void 0 ? inferEnvironment(process.env, detectHostedBuilder(options.cwd)) : null;
+  const fileLabelOverruled = fromEnv.environment === void 0 && environmentRaw !== void 0 && environmentRaw !== "production" && inferred.environment === "production";
+  const labelled = fileLabelOverruled ? void 0 : environmentRaw;
+  const environment = labelled ?? inferred.environment;
+  const environmentEvidence = labelled === void 0 ? inferred.evidence : [];
+  const environmentSource = labelled !== void 0 ? "override" : inferred.source;
+  const ignoredFileEnvironment = fileLabelOverruled ? environmentRaw : null;
   if (siteUuid !== null && siteUuid.length > 0 && !isCanonicalUuid(siteUuid)) {
     throw new PatchstackError(
       `Site UUID "${siteUuid}" does not look like a valid UUID.`,
@@ -2628,20 +2660,21 @@ async function resolveConfig(options) {
   }
   const apiKeyRaw = fromEnv.apiKey ?? fromSecretFile.apiKey ?? fromFile.apiKey ?? null;
   const pulseAuthRaw = fromEnv.pulseAuth ?? fromSecretFile.pulseAuth ?? fromFile.pulseAuth ?? apiKeyRaw;
-  const identity = options.detectSiteIdentity === true ? await resolveSiteIdentity(options.cwd, fromEnv, fromFile) : { url: null, name: null };
+  const identity2 = options.detectSiteIdentity === true ? await resolveSiteIdentity(options.cwd, fromEnv, fromFile) : { url: null, name: null };
   const claimToken = stated(options.cliClaimToken) ?? stated(process.env.PATCHSTACK_CLAIM_TOKEN);
   return {
     siteUuid: siteUuid === null || siteUuid.length === 0 ? null : siteUuid,
     apiKey: apiKeyRaw === null || apiKeyRaw.length === 0 ? null : apiKeyRaw,
     pulseAuth: pulseAuthRaw === null || pulseAuthRaw.length === 0 ? null : pulseAuthRaw,
-    siteUrl: identity.url,
-    siteName: identity.name,
+    siteUrl: identity2.url,
+    siteName: identity2.name,
     endpoint,
     endpointTrusted,
     timeoutMs,
     environment,
     environmentEvidence,
     environmentSource,
+    ignoredFileEnvironment,
     widget: fromFile.widget !== false,
     claimToken
   };
@@ -2696,7 +2729,7 @@ async function writeAtomicFile(target, content, mode) {
     throw error;
   }
 }
-async function ensureIgnored(cwd, entry) {
+async function ensureIgnored(cwd, entry, label = "Patchstack credential \u2014 never commit this") {
   const target = path8.join(cwd, ".gitignore");
   let existing = "";
   try {
@@ -2710,7 +2743,7 @@ async function ensureIgnored(cwd, entry) {
   if (ignoresEntry(existing, entry)) return { ignored: true };
   const separator = existing === "" || existing.endsWith("\n") ? "" : "\n";
   const block = `${separator}
-# Patchstack credential \u2014 never commit this
+# ${label}
 ${entry}
 `;
   try {
@@ -3023,6 +3056,9 @@ function buildInjectionSnippet(checksum, stack) {
   }
   return `<script ${MARKER_ATTR}>${statements.join("")}</script>`;
 }
+function buildSandboxSnippet() {
+  return `<script ${MARKER_ATTR}>window.__PATCHSTACK_ENV__="sandbox";</script>`;
+}
 function injectMarker(html, snippet) {
   const stripped = html.replace(
     new RegExp(`\\s*<script ${MARKER_ATTR}[^>]*>[\\s\\S]*?</script>`, "gi"),
@@ -3036,6 +3072,10 @@ function injectMarker(html, snippet) {
   }
   return stripped + snippet;
 }
+var HAND_MARKER_RE = /\s*<script(?![^>]*\bsrc\s*=)[^>]*>\s*(?:window\.__PATCHSTACK_(?:PROD|BUILD|STACK)__\s*=\s*[^;<]*;?\s*)+<\/script>/gi;
+function removeHandMarkers(html) {
+  return html.replace(HAND_MARKER_RE, "");
+}
 var JSX_SHELL_FRAMEWORKS = /* @__PURE__ */ new Set([
   "next",
   "remix",
@@ -3179,7 +3219,7 @@ function ensureSourceMarker(cwd, shell, framework, checksum = null) {
 }
 
 // src/guide.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync11, readdirSync as readdirSync6, statSync as statSync5 } from "fs";
 import path12 from "path";
 
 // src/architecture.ts
@@ -4082,18 +4122,144 @@ function templatesDir() {
 }
 
 // src/protect/install/adapters/tanstack-supabase.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync6 } from "fs";
+import { join as join9 } from "path";
+
+// src/protect/install/syntax.ts
+import { createRequire } from "module";
 import { join as join6 } from "path";
+function sourceCompiler(cwd) {
+  for (const base of [join6(cwd, "package.json"), import.meta.url]) {
+    try {
+      return createRequire(base)("typescript");
+    } catch {
+    }
+  }
+  return null;
+}
+function parsedSource(ts, file, source) {
+  const tree = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
+  return tree.parseDiagnostics.length ? null : tree;
+}
+function statementEndLine(ts, file, source, line) {
+  const tree = parsedSource(ts, file, source);
+  if (!tree) return null;
+  let end = null;
+  const visit = (node) => {
+    if ((ts.isImportDeclaration(node) || ts.isVariableStatement(node) || ts.isExpressionStatement(node)) && tree.getLineAndCharacterOfPosition(node.getStart(tree)).line === line) {
+      const tail = source.slice(node.end).split("\n", 1)[0].trim();
+      if (tail !== "" && !tail.startsWith("//")) return;
+      end = tree.getLineAndCharacterOfPosition(node.end).line;
+      return;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(tree);
+  return end;
+}
+function statementPosition(ts, file, source, line, matches) {
+  const tree = parsedSource(ts, file, source);
+  if (!tree) return null;
+  const statements = [];
+  const visit = (node) => {
+    if ((ts.isVariableStatement(node) || ts.isExpressionStatement(node)) && tree.getLineAndCharacterOfPosition(node.getStart(tree)).line === line && matches.test(node.getText(tree))) statements.push({ start: node.getStart(tree), end: node.end });
+    ts.forEachChild(node, visit);
+  };
+  visit(tree);
+  return statements.length === 1 ? statements[0] : null;
+}
+
+// src/protect/install/template-match.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join7 } from "path";
+function matchesGuardTemplate(cwd, file, template) {
+  if (!existsSync4(join7(cwd, file))) return false;
+  const ts = sourceCompiler(cwd);
+  if (!ts) return false;
+  const actual = canonical(ts, file, read(join7(cwd, file)));
+  const expected = canonical(ts, template, read(join7(templatesDir(), template)));
+  return actual !== null && expected !== null && actual === expected;
+}
+function canonical(ts, file, source) {
+  const tree = parsedSource(ts, file, source);
+  if (!tree) return null;
+  const normalized2 = ts.transform(tree, [(context) => (root) => {
+    const visit = (node) => {
+      if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.name.text === "PS_SITE_UUID" && node.initializer && ts.isStringLiteral(node.initializer)) {
+        return ts.factory.updateVariableDeclaration(
+          node,
+          node.name,
+          node.exclamationToken,
+          node.type,
+          ts.factory.createStringLiteral("__PATCHSTACK_SITE_UUID__")
+        );
+      }
+      if (ts.isStringLiteral(node)) return ts.factory.createStringLiteral(node.text);
+      return ts.visitEachChild(node, visit, context);
+    };
+    return ts.visitEachChild(root, visit, context);
+  }]);
+  try {
+    return ts.createPrinter({ removeComments: true }).printFile(normalized2.transformed[0]);
+  } finally {
+    normalized2.dispose();
+  }
+}
+
+// src/protect/install/template-upgrade.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync5 } from "fs";
+import { join as join8 } from "path";
+var PREVIOUS = {
+  "generic-guard.ts": "2c6bb8324b909e646049c36725704b474a8bfb1b6849c392eb3462eed83727e9",
+  "generic-guard.js": "42357bcf0cb0541e584821d03e06ced28f98d4ef91a76a50e39008ef18c63709",
+  "generic-guard.cjs": "8de21893474a3139eff9e8fc48a0c13e976e64421281db9e8e93b0c0549361b8",
+  "express-guard.ts": "6c30cc82b7cbd3fee62d423fcb20b27eba1d6cc1ed054efcf9d64eb360bc7b17",
+  "express-guard.js": "bce7c76a061297621791d4ebf838449e3880d05f333588fed7bf88431d1e712e",
+  "express-guard.cjs": "3a6430f00fc159c28a897e700cc492c306f39b556f0f4cb4b1e718993b6c40b4",
+  "fastify-plugin.ts": "5d606cb8f8f2e6fe35b9d377c5568c5a2090a81af9f0acb219ebc15a713792e9",
+  "fastify-plugin.js": "03327d437513571d53554ca34c84ba170ebeebb5e89c2602ae340fb82178ab48",
+  "fastify-plugin.cjs": "b3754bf023ebb5f2a22e0a95cfe74bb783034ec3db9ce61a3e7202237e09e1dd",
+  "guard.ts": "270e29769f5a7b3ab70ee39970be5a4e150e1b3949877687dca1ed83596afae7",
+  "sveltekit-hooks.ts": "0a68389ac9018dc0ab5805356ad78301f039cb4c701bf642e7f986cc959da990",
+  "astro-middleware.ts": "f217e302fb7019de451c7538e9266a5ce38aa6a6651072b6291d4593b31f60ce",
+  "nuxt-middleware.ts": "e377c48cc8c08d20c61c6119bb5f4c8991f0eed3ebd31310b8a0fc6eb5505e4e",
+  "next-middleware.ts": "65c163cdb2ddda4fe53c1a3cd20aa6ab63ad7595a66985d9141d595374ecfab3",
+  "next-guard.ts": "e37c4d67619df9d850a7d94b567bd76841b6ac8e774a5b442689482f5374c451"
+};
+var identity = /const PS_SITE_UUID = "([^"]*)";/;
+var normalized = (source) => source.replace(identity, 'const PS_SITE_UUID = "__PATCHSTACK_SITE_UUID__";');
+function installTemplate(cwd, file, template) {
+  const next = read(join8(templatesDir(), template));
+  const target = join8(cwd, file);
+  if (!existsSync5(target)) {
+    writeProjectFileSync(cwd, target, next);
+    return true;
+  }
+  const previous = read(target);
+  if (normalized(previous) === normalized(next)) return false;
+  if (createHash2("sha256").update(normalized(previous)).digest("hex") !== PREVIOUS[template]) {
+    log(`${file} is customized or unrecognized \u2014 preserved; review its request/response wiring and rule-refresh settings manually.`);
+    return false;
+  }
+  const site = identity.exec(previous)?.[1];
+  writeProjectFileSync(cwd, target, site ? next.replace(identity, () => `const PS_SITE_UUID = ${JSON.stringify(site)};`) : next);
+  log(`updated unchanged generated helper ${file}`);
+  return true;
+}
+
+// src/protect/install/adapters/tanstack-supabase.ts
 var CLIENT_TUNNEL = [
   "",
   "    // PATCHSTACK: in the browser, tunnel Supabase traffic through the app's own server guard",
   "    // (same-origin) so payloads are inspected before they reach Supabase.",
   "    if (typeof window !== 'undefined') {",
-  "      const target = typeof input === 'string' ? input : input instanceof Request ? input.url : String(input);",
-  "      const method = init?.method ?? (input instanceof Request ? input.method : 'GET');",
-  "      headers.set('x-ps-target', target);",
+  "      const original = new Request(input, init);",
   "      const guardUrl = new URL('/_patchstack/guard', window.location.origin).toString();",
-  "      return fetch(guardUrl, { ...init, method, headers });",
+  "      const forwarded = new Request(guardUrl, original);",
+  "      headers.forEach((value, key) => forwarded.headers.set(key, value));",
+  "      forwarded.headers.set('x-ps-target', original.url);",
+  "      return fetch(forwarded);",
   "    }",
   ""
 ].join("\n");
@@ -4102,19 +4268,19 @@ var GUARD_IMPORT_RE = /import \{[^}]*\} from "@\/integrations\/patchstack\/guard
 var START_IMPORTS = ['import { getRequest } from "@tanstack/react-start/server";', GUARD_IMPORT].join("\n");
 var REQUEST_MIDDLEWARE_BLOCK = [
   "// #region patchstack-guard (managed by patchstack-connect protect \u2014 do not edit)",
-  "// Browser\u2192Supabase tunnel + response screening; optional route WAF via PATCHSTACK_ROUTE_WAF=1.",
+  "// Screen native requests and responses as well as the browser\u2192Supabase tunnel.",
   "const patchstackGuard = createMiddleware().server(async ({ next }) => {",
   "  const request = getRequest();",
   "  if (request) {",
   "    const { pathname } = new URL(request.url);",
   "    if (pathname === GUARD_PATH) return handleGuardRequest(request);",
-  '    if (process.env.PATCHSTACK_ROUTE_WAF === "1") {',
-  "      const blocked = await guardRequest(request);",
-  "      if (blocked) return blocked;",
-  "    }",
+  "    const blocked = await guardRequest(request);",
+  "    if (blocked) return blocked;",
   "  }",
   "  // The request is passed so route/method-scoped response rules can apply their scope.",
-  "  return screenResponse(await next(), request);",
+  "  const result = await next();",
+  "  if (result instanceof Response) return screenResponse(result, request);",
+  "  return { ...result, response: await screenResponse(result.response, request) };",
   "});",
   "// #endregion patchstack-guard"
 ].join("\n");
@@ -4153,8 +4319,8 @@ function reconcileBlock(s, region, block, legacyConst, insertBefore) {
   return s.replace(insertBefore, block + "\n\n" + insertBefore);
 }
 function detect(cwd) {
-  const pkgPath = join6(cwd, "package.json");
-  if (!existsSync4(pkgPath)) return false;
+  const pkgPath = join9(cwd, "package.json");
+  if (!existsSync6(pkgPath)) return false;
   let pkg;
   try {
     pkg = JSON.parse(read(pkgPath));
@@ -4162,22 +4328,22 @@ function detect(cwd) {
     return false;
   }
   const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-  return Boolean(deps["@tanstack/react-start"]) && existsSync4(join6(cwd, "src/start.ts")) && existsSync4(join6(cwd, "src/integrations/supabase/client.ts"));
+  return Boolean(deps["@tanstack/react-start"]) && existsSync6(join9(cwd, "src/start.ts")) && existsSync6(join9(cwd, "src/integrations/supabase/client.ts"));
 }
 var GUARD_FILE = "src/integrations/patchstack/guard.ts";
 function scaffold(cwd, opts) {
   const templates = templatesDir();
-  const dst = join6(cwd, "src/integrations/patchstack");
+  const dst = join9(cwd, "src/integrations/patchstack");
   ensureProjectDirectorySync(cwd, dst);
-  copyProjectFileSync(cwd, join6(templates, "guard.ts"), join6(dst, "guard.ts"));
-  const changed = [GUARD_FILE];
-  const rulesDst = join6(dst, "rules.json");
+  const changed = [];
+  if (installTemplate(cwd, GUARD_FILE, "guard.ts")) changed.push(GUARD_FILE);
+  const rulesDst = join9(dst, "rules.json");
   if (opts.demo) {
-    copyProjectFileSync(cwd, join6(templates, "demo-rules.json"), rulesDst);
+    copyProjectFileSync(cwd, join9(templates, "demo-rules.json"), rulesDst);
     changed.push("src/integrations/patchstack/rules.json");
     log("scaffolded guard.ts + rules.json (demo sample rule set)");
-  } else if (!existsSync4(rulesDst)) {
-    copyProjectFileSync(cwd, join6(templates, "rules.json"), rulesDst);
+  } else if (!existsSync6(rulesDst)) {
+    copyProjectFileSync(cwd, join9(templates, "rules.json"), rulesDst);
     changed.push("src/integrations/patchstack/rules.json");
     log("scaffolded guard.ts + rules.json (starter rules)");
   } else {
@@ -4185,37 +4351,74 @@ function scaffold(cwd, opts) {
   }
   return changed;
 }
-function patchClient(cwd) {
-  const p = join6(cwd, "src/integrations/supabase/client.ts");
-  const s = read(p);
+function patchClient(ts, s) {
+  const tree = parsedSource(ts, "client.ts", s);
+  if (!tree) return null;
+  const anchors = [];
+  const visit = (node) => {
+    if (ts.isExpressionStatement(node) && ts.isCallExpression(node.expression)) {
+      const call = node.expression;
+      if (call.expression.getText(tree) === "headers.set" && call.arguments[0] && ts.isStringLiteral(call.arguments[0]) && call.arguments[0].text === "apikey" && call.arguments[1]?.getText(tree) === "supabaseKey") {
+        const block = node.parent;
+        const fn = block.parent;
+        if (ts.isBlock(block) && ts.isArrowFunction(fn) && fn.parameters.length === 2 && fn.parameters[0].name.getText(tree) === "input" && fn.parameters[1].name.getText(tree) === "init" && block.statements.some((statement) => ts.isVariableStatement(statement) && statement.declarationList.declarations.some((d) => ts.isIdentifier(d.name) && d.name.text === "headers" && d.initializer && ts.isNewExpression(d.initializer) && d.initializer.expression.getText(tree) === "Headers"))) anchors.push(node.end);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(tree);
+  if (anchors.length !== 1) return null;
   if (s.includes("x-ps-target")) {
-    log("client.ts already wired");
-    return false;
-  }
-  const anchor = "headers.set('apikey', supabaseKey);";
-  if (!s.includes(anchor)) {
-    log("client.ts anchor not found \u2014 skipping (template changed?)");
-    return false;
+    const code = ts.createPrinter({ removeComments: true }).printFile(tree);
+    return /\.set\(['"]x-ps-target['"],/.test(code) && /return fetch\(/.test(code) ? s : null;
   }
-  writeProjectFileSync(cwd, p, s.replace(anchor, anchor + "\n" + CLIENT_TUNNEL), { encoding: "utf8" });
-  log("patched client.ts (tunnel Supabase through the guard)");
-  return true;
+  return s.slice(0, anchors[0]) + "\n" + CLIENT_TUNNEL + s.slice(anchors[0]);
 }
-function patchStart(cwd) {
-  const p = join6(cwd, "src/start.ts");
-  let s = read(p);
+function patchStart(ts, original) {
+  let s = original;
   const importAnchor = 'import { createStart, createMiddleware } from "@tanstack/react-start";';
   const exportAnchor = "export const startInstance";
   const rmAnchor = "requestMiddleware: [";
+  const tree = parsedSource(ts, "start.ts", s);
+  if (!tree) return null;
+  const startImport = tree.statements.find((node) => ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "@tanstack/react-start" && !node.importClause?.isTypeOnly && !node.importClause?.name && node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings) && node.importClause.namedBindings.elements.length === 2 && node.importClause.namedBindings.elements.every((e) => !e.propertyName && !e.isTypeOnly && ["createStart", "createMiddleware"].includes(e.name.text)));
+  if (!startImport) return null;
+  const declaration = tree.statements.filter(ts.isVariableStatement).filter((node) => node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)).flatMap((node) => [...node.declarationList.declarations]).find((node) => ts.isIdentifier(node.name) && node.name.text === "startInstance");
+  const call = declaration?.initializer;
+  if (!call || !ts.isCallExpression(call) || call.expression.getText(tree) !== "createStart" || call.arguments.length !== 1) return null;
+  const factory = call.arguments[0];
+  if (!ts.isArrowFunction(factory) || factory.parameters.length) return null;
+  let config = factory.body;
+  while (ts.isParenthesizedExpression(config)) config = config.expression;
+  if (!ts.isObjectLiteralExpression(config)) return null;
+  if (config.properties.some((p) => !ts.isPropertyAssignment(p) || !ts.isIdentifier(p.name))) return null;
+  const edits = [{ start: startImport.getStart(tree), end: startImport.end, text: importAnchor }];
+  for (const name of ["requestMiddleware", "functionMiddleware"]) {
+    const properties = config.properties.filter((p) => p.name?.getText(tree) === name);
+    if (properties.length > 1 || name === "requestMiddleware" && !properties.length) return null;
+    const property = properties[0];
+    if (!property || !ts.isPropertyAssignment(property)) continue;
+    if (!ts.isArrayLiteralExpression(property.initializer)) return null;
+    edits.push({ start: property.getStart(tree), end: property.initializer.getStart(tree) + 1, text: `${name}: [` });
+  }
+  const guardImports = tree.statements.filter((node) => ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "@/integrations/patchstack/guard");
+  if (guardImports.length > 1) return null;
+  const guardImport = guardImports[0];
+  if (guardImport) {
+    if (!ts.isImportDeclaration(guardImport) || !guardImport.importClause?.namedBindings || !ts.isNamedImports(guardImport.importClause.namedBindings) || guardImport.importClause.namedBindings.elements.some((e) => e.propertyName || e.isTypeOnly || !["GUARD_PATH", "handleGuardRequest", "inspectServerFn", "screenResponse", "guardRequest"].includes(e.name.text))) return null;
+    edits.push({ start: guardImport.getStart(tree), end: guardImport.end, text: GUARD_IMPORT });
+  }
+  for (const edit of edits.sort((a, b) => b.start - a.start)) s = s.slice(0, edit.start) + edit.text + s.slice(edit.end);
   if (!s.includes(importAnchor) || !s.includes(exportAnchor)) {
-    log("start.ts anchors not found \u2014 skipping (template changed?)");
-    return false;
+    return null;
   }
-  const original = s;
+  if (!s.includes(rmAnchor)) return null;
   if (GUARD_IMPORT_RE.test(s)) {
     s = s.replace(GUARD_IMPORT_RE, GUARD_IMPORT);
   } else {
-    s = s.replace(importAnchor, importAnchor + "\n" + START_IMPORTS);
+    const requestImport = tree.statements.some((node) => ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "@tanstack/react-start/server" && !node.importClause?.isTypeOnly && node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings) && node.importClause.namedBindings.elements.some((e) => !e.propertyName && !e.isTypeOnly && e.name.text === "getRequest"));
+    if (!requestImport && /\bgetRequest\b/.test(original)) return null;
+    s = s.replace(importAnchor, importAnchor + "\n" + (requestImport ? GUARD_IMPORT : START_IMPORTS));
   }
   s = reconcileBlock(s, "patchstack-guard", REQUEST_MIDDLEWARE_BLOCK, "const patchstackGuard =", exportAnchor);
   s = reconcileBlock(s, "patchstack-function-guard", FUNCTION_MIDDLEWARE_BLOCK, "const patchstackFunctionGuard =", exportAnchor);
@@ -4230,34 +4433,56 @@ function patchStart(cwd) {
       s = s.replace(rmAnchor, "functionMiddleware: [patchstackFunctionGuard],\n    " + rmAnchor);
     }
   }
-  if (s === original) {
-    log("start.ts already wired");
-    return false;
-  }
-  writeProjectFileSync(cwd, p, s, { encoding: "utf8" });
-  log("patched start.ts (guard registered as request + function middleware)");
-  return true;
+  return parsedSource(ts, "start.ts", s) ? s : null;
 }
 function wire(cwd, opts) {
+  const ts = sourceCompiler(cwd);
+  const clientPath = join9(cwd, "src/integrations/supabase/client.ts");
+  const startPath = join9(cwd, "src/start.ts");
+  const oldClient = read(clientPath);
+  const oldStart = read(startPath);
+  const client = ts && patchClient(ts, oldClient);
+  const start = ts && patchStart(ts, oldStart);
+  if (!ts || !client || !start || !parsedSource(ts, "client.ts", client)) {
+    log("TanStack wiring needs manual integration: client and server left untouched; no browser traffic was redirected.");
+    return { ok: false, changed: [] };
+  }
   const changed = scaffold(cwd, opts);
+  if (!matchesGuardTemplate(cwd, GUARD_FILE, "guard.ts")) {
+    log("Custom guard helper needs manual review; client and server entries were left untouched.");
+    return { ok: false, changed };
+  }
   if (!opts.demo && bakeSiteUuid(cwd, GUARD_FILE)) changed.push(GUARD_FILE);
-  if (patchClient(cwd)) changed.push("src/integrations/supabase/client.ts");
-  if (patchStart(cwd)) changed.push("src/start.ts");
+  try {
+    if (start !== oldStart) {
+      writeProjectFileSync(cwd, startPath, start);
+      changed.push("src/start.ts");
+    }
+    if (client !== oldClient) {
+      writeProjectFileSync(cwd, clientPath, client);
+      changed.push("src/integrations/supabase/client.ts");
+    }
+  } catch (error) {
+    if (start !== oldStart) writeProjectFileSync(cwd, startPath, oldStart);
+    throw error;
+  }
   log(
     opts.demo ? "done \u2014 guard wired with the demo sample rules (blocks by default). Set PATCHSTACK_MODE=dry-run for log-only." : "done \u2014 guard wired and always-on (blocks by default). Set PATCHSTACK_MODE=dry-run for log-only."
   );
   return { ok: true, changed: [...new Set(changed)] };
 }
 function verify(cwd) {
-  const guardPath = join6(cwd, GUARD_FILE);
-  const clientPath = join6(cwd, "src/integrations/supabase/client.ts");
-  const startPath = join6(cwd, "src/start.ts");
-  const guard = existsSync4(guardPath) ? read(guardPath) : "";
-  const client = existsSync4(clientPath) ? read(clientPath) : "";
-  const start = existsSync4(startPath) ? read(startPath) : "";
+  const guardPath = join9(cwd, GUARD_FILE);
+  const clientPath = join9(cwd, "src/integrations/supabase/client.ts");
+  const startPath = join9(cwd, "src/start.ts");
+  const guard = existsSync6(guardPath) ? read(guardPath) : "";
+  const client = existsSync6(clientPath) ? read(clientPath) : "";
+  const start = existsSync6(startPath) ? read(startPath) : "";
+  const ts = sourceCompiler(cwd);
   const checks = [
     { label: "guard.ts scaffolded", ok: guard.length > 0, hint: "run `patchstack-connect protect`" },
-    { label: "Supabase client tunnels through the guard", ok: client.includes("x-ps-target"), hint: "run `patchstack-connect protect` to re-patch src/integrations/supabase/client.ts" },
+    { label: "guard helper implementation verified", ok: matchesGuardTemplate(cwd, GUARD_FILE, "guard.ts"), hint: "preserved custom helpers require manual review before redirecting browser traffic" },
+    { label: "Supabase client tunnels through the guard", ok: !!ts && client.includes("x-ps-target") && patchClient(ts, client) === client, hint: "run `patchstack-connect protect` to re-patch src/integrations/supabase/client.ts" },
     { label: "request middleware defined + registered", ok: start.includes("const patchstackGuard =") && start.includes("requestMiddleware: [patchstackGuard"), hint: "run `patchstack-connect protect` to re-patch src/start.ts" },
     { label: "server-function middleware defined + registered", ok: start.includes("const patchstackFunctionGuard =") && start.includes("functionMiddleware: [patchstackFunctionGuard"), hint: "run `patchstack-connect protect` to re-patch src/start.ts" }
   ];
@@ -4271,20 +4496,189 @@ var tanstackSupabaseAdapter = {
   verify
 };
 
+// src/protect/install/adapters/tanstack.ts
+import { existsSync as existsSync7 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { join as join10 } from "path";
+var ENTRY = "src/server.ts";
+var GUARD = "src/patchstack/guard.ts";
+var IMPORT = 'import { protectFetch } from "./patchstack/guard";';
+var DEFAULT = `import handler, { createServerEntry } from '@tanstack/react-start/server-entry';
+export default createServerEntry({ fetch: handler.fetch.bind(handler) });
+`;
+var EXTENSIONS = ["ts", "js", "mts", "mjs", "tsx", "jsx", "cts", "cjs"];
+function defaultEntryConfig(ts, file, source) {
+  const tree = parsedSource(ts, file, source);
+  if (!tree) return false;
+  const binding = (module, name) => tree.statements.filter(ts.isImportDeclaration).filter((n) => ts.isStringLiteral(n.moduleSpecifier) && n.moduleSpecifier.text === module && !n.importClause?.isTypeOnly).flatMap((n) => n.importClause?.namedBindings && ts.isNamedImports(n.importClause.namedBindings) ? n.importClause.namedBindings.elements.filter((e) => !e.isTypeOnly && (e.propertyName ?? e.name).text === name).map((e) => e.name.text) : []);
+  const defineConfig = binding("vite", "defineConfig");
+  const start = binding("@tanstack/react-start/plugin/vite", "tanstackStart");
+  const unwrap = (expression) => {
+    while (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isSatisfiesExpression(expression)) expression = expression.expression;
+    return expression;
+  };
+  const exports = tree.statements.filter(ts.isExportAssignment);
+  if (exports.length !== 1 || exports[0].isExportEquals) return false;
+  let config = unwrap(exports[0].expression);
+  if (ts.isCallExpression(config)) {
+    if (!ts.isIdentifier(config.expression) || !defineConfig.includes(config.expression.text) || config.arguments.length !== 1) return false;
+    config = unwrap(config.arguments[0]);
+  }
+  if (!ts.isObjectLiteralExpression(config)) return false;
+  let unsafe = false;
+  const visit = (node) => {
+    if (ts.isSpreadAssignment(node) || ts.isSpreadElement(node) || ts.isComputedPropertyName(node)) unsafe = true;
+    if (ts.isObjectLiteralExpression(node)) {
+      const names = /* @__PURE__ */ new Set();
+      for (const property of node.properties) {
+        if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name) && !ts.isStringLiteral(property.name)) {
+          unsafe = true;
+          continue;
+        }
+        const name = property.name.text;
+        if (names.has(name) || ["srcDirectory", "serverEntry", "entry", "server", "root"].includes(name)) unsafe = true;
+        names.add(name);
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(config);
+  if (unsafe) return false;
+  const plugins = config.properties.find((p) => ts.isPropertyAssignment(p) && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) && p.name.text === "plugins");
+  if (!plugins || !ts.isPropertyAssignment(plugins) || !ts.isArrayLiteralExpression(plugins.initializer)) return false;
+  const calls = plugins.initializer.elements.map(unwrap).filter((n) => ts.isCallExpression(n) && ts.isIdentifier(n.expression) && start.includes(n.expression.text));
+  if (calls.length !== 1) return false;
+  const call = calls[0];
+  return ts.isCallExpression(call) && (call.arguments.length === 0 || call.arguments.length === 1 && ts.isObjectLiteralExpression(unwrap(call.arguments[0])));
+}
+function entryProblem(cwd) {
+  try {
+    const file = createRequire2(join10(cwd, "package.json")).resolve("@tanstack/react-start/package.json");
+    if (!JSON.parse(read(file)).exports?.["./server-entry"]) return "the installed TanStack Start version does not expose server-entry";
+  } catch {
+    return "the installed TanStack Start version must expose its server-entry contract";
+  }
+  const entries = ["src/server", "server", ...EXTENSIONS.flatMap((ext) => [`src/server.${ext}`, `server.${ext}`])];
+  if (entries.some((file) => file !== ENTRY && existsSync7(join10(cwd, file)))) {
+    return "non-default or competing server entries require manual integration";
+  }
+  const configs = ["vite", "app", "rsbuild"].flatMap((name) => EXTENSIONS.map((ext) => `${name}.config.${ext}`)).filter((file) => existsSync7(join10(cwd, file)));
+  if (configs.length) {
+    const ts = sourceCompiler(cwd);
+    if (configs.length !== 1 || !configs[0].startsWith("vite.") || !ts || !defaultEntryConfig(ts, configs[0], read(join10(cwd, configs[0])))) {
+      return "the default server entry cannot be established from this configuration; integrate it manually";
+    }
+  }
+  return null;
+}
+function composeTanstackEntry(ts, source) {
+  const tree = parsedSource(ts, ENTRY, source);
+  if (!tree || /\bprotectFetch\b/.test(source)) return null;
+  const imported = tree.statements.some((node) => ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "@tanstack/react-start/server-entry" && !node.importClause?.isTypeOnly && node.importClause?.namedBindings && ts.isNamedImports(node.importClause.namedBindings) && node.importClause.namedBindings.elements.some((e) => !e.propertyName && !e.isTypeOnly && e.name.text === "createServerEntry"));
+  if (!imported) return null;
+  const exports = tree.statements.filter(ts.isExportAssignment);
+  if (exports.length !== 1 || exports[0].isExportEquals) return null;
+  const call = exports[0].expression;
+  if (!ts.isCallExpression(call) || call.expression.getText(tree) !== "createServerEntry" || call.arguments.length !== 1) return null;
+  const object = call.arguments[0];
+  if (!ts.isObjectLiteralExpression(object) || object.properties.some((p) => ts.isSpreadAssignment(p) || !p.name || ts.isComputedPropertyName(p.name))) return null;
+  const properties = object.properties.filter((p) => p.name?.getText(tree) === "fetch");
+  if (properties.length !== 1) return null;
+  const fetch2 = properties[0];
+  let replacement;
+  if (ts.isPropertyAssignment(fetch2)) replacement = `fetch: protectFetch(${fetch2.initializer.getText(tree)})`;
+  else if (ts.isMethodDeclaration(fetch2) && fetch2.body && !fetch2.asteriskToken) {
+    const text = fetch2.getText(tree);
+    replacement = `fetch: protectFetch(${text.replace(/^(async\s+)?fetch\s*\(/, "$1function (")})`;
+  } else if (ts.isShorthandPropertyAssignment(fetch2)) replacement = "fetch: protectFetch(fetch)";
+  else return null;
+  const patched = source.slice(0, fetch2.getStart(tree)) + replacement + source.slice(fetch2.end);
+  const insertion = tree.statements.filter(ts.isImportDeclaration).at(-1)?.end ?? 0;
+  const result = patched.slice(0, insertion) + "\n" + IMPORT + "\n" + patched.slice(insertion);
+  return parsedSource(ts, ENTRY, result) ? result : null;
+}
+function wiredEntry(ts, source) {
+  const tree = parsedSource(ts, ENTRY, source);
+  if (!tree) return false;
+  const imported = tree.statements.filter(ts.isImportDeclaration).filter((n) => n.getText(tree) === IMPORT);
+  if (imported.length !== 1) return false;
+  const wrappers = [];
+  const visit = (node) => {
+    if (ts.isCallExpression(node) && node.expression.getText(tree) === "protectFetch") wrappers.push(node);
+    ts.forEachChild(node, visit);
+  };
+  visit(tree);
+  if (wrappers.length !== 1 || wrappers[0].arguments.length !== 1) return false;
+  const wrapper = wrappers[0];
+  const plain = source.slice(0, wrapper.getStart(tree)) + wrapper.arguments[0].getText(tree) + source.slice(wrapper.end);
+  const composed = composeTanstackEntry(ts, plain.replace(IMPORT, ""));
+  const reparsed = composed && parsedSource(ts, ENTRY, composed);
+  const printer = ts.createPrinter({ removeComments: true });
+  return !!reparsed && printer.printFile(reparsed) === printer.printFile(tree);
+}
+var tanstackAdapter = {
+  name: "tanstack-start",
+  label: "TanStack Start",
+  detect: (cwd) => hasDependency(cwd, "@tanstack/react-start"),
+  wire(cwd, opts) {
+    const problem = entryProblem(cwd);
+    const ts = sourceCompiler(cwd);
+    if (problem || !ts) {
+      log(`TanStack server entry left untouched: ${problem ?? "parser unavailable"}.`);
+      return { ok: false, changed: [] };
+    }
+    const previous = existsSync7(join10(cwd, ENTRY)) ? read(join10(cwd, ENTRY)) : DEFAULT;
+    const next = wiredEntry(ts, previous) ? previous : composeTanstackEntry(ts, previous);
+    if (!next) {
+      log("Custom TanStack server entry left untouched; wrap its final Fetch boundary manually.");
+      return { ok: false, changed: [] };
+    }
+    const changed = [];
+    ensureProjectDirectorySync(cwd, join10(cwd, "src/patchstack"));
+    if (installTemplate(cwd, GUARD, "fetch-guard.ts")) changed.push(GUARD);
+    if (!matchesGuardTemplate(cwd, GUARD, "fetch-guard.ts")) {
+      log("Custom Fetch helper needs manual review; the server entry was left untouched.");
+      return { ok: false, changed };
+    }
+    const rules = "src/patchstack/rules.json";
+    if (opts.demo || !existsSync7(join10(cwd, rules))) {
+      copyProjectFileSync(cwd, join10(templatesDir(), opts.demo ? "demo-rules.json" : "rules.json"), join10(cwd, rules));
+      changed.push(rules);
+    }
+    if (!opts.demo && bakeSiteUuid(cwd, GUARD)) changed.push(GUARD);
+    if (next !== previous || !existsSync7(join10(cwd, ENTRY))) {
+      writeProjectFileSync(cwd, join10(cwd, ENTRY), next);
+      changed.push(ENTRY);
+    }
+    log("TanStack server entry screens requests and final Responses; browser-direct backend traffic and separately deployed functions need their own protection.");
+    return { ok: true, changed };
+  },
+  verify(cwd) {
+    const ts = sourceCompiler(cwd);
+    const problem = entryProblem(cwd);
+    const wired = !problem && !!ts && existsSync7(join10(cwd, ENTRY)) && wiredEntry(ts, read(join10(cwd, ENTRY))) && matchesGuardTemplate(cwd, GUARD, "fetch-guard.ts") && existsSync7(join10(cwd, "src/patchstack/rules.json"));
+    return { wired, checks: [
+      { label: "TanStack server Fetch boundary wired", ok: wired, hint: problem ?? "run protect; manually review unsupported custom server entries" },
+      { label: "browser-direct services and separately deployed functions are not covered by this entry", ok: true, unverifiable: true, hint: "install protection at each independently exposed backend; retain backend authorization and RLS" }
+    ] };
+  }
+};
+
 // src/protect/install/adapters/next.ts
-import { existsSync as existsSync5, lstatSync as lstatSync2, readdirSync as readdirSync3 } from "fs";
-import { dirname as dirname3, join as join8, relative as relative3 } from "path";
+import { existsSync as existsSync8, lstatSync as lstatSync2, readdirSync as readdirSync3 } from "fs";
+import { dirname as dirname3, join as join12, relative as relative3 } from "path";
+import { createRequire as createRequire4 } from "module";
 
 // src/protect/install/adapters/next-source.ts
-import { createRequire } from "module";
-import { join as join7 } from "path";
+import { createRequire as createRequire3 } from "module";
+import { join as join11 } from "path";
 var NEXT_MARKER = "// #region patchstack-next-composed";
 var ROUTE_MARKER = "// #region patchstack-next-route";
 var METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 function nextCompiler(cwd) {
-  for (const base of [join7(cwd, "package.json"), import.meta.url]) {
+  for (const base of [join11(cwd, "package.json"), import.meta.url]) {
     try {
-      return createRequire(base)("typescript");
+      return createRequire3(base)("typescript");
     } catch {
     }
   }
@@ -4356,7 +4750,7 @@ function standardNextRouting(ts, file, source) {
     return false;
   };
   if (!literal(target) || ![...objects.values()].every(literal)) return false;
-  return target.properties.every((p) => p.name && !["basePath", "i18n", "skipMiddlewareUrlNormalize", "pageExtensions", "__proto__"].includes(
+  return target.properties.every((p) => p.name && !["basePath", "i18n", "skipMiddlewareUrlNormalize", "skipProxyUrlNormalize", "pageExtensions", "__proto__"].includes(
     ts.isIdentifier(p.name) || ts.isStringLiteral(p.name) ? p.name.text : ""
   ));
 }
@@ -4420,7 +4814,7 @@ function prelude(request, marker) {
 function composeNextMiddleware(ts, file, source, guardImport) {
   const sf = parse(ts, file, source);
   if (!sf || /\b(?:psProtection|psBlocked|psRequest|getPatchstackProtection)\b/.test(source)) return null;
-  const found = handlers(ts, sf, /* @__PURE__ */ new Set(["middleware"]));
+  const found = handlers(ts, sf, /* @__PURE__ */ new Set([/proxy\.[jt]s$/.test(file) ? "proxy" : "middleware"]));
   if (found.length !== 1 || sf.statements.some((s) => ts.isExportAssignment(s) || ts.isExportDeclaration(s))) return null;
   const fn = found[0];
   const request = requestName(ts, fn);
@@ -4482,7 +4876,7 @@ function nextSourceWired(ts, file, source, guardImport, route = false) {
   const imported = sf.statements.some((s) => ts.isImportDeclaration(s) && ts.isStringLiteral(s.moduleSpecifier) && s.moduleSpecifier.text === guardImport && s.importClause?.namedBindings && ts.isNamedImports(s.importClause.namedBindings) && s.importClause.namedBindings.elements.some((e) => !e.propertyName && e.name.text === "getPatchstackProtection"));
   if (!imported) return false;
   if (route && !sf.statements.some((s) => ts.isImportDeclaration(s) && ts.isStringLiteral(s.moduleSpecifier) && s.moduleSpecifier.text === guardImport && s.importClause?.namedBindings && ts.isNamedImports(s.importClause.namedBindings) && s.importClause.namedBindings.elements.some((e) => !e.propertyName && e.name.text === "screenPatchstackResponse"))) return false;
-  const found = handlers(ts, sf, route ? METHODS : /* @__PURE__ */ new Set(["middleware"]));
+  const found = handlers(ts, sf, route ? METHODS : /* @__PURE__ */ new Set([/proxy\.[jt]s$/.test(file) ? "proxy" : "middleware"]));
   if (!found.length || sf.statements.some((s) => ts.isExportDeclaration(s) || ts.isExportAssignment(s))) return false;
   if (route && methodExportCount(ts, sf) !== found.length) return false;
   const compact = (text) => text.replace(/\s+/g, "");
@@ -4517,17 +4911,48 @@ function nextSourceWired(ts, file, source, guardImport, route = false) {
 
 // src/protect/install/adapters/next.ts
 function middlewareInfo(cwd) {
-  const candidates = ["middleware.ts", "middleware.js", "src/middleware.ts", "src/middleware.js"];
-  const relFile = candidates.find((rel) => existsSync5(join8(cwd, rel))) ?? (existsSync5(join8(cwd, "src")) ? "src/middleware.ts" : "middleware.ts");
-  return { relFile, relDir: dirname3(relFile), exists: existsSync5(join8(cwd, relFile)) };
+  const candidates = entryFiles(cwd);
+  const name = (nextMajor(cwd) ?? 0) >= 16 ? "proxy" : "middleware";
+  const relFile = candidates.find((rel) => existsSync8(join12(cwd, rel))) ?? (existsSync8(join12(cwd, "src")) ? `src/${name}.ts` : `${name}.ts`);
+  return { relFile, relDir: dirname3(relFile), exists: existsSync8(join12(cwd, relFile)) };
+}
+function nextMajor(cwd) {
+  try {
+    const file = createRequire4(join12(cwd, "package.json")).resolve("next/package.json");
+    return Number(JSON.parse(read(file)).version.split(".")[0]);
+  } catch {
+    try {
+      const pkg = JSON.parse(read(join12(cwd, "package.json")));
+      const version = pkg.dependencies?.next ?? pkg.devDependencies?.next;
+      const match = typeof version === "string" && /^[~^]?(\d+)\./.exec(version);
+      return match ? Number(match[1]) : null;
+    } catch {
+      return null;
+    }
+  }
 }
-function proxyFiles(cwd) {
-  return ["proxy.ts", "proxy.js", "src/proxy.ts", "src/proxy.js"].filter((file) => existsSync5(join8(cwd, file)));
+function entryFiles(cwd) {
+  return [
+    "middleware.ts",
+    "middleware.js",
+    "src/middleware.ts",
+    "src/middleware.js",
+    "proxy.ts",
+    "proxy.js",
+    "src/proxy.ts",
+    "src/proxy.js"
+  ].filter((file) => existsSync8(join12(cwd, file)));
+}
+function entryProblem2(cwd) {
+  const files = entryFiles(cwd);
+  if (files.length > 1) return `multiple Next.js middleware/proxy entries (${files.join(", ")}); select one manually`;
+  if (files.some((file) => /proxy\.[jt]s$/.test(file)) && (nextMajor(cwd) ?? 0) < 16) return `${files.join(", ")} requires a verified Next.js 16+ installation`;
+  return null;
 }
 function paths(cwd) {
   const mw = middlewareInfo(cwd);
   const ext = mw.relFile.endsWith(".js") ? "js" : "ts";
-  return { ...mw, rules: join8(mw.relDir, "patchstack.rules.json"), guard: join8(mw.relDir, `patchstack.next.${ext}`) };
+  return { ...mw, rules: join12(mw.relDir, "patchstack.rules.json"), guard: join12(mw.relDir, `patchstack.next.${ext}`) };
 }
 function importFrom(file, guard) {
   const rel = relative3(dirname3(file), guard).replace(/\\/g, "/").replace(/\.ts$/, "");
@@ -4542,7 +4967,7 @@ function routes(cwd) {
       incomplete = true;
       return;
     }
-    const full = join8(cwd, rel);
+    const full = join12(cwd, rel);
     if (lstatSync2(full).isSymbolicLink()) {
       incomplete = true;
       return;
@@ -4553,14 +4978,14 @@ function routes(cwd) {
         incomplete = true;
         continue;
       }
-      const child = join8(rel, entry.name);
+      const child = join12(rel, entry.name);
       if (entry.isDirectory()) walk2(child);
       else if (entry.isFile() && /^route\.(?:tsx?|jsx?)$/.test(entry.name)) files.push(child);
     }
   };
   for (const root of ["app", "src/app"]) {
-    if (!existsSync5(join8(cwd, root))) continue;
-    if (root.startsWith("src/") && lstatSync2(join8(cwd, "src")).isSymbolicLink()) {
+    if (!existsSync8(join12(cwd, root))) continue;
+    if (root.startsWith("src/") && lstatSync2(join12(cwd, "src")).isSymbolicLink()) {
       incomplete = true;
       continue;
     }
@@ -4574,53 +4999,62 @@ function routes(cwd) {
 }
 function customRouting(cwd, ts) {
   return ["js", "mjs", "ts", "cjs"].some((ext) => {
-    const file = join8(cwd, `next.config.${ext}`);
-    return existsSync5(file) && !standardNextRouting(ts, file, read(file));
+    const file = join12(cwd, `next.config.${ext}`);
+    return existsSync8(file) && !standardNextRouting(ts, file, read(file));
   });
 }
 function sharedGuardPresent(file) {
-  if (!existsSync5(file)) return false;
+  if (!existsSync8(file)) return false;
   const source = read(file);
   return source.includes("export async function getPatchstackProtection") && source.includes("export async function screenPatchstackResponse") && source.includes('import { createProtection } from "@patchstack/connect/protect"');
 }
 function wire2(cwd, opts) {
-  const proxies = proxyFiles(cwd);
-  if (proxies.length) {
-    log(`left ${proxies.join(", ")} untouched: Next.js proxy integration requires manual wiring. Do not add middleware alongside a proxy; protect --check reports this gap.`);
+  const problem = entryProblem2(cwd);
+  if (problem) {
+    log(`Next.js entries left untouched: ${problem}. Do not add middleware alongside a proxy.`);
     return { ok: false, changed: [] };
   }
   const templates = templatesDir();
   const mw = paths(cwd);
-  ensureProjectDirectorySync(cwd, join8(cwd, mw.relDir));
+  ensureProjectDirectorySync(cwd, join12(cwd, mw.relDir));
   const changed = [];
-  if (opts.demo || !existsSync5(join8(cwd, mw.rules))) {
-    copyProjectFileSync(cwd, join8(templates, opts.demo ? "demo-rules.json" : "rules.json"), join8(cwd, mw.rules));
+  if (opts.demo || !existsSync8(join12(cwd, mw.rules))) {
+    copyProjectFileSync(cwd, join12(templates, opts.demo ? "demo-rules.json" : "rules.json"), join12(cwd, mw.rules));
     changed.push(mw.rules);
   }
   const ts = nextCompiler(cwd);
-  const guardPath = join8(cwd, mw.guard);
-  const guardConflict = existsSync5(guardPath) && !sharedGuardPresent(guardPath);
+  const guardPath = join12(cwd, mw.guard);
+  const guardConflict = existsSync8(guardPath) && !sharedGuardPresent(guardPath);
   const ensureGuard = () => {
-    if (existsSync5(guardPath)) return;
-    const source = read(join8(templates, "next-guard.ts"));
+    if (existsSync8(guardPath)) {
+      if (mw.guard.endsWith(".ts") && installTemplate(cwd, mw.guard, "next-guard.ts")) changed.push(mw.guard);
+      return;
+    }
+    const source = read(join12(templates, "next-guard.ts"));
     writeProjectFileSync(cwd, guardPath, mw.guard.endsWith(".js") ? ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022, module: ts.ModuleKind.ESNext } }).outputText : source);
     if (!opts.demo) bakeSiteUuid(cwd, mw.guard);
     changed.push(mw.guard);
   };
-  const existing = mw.exists ? read(join8(cwd, mw.relFile)) : "";
+  const existing = mw.exists ? read(join12(cwd, mw.relFile)) : "";
   if (!mw.exists) {
-    copyProjectFileSync(cwd, join8(templates, "next-middleware.ts"), join8(cwd, mw.relFile));
+    if (/proxy\.[jt]s$/.test(mw.relFile)) {
+      const composed = ts && !guardConflict && composeNextMiddleware(ts, mw.relFile, 'export function proxy(request: Request) {}\nexport const config = { matcher: "/:path*" };\n', importFrom(mw.relFile, mw.guard));
+      if (!composed) return { ok: false, changed };
+      ensureGuard();
+      writeProjectFileSync(cwd, join12(cwd, mw.relFile), composed);
+    } else copyProjectFileSync(cwd, join12(templates, "next-middleware.ts"), join12(cwd, mw.relFile));
     if (!opts.demo) bakeSiteUuid(cwd, mw.relFile);
     changed.push(mw.relFile);
     log(`scaffolded ${mw.relFile} (request-phase guard)`);
   } else if (existing.includes(NEXT_MARKER) || existing.includes("#region patchstack-next (")) {
+    if (existing.includes("#region patchstack-next (") && installTemplate(cwd, mw.relFile, "next-middleware.ts")) changed.push(mw.relFile);
     log(`${mw.relFile} already has a Patchstack guard \u2014 left as-is`);
     if (ts && existing.includes(NEXT_MARKER)) ensureGuard();
   } else {
     const composed = ts && !guardConflict && !customRouting(cwd, ts) && composeNextMiddleware(ts, mw.relFile, existing, importFrom(mw.relFile, mw.guard));
     if (composed) {
       ensureGuard();
-      writeProjectFileSync(cwd, join8(cwd, mw.relFile), composed);
+      writeProjectFileSync(cwd, join12(cwd, mw.relFile), composed);
       changed.push(mw.relFile);
       log(`composed ${mw.relFile}: request guard first; existing middleware keeps its original matcher scope`);
     } else {
@@ -4629,7 +5063,7 @@ function wire2(cwd, opts) {
   }
   const inventory = routes(cwd);
   for (const file of inventory.files) {
-    const source = read(join8(cwd, file));
+    const source = read(join12(cwd, file));
     if (source.includes(ROUTE_MARKER)) {
       if (ts) ensureGuard();
       continue;
@@ -4637,7 +5071,7 @@ function wire2(cwd, opts) {
     const composed = ts && !guardConflict && /\.(?:ts|js)$/.test(file) && composeNextRoute(ts, file, source, importFrom(file, mw.guard));
     if (composed) {
       ensureGuard();
-      writeProjectFileSync(cwd, join8(cwd, file), composed);
+      writeProjectFileSync(cwd, join12(cwd, file), composed);
       changed.push(file);
       log(`wired ${file} (request checks + response filtering)`);
     } else {
@@ -4650,25 +5084,21 @@ function wire2(cwd, opts) {
   return { ok: true, changed: [...new Set(changed)] };
 }
 function verify2(cwd) {
-  const proxies = proxyFiles(cwd);
-  if (proxies.length) return {
+  const problem = entryProblem2(cwd);
+  if (problem) return {
     wired: false,
-    checks: [{
-      label: "Next.js proxy wiring requires manual verification",
-      ok: false,
-      hint: `review ${proxies.join(", ")}; automatic proxy integration is not supported. Next.js cannot use middleware and proxy together.`
-    }]
+    checks: [{ label: "Next.js request entry needs review", ok: false, hint: problem }]
   };
   const mw = paths(cwd);
   const ts = nextCompiler(cwd);
-  const source = mw.exists ? read(join8(cwd, mw.relFile)) : "";
-  const shared = sharedGuardPresent(join8(cwd, mw.guard));
+  const source = mw.exists ? read(join12(cwd, mw.relFile)) : "";
+  const shared = sharedGuardPresent(join12(cwd, mw.guard));
   const legacy = source.includes("#region patchstack-next (") && source.includes("await protection.fetchGuard()(request)") && source.includes("if (blocked) return blocked") && source.includes('matcher: "/:path*"');
   const composed = ts && shared && !customRouting(cwd, ts) && nextSourceWired(ts, mw.relFile, source, importFrom(mw.relFile, mw.guard));
   const present2 = !!(legacy || composed);
-  const rulesPresent = existsSync5(join8(cwd, mw.rules));
+  const rulesPresent = existsSync8(join12(cwd, mw.rules));
   const inventory = routes(cwd);
-  const missing = inventory.files.filter((file) => !(ts && shared && nextSourceWired(ts, file, read(join8(cwd, file)), importFrom(file, mw.guard), true)));
+  const missing = inventory.files.filter((file) => !(ts && shared && nextSourceWired(ts, file, read(join12(cwd, file)), importFrom(file, mw.guard), true)));
   return {
     wired: present2 && rulesPresent && missing.length === 0 && !inventory.incomplete,
     checks: [
@@ -4707,51 +5137,63 @@ var nextAdapter = {
 };
 
 // src/protect/install/seam.ts
-import { existsSync as existsSync6 } from "fs";
-import { join as join9, dirname as dirname4 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join13, dirname as dirname4 } from "path";
 function rulesRel(seamRel) {
   const d = dirname4(seamRel);
   return (d === "." ? "patchstack.rules.json" : `${d}/patchstack.rules.json`).replace(/\\/g, "/");
 }
 function wireSeam(cwd, opts, spec) {
   const templates = templatesDir();
-  const existing = spec.candidates.find((c) => existsSync6(join9(cwd, c)));
+  const existing = spec.candidates.find((c) => existsSync9(join13(cwd, c)));
   const seamRel = existing ?? spec.target;
-  ensureProjectDirectorySync(cwd, dirname4(join9(cwd, seamRel)));
-  const rulesDst = join9(cwd, rulesRel(seamRel));
+  ensureProjectDirectorySync(cwd, dirname4(join13(cwd, seamRel)));
+  const rulesDst = join13(cwd, rulesRel(seamRel));
   const changed = [];
-  if (opts.demo || !existsSync6(rulesDst)) {
-    copyProjectFileSync(cwd, join9(templates, opts.demo ? "demo-rules.json" : "rules.json"), rulesDst);
+  if (opts.demo || !existsSync9(rulesDst)) {
+    copyProjectFileSync(cwd, join13(templates, opts.demo ? "demo-rules.json" : "rules.json"), rulesDst);
     changed.push(rulesRel(seamRel));
   }
-  const current = existing ? read(join9(cwd, existing)) : "";
+  const current = existing ? read(join13(cwd, existing)) : "";
   if (existing && current.includes(spec.marker)) {
-    log(`${existing} already has the Patchstack guard \u2014 left as-is`);
+    if (installTemplate(cwd, seamRel, spec.templateName)) changed.push(seamRel);
     return { ok: true, changed };
   }
   if (existing) {
     log(`existing ${existing} left untouched \u2014 scaffolded ${rulesRel(seamRel)}; ${spec.planHint}`);
     return { ok: true, changed };
   }
-  copyProjectFileSync(cwd, join9(templates, spec.templateName), join9(cwd, seamRel));
+  copyProjectFileSync(cwd, join13(templates, spec.templateName), join13(cwd, seamRel));
   if (!opts.demo) bakeSiteUuid(cwd, seamRel);
   changed.push(seamRel);
   log(`scaffolded ${seamRel}`);
   return { ok: true, changed: [...new Set(changed)] };
 }
 function verifySeam(cwd, spec) {
-  const existing = spec.candidates.find((c) => existsSync6(join9(cwd, c)));
+  const existing = spec.candidates.find((c) => existsSync9(join13(cwd, c)));
   const seamRel = existing ?? spec.target;
-  const present2 = existing ? read(join9(cwd, existing)).includes(spec.marker) : false;
-  const rulesPresent = existsSync6(join9(cwd, rulesRel(seamRel)));
+  const present2 = existing ? templateWiringPresent(cwd, existing, spec.templateName) : false;
+  const rulesPresent = existsSync9(join13(cwd, rulesRel(seamRel)));
   return {
     wired: present2 && rulesPresent,
     checks: [
-      { label: `${spec.seamLabel} present`, ok: present2, hint: `run \`patchstack-connect protect\` (writes ${spec.target})` },
+      { label: `${spec.seamLabel} wiring verified`, ok: present2, hint: `run \`patchstack-connect protect\`; customized hooks need manual verification (${spec.target})` },
       { label: "rules co-located with the guard", ok: rulesPresent, hint: "run `patchstack-connect protect`" }
     ]
   };
 }
+function templateWiringPresent(cwd, file, template) {
+  const ts = sourceCompiler(cwd);
+  if (!ts) return false;
+  const actual = parsedSource(ts, file, read(join13(cwd, file)));
+  const expected = parsedSource(ts, template, read(join13(templatesDir(), template)));
+  if (!actual || !expected) return false;
+  const printer = ts.createPrinter({ removeComments: true });
+  const emit = (node, tree) => printer.printNode(ts.EmitHint.Unspecified, node, tree);
+  const required = expected.statements.filter((node) => ts.isExportAssignment(node) || ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) || ts.isFunctionDeclaration(node) && node.name?.text === "getProtection" || ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === "@patchstack/connect/protect");
+  const code = actual.statements.map((node) => emit(node, actual));
+  return required.length >= 3 && required.every((node) => code.filter((text) => text === emit(node, expected)).length === 1);
+}
 
 // src/protect/install/adapters/sveltekit.ts
 var SPEC = {
@@ -4833,7 +5275,7 @@ var nuxtAdapter = {
 
 // src/protect/install/find-app.ts
 import { readFileSync as readFileSync8, readdirSync as readdirSync4, lstatSync as lstatSync3 } from "fs";
-import { join as join10, relative as relative4, dirname as dirname5 } from "path";
+import { join as join14, relative as relative4, dirname as dirname5 } from "path";
 var SKIP_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   "patchstack",
@@ -4865,7 +5307,7 @@ function findAppInstance(cwd, re) {
     }
     for (const name of entries) {
       if (SKIP_DIRS2.has(name) || name.startsWith(".")) continue;
-      const p = join10(dir, name);
+      const p = join14(dir, name);
       let st;
       try {
         st = lstatSync3(p);
@@ -4924,7 +5366,7 @@ function declaredEntries(cwd) {
   const paths2 = /* @__PURE__ */ new Set();
   let pkg;
   try {
-    pkg = JSON.parse(readFileSync8(join10(cwd, "package.json"), "utf8"));
+    pkg = JSON.parse(readFileSync8(join14(cwd, "package.json"), "utf8"));
   } catch {
     return paths2;
   }
@@ -4950,17 +5392,17 @@ function importSpecifier(fromRel, toRel, preserveExtension = false) {
 }
 
 // src/protect/install/register.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join13, resolve as resolve3 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { join as join17, resolve as resolve3 } from "path";
 
 // src/protect/install/generic.ts
-import { readFileSync as readFileSync9, existsSync as existsSync8, readdirSync as readdirSync5, lstatSync as lstatSync4 } from "fs";
-import { join as join12, dirname as dirname7 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync11, readdirSync as readdirSync5, lstatSync as lstatSync4 } from "fs";
+import { join as join16, dirname as dirname7 } from "path";
 
 // src/protect/install/source-scope.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync7 } from "fs";
-import { dirname as dirname6, join as join11, resolve as resolve2 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { dirname as dirname6, join as join15, resolve as resolve2 } from "path";
 
 // src/protect/install/node-flags.ts
 var flagName = (token) => token.split("=")[0];
@@ -5250,8 +5692,8 @@ function moduleKindOf(filePath, packageIsModule) {
 }
 function resolvesToGuardModule(specifier, query) {
   const resolved = resolve2(dirname6(query.fromFile), specifier);
-  if (withoutModuleExtension(resolved) !== join11(query.guardDir, "guard")) return false;
-  const existing = GUARD_FILENAMES.filter((name) => existsSync7(join11(query.guardDir, name)));
+  if (withoutModuleExtension(resolved) !== join15(query.guardDir, "guard")) return false;
+  const existing = GUARD_FILENAMES.filter((name) => existsSync10(join15(query.guardDir, name)));
   if (existing.length === 0) return false;
   const extension = /(\.[A-Za-z0-9]+)$/.exec(specifier)?.[1] ?? "";
   if (!query.strictExtensions) return true;
@@ -5260,7 +5702,7 @@ function resolvesToGuardModule(specifier, query) {
     if (query.kind === "cjs") return existing.includes("guard.js");
     return true;
   }
-  if (existsSync7(resolved)) return true;
+  if (existsSync10(resolved)) return true;
   return query.kind === "ts" && extension === ".js" && existing.includes("guard.ts");
 }
 function withoutModuleExtension(filePath) {
@@ -5270,16 +5712,16 @@ function withoutModuleExtension(filePath) {
 // src/protect/install/generic.ts
 function packageIsEsm(cwd) {
   try {
-    return JSON.parse(read(join12(cwd, "package.json"))).type === "module";
+    return JSON.parse(read(join16(cwd, "package.json"))).type === "module";
   } catch {
     return false;
   }
 }
 function genericDir(cwd) {
-  return existsSync8(join12(cwd, "src")) ? "src/patchstack" : "patchstack";
+  return existsSync11(join16(cwd, "src")) ? "src/patchstack" : "patchstack";
 }
 function hasTypeScript(cwd) {
-  return existsSync8(join12(cwd, "tsconfig.json")) || candidateEntries(cwd).some((entry) => /\.tsx?$/.test(entry));
+  return existsSync11(join16(cwd, "tsconfig.json")) || candidateEntries(cwd).some((entry) => /\.tsx?$/.test(entry));
 }
 function genericGuardTarget(cwd) {
   if (hasTypeScript(cwd)) {
@@ -5293,7 +5735,7 @@ function genericGuardTarget(cwd) {
 function genericScaffoldFiles(cwd) {
   const dir = genericDir(cwd);
   const candidates = ["guard.ts", "guard.js", "guard.cjs", "rules.json"];
-  return candidates.map((file) => `${dir}/${file}`).filter((relative9) => existsSync8(join12(cwd, relative9)));
+  return candidates.map((file) => `${dir}/${file}`).filter((relative9) => existsSync11(join16(cwd, relative9)));
 }
 function scaffoldGeneric(cwd, opts, guardTemplate, guardFile) {
   const target = genericGuardTarget(cwd);
@@ -5301,15 +5743,15 @@ function scaffoldGeneric(cwd, opts, guardTemplate, guardFile) {
   guardFile ??= target.file;
   const templates = templatesDir();
   const dir = genericDir(cwd);
-  const dst = join12(cwd, dir);
+  const dst = join16(cwd, dir);
   ensureProjectDirectorySync(cwd, dst);
-  copyProjectFileSync(cwd, join12(templates, guardTemplate), join12(dst, guardFile));
   const guardRel = `${dir}/${guardFile}`;
-  const changed = [guardRel];
-  if (!opts.demo) bakeSiteUuid(cwd, guardRel);
-  const rulesDst = join12(dst, "rules.json");
-  if (opts.demo || !existsSync8(rulesDst)) {
-    copyProjectFileSync(cwd, join12(templates, opts.demo ? "demo-rules.json" : "rules.json"), rulesDst);
+  const changed = [];
+  if (installTemplate(cwd, guardRel, guardTemplate)) changed.push(guardRel);
+  if (!opts.demo && matchesGuardTemplate(cwd, guardRel, guardTemplate)) bakeSiteUuid(cwd, guardRel);
+  const rulesDst = join16(dst, "rules.json");
+  if (opts.demo || !existsSync11(rulesDst)) {
+    copyProjectFileSync(cwd, join16(templates, opts.demo ? "demo-rules.json" : "rules.json"), rulesDst);
     changed.push(`${dir}/rules.json`);
   }
   return { changed, dir };
@@ -5330,10 +5772,10 @@ function candidateEntries(cwd) {
     "app.ts",
     "app.js"
   ];
-  const hits = names.filter((n) => existsSync8(join12(cwd, n)));
+  const hits = names.filter((n) => existsSync11(join16(cwd, n)));
   try {
-    const pkg = JSON.parse(read(join12(cwd, "package.json")));
-    if (typeof pkg.main === "string" && existsSync8(join12(cwd, pkg.main))) hits.push(pkg.main);
+    const pkg = JSON.parse(read(join16(cwd, "package.json")));
+    if (typeof pkg.main === "string" && existsSync11(join16(cwd, pkg.main))) hits.push(pkg.main);
   } catch {
   }
   return [...new Set(hits)];
@@ -5436,13 +5878,16 @@ function escapeForRegExp(value) {
 function genericVerify(cwd) {
   const dir = genericDir(cwd);
   const target = genericGuardTarget(cwd);
-  const present2 = GUARD_FILENAMES.find((name) => existsSync8(join12(cwd, dir, name)));
+  const present2 = GUARD_FILENAMES.find((name) => existsSync11(join16(cwd, dir, name)));
   const scaffolded = present2 !== void 0;
-  const imported = scaffolded && guardIsImported(cwd, join12(cwd, dir, present2));
+  const template = present2?.endsWith(".ts") ? "generic-guard.ts" : present2?.endsWith(".cjs") ? "generic-guard.cjs" : "generic-guard.js";
+  const helperVerified = !!present2 && matchesGuardTemplate(cwd, `${dir}/${present2}`, template);
+  const imported = scaffolded && guardIsImported(cwd, join16(cwd, dir, present2));
   return {
-    wired: scaffolded && imported,
+    wired: scaffolded && helperVerified && imported,
     checks: [
       { label: "generic guard scaffolded", ok: scaffolded, hint: "run `patchstack-connect protect`" },
+      { label: "guard helper implementation verified", ok: helperVerified, hint: "preserved custom helpers require manual review of their exports and request/response screening" },
       {
         label: "guard imported and called in a server entry",
         ok: imported,
@@ -5474,7 +5919,7 @@ var NON_RUNTIME_DIRS = /* @__PURE__ */ new Set([
 function guardIsImported(cwd, guardPath) {
   const guardDir = dirname7(guardPath);
   const packageIsModule = packageIsEsm(cwd);
-  const root = existsSync8(join12(cwd, "src")) ? join12(cwd, "src") : cwd;
+  const root = existsSync11(join16(cwd, "src")) ? join16(cwd, "src") : cwd;
   let found = false;
   const walk2 = (d, depth) => {
     if (found || depth > 8) return;
@@ -5487,7 +5932,7 @@ function guardIsImported(cwd, guardPath) {
     for (const name of entries) {
       if (found) return;
       if (NON_RUNTIME_DIRS.has(name) || name.startsWith(".")) continue;
-      const p = join12(d, name);
+      const p = join16(d, name);
       let st;
       try {
         st = lstatSync4(p);
@@ -5510,7 +5955,7 @@ function guardIsImported(cwd, guardPath) {
 
 // src/protect/install/register.ts
 var routeRegistration = (appVar) => new RegExp(
-  `^\\s*${appVar}\\.(?:get|post|put|patch|delete|head|options|all|route)\\(|^\\s*${appVar}\\.use\\(\\s*['"\`]`,
+  `^\\s*${appVar}\\.(?:get|post|put|patch|delete|head|options|all|route)\\(|^\\s*${appVar}\\.use\\(\\s*(?:['"\`]|[\\w$]+(?:\\.[\\w$]+)*\\s*[,\\)])`,
   "m"
 );
 function routesBefore(source, appVar, guardIndex) {
@@ -5546,7 +5991,7 @@ function guardTarget(cwd, entryRel, spec) {
 }
 function packageType(cwd) {
   try {
-    return JSON.parse(read(join13(cwd, "package.json"))).type;
+    return JSON.parse(read(join17(cwd, "package.json"))).type;
   } catch {
     return void 0;
   }
@@ -5563,7 +6008,7 @@ function wiringState(source, spec, appVar, fileRel, guard) {
   );
   const appIndex = maskedLines.findIndex((line) => spec.appRe.test(line));
   const anchor = spec.callAfter ? spec.callAfter(appVar) : null;
-  const anchorIndex = anchor ? maskedLines.findIndex((line) => anchor.test(line)) : -1;
+  const anchorIndex = anchor ? maskedLines.reduce((last, line, index) => anchor.test(line) ? index : last, -1) : -1;
   return {
     importAtTopLevel: importIndex !== -1 && isTopLevelLine(code, importIndex),
     callInAppScope: callIndex !== -1 && inSameBlockAfter(code, appIndex, callIndex),
@@ -5582,8 +6027,8 @@ function bindsGuard(line, maskedLine, importName, call, fileRel, guard) {
 }
 function namesGuardModule(specifier, fileRel, guard) {
   return resolvesToGuardModule(specifier, {
-    fromFile: join13(guard.cwd, fileRel),
-    guardDir: resolve3(join13(guard.cwd, guard.guardDir)),
+    fromFile: join17(guard.cwd, fileRel),
+    guardDir: resolve3(join17(guard.cwd, guard.guardDir)),
     kind: moduleKindOf(fileRel, packageType(guard.cwd) === "module"),
     strictExtensions: true
   });
@@ -5602,8 +6047,17 @@ function wireRegister(cwd, opts, spec) {
   }
   const target = guardTarget(cwd, entry.relPath, spec);
   const { changed, dir } = scaffoldGeneric(cwd, opts, target.template, target.file);
-  const p = join13(cwd, entry.relPath);
+  if (!matchesGuardTemplate(cwd, `${dir}/${target.file}`, target.template)) {
+    log(`${dir}/${target.file} needs manual review; the existing helper and ${entry.relPath} were left untouched.`);
+    return { ok: false, changed };
+  }
+  const p = join17(cwd, entry.relPath);
   const s = read(p);
+  const compiler = sourceCompiler(cwd);
+  if (!compiler || !parsedSource(compiler, entry.relPath, s)) {
+    log(`${entry.relPath} left untouched: a working TypeScript parser is required for source edits; ${spec.manualHint}`);
+    return { ok: false, changed };
+  }
   const state = wiringState(s, spec, entry.appVar, entry.relPath, { cwd, guardDir: dir });
   if (state.importAtTopLevel && state.callInAppScope) {
     log(
@@ -5630,17 +6084,35 @@ function wireRegister(cwd, opts, spec) {
   const lines = s.split("\n");
   if (!state.importAtTopLevel) {
     const lastImport = lastTopLevelImportLine(s);
-    const importIdx = lastImport === -1 ? firstStatementLine(lines) : lastImport + 1;
+    const importEnd = lastImport === -1 ? -1 : statementEndLine(compiler, entry.relPath, s, lastImport);
+    if (importEnd === null) return { ok: false, changed };
+    const importIdx = lastImport === -1 ? firstStatementLine(lines) : importEnd + 1;
     lines.splice(importIdx, 0, importLine);
   }
   const appIdx = lines.findIndex((l) => spec.appRe.test(l));
   if (appIdx !== -1 && !state.callInAppScope) {
     const preferred = spec.callAfter?.(entry.appVar);
-    const preferredIdx = preferred ? lines.findIndex((line, index) => index > appIdx && preferred.test(line)) : -1;
+    const preferredIdx = preferred ? lines.reduce((last, line, index) => index > appIdx && preferred.test(line) && inSameBlockAfter(lines.join("\n"), appIdx, index) ? index : last, -1) : -1;
     const callIdx = preferredIdx === -1 ? appIdx : preferredIdx;
-    lines.splice(callIdx + 1, 0, REGION, spec.call(entry.appVar), "// #endregion patchstack");
+    if (spec.requireCallAfter && preferredIdx === -1) return { ok: false, changed };
+    const current = lines.join("\n");
+    const statement = statementPosition(compiler, entry.relPath, current, callIdx, preferredIdx === -1 ? spec.appRe : preferred);
+    if (statement === null) return { ok: false, changed };
+    const { start, end } = statement;
+    const tail = current.slice(end);
+    const trailingComment = /^[ \t]*\/\//.test(tail);
+    const insertion = trailingComment ? current.indexOf("\n", end) : end;
+    const position = insertion === -1 ? current.length : insertion;
+    const separator = current.slice(0, end).trimEnd().endsWith(";") ? "" : ";";
+    const prefix = current.slice(current.lastIndexOf("\n", start - 1) + 1, start).trim();
+    const updated = current.slice(0, start) + (prefix ? "\n" : "") + current.slice(start, end) + separator + current.slice(end, position) + "\n" + REGION + "\n" + spec.call(entry.appVar) + "\n// #endregion patchstack\n" + current.slice(position);
+    lines.splice(0, lines.length, ...updated.split("\n"));
   }
   const patched = lines.join("\n");
+  if (!parsedSource(compiler, entry.relPath, patched)) {
+    log(`${entry.relPath} would not parse after patching \u2014 left untouched; ${spec.manualHint}`);
+    return { ok: false, changed };
+  }
   writeProjectFileSync(cwd, p, patched, { encoding: "utf8" });
   if (spec.callAfter) {
     const guardIndex = lines.findIndex((line) => line.includes(spec.call(entry.appVar)));
@@ -5672,26 +6144,30 @@ function firstStatementLine(lines) {
   return i;
 }
 function serverIsGuarded(cwd, spec, server, guardDir) {
-  const source = read(join13(cwd, server.relPath));
+  const target = guardTarget(cwd, server.relPath, spec);
+  if (!matchesGuardTemplate(cwd, `${guardDir}/${target.file}`, target.template)) return false;
+  const source = read(join17(cwd, server.relPath));
   const state = wiringState(source, spec, server.appVar, server.relPath, { cwd, guardDir });
   if (!state.importAtTopLevel || !state.callInAppScope || !state.ordered) return false;
   return !spec.callAfter || routesBefore(source, server.appVar, state.callIndex).length === 0;
 }
 function verifyRegister(cwd, spec) {
-  const dir = existsSync9(join13(cwd, "src")) ? "src/patchstack" : "patchstack";
+  const dir = existsSync12(join17(cwd, "src")) ? "src/patchstack" : "patchstack";
   const entry = findAppInstance(cwd, spec.appRe);
   const target = entry ? guardTarget(cwd, entry.relPath, spec) : null;
-  const scaffolded = target ? existsSync9(join13(cwd, dir, target.file)) : false;
-  const entrySource = entry ? read(join13(cwd, entry.relPath)) : "";
+  const scaffolded = target ? existsSync12(join17(cwd, dir, target.file)) : false;
+  const helperVerified = !!target && matchesGuardTemplate(cwd, `${dir}/${target.file}`, target.template);
+  const entrySource = entry ? read(join17(cwd, entry.relPath)) : "";
   const state = entry ? wiringState(entrySource, spec, entry.appVar, entry.relPath, { cwd, guardDir: dir }) : { importAtTopLevel: false, callInAppScope: false, ordered: false, callIndex: -1, appIndex: -1 };
   const wired = state.importAtTopLevel && state.callInAppScope && state.ordered;
   const early = spec.callAfter && entry ? routesBefore(entrySource, entry.appVar, state.callIndex) : [];
   const noEarlyRoutes = early.length === 0;
   const unguarded = (entry?.others ?? []).filter((other) => !serverIsGuarded(cwd, spec, other, dir)).map((other) => other.relPath);
   return {
-    wired: scaffolded && wired && noEarlyRoutes && unguarded.length === 0,
+    wired: scaffolded && helperVerified && wired && noEarlyRoutes && unguarded.length === 0,
     checks: [
       { label: `${spec.label} guard scaffolded`, ok: scaffolded, hint: "run `patchstack-connect protect`" },
+      { label: "guard helper implementation verified", ok: helperVerified, hint: "preserved custom helpers require manual review of their exports and request/response screening" },
       { label: `guard registered on the ${spec.label}`, ok: wired, hint: spec.manualHint },
       ...entry && entry.others.length > 0 ? [
         {
@@ -5772,8 +6248,8 @@ var expressAdapter = {
 };
 
 // src/protect/install/reporting.ts
-import { existsSync as existsSync10 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join18 } from "path";
 
 // src/protect/reporting-state.js
 var REPORTING_STATES = Object.freeze([
@@ -5831,9 +6307,9 @@ function explainReportingState(state) {
 
 // src/protect/install/reporting.ts
 function siteIdentity(cwd, env) {
-  const rc = join14(cwd, ".patchstackrc.json");
+  const rc = join18(cwd, ".patchstackrc.json");
   let recorded;
-  if (existsSync10(rc)) {
+  if (existsSync13(rc)) {
     try {
       recorded = JSON.parse(read(rc)).siteUuid;
     } catch {
@@ -5889,6 +6365,7 @@ function reportingChecks(cwd, env = process.env) {
 // src/protect/install/index.ts
 var ADAPTERS = [
   tanstackSupabaseAdapter,
+  tanstackAdapter,
   nextAdapter,
   sveltekitAdapter,
   astroAdapter,
@@ -5913,7 +6390,10 @@ function runProtect(cwd, opts = {}) {
     adapter = ADAPTERS.find((a) => a.detect(cwd));
     if (adapter) {
       const result = adapter.wire(cwd, opts);
-      return { status: "wired", adapter: adapter.name, changed: result.changed };
+      const verification = adapter.verify(cwd);
+      if (result.ok && verification.wired) return { status: "wired", adapter: adapter.name, changed: result.changed };
+      const plan = verification.checks.filter((check) => !check.ok).map((check) => check.hint ?? check.label).join("\n");
+      return { status: "scaffolded", adapter: adapter.name, changed: result.changed, plan };
     }
   } catch (err) {
     log(`adapter ${adapter?.name ?? ""} failed (${err?.message ?? err}); falling back to a generic guard`);
@@ -5928,7 +6408,7 @@ function runProtect(cwd, opts = {}) {
     return { status: "scaffolded", adapter: "generic", changed: [], plan: "" };
   }
 }
-var RUNTIMES_WITHOUT_CONFIG_FILE = /* @__PURE__ */ new Set(["nextjs", "sveltekit", "astro", "nuxt", "generic"]);
+var RUNTIMES_WITHOUT_CONFIG_FILE = /* @__PURE__ */ new Set(["tanstack-start", "nextjs", "sveltekit", "astro", "nuxt", "generic"]);
 function credentialNote(cwd, adapterName) {
   if (!RUNTIMES_WITHOUT_CONFIG_FILE.has(adapterName)) return [];
   const localHint = hasResolvableCredential(cwd) ? "a credential is configured here; set the same one in your deployment" : "no credential found here either \u2014 run `npx @patchstack/connect scan` to provision one";
@@ -5982,7 +6462,7 @@ function runVerify(cwd) {
 }
 
 // src/widget.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync10 } from "fs";
 import path11 from "path";
 var WIDGET_SCRIPT_URL = "https://cdn.patchstack.com/patchstack-widget.js";
 var WIDGET_MARKER_ATTR = "data-patchstack-connect-widget";
@@ -6021,7 +6501,7 @@ ${indent}</body>`;
 }
 function findSourceShell(cwd) {
   for (const candidate of SOURCE_SHELL_CANDIDATES) {
-    if (existsSync11(path11.join(cwd, candidate))) {
+    if (existsSync14(path11.join(cwd, candidate))) {
       return candidate;
     }
   }
@@ -6033,7 +6513,7 @@ function ensureSourceWidget(cwd, siteUuid, jsxShell = null) {
     return { shell: null, action: "no-shell" };
   }
   const file = path11.join(cwd, shell);
-  if (!existsSync11(file)) {
+  if (!existsSync14(file)) {
     return { shell: null, action: "no-shell" };
   }
   const before = readFileSync10(file, "utf8");
@@ -6259,7 +6739,7 @@ function detectPackageManager(cwd) {
     return declared;
   }
   for (const { filename, pm } of PM_BY_LOCKFILE) {
-    if (existsSync12(path12.join(cwd, filename))) {
+    if (existsSync15(path12.join(cwd, filename))) {
       return pm;
     }
   }
@@ -6356,7 +6836,7 @@ function resolveWidgetFileHint(cwd, framework) {
     ...GENERIC_WIDGET_FILES
   ];
   for (const candidate of candidates) {
-    if (existsSync12(path12.join(cwd, candidate))) {
+    if (existsSync15(path12.join(cwd, candidate))) {
       return candidate;
     }
   }
@@ -6436,9 +6916,9 @@ async function collectGuideState(cwd) {
     hasBuildScript: Boolean(pkg?.scripts?.build?.trim()),
     installScanWired: (pkg?.scripts?.postinstall ?? "").includes("patchstack-connect scan"),
     // The scan has to run first: a later prebuild command may upload and stamp the map that the bundle
-    // must retain. Bun skips npm-style pre/post scripts, so its build chain follows the same order.
-    prebuildWired: /^\s*patchstack-connect\s+scan(?:\s*(?:&&|;)|\s*$)/.test(pkg?.scripts?.prebuild ?? "") || /^\s*patchstack-connect\s+scan(?:\s*(?:&&|;)|\s*$)/.test(pkg?.scripts?.build ?? ""),
-    postbuildWired: (pkg?.scripts?.postbuild ?? "").includes("patchstack-connect mark-build") || (pkg?.scripts?.build ?? "").includes("patchstack-connect mark-build"),
+    // must retain. Non-npm managers use explicit chains independent of lifecycle settings.
+    prebuildWired: packageManager === "npm" && /^\s*patchstack-connect\s+scan(?:\s*(?:&&|;)|\s*$)/.test(pkg?.scripts?.prebuild ?? "") || /^\s*patchstack-connect\s+scan(?:\s*(?:&&|;)|\s*$)/.test(pkg?.scripts?.build ?? ""),
+    postbuildWired: packageManager === "npm" && (pkg?.scripts?.postbuild ?? "").includes("patchstack-connect mark-build") || (pkg?.scripts?.build ?? "").includes("patchstack-connect mark-build"),
     widgetInstalled: widget.found,
     widgetTokenMatches: widget.uuidMatches,
     widgetOptOut,
@@ -6508,10 +6988,10 @@ function buildScriptLines(state) {
   const lines = [];
   if (!state.installScanWired) lines.push('"postinstall": "patchstack-connect scan"');
   if (state.hasBuildScript && !(state.prebuildWired && state.postbuildWired)) {
-    if (state.packageManager === "bun") {
-      lines.push('"build": "patchstack-connect scan && <existing build command> && patchstack-connect mark-build"');
+    if (state.packageManager !== "npm") {
+      lines.push('"build": "patchstack-connect scan && patchstack-connect map --upload && <existing build command> && patchstack-connect mark-build"');
     } else {
-      if (!state.prebuildWired) lines.push('"prebuild": "patchstack-connect scan"');
+      if (!state.prebuildWired) lines.push('"prebuild": "patchstack-connect scan && patchstack-connect map --upload"');
       if (!state.postbuildWired) lines.push('"postbuild": "patchstack-connect mark-build"');
     }
   }
@@ -6629,7 +7109,7 @@ import {
 } from "fs";
 import { tmpdir } from "os";
 import path13 from "path";
-import { createHash as createHash2, randomUUID as randomUUID3 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID3 } from "crypto";
 function baseFrom(manifestEndpoint) {
   const url = new URL(manifestEndpoint);
   const p = url.pathname.replace(/\/$/, "");
@@ -6639,7 +7119,7 @@ function baseFrom(manifestEndpoint) {
   return url.toString().replace(/\/$/, "");
 }
 function pendingPath(siteUuid, intent) {
-  const key = createHash2("sha256").update(siteUuid).digest("hex").slice(0, 16);
+  const key = createHash3("sha256").update(siteUuid).digest("hex").slice(0, 16);
   return path13.join(tmpdir(), `patchstack-${intent}-${key}.json`);
 }
 function savePending(siteUuid, intent, pending) {
@@ -6915,8 +7395,8 @@ async function claim2(config, onPrompt, deps = {}) {
 import { relative as relative5 } from "path";
 
 // src/protect/install/runtime/entry.ts
-import { existsSync as existsSync13, readFileSync as readFileSync13, realpathSync as realpathSync4, statSync as statSync6 } from "fs";
-import { join as join15, resolve as resolve4, sep as sep2 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync13, realpathSync as realpathSync4, statSync as statSync6 } from "fs";
+import { join as join19, resolve as resolve4, sep as sep2 } from "path";
 var CONVENTIONAL = [
   "server.js",
   "server.mjs",
@@ -6942,7 +7422,7 @@ var CONVENTIONAL = [
 var LOADABLE = /\.(?:js|mjs|cjs)$/;
 function readPackage2(cwd) {
   try {
-    const parsed = JSON.parse(readFileSync13(join15(cwd, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync13(join19(cwd, "package.json"), "utf8"));
     return parsed !== null && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
@@ -7012,14 +7492,14 @@ function resolveEntry(cwd) {
   }
   return {
     kind: "unavailable",
-    reason: existsSync13(join15(cwd, "package.json")) ? 'no directly loadable entry was found \u2014 declare one as a "start" script of the form `node <file>`, or run the check against a built output' : "there is no package.json here"
+    reason: existsSync16(join19(cwd, "package.json")) ? 'no directly loadable entry was found \u2014 declare one as a "start" script of the form `node <file>`, or run the check against a built output' : "there is no package.json here"
   };
 }
 
 // src/protect/install/runtime/probe.ts
 import { spawn } from "child_process";
-import { createHash as createHash3, randomBytes } from "crypto";
-import { existsSync as existsSync14 } from "fs";
+import { createHash as createHash4, randomBytes } from "crypto";
+import { existsSync as existsSync17 } from "fs";
 import { request as httpRequest } from "http";
 import { request as httpsRequest, Agent as HttpsAgent } from "https";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -7036,7 +7516,7 @@ var ANSWER_LIMIT = 8192;
 var LOOPBACK = ["127.0.0.1", "::1"];
 var ENDING_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
 function expectedAnswerFor(challenge) {
-  return createHash3("sha256").update(`patchstack-verify:${challenge}`).digest("hex");
+  return createHash4("sha256").update(`patchstack-verify:${challenge}`).digest("hex");
 }
 function preloadPath() {
   const candidates = [
@@ -7047,7 +7527,7 @@ function preloadPath() {
   ];
   for (const candidate of candidates) {
     const path17 = fileURLToPath2(candidate);
-    if (existsSync14(path17)) return path17;
+    if (existsSync17(path17)) return path17;
   }
   return null;
 }
@@ -7397,12 +7877,12 @@ function formatRuntimeCheck(report) {
 import path14 from "path";
 
 // src/map/ts-loader.ts
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire5 } from "module";
 import { pathToFileURL } from "url";
-import { join as join16 } from "path";
+import { join as join20 } from "path";
 async function loadTypeScript(cwd) {
   try {
-    const req = createRequire2(pathToFileURL(join16(cwd, "package.json")));
+    const req = createRequire5(pathToFileURL(join20(cwd, "package.json")));
     const resolved = req.resolve("typescript");
     const mod = await import(pathToFileURL(resolved).href);
     return mod.default ?? mod;
@@ -7418,7 +7898,7 @@ async function loadTypeScript(cwd) {
 
 // src/map/extract.ts
 import { readFileSync as readFileSync16, realpathSync as realpathSync6 } from "fs";
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { relative as relative7 } from "path";
 
 // src/map/bindings.ts
@@ -7548,7 +8028,7 @@ function npmPackageOf(spec) {
 }
 
 // src/map/sinks.ts
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash5 } from "crypto";
 
 // src/map/capabilities.ts
 var PACKAGE_SINK_MODELS = [
@@ -7947,7 +8427,7 @@ function argumentRoleOf(sinkKind, method, index, total = 0) {
   return table?.[index] ?? "unknown";
 }
 function sinkId(s, owner) {
-  return createHash4("sha256").update([s.kind, s.provider, s.package, s.table, s.op, s.file ?? owner, s.start, s.end].join("|")).digest("hex").slice(0, 12);
+  return createHash5("sha256").update([s.kind, s.provider, s.package, s.table, s.op, s.file ?? owner, s.start, s.end].join("|")).digest("hex").slice(0, 12);
 }
 function dedupeSinks(sinks, owner) {
   const seen = /* @__PURE__ */ new Set();
@@ -8969,11 +9449,11 @@ function capEndpoint(e, limits) {
     drop((f) => kept.has(byIndex.get(f)));
   }
   const ranked = [...flows].sort((a, b) => keepPriority(b) - keepPriority(a));
-  const pick = (items, limit, idOf) => {
+  const pick = (items, limit, idOf2) => {
     if (items.length <= limit) return { kept: items, omitted: 0 };
     const wanted = /* @__PURE__ */ new Set();
     for (const f of ranked) {
-      const id = idOf(f);
+      const id = idOf2(f);
       if (id !== void 0 && wanted.size < limit) wanted.add(id);
     }
     const chosen = new Set(items.filter((it) => it.id !== void 0 && wanted.has(it.id)));
@@ -9073,7 +9553,7 @@ function withNote(doc) {
 
 // src/map/module-graph.ts
 import { readFileSync as readFileSync14, realpathSync as realpathSync5, statSync as statSync7 } from "fs";
-import { dirname as dirname9, join as join17, relative as relative6, resolve as resolvePath } from "path";
+import { dirname as dirname9, join as join21, relative as relative6, resolve as resolvePath } from "path";
 var RESOLVE_EXTS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
 function createModuleGraph(ts, opts) {
   const cache = /* @__PURE__ */ new Map();
@@ -9151,7 +9631,7 @@ function resolveRelativeModule(fromFile, spec) {
   }
   candidates.push(base);
   for (const e of RESOLVE_EXTS) candidates.push(base + e);
-  for (const e of RESOLVE_EXTS) candidates.push(join17(base, "index" + e));
+  for (const e of RESOLVE_EXTS) candidates.push(join21(base, "index" + e));
   for (const c of candidates) {
     try {
       if (statSync7(c).isFile()) return c;
@@ -9441,7 +9921,7 @@ function handlerEntry(name, kindLabel, params, body, ts, localSinks, bindings, c
 
 // src/map/imports.ts
 import { readFileSync as readFileSync15 } from "fs";
-import { join as join18 } from "path";
+import { join as join23 } from "path";
 var MAX_SITES2 = 5;
 var NPM_NAME = /^(?:@[^/@\s~][^/@\s]*\/)?[^/@\s.~][^/@\s]*$/;
 function isNpmPackageName(pkg) {
@@ -9452,7 +9932,7 @@ function readPathAliases(cwd) {
   for (const name of ["tsconfig.json", "jsconfig.json"]) {
     let paths2;
     try {
-      const raw = readFileSync15(join18(cwd, name), "utf8");
+      const raw = readFileSync15(join23(cwd, name), "utf8");
       const parsed = JSON.parse(stripJsonComments(raw));
       paths2 = parsed.compilerOptions?.paths;
     } catch {
@@ -9719,7 +10199,7 @@ async function extractInputMap(cwd, ts, options = {}) {
   let sourceBytes = 0;
   const calls = { total: 0, dependency: 0, local: 0, ambiguous: 0 };
   const startedAt = Date.now();
-  const entryFiles = /* @__PURE__ */ new Set();
+  const entryFiles2 = /* @__PURE__ */ new Set();
   const hopTargets = /* @__PURE__ */ new Set();
   for (const file of files) {
     try {
@@ -9745,8 +10225,8 @@ async function extractInputMap(cwd, ts, options = {}) {
         continue;
       }
       parsed++;
-      entryFiles.add(file);
-      const fingerprint = createHash5("sha256").update(text).digest("hex").slice(0, 16);
+      entryFiles2.add(file);
+      const fingerprint = createHash6("sha256").update(text).digest("hex").slice(0, 16);
       const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, guessScriptKind(ts, file));
       const bindings = buildModuleBindings(sf, ts);
       for (const specifier of bindings.imports) {
@@ -9799,7 +10279,7 @@ async function extractInputMap(cwd, ts, options = {}) {
   let hopParsed = 0;
   let hopFailures = 0;
   for (const target of hopTargets) {
-    if (entryFiles.has(target)) continue;
+    if (entryFiles2.has(target)) continue;
     try {
       const text = readFileSync16(target, "utf8");
       const sf = ts.createSourceFile(target, text, ts.ScriptTarget.Latest, true, guessScriptKind(ts, target));
@@ -9965,7 +10445,7 @@ function getStringFlag(flags, name) {
 
 // src/build-stamp.ts
 import { lstatSync as lstatSync5, readFileSync as readFileSync17, readdirSync as readdirSync7, realpathSync as realpathSync7 } from "fs";
-import { join as join19, relative as relative8, sep as sep3 } from "path";
+import { join as join24, relative as relative8, sep as sep3 } from "path";
 var RULES_FILE_NAMES = /* @__PURE__ */ new Set(["rules.json", "patchstack.rules.json"]);
 var SKIP_DIRECTORIES = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage", "tmp", "vendor"]);
 var MAX_DEPTH2 = 6;
@@ -9983,7 +10463,7 @@ function guardImportsRulesFile(dir, rulesName) {
   }
   for (const name of siblings) {
     if (!GUARD_SOURCE.test(name)) continue;
-    const path17 = join19(dir, name);
+    const path17 = join24(dir, name);
     try {
       const entry = lstatSync5(path17);
       if (!entry.isFile() || entry.isSymbolicLink() || entry.size > MAX_GUARD_SOURCE_BYTES) continue;
@@ -10026,7 +10506,7 @@ function findRulesFile(cwd) {
     }
     for (const name of entries) {
       if (name.startsWith(".")) continue;
-      const path17 = join19(dir, name);
+      const path17 = join24(dir, name);
       let entry;
       try {
         entry = lstatSync5(path17);
@@ -10104,6 +10584,8 @@ function applyBuildStamp(cwd, id) {
 }
 
 // src/build-hook.ts
+import { readFileSync as readFileSync18 } from "fs";
+import { join as join25 } from "path";
 var INSTALL_AND_BUILD_EVENTS = /* @__PURE__ */ new Set([
   "preinstall",
   "install",
@@ -10117,11 +10599,16 @@ function isInstallOrBuildHook(env = process.env) {
   const event = env.npm_lifecycle_event;
   return typeof event === "string" && INSTALL_AND_BUILD_EVENTS.has(event);
 }
-function isPreBundleBuildHook(env = process.env) {
+function isPreBundleBuildHook(env = process.env, cwd = process.cwd()) {
   const event = env.npm_lifecycle_event;
   if (event === "prebuild") return true;
   if (event !== "build") return false;
-  return /^\s*patchstack-connect\s+scan(?:\s*(?:&&|;)|\s*$)/.test(env.npm_lifecycle_script ?? "");
+  try {
+    const pkg = JSON.parse(readFileSync18(join25(cwd, "package.json"), "utf8"));
+    return typeof pkg.scripts?.build === "string" && /^\s*patchstack-connect\s+scan(?:\s*(?:&&|;)|\s*$)/.test(pkg.scripts.build);
+  } catch {
+    return false;
+  }
 }
 function undeliveredReportLines(err, config, cwd) {
   const lines = [`patchstack: could not send the package list to Patchstack \u2014 ${err.message}`];
@@ -10145,7 +10632,7 @@ function undeliveredReportLines(err, config, cwd) {
 }
 
 // src/input-map-id.ts
-import { createHash as createHash6 } from "crypto";
+import { createHash as createHash7 } from "crypto";
 var NonCanonicalInputMap = class extends Error {
 };
 function canonicalString(value) {
@@ -10189,27 +10676,32 @@ function inputMapBuildId(map) {
       material = { ...mapDocument, coverage: stableCoverage };
     } else material = mapDocument;
   }
-  return createHash6("sha256").update("patchstack-input-map-v1\0", "utf8").update(canonicalText(material), "utf8").digest("hex");
+  return createHash7("sha256").update("patchstack-input-map-v1\0", "utf8").update(canonicalText(material), "utf8").digest("hex");
 }
 
 // src/map-command.ts
 async function runMap(flags) {
+  return (await runMapDetailed(flags)).code;
+}
+async function runMapDetailed(flags, options = {}) {
+  const log2 = options.log ?? console.error;
   const cwd = getStringFlag(flags, "dir") ?? process.cwd();
+  if (options.setup) applyBuildStamp(cwd, null);
   const { map, error } = await buildInputMap(cwd, {
     followSymlinks: flags.get("follow-symlinks") === true
   });
   if (!map) {
-    console.error(`patchstack: ${error}`);
-    return 1;
+    log2(`patchstack: ${error}`);
+    return { code: isPreBundleBuildHook() ? 0 : 1, error: error ?? "could not analyse the project" };
   }
   const inputs = map.endpoints.reduce((n, e) => n + e.inputs.length, 0);
   const sinks = map.endpoints.reduce((n, e) => n + e.sinks.length, 0);
   const proven = map.endpoints.reduce((n, e) => n + e.flows.filter((f) => isProvenFlow(f.confidence)).length, 0);
   const c = map.coverage;
-  console.error(
+  log2(
     `patchstack: ${map.endpoints.length} entry point(s), ${inputs} input(s), ${sinks} sink(s), ${proven} proven input\u2192sink flow(s) [${map.framework}].`
   );
-  console.error(
+  log2(
     // All three buckets, explicitly: "6/66 parsed" reads as "91% unanalysed" when the other 60 files
     // simply contain no server entry point (most of a project is client code). Only `skipped` is a
     // failure to analyse.
@@ -10222,14 +10714,14 @@ async function runMap(flags) {
     const ambiguous = c2.callsAmbiguous ?? 0;
     const denominator = dependency + ambiguous;
     const quality = denominator > 0 ? Math.round(100 * dependency / denominator) : 100;
-    console.error(
+    log2(
       `patchstack: ${invoked.length} dependency API call(s) resolved across ${new Set(invoked.map((i) => i.package)).size} package(s) from ${c2.callsTotal ?? 0} call site(s) \u2014 ${quality}% of dependency-candidate receivers resolved (${c2.callsLocal ?? 0} local, ${ambiguous} ambiguous). Positive evidence only: absence here never means an API is not called.`
     );
   }
   const imported = map.imports ?? [];
   if (imported.length > 0) {
     const unmodelled = imported.filter((d) => d.recognizedSinkKinds.length === 0).length;
-    console.error(
+    log2(
       `patchstack: ${imported.length} package(s) imported \u2014 ${unmodelled} with no recognized sink family, so a vulnerability in those cannot be judged reachable or unreachable from this map.`
     );
   }
@@ -10237,62 +10729,64 @@ async function runMap(flags) {
   const out = getStringFlag(flags, "out");
   if (out) {
     atomicWriteFileSync(path14.resolve(out), json, { encoding: "utf8" });
-    console.error(`patchstack: wrote ${out}`);
+    log2(`patchstack: wrote ${out}`);
   } else if (flags.get("upload") !== true) {
     console.log(json);
   }
   if (flags.get("upload") === true) {
     const problems = ingestProblems(map);
     if (problems.length > 0) {
-      console.error(`patchstack: did not upload the attack surface \u2014 it cannot be fitted to the size Patchstack accepts (${problems.join("; ")}).`);
-      return 0;
+      log2(`patchstack: did not upload the attack surface \u2014 it cannot be fitted to the size Patchstack accepts (${problems.join("; ")}).`);
+      return { code: 0, endpoints: map.endpoints.length, error: problems.join("; ") };
     }
     if (map.endpoints.length === 0) {
-      console.error(
+      log2(
         "patchstack: no server entry points were recognized \u2014 uploading the import inventory and coverage notes anyway, so a vulnerability can still be judged imported or not. Nothing here can decide whether a request reaches it."
       );
     }
-    const config = await resolveConfig({
+    const config = options.config ?? await resolveConfig({
       cwd,
       cliSiteUuid: getStringFlag(flags, "site-uuid"),
       cliEndpoint: getStringFlag(flags, "endpoint")
     });
     let buildId = null;
-    if (isPreBundleBuildHook()) {
+    if (options.setup || isPreBundleBuildHook()) {
       const candidate = inputMapBuildId(map);
       const stamp = applyBuildStamp(cwd, candidate);
       if (stamp.kind === "stamped" || stamp.kind === "unchanged") {
         buildId = candidate;
-        console.error(`patchstack: bound this map to ${stamp.file} (${candidate.slice(0, 12)}).`);
+        log2(`patchstack: bound this map to ${stamp.file} (${candidate.slice(0, 12)}).`);
       } else {
         const reason = stamp.kind === "skipped" ? stamp.reason : "the rules file did not retain the map identity";
-        console.error(
+        log2(
           `patchstack: could not bind this map to the runtime guard \u2014 ${reason}. Rules generated from these coordinates will detect only, not block.`
         );
       }
     } else {
-      console.error(
+      log2(
         "patchstack: no runtime binding recorded \u2014 run `map --upload` in a prebuild hook before the bundler, so rules generated from these coordinates can be tied to the runtime guard. Until then they detect only, not block."
       );
     }
     const outcome = await postInputMap(config, map, buildId);
     if (outcome.result === "stored") {
-      console.error(`patchstack: uploaded the attack surface (revision ${outcome.revision}).`);
+      log2(`patchstack: uploaded the attack surface (revision ${outcome.revision}).`);
     } else if (outcome.result === "unchanged") {
-      console.error(`patchstack: attack surface unchanged since revision ${outcome.revision} \u2014 nothing to store.`);
+      log2(`patchstack: attack surface unchanged since revision ${outcome.revision} \u2014 nothing to store.`);
     } else if (outcome.result === "skipped") {
-      console.error(`patchstack: did not upload the attack surface \u2014 ${outcome.message}`);
+      log2(`patchstack: did not upload the attack surface \u2014 ${outcome.message}`);
     } else {
-      console.error(`patchstack: could not upload the attack surface \u2014 ${outcome.message}`);
+      log2(`patchstack: could not upload the attack surface \u2014 ${outcome.message}`);
     }
+    return { code: 0, endpoints: map.endpoints.length, buildId, upload: outcome };
   }
-  return 0;
+  return { code: 0, endpoints: map.endpoints.length };
 }
 
 // src/setup.ts
-import { readFileSync as readFileSync18 } from "fs";
+import { readFileSync as readFileSync19 } from "fs";
 import path15 from "path";
 var SCAN_COMMAND = "patchstack-connect scan";
+var MAP_COMMAND = "patchstack-connect map --upload";
 var MARK_BUILD_COMMAND = "patchstack-connect mark-build";
 function setupProtection(cwd) {
   const { result: install, lines: log2 } = collectProtectLog(() => runProtect(cwd));
@@ -10312,12 +10806,65 @@ function prependHook(existing, command) {
   if (existing === void 0 || existing.trim().length === 0) return command;
   const escaped = command.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   if (new RegExp(`^\\s*${escaped}\\s*(?:;|\\|\\|)`).test(existing)) return existing;
-  const remaining = existing.split(/\s*&&\s*/).filter((part) => part.trim() !== command && part.trim().length > 0);
+  const remaining = splitAndChain(existing).filter((part) => part.trim() !== command && part.trim().length > 0);
   return [command, ...remaining].join(" && ");
 }
+function splitAndChain(source) {
+  const parts = [];
+  let start = 0;
+  let quote = "";
+  const groups = [];
+  for (let i = 0; i < source.length; i++) {
+    const char = source[i];
+    if (char === "\\" && quote !== "'") {
+      i++;
+      continue;
+    }
+    if (quote === "'" || quote === "`") {
+      if (char === quote) quote = quote === "`" ? groups.pop().quote : "";
+      continue;
+    }
+    if (char === "`") {
+      groups.push({ close: "`", quote });
+      quote = "`";
+      continue;
+    }
+    if (char === "$" && (source[i + 1] === "(" || source[i + 1] === "{")) {
+      groups.push({ close: source[++i] === "(" ? ")" : "}", quote });
+      quote = "";
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = "";
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (char === "#" && (i === 0 || /\s/.test(source[i - 1]))) {
+      const newline = source.indexOf("\n", i);
+      if (newline === -1) break;
+      i = newline;
+      continue;
+    }
+    if (char === "(" || char === "{") groups.push({ close: char === "(" ? ")" : "}", quote: "" });
+    if (char === groups.at(-1)?.close) quote = groups.pop().quote;
+    if (groups.length === 0 && char === "&" && source[i + 1] === "&") {
+      parts.push(source.slice(start, i).trim());
+      start = ++i + 1;
+    }
+  }
+  parts.push(source.slice(start).trim());
+  return parts;
+}
+function finishWithMap(existing) {
+  if (/(?:^|&&|;)\s*patchstack-connect map --upload\s*$/.test(existing)) return existing;
+  return `${existing} && ${MAP_COMMAND}`;
+}
 function wireBuildScripts(cwd, packageManager) {
   const target = path15.join(cwd, "package.json");
-  const raw = readFileSync18(target, "utf8");
+  const raw = readFileSync19(target, "utf8");
   const pkg = JSON.parse(raw);
   const scripts = pkg.scripts ?? {};
   const build = scripts.build;
@@ -10331,8 +10878,11 @@ function wireBuildScripts(cwd, packageManager) {
       };
     }
     scripts.postinstall = postinstall;
-  } else if (packageManager === "bun") {
+  } else if (packageManager !== "npm") {
     let nextBuild = prependHook(build, SCAN_COMMAND);
+    if (!/^\s*patchstack-connect scan\s*&&\s*patchstack-connect map --upload(?:\s*(?:&&|;)|\s*$)/.test(nextBuild)) {
+      nextBuild = nextBuild.replace(SCAN_COMMAND, `${SCAN_COMMAND} && ${MAP_COMMAND}`);
+    }
     if (!nextBuild.includes(MARK_BUILD_COMMAND)) {
       nextBuild = `${nextBuild} && ${MARK_BUILD_COMMAND}`;
     }
@@ -10346,7 +10896,7 @@ function wireBuildScripts(cwd, packageManager) {
     scripts.postinstall = postinstall;
     scripts.build = nextBuild;
   } else {
-    const prebuild = prependHook(scripts.prebuild, SCAN_COMMAND);
+    const prebuild = finishWithMap(prependHook(scripts.prebuild, SCAN_COMMAND));
     const postbuild = appendHook(scripts.postbuild, MARK_BUILD_COMMAND);
     if (prebuild === scripts.prebuild && postbuild === scripts.postbuild && postinstall === scripts.postinstall) {
       return {
@@ -10371,95 +10921,1889 @@ function wireBuildScripts(cwd, packageManager) {
       detail: "added a dependency-install scan; package.json has no build script."
     };
   }
-  return packageManager === "bun" ? {
+  return packageManager !== "npm" ? {
     changed: true,
     strategy: "build-chain",
-    detail: "added a dependency-install scan and chained scan/mark-build around the build."
+    detail: "added a dependency-install scan and chained scan/map-upload/mark-build around the build."
   } : {
     changed: true,
     strategy: "lifecycle-hooks",
-    detail: "added scans to postinstall/prebuild and mark-build to postbuild."
+    detail: "added scans to postinstall/prebuild, map upload before bundling, and mark-build to postbuild."
   };
 }
 
-// src/cli.ts
-var HELP = `@patchstack/connect \u2014 scan your lockfile and report packages to Patchstack.
+// src/setup-sync.ts
+import { join as join26 } from "path";
 
-Usage:
-  patchstack-connect scan   [options]                Scan lockfile and POST to Patchstack.
-                                                     If no UUID is configured, the server
-                                                     provisions one and we persist it. After a
-                                                     successful post it also adds/updates the
-                                                     Patchstack Connector <script> tag in the root
-                                                     HTML shell (index.html, public/index.html,
-                                                     or src/app.html) \u2014 opt out with
-                                                     "widget": false in .patchstackrc.json.
-                                                     Run as a postinstall/prebuild/build hook, a
-                                                     report Patchstack cannot accept is printed
-                                                     and exits 0 so the build goes on; run
-                                                     directly, the same failure exits 1
-  patchstack-connect setup  [options]                Finish the bounded project setup: run scan,
-                                                     manage the widget, install + verify runtime
-                                                     protection, and wire dependency/build scans.
-                                                     Never runs the project build
-  patchstack-connect map    [--dir <p>] [--out <f>] [--upload]
-                                                     Map the app's attack surface: entry points, the
-                                                     inputs each reads, the sinks it can reach, and
-                                                     evidence-backed input\u2192sink flows (each labelled
-                                                     with how the link was established). Best-effort static
-                                                     analysis \u2014 reports the DETECTED surface, with
-                                                     coverage counters. Prints JSON (--out writes a
-                                                     file; a pre-bundle --upload also stamps the existing
-                                                     guard rules file; --follow-symlinks leaves the project dir).
-                                                     Uses the app's own TypeScript
-  patchstack-connect init   <site-uuid>              Optional: pre-seed .patchstackrc.json
-                                                     with an existing site UUID
-  patchstack-connect status [options]                Show current configuration and whether the
-                                                     site still exists on Patchstack (active /
-                                                     removed)
-  patchstack-connect uninstall [options]             Signal Patchstack that this package is being
-                                                     removed from the project. An unclaimed site
-                                                     record is deleted; a claimed site is flagged
-                                                     for its owner to remove in the dashboard.
-                                                     Does NOT touch local files \u2014 see the
-                                                     "Uninstalling" steps in AGENT-INSTALL.md
-  patchstack-connect mark-build [options]            Stamp built HTML with a production flag +
-                                                     build fingerprint, and ensure the widget
-                                                     tag in built pages (run as a postbuild step).
-                                                     The flag marks a page as the LIVE site, so it
-                                                     is stamped only on a production build; a local
-                                                     or preview build gets the widget tag and no
-                                                     marker (and any stale marker is removed).
-                                                     Looks in the framework's own output dir, an
-                                                     --output the build script names, then dist/,
-                                                     build/, out/, .output/public/, _site/ \u2014 inside
-                                                     the project only. --dir <path> overrides.
-  patchstack-connect protect [--demo|--check]        Install always-on runtime protection (the
-                                                     guard). Auto-wires supported server stacks;
-                                                     for others it scaffolds a
-                                                     generic guard + prints a wiring plan.
-                                                     --demo seeds a broad sample rule set (for
-                                                     demonstrations, not production).
-                                                     --check verifies the guard is wired (exit 1
-                                                     if not) \u2014 for the wire-then-verify loop.
-                                                     It reads the app's source and never runs it.
-                                                     --check --runtime additionally STARTS THE APP
-                                                     on a loopback port and sends it one request,
-                                                     to establish that a request reaches the
-                                                     guard. Opt-in, and the only mode that runs
-                                                     the app. Exit 0 traversed, 1 a listener
-                                                     answered instead of the guard, 2 could not
-                                                     be established (e.g. a TypeScript or
-                                                     framework entry this must not start).
-  patchstack-connect demo node-serialize [--url URL] Run the production-backed node-serialize
-                                                     walkthrough: verify the vulnerable package,
-                                                     scan it, wait for live rule 18843, install +
-                                                     verify the guard, and print test requests.
-                                                     Does not install vulnerable dependencies.
-  patchstack-connect demo-guide node-serialize       Show a read-only, state-aware walkthrough for
-                                                     preparing, running, proving, and cleaning up
-                                                     the production-backed local demo.
-  patchstack-connect guide [--full]                  Show this project's setup status (what's done,
+// src/protect/rules/contract.js
+var SOURCES = Object.freeze({
+  raw: Object.freeze({ keyed: false }),
+  all: Object.freeze({ keyed: false }),
+  false: Object.freeze({ keyed: false }),
+  rules: Object.freeze({ keyed: false, group: true }),
+  get: Object.freeze({ keyed: true, keys: "any", wildcard: true }),
+  post: Object.freeze({ keyed: true, keys: "any", wildcard: true }),
+  request: Object.freeze({ keyed: true, keys: "any", wildcard: true }),
+  cookie: Object.freeze({ keyed: true, keys: "any", wildcard: true }),
+  // A bare `files.<name>` resolves to the filename; an optional trailing attribute selects another part
+  // of the upload. Optional, not required — filename-scoped rules use the bare form.
+  files: Object.freeze({
+    keyed: true,
+    keys: "any",
+    wildcard: true,
+    optional_key_suffixes: Object.freeze(["content", "filename", "type"])
+  }),
+  server: Object.freeze({
+    keyed: true,
+    keys: Object.freeze([
+      "REQUEST_URI",
+      "REQUEST_METHOD",
+      "HTTP_USER_AGENT",
+      "HTTP_REFERER",
+      "HTTP_HOST",
+      "REMOTE_ADDR",
+      "ip",
+      "CONTENT_TYPE",
+      "CONTENT_LENGTH"
+    ]),
+    key_prefixes: Object.freeze(["HTTP_"])
+  }),
+  response: Object.freeze({
+    keyed: true,
+    keys: Object.freeze(["status", "body", "headers"]),
+    key_prefixes: Object.freeze(["header."])
+  }),
+  egress: Object.freeze({ keyed: true, keys: Object.freeze(["url", "host", "method"]) })
+});
+var MATCH_TYPES = Object.freeze([
+  "array_in_array",
+  "array_key_value",
+  "contains",
+  "cors_reflected",
+  "cross_origin",
+  "ctype_alnum",
+  "ctype_digit",
+  "ctype_special",
+  "equals",
+  "equals_strict",
+  "hostname",
+  "in_array",
+  "inline_js_xss",
+  "inline_xss",
+  "internal_host",
+  "is_numeric",
+  "isset",
+  "jwt_claim_equals",
+  "less_than",
+  "more_than",
+  "not_contains",
+  "not_in_array",
+  "off_origin",
+  "quotes",
+  "regex",
+  "stripos"
+]);
+var PARAMETERLESS_MATCH_TYPES = Object.freeze(["cross_origin", "off_origin", "cors_reflected"]);
+var OPERANDLESS_MATCH_TYPES = Object.freeze([
+  "isset",
+  "quotes",
+  "is_numeric",
+  "ctype_alnum",
+  "ctype_digit",
+  "ctype_special",
+  "inline_xss",
+  "inline_js_xss",
+  "internal_host",
+  "cross_origin",
+  "off_origin",
+  "cors_reflected"
+]);
+var OPERAND_SHAPES = Object.freeze([
+  "positive-number",
+  "boolean",
+  "non-empty-string",
+  "regex-literal",
+  "string-or-string-list",
+  "scalar",
+  "string",
+  "numeric",
+  "scalar-or-non-empty-list",
+  "non-empty-list",
+  "object",
+  "non-empty-object",
+  "non-empty-string-list",
+  "header-name-map",
+  "header-name-list",
+  "cookie-flags"
+]);
+var COOKIE_FLAGS = Object.freeze(["httpOnly", "secure", "sameSite"]);
+var SAME_SITE_VALUES = Object.freeze(["Strict", "Lax", "None"]);
+var HEADER_NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var REGEX_LITERAL = /^\/(.+?)\/([gimsuy]*)$/s;
+var MATCH_OPERANDS = Object.freeze({
+  array_key_value: Object.freeze({
+    required: Object.freeze(["key", "match"]),
+    shapes: Object.freeze({ key: "string-or-string-list", match: "object" })
+  }),
+  // Decides on a JWT's DECODED payload rather than its shape, and yields the matching token spans so
+  // `redact` masks only those tokens. `claim` names an own, top-level claim; `value` is compared with
+  // exact string equality. Anything not positively identified — undecodable, not JSON, not an object,
+  // oversized, claim missing, claim not a string, or a different value — is a no-match.
+  jwt_claim_equals: Object.freeze({
+    required: Object.freeze(["claim", "value"]),
+    shapes: Object.freeze({ claim: "non-empty-string", value: "non-empty-string" })
+  }),
+  regex: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "regex-literal" }) }),
+  contains: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "non-empty-string" }) }),
+  stripos: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "non-empty-string" }) }),
+  not_contains: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "non-empty-string" }) }),
+  // A hostname is compared to `new URL(value).hostname`, so an empty one only ever equals the empty
+  // hostname of an opaque-scheme URL (`file:`, `mailto:`, `data:`) — never a host, and a false positive
+  // on those. The other three are the list-membership family: an empty list makes `in_array` and
+  // `array_in_array` inert and `not_in_array` true for every value.
+  hostname: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "non-empty-string" }) }),
+  in_array: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "scalar-or-non-empty-list" }) }),
+  not_in_array: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "scalar-or-non-empty-list" }) }),
+  array_in_array: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "non-empty-list" }) }),
+  // The comparison family. `equals` coerces, so any scalar can match. `equals_strict` does not, and its
+  // subject is always a string by the time it is compared — so a number operand is unconditionally
+  // inert, which is the trap the engine's own note about `'1' !== 1` describes.
+  equals: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "scalar" }) }),
+  equals_strict: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "string" }) }),
+  less_than: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "numeric" }) }),
+  more_than: Object.freeze({ required: Object.freeze(["value"]), shapes: Object.freeze({ value: "numeric" }) })
+});
+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";
+    case "boolean":
+      return typeof value === "boolean" ? null : "must be true or false";
+    case "non-empty-string":
+      return isFilledString(value) ? null : "must be a non-empty string";
+    case "regex-literal":
+      if (!isFilledString(value)) return "must be a non-empty string";
+      return REGEX_LITERAL.test(value) ? null : "must be a delimited pattern, as in /pattern/i";
+    case "string-or-string-list":
+      if (isFilledString(value)) return null;
+      if (Array.isArray(value) && value.length > 0 && value.every(isFilledString)) return null;
+      return "must be a non-empty string, or a non-empty list of them";
+    case "scalar":
+      return isScalar(value) ? null : "must be a string, number or boolean";
+    case "string":
+      return typeof value === "string" ? null : "must be a string (this comparison is type-strict)";
+    case "numeric":
+      return isScalar(value) && Number.isFinite(Number(value)) ? null : "must be a number";
+    case "scalar-or-non-empty-list":
+      if (isScalar(value)) return null;
+      if (Array.isArray(value) && value.length > 0 && value.every(isScalar)) return null;
+      return "must be a scalar, or a non-empty list of them";
+    case "non-empty-list":
+      return Array.isArray(value) && value.length > 0 && value.every(isScalar) ? null : "must be a non-empty list of scalars";
+    case "header-name-map": {
+      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));
+      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";
+      const bad = value.find((name) => !isHeaderName(name));
+      return bad === void 0 ? null : `names an invalid HTTP header, ${JSON.stringify(bad)}`;
+    }
+    case "cookie-flags": {
+      if (value === null || typeof value !== "object" || Array.isArray(value)) return "must be an object";
+      const unknown = Object.keys(value).filter((key) => !COOKIE_FLAGS.includes(key));
+      if (unknown.length > 0) return `has no flag named ${unknown.map((k) => JSON.stringify(k)).join(", ")}`;
+      for (const flag of ["httpOnly", "secure"]) {
+        if (value[flag] !== void 0 && typeof value[flag] !== "boolean") {
+          return `flag "${flag}" must be true or false`;
+        }
+      }
+      const sameSite = value.sameSite;
+      const sameSiteOff = sameSite === false;
+      if (sameSite !== void 0 && !sameSiteOff) {
+        if (typeof sameSite !== "string" || !SAME_SITE_VALUES.some((v) => v.toLowerCase() === sameSite.toLowerCase())) {
+          return `flag "sameSite" must be false, or one of ${SAME_SITE_VALUES.join(", ")}`;
+        }
+      }
+      if (value.httpOnly === false && value.secure === false && sameSiteOff) {
+        return "turns off every flag, so it would harden nothing";
+      }
+      return null;
+    }
+    case "object":
+      return value !== null && typeof value === "object" && !Array.isArray(value) ? null : "must be an object";
+    case "non-empty-object":
+      return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0 ? null : "must be an object with at least one entry";
+    case "non-empty-string-list":
+      return Array.isArray(value) && value.length > 0 && value.every(isFilledString) ? null : "must be a non-empty list of non-empty strings";
+    default:
+      return null;
+  }
+}
+var MUTATIONS = Object.freeze([
+  "base64_decode",
+  "getArrayValues",
+  "htmlentitydecode",
+  "intval",
+  "json_decode",
+  "json_encode",
+  "urldecode"
+]);
+var PHASES = Object.freeze(["request", "response", "egress"]);
+var ACTIONS = Object.freeze([
+  "block",
+  "redact",
+  "encode",
+  "set-header",
+  "remove-header",
+  "harden-cookie"
+]);
+var RULE_PROPERTY_SHAPES = Object.freeze({
+  max_bytes: "positive-number",
+  bypass_limit: "boolean",
+  ensure: "boolean",
+  prefilter: "non-empty-string-list"
+});
+var ENFORCEMENT_VALUES = Object.freeze(["dry-run"]);
+var WHEN_KEYS = Object.freeze(["path", "method"]);
+var BUILD_SCOPE_PROPERTY = "build_scope";
+var BUILD_SCOPE = Object.freeze({
+  applies_to: Object.freeze(["firewall"]),
+  usable: Object.freeze({
+    type: "string",
+    trim: true,
+    pattern: "^[0-9a-fA-F]{64}$",
+    canonical: "lowercase"
+  }),
+  unreadable: "the rule remains accepted and detects only by default",
+  local_override: "trustLocalRuleScope may explicitly enforce a caller-supplied rule"
+});
+var RULE_PROPERTIES = Object.freeze([
+  "id",
+  "rule_id",
+  "title",
+  "category",
+  "phase",
+  "action",
+  "rule_v2",
+  "when",
+  "message",
+  "enforcement",
+  "source_revision",
+  "prefilter",
+  "max_bytes",
+  "bypass_limit",
+  "set_headers",
+  "remove_headers",
+  "cookie_flags",
+  "ensure",
+  "capture",
+  BUILD_SCOPE_PROPERTY
+]);
+var CAPTURE_KEYS = Object.freeze(["version", "raw_chars"]);
+var NULL_EXEMPT_PROPERTIES = Object.freeze(["capture", BUILD_SCOPE_PROPERTY]);
+var ACTION_PROPERTIES = Object.freeze({
+  block: Object.freeze({ required: Object.freeze([]), defaulted: Object.freeze([]), phases: Object.freeze(["request", "response", "egress"]) }),
+  redact: Object.freeze({ required: Object.freeze([]), defaulted: Object.freeze([]), phases: Object.freeze(["response"]) }),
+  encode: Object.freeze({ required: Object.freeze([]), defaulted: Object.freeze([]), phases: Object.freeze(["response"]) }),
+  "set-header": Object.freeze({
+    required: Object.freeze(["set_headers"]),
+    defaulted: Object.freeze(["ensure"]),
+    phases: Object.freeze(["response"]),
+    shapes: Object.freeze({ set_headers: "header-name-map" })
+  }),
+  "remove-header": Object.freeze({
+    required: Object.freeze(["remove_headers"]),
+    defaulted: Object.freeze([]),
+    phases: Object.freeze(["response"]),
+    shapes: Object.freeze({ remove_headers: "header-name-list" })
+  }),
+  "harden-cookie": Object.freeze({
+    required: Object.freeze([]),
+    defaulted: Object.freeze(["cookie_flags"]),
+    phases: Object.freeze(["response"]),
+    shapes: Object.freeze({ cookie_flags: "cookie-flags" })
+  })
+});
+var LIMITS = Object.freeze({
+  maxRules: 5e3,
+  maxWhitelists: 2e3,
+  maxConditionsPerRule: 250,
+  maxConditionNodesPerRule: 1e3,
+  maxConditionNodesPerBundle: 25e3,
+  maxNestingDepth: 12,
+  maxRegexLength: 1e3,
+  maxValueLength: 8192,
+  maxParameterLength: 512,
+  maxParameterItems: 64,
+  maxOperandItems: 256,
+  maxMapEntries: 128,
+  maxPathSegments: 64
+});
+var GROUP_PARAMETER = "rules";
+function isGroup(condition) {
+  return condition?.parameter === GROUP_PARAMETER && Array.isArray(condition?.rules);
+}
+function conditionShapeProblem(condition) {
+  if (!condition || typeof condition !== "object") return "condition is not an object";
+  const named = condition.parameter === GROUP_PARAMETER;
+  const nested = Array.isArray(condition.rules);
+  if (named && !nested) {
+    return `parameter "${GROUP_PARAMETER}" is a group and needs a "rules" array`;
+  }
+  if (nested && !named) {
+    return `condition carries nested rules but its parameter is ${JSON.stringify(condition.parameter)}; a group must be {"parameter":"${GROUP_PARAMETER}"}`;
+  }
+  if (condition.inclusive !== void 0 && typeof condition.inclusive !== "boolean") {
+    return "inclusive must be true or false";
+  }
+  if (named && nested) {
+    if (condition.match !== void 0) return "a group carries no match of its own; the engine ignores it";
+    if (condition.mutations !== void 0) return "a group carries no mutations of its own; the engine ignores them";
+    if (condition.rules.length === 0) return "group has no conditions (would never match)";
+  }
+  return null;
+}
+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";
+      if (member === void 0 || member === null) return "parameter list members must be non-empty strings";
+      const problem = parameterProblem(member);
+      if (problem !== null) return problem;
+    }
+    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`;
+  }
+  const dot = parameter.indexOf(".");
+  const name = dot === -1 ? parameter : parameter.slice(0, dot);
+  const source = SOURCES[name];
+  if (source === void 0) return `unknown parameter source "${name}"`;
+  if (dot === -1) {
+    return source.keyed === true ? `source "${name}" needs a key, e.g. "${name}.fieldname"` : null;
+  }
+  if (source.keyed !== true) return `source "${name}" takes no key`;
+  const key = parameter.slice(dot + 1);
+  if (key === "") return `source "${name}" needs a key after the dot`;
+  return keyProblem(name, source, key);
+}
+function keyProblem(name, source, key) {
+  if (key.endsWith("*") && source.wildcard !== true) {
+    return `"${name}" does not fan out over a wildcard key`;
+  }
+  const bare = key.endsWith("*") ? key.slice(0, -1) : key;
+  if (source.keys === "any") return null;
+  if (Array.isArray(source.keys) && source.keys.includes(bare)) return null;
+  for (const prefix of source.key_prefixes ?? []) {
+    if (bare.startsWith(prefix) && bare.length > prefix.length) return null;
+  }
+  const accepted = [
+    ...Array.isArray(source.keys) ? source.keys : [],
+    ...(source.key_prefixes ?? []).map((p) => `${p}\u2026`)
+  ].join(", ");
+  return `"${name}" has no key "${key}" (expected one of: ${accepted})`;
+}
+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`;
+  }
+  if (parameterless && parameter !== void 0 && parameter !== null) {
+    return `match type "${match.type}" reads the whole request and takes no parameter`;
+  }
+  const operands = MATCH_OPERANDS[match.type];
+  if (operands) {
+    for (const required of operands.required) {
+      if (match[required] === void 0 || match[required] === null) {
+        return `match type "${match.type}" needs "${required}"`;
+      }
+    }
+    for (const [operand, shape] of Object.entries(operands.shapes ?? {})) {
+      if (match[operand] === void 0) continue;
+      const problem = operandShapeProblem(shape, match[operand]);
+      if (problem) return `match type "${match.type}" operand "${operand}" ${problem}`;
+    }
+  } 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 paths2 = Array.isArray(match.key) ? match.key : [match.key];
+    if (paths2.some((path17) => typeof path17 === "string" && path17.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`;
+    }
+  }
+  return null;
+}
+function whenProblem(when) {
+  if (when === void 0 || when === null) return null;
+  if (typeof when !== "object" || Array.isArray(when)) return "when must be an object";
+  const keys = Object.keys(when);
+  if (keys.length === 0) return "when is empty \u2014 remove it, or name a path or method";
+  const unknown = keys.filter((key) => !WHEN_KEYS.includes(key));
+  if (unknown.length > 0) {
+    return `when names no supported key (${unknown.join(", ")}) \u2014 the engine understands ${WHEN_KEYS.join(" and ")}, and an unrecognised scope is ignored, so the rule would apply to every request`;
+  }
+  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;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function nullPropertyProblem(rule) {
+  if (!rule || typeof rule !== "object") return null;
+  for (const property of RULE_PROPERTIES) {
+    if (NULL_EXEMPT_PROPERTIES.includes(property)) continue;
+    if (property in rule && rule[property] === null) {
+      return `"${property}" is present but null; omit it to mean the default, since a null is a value that was meant to be something and is not`;
+    }
+  }
+  return null;
+}
+function rulePropertyProblem(rule) {
+  if (!rule || typeof rule !== "object") return null;
+  for (const [property, shape] of Object.entries(RULE_PROPERTY_SHAPES)) {
+    if (rule[property] === void 0 || rule[property] === null) continue;
+    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) {
+  if (action === void 0 || action === null) return null;
+  if (!ACTIONS.includes(action)) return `unknown action "${action}"`;
+  const spec = ACTION_PROPERTIES[action];
+  for (const required of spec?.required ?? []) {
+    if (rule?.[required] === void 0 || rule?.[required] === null) {
+      return `action "${action}" needs "${required}"`;
+    }
+  }
+  for (const [property, shape] of Object.entries(spec?.shapes ?? {})) {
+    if (rule?.[property] === void 0 || rule?.[property] === null) continue;
+    const problem = operandShapeProblem(shape, rule[property]);
+    if (problem) return `action "${action}" property "${property}" ${problem}`;
+  }
+  const phase = rule?.phase ?? "request";
+  if (spec !== void 0 && !spec.phases.includes(phase)) {
+    return `action "${action}" is carried out on the ${spec.phases.join("/")} phase; on "${phase}" the rule blocks instead`;
+  }
+  return null;
+}
+
+// src/protect/engine/response-json.js
+var MAX_RULE_RESPONSE_BYTES = 5 * 1024 * 1024;
+async function readBoundedJson2(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 {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        void reader.cancel().catch(() => {
+        });
+        throw new Error(`rule response exceeds ${maxBytes} bytes`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+
+// src/protect/engine/client.js
+var DEFAULT_BASE_URL = "https://api.patchstack.com";
+var DEFAULT_CACHE_TTL = 3e5;
+var JITTER_FRACTION = 0.1;
+var PatchstackRuleClient = class {
+  #token;
+  #baseUrl;
+  #cacheTtl;
+  #cache = null;
+  #cacheTime = null;
+  #ttlEffective = 0;
+  #etag;
+  #timeoutMs;
+  constructor({ token, baseUrl, cacheTtl, etag, timeoutMs } = {}) {
+    this.#timeoutMs = Number(timeoutMs) > 0 ? Number(timeoutMs) : 3e4;
+    this.#token = token ?? process.env.PATCHSTACK_WAF_TOKEN;
+    this.#baseUrl = safeBaseUrl(baseUrl ?? process.env.PATCHSTACK_WAF_API_URL, DEFAULT_BASE_URL, "rule endpoint");
+    this.#cacheTtl = Number.isFinite(cacheTtl) && cacheTtl > 0 ? cacheTtl : DEFAULT_CACHE_TTL;
+    this.#etag = etag ?? null;
+    if (!this.#token) {
+      throw new Error("Patchstack WAF token is required. Pass { token } or set PATCHSTACK_WAF_TOKEN env var.");
+    }
+  }
+  async getRules() {
+    const now = Date.now();
+    if (this.#cache && this.#cacheTime !== null && now - this.#cacheTime < this.#ttlEffective) {
+      return this.#cache;
+    }
+    const url = `${this.#baseUrl}/api/get-rules/3`;
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.#token}`,
+        "LicenseID": "1"
+        // Hard-coded, is never actually used but needed by the API
+      };
+      if (this.#etag) headers["If-None-Match"] = this.#etag;
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({}),
+        signal: AbortSignal.timeout(this.#timeoutMs)
+      });
+      if (response.status === 304) {
+        this.#touch(now);
+        return this.#cache ?? { success: true, notModified: true, etag: this.#etag, firewall: [], whitelists: [], whitelist_keys: {} };
+      }
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `API returned ${response.status}: ${response.statusText}`,
+          firewall: [],
+          whitelists: [],
+          whitelist_keys: {}
+        };
+      }
+      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: {} };
+      }
+      const result = {
+        success: true,
+        notModified: false,
+        etag: response.headers?.get?.("etag") ?? null,
+        firewall: data.firewall,
+        whitelists: Array.isArray(data.whitelists) ? data.whitelists : [],
+        whitelist_keys: data.whitelist_keys ?? {}
+      };
+      this.#cache = result;
+      this.#etag = result.etag;
+      this.#touch(now);
+      return result;
+    } catch (err) {
+      return {
+        success: false,
+        error: err.name === "TimeoutError" ? "Request timed out" : err.message,
+        firewall: [],
+        whitelists: [],
+        whitelist_keys: {}
+      };
+    }
+  }
+  #touch(now) {
+    this.#cacheTime = now;
+    this.#ttlEffective = this.#cacheTtl - Math.floor(Math.random() * this.#cacheTtl * JITTER_FRACTION);
+  }
+  clearCache() {
+    this.#cache = null;
+    this.#cacheTime = null;
+    this.#etag = null;
+  }
+};
+
+// src/protect/engine/normalizer.js
+var utf8 = new TextDecoder();
+var MAX_RAW_CHARS = 1024 * 1024;
+
+// src/protect/notify.js
+var reported = /* @__PURE__ */ new WeakMap();
+var warnings = 0;
+var MAX_WARNINGS = 20;
+function notify(fn, arg, label) {
+  if (typeof fn !== "function") return false;
+  try {
+    const result = fn(arg);
+    if (result !== null && typeof result === "object" && typeof result.then === "function") {
+      try {
+        result.then(void 0, (err) => warnOnce2(fn, label, err));
+      } catch {
+      }
+    }
+    return true;
+  } catch (err) {
+    warnOnce2(fn, label, err);
+    return false;
+  }
+}
+function warnOnce2(fn, label, err) {
+  let labels = reported.get(fn);
+  if (labels?.has(label)) return;
+  if (!labels) {
+    labels = /* @__PURE__ */ new Set();
+    reported.set(fn, labels);
+  }
+  labels.add(label);
+  if (warnings > MAX_WARNINGS) return;
+  warnings++;
+  try {
+    if (warnings > MAX_WARNINGS) {
+      console.warn("Patchstack: further failing callbacks passed to createProtection are not reported in this process.");
+      return;
+    }
+    console.warn(
+      `Patchstack: the ${label} callback passed to createProtection failed and was ignored. Protection is unaffected; this callback's failures are reported once. Cause: ${err && err.message ? err.message : String(err)}`
+    );
+  } catch {
+  }
+}
+
+// src/protect/engine/engine.js
+var GRP = "(?:[^()]|\\([^()]*\\))*";
+var REDOS_PATTERNS = [
+  /\([^)]*[+*}][^)]*\)\s*[+*]/,
+  /\([^)]*\|[^)]*\)\s*[+*]/,
+  new RegExp("\\(" + GRP + "[+*}]" + GRP + "\\)\\s*[+*]"),
+  // nested quantified subgroup
+  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 parseRepetition(body) {
+  let i = 0;
+  const parseAlternation = () => {
+    const branches = [parseSequence()];
+    while (body[i] === "|") {
+      i++;
+      branches.push(parseSequence());
+    }
+    return branches.length === 1 ? branches[0] : { type: "alt", branches };
+  };
+  const parseSequence = () => {
+    const items = [];
+    while (i < body.length && body[i] !== "|" && body[i] !== ")") {
+      const atom = parseAtom();
+      if (atom === null) return null;
+      const quantified = parseQuantifier(atom);
+      if (quantified === null) return null;
+      items.push(quantified);
+    }
+    return { type: "seq", items };
+  };
+  const parseAtom = () => {
+    const ch = body[i];
+    if (ch === "(") {
+      const start2 = i;
+      i++;
+      let kind = "capture";
+      if (body.startsWith("?:", i)) {
+        kind = "group";
+        i += 2;
+      } else if (body.startsWith("?=", i) || body.startsWith("?!", i)) {
+        kind = "look";
+        i += 2;
+      } else if (body.startsWith("?<=", i) || body.startsWith("?<!", i)) {
+        kind = "look";
+        i += 3;
+      } else if (body.startsWith("?<", i)) {
+        const close = body.indexOf(">", i + 2);
+        if (close === -1) return null;
+        i = close + 1;
+      } else if (body[i] === "?") {
+        return null;
+      }
+      const inner = parseAlternation();
+      if (inner === null || body[i] !== ")") return null;
+      i++;
+      return { type: "group", kind, body: inner, source: body.slice(start2, i) };
+    }
+    const start = i;
+    if (ch === "[") {
+      i++;
+      if (body[i] === "^") i++;
+      if (body[i] === "]") i++;
+      while (i < body.length && body[i] !== "]") i += body[i] === "\\" ? 2 : 1;
+      if (body[i] !== "]") return null;
+      i++;
+      return { type: "atom", source: body.slice(start, i) };
+    }
+    if (ch === "\\") {
+      const next = body[i + 1];
+      if (next === void 0) return null;
+      if ((next === "p" || next === "P" || next === "u") && body[i + 2] === "{") {
+        const close = body.indexOf("}", i + 3);
+        if (close === -1) return null;
+        i = close + 1;
+      } else if (next === "k" && body[i + 2] === "<") {
+        const close = body.indexOf(">", i + 3);
+        if (close === -1) return null;
+        i = close + 1;
+      } else {
+        i += 2;
+      }
+      return { type: /[bB]/.test(next) ? "assert" : "atom", source: body.slice(start, i) };
+    }
+    if (ch === "^" || ch === "$") {
+      i++;
+      return { type: "assert" };
+    }
+    if (ch === "*" || ch === "+" || ch === "?") return null;
+    i++;
+    return { type: "atom", source: body.slice(start, i) };
+  };
+  const parseQuantifier = (atom) => {
+    let min;
+    let max;
+    const ch = body[i];
+    if (ch === "*") [min, max, i] = [0, Infinity, i + 1];
+    else if (ch === "+") [min, max, i] = [1, Infinity, i + 1];
+    else if (ch === "?") [min, max, i] = [0, 1, i + 1];
+    else if (ch === "{") {
+      const bounds = /^\{(\d+)(,(\d*))?\}/.exec(body.slice(i));
+      if (!bounds) return atom;
+      min = Number(bounds[1]);
+      max = bounds[2] === void 0 ? min : bounds[3] === "" ? Infinity : Number(bounds[3]);
+      i += bounds[0].length;
+    } else {
+      return atom;
+    }
+    if (body[i] === "?") i++;
+    if (body[i] === "*" || body[i] === "+" || body[i] === "?" || body[i] === "{") return null;
+    return { type: "quant", min, max, body: atom };
+  };
+  const root = parseAlternation();
+  return root !== null && i === body.length ? root : null;
+}
+function* nodesOf(node) {
+  if (!node) return;
+  yield node;
+  if (node.type === "alt") for (const branch of node.branches) yield* nodesOf(branch);
+  else if (node.type === "seq") for (const item of node.items) yield* nodesOf(item);
+  else if (node.type === "group" || node.type === "quant") yield* nodesOf(node.body);
+}
+var BOUNDED_NESTING_LIMIT = 100;
+var BOUNDED_ALTERNATION_LIMIT = 16;
+var OPTIONAL_REPEAT_LIMIT = 8;
+function hasFencedRepetitions(quant, flags) {
+  let body = quant.body;
+  if (body.type === "group" && body.kind !== "look") body = body.body;
+  if (body.type !== "seq" || body.items.length < 2) return false;
+  const variable = [...nodesOf(body)].filter((n) => n.type === "quant" && (n.max > 1 || n.min < n.max));
+  if (variable.some((n) => n.body.type !== "atom" || n.body.source === void 0)) return false;
+  const atomFlags = flags.replace(/[^i]/g, "");
+  const unicode = /[uv]/.test(flags);
+  let insides;
+  try {
+    insides = variable.map((n) => new RegExp(`^(?:${n.body.source})$`, `${atomFlags}${unicode ? "u" : ""}`));
+  } catch {
+    return false;
+  }
+  const literalOf = (source) => {
+    if (source.length === 1 && !".[]()|^$\\".includes(source)) return source;
+    if (source.length === 2 && source[0] === "\\" && /[^\w\s]/.test(source[1])) return source[1];
+    return null;
+  };
+  const disjoint = (edge) => {
+    if (edge?.type !== "atom" || edge.source === void 0) return false;
+    const literal = literalOf(edge.source);
+    if (literal !== null) return insides.every((re) => !re.test(literal));
+    if (unicode) return false;
+    let fence;
+    try {
+      fence = new RegExp(`^(?:${edge.source})$`, atomFlags);
+    } catch {
+      return false;
+    }
+    for (let unit = 0; unit <= 65535; unit++) {
+      const ch = String.fromCharCode(unit);
+      if (fence.test(ch) && insides.some((re) => re.test(ch))) return false;
+    }
+    return true;
+  };
+  return disjoint(body.items[0]) || disjoint(body.items[body.items.length - 1]);
+}
+function hasCatastrophicShape(body, flags) {
+  const root = parseRepetition(body);
+  if (root === null) return null;
+  for (const node of nodesOf(root)) {
+    if (node.type === "group" && node.kind === "look" && hasAdjacentUnbounded(lookaroundBody(node.source), flags)) return true;
+    if (node.type !== "quant" || node.max <= 1) continue;
+    const fenced = hasFencedRepetitions(node, flags);
+    for (const inner of nodesOf(node.body)) {
+      if (inner === node.body && inner.type === "quant") continue;
+      if (inner.type === "quant" && inner.max > 1 && !fenced) {
+        if (node.max === Infinity || inner.max === Infinity || node.max * inner.max > BOUNDED_NESTING_LIMIT) return true;
+      }
+      if (inner.type === "quant" && inner.min === 0 && inner.max <= 1 && !fenced && (node.max === Infinity || node.max > OPTIONAL_REPEAT_LIMIT)) {
+        return true;
+      }
+      if (inner.type === "alt" && inner.branches.length > 1 && (node.max === Infinity || node.max > BOUNDED_ALTERNATION_LIMIT)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function lookaroundBody(source) {
+  return source.slice(source.startsWith("(?<") ? 4 : 3, -1);
+}
+function groupEnd(body, start) {
+  let depth = 0;
+  let inClass = false;
+  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 MAX_PATTERN_LENGTH = 1e3;
+var regexVerdicts = /* @__PURE__ */ new Map();
+var REGEX_VERDICT_LIMIT = 2048;
+function safeRegExp(pattern) {
+  if (!pattern) {
+    return null;
+  }
+  if (typeof pattern !== "string" || pattern.length > MAX_PATTERN_LENGTH) {
+    return null;
+  }
+  const match = pattern.match(/^\/(.+?)\/([gimsuy]*)$/s);
+  if (!match) {
+    return null;
+  }
+  let safe = regexVerdicts.get(pattern);
+  if (safe === void 0) {
+    safe = isSafeBody(match[1], match[2]);
+    if (regexVerdicts.size >= REGEX_VERDICT_LIMIT) regexVerdicts.clear();
+    regexVerdicts.set(pattern, safe);
+  }
+  if (!safe) return null;
+  try {
+    return new RegExp(match[1], match[2]);
+  } catch {
+    return null;
+  }
+}
+function isSafeBody(body, flags) {
+  for (const dangerous of REDOS_PATTERNS) {
+    if (dangerous.test(body)) return false;
+  }
+  if (hasAdjacentUnbounded(body, flags)) return false;
+  if (hasCatastrophicShape(body, flags) === true) return false;
+  try {
+    new RegExp(body, flags);
+  } catch {
+    return false;
+  }
+  return true;
+}
+
+// src/protect/engine/pulse-client.js
+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;
+  #timeoutMs;
+  #baseUrl;
+  #cacheTtl;
+  #cache = null;
+  #cacheTime = null;
+  #ttlEffective = 0;
+  #etag;
+  #pulseAuth;
+  #detectionState;
+  #buildId;
+  constructor({ siteUuid, baseUrl, cacheTtl, etag, timeoutMs, pulseAuth, detectionState, buildId } = {}) {
+    this.#timeoutMs = Number(timeoutMs) > 0 ? Number(timeoutMs) : 3e4;
+    this.#siteUuid = siteUuid ?? process.env.PATCHSTACK_SITE_UUID;
+    this.#baseUrl = safeBaseUrl(baseUrl ?? process.env.PATCHSTACK_PULSE_RULES_URL, DEFAULT_BASE_URL2, "rule endpoint");
+    this.#cacheTtl = Number.isFinite(cacheTtl) && cacheTtl > 0 ? cacheTtl : DEFAULT_CACHE_TTL2;
+    this.#etag = etag ?? null;
+    this.#pulseAuth = pulseAuth ?? null;
+    this.#detectionState = typeof detectionState === "string" ? detectionState : null;
+    this.#buildId = canonicalBuildId(buildId);
+    if (!this.#siteUuid) {
+      throw new Error("Patchstack site UUID is required. Pass { siteUuid } or set PATCHSTACK_SITE_UUID.");
+    }
+  }
+  async getRules() {
+    const now = Date.now();
+    if (this.#cache && this.#cacheTime !== null && now - this.#cacheTime < this.#ttlEffective) {
+      return this.#cache;
+    }
+    const url = `${this.#baseUrl}/rules/${encodeURIComponent(this.#siteUuid)}`;
+    try {
+      const auth = await pulseAuthHeader(
+        { pulseAuth: this.#pulseAuth, endpoint: this.#baseUrl, timeoutMs: this.#timeoutMs },
+        fetch
+      );
+      const headers = { Accept: "application/json", ...auth };
+      if (this.#detectionState !== null && typeof auth.Authorization === "string") {
+        headers["X-Patchstack-Detections"] = this.#detectionState;
+      }
+      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) {
+        this.#touch(now);
+        const result2 = {
+          ...this.#cache ?? { firewall: [], whitelists: [], whitelist_keys: {} },
+          success: true,
+          notModified: true,
+          etag: response.headers?.get?.("etag") ?? this.#etag,
+          build: buildVerdictOf(response.headers)
+        };
+        this.#cache = result2;
+        this.#etag = result2.etag;
+        return result2;
+      }
+      if (!response.ok) {
+        return { success: false, error: `API returned ${response.status}`, firewall: [], whitelists: [], whitelist_keys: {} };
+      }
+      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: {} };
+      }
+      const result = {
+        success: true,
+        notModified: false,
+        etag: response.headers?.get?.("etag") ?? null,
+        firewall: data.firewall,
+        whitelists: Array.isArray(data.whitelists) ? data.whitelists : [],
+        whitelist_keys: data.whitelist_keys ?? {},
+        ...enforcementField(data),
+        // Carried through so the caller can decide what a build-scoped rule may do. Response metadata,
+        // rather than bundle content, because it varies with the build asking and is also present on 304.
+        build: buildVerdictOf(response.headers)
+      };
+      this.#cache = result;
+      this.#etag = result.etag;
+      this.#touch(now);
+      return result;
+    } catch (err) {
+      return {
+        success: false,
+        error: err.name === "TimeoutError" ? "Request timed out" : err.message,
+        firewall: [],
+        whitelists: [],
+        whitelist_keys: {}
+      };
+    }
+  }
+  #touch(now) {
+    this.#cacheTime = now;
+    this.#ttlEffective = this.#cacheTtl - Math.floor(Math.random() * this.#cacheTtl * JITTER_FRACTION2);
+  }
+  clearCache() {
+    this.#cache = null;
+    this.#cacheTime = null;
+    this.#etag = null;
+  }
+};
+function buildVerdictOf(headers) {
+  const get = headers !== null && typeof headers === "object" && typeof headers.get === "function" ? (name) => headers.get(name) : () => null;
+  const stated2 = get(BUILD_VERDICT_HEADER);
+  const verdict = stated2 === "match" || stated2 === "missing" || stated2 === "mismatch" ? stated2 : "unknown";
+  const matched = get(BUILD_IDENTITY_HEADER);
+  return { verdict, matchedBuildId: typeof matched === "string" ? matched : null };
+}
+function enforcementField(data) {
+  if (!data || typeof data !== "object") return {};
+  const v = data.enforcement ?? data.mode;
+  return v === "block" || v === "dry-run" ? { enforcement: v } : {};
+}
+
+// src/protect/rules/validate.js
+var LIMITS2 = LIMITS;
+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.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.slice(0, LIMITS2.maxWhitelists)) {
+    if (!opts.allowGlobalWhitelists && wl && Array.isArray(wl.rule_v2) && !wl.rule_id) {
+      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) {
+      reject({ id: idOf(wl), reason: `whitelist may not carry ${BUILD_SCOPE_PROPERTY}` });
+      continue;
+    }
+    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, whitelist_keys: whitelistKeys },
+    rejected
+  };
+}
+function idOf(rule) {
+  const id = rule?.id ?? rule?.rule_id;
+  if (id === void 0 || id === null) return "(unidentified)";
+  try {
+    return String(id).slice(0, 128);
+  } catch {
+    return "(unidentified)";
+  }
+}
+function enforceableRuleProblem(rule, bundleBudget = null) {
+  if (!rule || typeof rule !== "object") return "not an object";
+  const nullReason = nullPropertyProblem(rule);
+  if (nullReason) return nullReason;
+  if (rule.phase !== void 0 && !PHASES2.has(rule.phase)) return `unknown phase "${rule.phase}"`;
+  const actionReason = actionProblem(rule.action, rule);
+  if (actionReason) return actionReason;
+  const scopeReason = whenProblem(rule.when);
+  if (scopeReason) return scopeReason;
+  const propertyReason = rulePropertyProblem(rule);
+  if (propertyReason) return propertyReason;
+  return conditionsProblem(rule.rule_v2, 0, { count: 0 }, bundleBudget);
+}
+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}`;
+  if (conditions.length > LIMITS2.maxConditionsPerRule) {
+    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, ruleBudget, bundleBudget);
+      if (nested) return nested;
+      continue;
+    }
+    const parameterReason = parameterProblem(c.parameter);
+    if (parameterReason) return parameterReason;
+    const mutationReason = mutationsProblem(c.mutations);
+    if (mutationReason) return mutationReason;
+    const matchReason = matchProblem(c.match, c.parameter);
+    if (matchReason) return matchReason;
+    const m = c.match;
+    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,
+        ruleBudget,
+        bundleBudget
+      );
+      if (nested) return nested;
+    }
+  }
+  return null;
+}
+
+// src/protect/rules/source.js
+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 : [],
+      whitelist_keys: res.whitelist_keys
+    },
+    { allowGlobalWhitelists: options.allowGlobalWhitelists }
+  );
+  return rejected;
+}
+function reportRejections(rejected, options, label) {
+  const report = options.onRuleRejected;
+  for (const r of rejected) {
+    if (typeof report === "function") {
+      notify(report, { ...r, accepted: false }, "onRuleRejected");
+    }
+  }
+  const sample = rejected.slice(0, 3).map((r) => `${r.id} (${r.reason})`).join("; ");
+  notify(options.onError, new Error(
+    `${label}: rejected the entire update because ${rejected.length} rule(s) failed validation \u2014 keeping the previous ruleset and NOT caching this response: ${sample}${rejected.length > 3 ? ", \u2026" : ""}`
+  ), "onError");
+}
+function fromSource(bundle, origin, reason) {
+  return {
+    ...bundle,
+    source: reason === void 0 ? { ok: true, origin } : { ok: false, origin, reason }
+  };
+}
+function buildIdentity(options) {
+  if (options.buildId !== void 0 && options.buildId !== null) {
+    const explicit = canonicalBuildId(options.buildId);
+    return explicit === null ? { id: null, reason: "the buildId option is not a complete 64-hex SHA-256 identity" } : { id: explicit };
+  }
+  const stamped = readBuildStamp(options.rules);
+  if (stamped !== null) return { id: stamped };
+  return {
+    id: null,
+    reason: options.rules ? "the guard rules file carries no build identity \u2014 the build did not stamp one" : "this guard was configured without bundled rules, so it carries no build identity"
+  };
+}
+function withScopedDryRun(bundle, confirmed, reason, options = {}) {
+  let held = 0;
+  let unusable = 0;
+  const firewall = bundle.firewall.map((rule) => {
+    if (rule === null || typeof rule !== "object") return rule;
+    if (!(BUILD_SCOPE_PROPERTY in rule)) return rule;
+    const scope = rule[BUILD_SCOPE_PROPERTY];
+    const target = canonicalBuildId(scope);
+    if (target !== null && confirmed !== null && target === confirmed) return rule;
+    if (rule.enforcement === "dry-run") return rule;
+    held += 1;
+    if (target === null) unusable += 1;
+    return { ...rule, enforcement: "dry-run" };
+  });
+  if (held === 0) return bundle;
+  const explanations = [
+    ...unusable > 0 ? [`${unusable} rule(s) carry an unusable ${BUILD_SCOPE_PROPERTY}`] : [],
+    ...held > unusable ? [reason] : []
+  ];
+  const message = `${held} build-scoped rule(s) are detecting only, not blocking: ${explanations.join("; ")}`;
+  if (typeof options.onError === "function") notify(options.onError, new Error(message), "onError");
+  else warnHeldOnce(message);
+  return { ...bundle, firewall };
+}
+var warnedHeld = /* @__PURE__ */ new Set();
+function warnHeldOnce(message) {
+  if (warnedHeld.has(message)) return;
+  warnedHeld.add(message);
+  console.warn(`[patchstack] ${message}. Pass { onError } to handle this yourself.`);
+}
+function confirmedBy(res, presented) {
+  if (presented === null) return null;
+  const verdict = res?.build;
+  if (verdict?.verdict !== "match") return null;
+  return canonicalBuildId(verdict.matchedBuildId) === presented ? presented : null;
+}
+async function resolveRules(options, store, ctx = {}) {
+  const timeoutMs = ctx.timeoutMs;
+  if (options.siteUuid) {
+    const prior = await store.read();
+    const identity2 = buildIdentity(options);
+    const sameBuild = prior?.buildId === identity2.id;
+    const cacheConfirmed = identity2.id !== null && sameBuild && prior?.matchedBuildId === identity2.id ? identity2.id : null;
+    const unconfirmed = identity2.reason ?? "the platform did not confirm that these coordinates belong to this map";
+    const served = (bundle, confirmed) => withScopedDryRun(bundle, confirmed, unconfirmed, options);
+    const local = (bundle) => options.trustLocalRuleScope === true ? bundle : withScopedDryRun(bundle, identity2.id, identity2.reason ?? "these rules name a different map", options);
+    const client = new PulseRuleClient({
+      siteUuid: options.siteUuid,
+      baseUrl: options.pulseRulesUrl,
+      etag: sameBuild ? prior?.etag : null,
+      timeoutMs,
+      pulseAuth: ctx.pulseAuth,
+      detectionState: ctx.detectionState,
+      buildId: identity2.id
+    });
+    const res = await client.getRules();
+    if (res.success && res.notModified && prior?.bundle) {
+      const confirmed = confirmedBy(res, identity2.id);
+      await store.write({
+        bundle: prior.bundle,
+        etag: res.etag ?? prior.etag ?? null,
+        buildId: identity2.id,
+        matchedBuildId: confirmed
+      });
+      return fromSource(served(normalizeBundle(prior.bundle, options), confirmed), "cache");
+    }
+    if (res.success && !res.notModified) {
+      const confirmed = confirmedBy(res, identity2.id);
+      const rejected = liveUpdateRejections(res, options);
+      if (rejected.length > 0) {
+        reportRejections(rejected, options, "rule update rejected");
+        if (prior?.bundle) return fromSource(served(normalizeBundle(prior.bundle, options), cacheConfirmed), "cache", "update rejected");
+        if (options.rules) return fromSource(local(normalizeBundle(options.rules, options)), "bundled", "update rejected");
+        return fromSource(emptyBundle(), "empty", "update rejected");
+      }
+      const bundle = normalizeBundle(res, options);
+      await store.write({ bundle, etag: res.etag ?? null, buildId: identity2.id, matchedBuildId: confirmed });
+      return fromSource(served(bundle, confirmed), "api");
+    }
+    if (prior?.bundle) {
+      notify(options.onError, new Error(`pulse rule fetch failed (${res.error ?? "no usable response"}); using cached bundle`), "onError");
+      return fromSource(served(normalizeBundle(prior.bundle, options), cacheConfirmed), "cache", res.error ?? "no usable response");
+    }
+    if (options.rules) {
+      notify(options.onError, new Error(`pulse rule fetch failed (${res.error ?? "no usable response"}); using bundled fallback`), "onError");
+      return fromSource(local(normalizeBundle(options.rules, options)), "bundled", res.error ?? "no usable response");
+    }
+    notify(options.onError, new Error(`pulse rule fetch failed (${res.error ?? "no usable response"}); no cache \u2014 running with no rules`), "onError");
+    return fromSource(emptyBundle(), "empty", res.error ?? "no usable response");
+  }
+  if (options.token) {
+    const identity2 = buildIdentity(options);
+    const remote = (bundle) => withScopedDryRun(
+      bundle,
+      null,
+      "the token-authenticated rules service did not corroborate this map",
+      options
+    );
+    const local = (bundle) => options.trustLocalRuleScope === true ? bundle : withScopedDryRun(bundle, identity2.id, identity2.reason ?? "these rules name a different map", options);
+    const prior = await store.read();
+    const client = new PatchstackRuleClient({ token: options.token, baseUrl: options.baseUrl, etag: prior?.etag, timeoutMs });
+    const res = await client.getRules();
+    if (res.success && res.notModified && prior?.bundle) {
+      return fromSource(remote(normalizeBundle(prior.bundle, options)), "cache");
+    }
+    if (res.success && !res.notModified) {
+      const rejected = liveUpdateRejections(res, options);
+      if (rejected.length > 0) {
+        reportRejections(rejected, options, "rule update rejected");
+        if (prior?.bundle) return fromSource(remote(normalizeBundle(prior.bundle, options)), "cache", "update rejected");
+        if (options.rules) return fromSource(local(normalizeBundle(options.rules, options)), "bundled", "update rejected");
+        return fromSource(emptyBundle(), "empty", "update rejected");
+      }
+      const bundle = normalizeBundle(res, options);
+      await store.write({ bundle, etag: res.etag ?? null });
+      return fromSource(remote(bundle), "api");
+    }
+    if (prior?.bundle) {
+      notify(options.onError, new Error(`rule fetch failed (${res.error ?? "no usable response"}); using cached bundle`), "onError");
+      return fromSource(remote(normalizeBundle(prior.bundle, options)), "cache", res.error ?? "no usable response");
+    }
+    notify(options.onError, new Error(`rule fetch failed (${res.error ?? "no usable response"}); no cache \u2014 running with no rules`), "onError");
+    return fromSource(emptyBundle(), "empty", res.error ?? "no usable response");
+  }
+  if (options.rules) {
+    const identity2 = buildIdentity(options);
+    const bundle = normalizeBundle(options.rules, options);
+    if (options.trustLocalRuleScope === true) return fromSource(bundle, "bundled");
+    return fromSource(
+      withScopedDryRun(bundle, identity2.id, identity2.reason ?? "these rules name a different map", options),
+      "bundled"
+    );
+  }
+  return fromSource(emptyBundle(), "empty");
+}
+function normalizeBundle(b, options = {}) {
+  const enforcement = b?.enforcement ?? b?.mode;
+  const { bundle: checked, rejected } = validateBundle(
+    {
+      firewall: Array.isArray(b.firewall) ? b.firewall : [],
+      whitelists: Array.isArray(b.whitelists) ? b.whitelists : [],
+      whitelist_keys: b.whitelist_keys
+    },
+    { allowGlobalWhitelists: options.allowGlobalWhitelists }
+  );
+  if (rejected.length > 0) {
+    const report = options.onRuleRejected;
+    if (typeof report === "function") {
+      for (const r of rejected) {
+        notify(report, r, "onRuleRejected");
+      }
+    } else {
+      const sample = rejected.slice(0, 3).map((r) => `${r.id} (${r.reason})`).join("; ");
+      console.warn(
+        `[patchstack] ${rejected.length} delivered rule(s) rejected as invalid/oversized and are NOT enforced: ${sample}` + (rejected.length > 3 ? ", \u2026" : "")
+      );
+    }
+  }
+  return {
+    firewall: checked.firewall,
+    whitelists: checked.whitelists,
+    whitelist_keys: checked.whitelist_keys,
+    ...enforcement === "block" || enforcement === "dry-run" ? { enforcement } : {}
+  };
+}
+function emptyBundle() {
+  return { firewall: [], whitelists: [], whitelist_keys: {} };
+}
+
+// src/protect/rules/store.js
+var fsMod;
+async function loadFs() {
+  if (fsMod !== void 0) return fsMod;
+  try {
+    const [fs, path17] = 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,
+      mkdirSync: fs.mkdirSync,
+      renameSync: fs.renameSync,
+      unlinkSync: fs.unlinkSync,
+      writeFileSync: fs.writeFileSync,
+      join: path17.join
+    };
+  } catch {
+    fsMod = null;
+  }
+  return fsMod;
+}
+async function sourceIdentity(options = {}) {
+  if (typeof options.siteUuid === "string" && options.siteUuid.trim() !== "") {
+    const endpoint = typeof options.pulseRulesUrl === "string" ? options.pulseRulesUrl : "";
+    return `site:${options.siteUuid.trim().toLowerCase()}@${endpoint}`;
+  }
+  if (typeof options.token === "string" && options.token !== "") {
+    const digest = await sha256Hex(options.token);
+    if (digest === null) return null;
+    const endpoint = typeof options.baseUrl === "string" ? options.baseUrl : "";
+    return `token:${digest}@${endpoint}`;
+  }
+  return null;
+}
+async function sha256Hex(text) {
+  try {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle || typeof TextEncoder === "undefined") return null;
+    const digest = await subtle.digest("SHA-256", new TextEncoder().encode(text));
+    return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+  } catch {
+    return null;
+  }
+}
+function makeStore(options = {}) {
+  let mem = null;
+  const durable = durableTier(options);
+  let identity2;
+  const identityOf = () => identity2 ??= sourceIdentity(options);
+  return {
+    async read() {
+      if (mem) return mem;
+      const source = await identityOf();
+      if (source === null) return null;
+      const env = await durable.read();
+      if (!env || env.source !== source) return null;
+      mem = env;
+      return env;
+    },
+    async write(env) {
+      if (!env) return;
+      const stamped = { ...env, source: await identityOf() };
+      mem = stamped;
+      await durable.write(stamped);
+    }
+  };
+}
+function durableTier(options) {
+  const adapter = options.ruleCache;
+  if (adapter && typeof adapter.read === "function" && typeof adapter.write === "function") {
+    return {
+      read: async () => {
+        try {
+          return toEnvelope(await adapter.read());
+        } catch {
+          return null;
+        }
+      },
+      write: async (env) => {
+        try {
+          await adapter.write(env);
+        } catch {
+        }
+      }
+    };
+  }
+  const dir = options.cacheDir;
+  return {
+    read: async () => cacheRead(dir),
+    write: async (env) => cacheWrite(dir, env)
+  };
+}
+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 });
+    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 {
+    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") {
+    const buildId = canonicalBuildId(value.buildId);
+    const matched = canonicalBuildId(value.matchedBuildId);
+    return {
+      bundle: value.bundle,
+      etag: value.etag ?? null,
+      buildId,
+      // A confirmation belongs to the presentation stored beside it. A crossed or partially written
+      // envelope confirms nothing, even when one of its fields happens to name the current map.
+      matchedBuildId: buildId !== null && matched === buildId ? matched : null,
+      source: typeof value.source === "string" ? value.source : null
+    };
+  }
+  if (Array.isArray(value.firewall) || Array.isArray(value.whitelists)) {
+    return { bundle: value, etag: null, buildId: null, matchedBuildId: null, source: null };
+  }
+  return null;
+}
+
+// src/setup-sync.ts
+async function syncSetupProtection(cwd, config) {
+  const notices = [];
+  const warnings2 = [];
+  let map;
+  try {
+    map = await runMapDetailed(/* @__PURE__ */ new Map([["dir", cwd], ["upload", true]]), {
+      config,
+      setup: true,
+      log: (line) => notices.push(line)
+    });
+  } catch {
+    map = { code: 1, error: "Could not analyse or bind the map; check the project files and permissions." };
+  }
+  const unavailable = (error) => ({
+    map,
+    rules: { ok: false, count: 0, origin: "empty", error },
+    notices,
+    warnings: warnings2
+  });
+  if (!isCanonicalUuid(config.siteUuid)) return unavailable("No site UUID is configured.");
+  if (!config.pulseAuth) return unavailable("Set PATCHSTACK_API_KEY or run patchstack-connect login to fetch live rules.");
+  try {
+    const rulesUrl = buildRulesUrl(config.endpoint, config.siteUuid);
+    assertConnectableEndpoint(config, rulesUrl);
+    const base = rulesUrl.slice(0, rulesUrl.lastIndexOf("/rules/"));
+    const defaultRules = buildRulesUrl(DEFAULT_ENDPOINT, config.siteUuid);
+    if (rulesUrl !== defaultRules && process.env.PATCHSTACK_PULSE_RULES_URL !== base) {
+      warnings2.push("A custom rules service was used for setup. Set PATCHSTACK_PULSE_RULES_URL to the same Pulse base in the server environment for runtime updates.");
+    }
+    const options = {
+      siteUuid: config.siteUuid,
+      // Match the ordinary guard's default cache identity; explicit endpoints remain isolated.
+      pulseRulesUrl: base,
+      cacheDir: join26(cwd, ".patchstack"),
+      buildId: map.buildId ?? void 0,
+      onError: () => notices.push("Some rules could not be refreshed or are detect-only; verify delivery after starting the app.")
+    };
+    const ignored = await ensureIgnored(cwd, ".patchstack/", "Patchstack local runtime cache");
+    if (!ignored.ignored) warnings2.push("The local rule cache is not git-ignored. Keep .patchstack/ out of version control.");
+    const store = makeStore({ ...options, pulseRulesUrl: rulesUrl === defaultRules ? void 0 : base });
+    const bundle = await resolveRules(options, store, {
+      pulseAuth: config.pulseAuth,
+      timeoutMs: Math.min(config.timeoutMs, 1e4)
+    });
+    return {
+      map,
+      notices,
+      warnings: warnings2,
+      rules: {
+        ok: bundle.source.ok,
+        origin: bundle.source.origin,
+        count: bundle.firewall.length,
+        ...bundle.source.ok ? {} : { error: bundle.source.reason ?? "Live rules could not be fetched." }
+      }
+    };
+  } catch {
+    return unavailable("Live rules could not be fetched. Check the endpoint, authentication and project permissions.");
+  }
+}
+
+// src/cli.ts
+var HELP = `@patchstack/connect \u2014 scan your lockfile and report packages to Patchstack.
+
+Usage:
+  patchstack-connect scan   [options]                Scan lockfile and POST to Patchstack.
+                                                     If no UUID is configured, the server
+                                                     provisions one and we persist it. After a
+                                                     successful post it also adds/updates the
+                                                     Patchstack Connector <script> tag in the root
+                                                     HTML shell (index.html, public/index.html,
+                                                     or src/app.html) \u2014 opt out with
+                                                     "widget": false in .patchstackrc.json.
+                                                     Run as a postinstall/prebuild/build hook, a
+                                                     report Patchstack cannot accept is printed
+                                                     and exits 0 so the build goes on; run
+                                                     directly, the same failure exits 1
+  patchstack-connect setup  [options]                Finish the bounded project setup: run scan,
+                                                     manage the widget, install + verify runtime
+                                                     protection, upload the attack-surface map, pull
+                                                     live rules, and wire dependency/build scans.
+                                                     Never runs the project build
+  patchstack-connect map    [--dir <p>] [--out <f>] [--upload]
+                                                     Map the app's attack surface: entry points, the
+                                                     inputs each reads, the sinks it can reach, and
+                                                     evidence-backed input\u2192sink flows (each labelled
+                                                     with how the link was established). Best-effort static
+                                                     analysis \u2014 reports the DETECTED surface, with
+                                                     coverage counters. Prints JSON (--out writes a
+                                                     file; a pre-bundle --upload also stamps the existing
+                                                     guard rules file; --follow-symlinks leaves the project dir).
+                                                     Uses the app's own TypeScript
+  patchstack-connect init   <site-uuid>              Optional: pre-seed .patchstackrc.json
+                                                     with an existing site UUID
+  patchstack-connect status [options]                Show current configuration and whether the
+                                                     site still exists on Patchstack (active /
+                                                     removed)
+  patchstack-connect uninstall [options]             Signal Patchstack that this package is being
+                                                     removed from the project. An unclaimed site
+                                                     record is deleted; a claimed site is flagged
+                                                     for its owner to remove in the dashboard.
+                                                     Does NOT touch local files \u2014 see the
+                                                     "Uninstalling" steps in AGENT-INSTALL.md
+  patchstack-connect mark-build [options]            Stamp built HTML with a production flag +
+                                                     build fingerprint, and ensure the widget
+                                                     tag in built pages (run as a postbuild step).
+                                                     The flag marks a page as the LIVE site, so it
+                                                     is stamped only on a production build; a local
+                                                     or preview build gets the widget tag and no
+                                                     marker (and any stale marker is removed).
+                                                     Looks in the framework's own output dir, an
+                                                     --output the build script names, then dist/,
+                                                     build/, out/, .output/public/, _site/ \u2014 inside
+                                                     the project only. --dir <path> overrides.
+  patchstack-connect protect [--demo|--check]        Install always-on runtime protection (the
+                                                     guard). Auto-wires supported server stacks;
+                                                     for others it scaffolds a
+                                                     generic guard + prints a wiring plan.
+                                                     --demo seeds a broad sample rule set (for
+                                                     demonstrations, not production).
+                                                     --check verifies the guard is wired (exit 1
+                                                     if not) \u2014 for the wire-then-verify loop.
+                                                     It reads the app's source and never runs it.
+                                                     --check --runtime additionally STARTS THE APP
+                                                     on a loopback port and sends it one request,
+                                                     to establish that a request reaches the
+                                                     guard. Opt-in, and the only mode that runs
+                                                     the app. Exit 0 traversed, 1 a listener
+                                                     answered instead of the guard, 2 could not
+                                                     be established (e.g. a TypeScript or
+                                                     framework entry this must not start).
+  patchstack-connect demo node-serialize [--url URL] Run the production-backed node-serialize
+                                                     walkthrough: verify the vulnerable package,
+                                                     scan it, wait for live rule 18843, install +
+                                                     verify the guard, and print test requests.
+                                                     Does not install vulnerable dependencies.
+  patchstack-connect demo-guide node-serialize       Show a read-only, state-aware walkthrough for
+                                                     preparing, running, proving, and cleaning up
+                                                     the production-backed local demo.
+  patchstack-connect guide [--full]                  Show this project's setup status (what's done,
                                                      what's missing, with tailored commands), then
                                                      print the full setup guide. --full prints the
                                                      guide even when setup is complete
@@ -10851,11 +13195,14 @@ async function runScan(args, options = {}) {
     );
   }
   if (config.environment === "local") {
-    say("Environment: local (this machine). Set PATCHSTACK_ENVIRONMENT=production on a live build your host does not identify.");
+    const because = (config.environmentEvidence ?? []).join("; ") || "this machine";
+    say(`Environment: local (${because}). Set PATCHSTACK_ENVIRONMENT=production on a live build your host does not identify.`);
   } else {
     const because = (config.environmentEvidence ?? []).length > 0 ? ` (${config.environmentEvidence.join("; ")})` : "";
     say(`Environment: ${config.environment}${because}.`);
   }
+  const overruled = ignoredFileEnvironmentWarning(config);
+  if (overruled !== null) console.warn(`patchstack: ${overruled}`);
   if (config.endpoint !== DEFAULT_ENDPOINT) {
     say(`Endpoint override: ${config.endpoint}`);
   }
@@ -11051,6 +13398,12 @@ function reportSourceWidget(siteUuid, framework, report) {
     detail(`Widget: skipped (${err.message}).`);
   }
 }
+function ignoredFileEnvironmentWarning(config) {
+  const ignored = config.ignoredFileEnvironment;
+  if (ignored == null) return null;
+  const because = (config.environmentEvidence ?? []).length > 0 ? ` (${config.environmentEvidence.join("; ")})` : "";
+  return `.patchstackrc.json sets "environment": "${ignored}", but this build is production${because}, so it is treated as production. Remove "environment" from .patchstackrc.json and set PATCHSTACK_ENVIRONMENT=${ignored} only in the process that needs it.`;
+}
 function reportSourceMarker(framework, checksum, report) {
   try {
     const shell = resolveWidgetFileHint(process.cwd(), framework);
@@ -11233,7 +13586,7 @@ async function runGuide(args) {
   console.log("\u2014\u2014\u2014\u2014 Full reference guide (ships as AGENT-INSTALL.md) \u2014\u2014\u2014\u2014");
   console.log("");
   const guidePath = new URL("../AGENT-INSTALL.md", import.meta.url);
-  console.log(readFileSync19(guidePath, "utf8"));
+  console.log(readFileSync20(guidePath, "utf8"));
   return 0;
 }
 function reportProtection(protection, report) {
@@ -11288,11 +13641,11 @@ Run: ${installCommand(before.packageManager)}`
     return 1;
   }
   const report = emptyReport();
-  let reported = {};
+  let reported2 = {};
   const scanCode = await runScan(args, {
     report,
     onReported: (outcome) => {
-      reported = outcome;
+      reported2 = outcome;
     }
   });
   if (scanCode !== 0) {
@@ -11303,11 +13656,29 @@ Run: ${installCommand(before.packageManager)}`
   report.done.push(buildStepsLine(wired));
   detail(`Build hooks: ${wired.detail}`);
   const config = await resolveCliConfig(args);
+  const synced = await syncSetupProtection(process.cwd(), config);
+  for (const line of synced.notices) detail(line);
+  for (const [index, warning] of synced.warnings.entries()) {
+    report.missing.push({ key: `setup-sync-${index}`, text: warning });
+  }
+  const uploaded = synced.map.upload;
+  if (uploaded?.result === "stored" || uploaded?.result === "unchanged") {
+    report.done.push(`Attack-surface map uploaded (revision ${uploaded.revision}; ${synced.map.endpoints ?? 0} detected entry points)`);
+    if (!synced.map.buildId) report.missing.push({ key: "map-binding", text: "Map is not linked to runtime protection", hint: ["Finish the reported protection integration, then rerun setup. Rules for specific inputs can only detect, not block, until linked."] });
+  } else {
+    report.missing.push({ key: "map-upload", text: "Attack-surface map was not uploaded", hint: [synced.map.error ?? uploaded?.message ?? "Check connectivity and rerun setup."] });
+  }
+  if (synced.rules.ok) {
+    report.done.push(`Live rule lookup succeeded (${synced.rules.count} delivered rules; ${synced.rules.count === 0 ? "no rules currently assigned" : "not proof of runtime enforcement"})`);
+  } else {
+    report.missing.push({ key: "rules-pull", text: "Live rule lookup is incomplete", hint: [synced.rules.error ?? "Check authentication and rerun setup."] });
+  }
+  report.missing.push({ key: "runtime-restart", text: "Load the new protection in your running app", hint: ["Restart the preview/server if it is already running. Deploy a new build to update the live app. Setup does not start or deploy it."] });
   const after = await collectGuideState(process.cwd());
-  const missing = mergeMissing(report.missing, guideMissing(after, reported));
+  const missing = mergeMissing(report.missing, guideMissing(after, reported2));
   const context = scanNextStepContext(config, after, after.siteUuid);
   if (verbose) console.log("");
-  for (const line of renderStatus("Patchstack setup", { done: report.done, missing }, guideProgress(after, reported), context, {
+  for (const line of renderStatus("Patchstack setup", { done: report.done, missing }, guideProgress(after, reported2), context, {
     useColor: useColor(),
     verbose
   })) {
@@ -11381,7 +13752,7 @@ function describeStack(stack) {
 }
 function readBuildScript(cwd) {
   try {
-    const pkg = JSON.parse(readFileSync19(path16.join(cwd, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync20(path16.join(cwd, "package.json"), "utf8"));
     return pkg.scripts?.build;
   } catch {
     return void 0;
@@ -11438,6 +13809,8 @@ async function runMarkBuild(args) {
     }
     environment = config.environment;
     environmentEvidence = config.environmentEvidence ?? [];
+    const overruled = ignoredFileEnvironmentWarning(config);
+    if (overruled !== null) console.warn(`mark-build: ${overruled}`);
   } catch (err) {
     console.warn(
       `mark-build: could not resolve the site UUID (${err.message}). Skipping the widget pass.`
@@ -11445,7 +13818,7 @@ async function runMarkBuild(args) {
   }
   const forcedProduction = args.flags.get("production") === true;
   const published = forcedProduction || marksPublishedBuild(environment);
-  const reported = config !== null && forcedProduction && config.environment !== "production" ? { ...config, environment: "production", environmentSource: "override" } : config;
+  const reported2 = config !== null && forcedProduction && config.environment !== "production" ? { ...config, environment: "production", environmentSource: "override" } : config;
   const buildDirOptions = { framework: stack?.framework ?? null, buildScript: readBuildScript(cwd) };
   const dir = resolveBuildDir(cwd, getStringFlag(args.flags, "dir"), buildDirOptions);
   if (dir === null) {
@@ -11456,14 +13829,14 @@ async function runMarkBuild(args) {
     console.warn(
       'mark-build: if the build writes elsewhere, set it once in package.json \u2192 "postbuild": "patchstack-connect mark-build --dir <path>".'
     );
-    await reportBuildStamp(reported, wirePayload, "no-output");
+    await reportBuildStamp(reported2, wirePayload, "no-output");
     return 0;
   }
   const files = findHtmlFiles(dir);
   if (files.length === 0) {
     console.warn(`mark-build: found ${dir} but no HTML files in it.`);
     console.warn("mark-build: this looks like a server-rendered app. Run `npx @patchstack/connect guide` to see what your main layout needs.");
-    await reportBuildStamp(reported, wirePayload, "no-pages");
+    await reportBuildStamp(reported2, wirePayload, "no-pages");
     return 0;
   }
   const staleBy = staleBuildAge(files, startedAt);
@@ -11472,12 +13845,18 @@ async function runMarkBuild(args) {
       `mark-build: nothing in ${dir} changed in the last ${Math.round(staleBy / 6e4)} minute(s). Run it right after the build (as postbuild).`
     );
   }
-  const snippet = published ? buildInjectionSnippet(checksum, stack) : "";
+  const snippet = published ? buildInjectionSnippet(checksum, stack) : environment === "sandbox" ? buildSandboxSnippet() : "";
   let marked = 0;
   let widgetTouched = 0;
+  let handRemoved = 0;
   for (const file of files) {
-    const before = readFileSync19(file, "utf8");
+    const before = readFileSync20(file, "utf8");
     let after = injectMarker(before, snippet);
+    if (!published) {
+      const cleared = removeHandMarkers(after);
+      if (cleared !== after) handRemoved += 1;
+      after = cleared;
+    }
     if (widgetUuid !== null) {
       const ensured = ensureWidgetInHtml(after, widgetUuid);
       if (ensured.action === "added" || ensured.action === "updated") {
@@ -11496,7 +13875,7 @@ async function runMarkBuild(args) {
     detail(
       `mark-build: marked ${marked} HTML file(s) in ${dir}${checksum !== null ? ` (build ${checksum})` : ""}${widgetTouched > 0 ? `, widget tag ensured in ${widgetTouched}` : ""}${stackSummary !== null ? ` [${stackSummary}]` : ""}.`
     );
-    await reportBuildStamp(reported, wirePayload, "stamped");
+    await reportBuildStamp(reported2, wirePayload, "stamped");
     return 0;
   }
   const because = environmentEvidence.length > 0 ? ` (${environmentEvidence.join("; ")})` : "";
@@ -11506,12 +13885,17 @@ async function runMarkBuild(args) {
   detail(
     `mark-build: ${environment} build${because}, so no production marker in ${files.length} HTML file(s) in ${dir}${widgetTouched > 0 ? `, widget tag ensured in ${widgetTouched}` : ""}${stackSummary !== null ? ` [${stackSummary}]` : ""}.`
   );
-  await reportBuildStamp(reported, wirePayload, "withheld");
+  if (handRemoved > 0) {
+    console.warn(
+      `mark-build: removed a hand-added __PATCHSTACK_PROD__ script from ${plural(handRemoved, "page", "pages")}. Production builds get the marker from mark-build, so it does not need to be in your source.`
+    );
+  }
+  await reportBuildStamp(reported2, wirePayload, "withheld");
   return 0;
 }
 function packageVersion() {
   try {
-    const require2 = createRequire3(import.meta.url);
+    const require2 = createRequire6(import.meta.url);
     const manifest = require2("../package.json");
     return typeof manifest.version === "string" && manifest.version.length > 0 ? manifest.version : "unknown";
   } catch {