canship 0.4.0 → 0.6.0

package/dist/index.js

@@ -8,6 +8,7 @@ import { resolve as resolve2 } from "path";
 var IRRELEVANT_HOSTS = /^(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]|host\.docker\.internal|.*\.?example\.(?:com|org|net)|.*\.(?:test|invalid|localhost))$/i;
 var JWT_SOURCE = String.raw`eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}`;
 var SB_SECRET_SOURCE = String.raw`sb_secret_[A-Za-z0-9_-]{8,}`;
+var PRIVATE_KEY_BEGIN_SOURCE = String.raw`-----BEGIN (?:(?:RSA|EC|DSA|OPENSSH|ENCRYPTED|PGP) )?PRIVATE KEY(?: BLOCK)?-----`;
 var SECRET_PATTERNS = [
   {
     id: "openai",
@@ -133,7 +134,7 @@ var SECRET_PATTERNS = [
     id: "private-key",
     name: "Private key file contents",
     rotateLabel: "private key",
-    pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/g,
+    pattern: new RegExp(PRIVATE_KEY_BEGIN_SOURCE, "g"),
     impact: "A private key in source code can be used to impersonate your server, decrypt traffic, or log into your machines."
   },
   {
@@ -214,13 +215,29 @@ function redactSecret(secret) {
   return `${head}\u2026(${secret.length} chars)\u2026${tail}`;
 }
 function redactLine(line, secret) {
-  const trimmed = line.trim();
+  const trimmed = redactPrivateKeys(line.trim());
   if (!secret) return trimmed;
   return trimmed.split(secret).join(redactSecret(secret));
 }
 var JWT_SHAPED = new RegExp(String.raw`\b${JWT_SOURCE}\b`, "g");
+function redactPrivateKeys(text) {
+  const starts = new RegExp(PRIVATE_KEY_BEGIN_SOURCE, "g");
+  const parts = [];
+  let from = 0;
+  let match;
+  while ((match = starts.exec(text)) !== null) {
+    const closing = match[0].replace("BEGIN ", "END ");
+    const end = text.indexOf(closing, starts.lastIndex);
+    parts.push(text.slice(from, match.index), "[REDACTED PRIVATE KEY]");
+    from = end === -1 ? text.length : end + closing.length;
+    starts.lastIndex = from;
+    if (end === -1) break;
+  }
+  parts.push(text.slice(from));
+  return parts.join("");
+}
 function redactAll(text) {
-  let out = text;
+  let out = redactPrivateKeys(text);
   for (const pat of SECRET_PATTERNS) {
     const re = new RegExp(pat.pattern.source, pat.pattern.flags);
     out = out.replace(re, (match) => redactSecret(match));
@@ -235,8 +252,8 @@ function truncate(s, max = 120) {
 import { basename as basename2 } from "path";
 
 // src/walker.ts
-import { readdirSync, readFileSync as readFileSync2, statSync as statSync2, lstatSync as lstatSync2, openSync, readSync, closeSync } from "fs";
-import { join as join2, relative as relative2, sep as sep2, extname, basename } from "path";
+import { opendirSync, readFileSync as readFileSync2, statSync as statSync2, lstatSync as lstatSync2, realpathSync as realpathSync2, openSync, readSync, closeSync } from "fs";
+import { join as join2, relative as relative2, isAbsolute as isAbsolute2, sep as sep2, extname, basename } from "path";
 
 // src/git.ts
 import { execFileSync } from "child_process";
@@ -473,6 +490,7 @@ function execGitBatch(executable, root, args, input, options = {}) {
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
 var MAX_SCAN_BYTES = 128 * 1024 * 1024;
 var MAX_SCAN_FILES = 1e4;
+var MAX_WALK_ENTRIES = 5e4;
 var MAX_WALK_DEPTH = 16;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -649,16 +667,16 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".sqlite3",
   ".mo"
 ]);
-function probeFileType(absPath) {
+function probeFileType(absPath, limit) {
   let fd = null;
   try {
     fd = openSync(absPath, "r");
-    const buf = Buffer.alloc(PROBE_BYTES);
-    const read = readSync(fd, buf, 0, PROBE_BYTES, 0);
+    const buf = Buffer.alloc(limit);
+    const read = readSync(fd, buf, 0, limit, 0);
     const head = buf.subarray(0, read);
     const hasTextBom = head.length >= 2 && head[0] === 255 && head[1] === 254 || head.length >= 2 && head[0] === 254 && head[1] === 255 || head.length >= 3 && head[0] === 239 && head[1] === 187 && head[2] === 191;
-    if (hasTextBom) return { kind: "text" };
-    return head.includes(0) ? { kind: "binary" } : { kind: "text" };
+    if (hasTextBom) return { kind: "text", bytes: read };
+    return { kind: head.includes(0) ? "binary" : "text", bytes: read };
   } catch (err) {
     return {
       kind: "unreadable",
@@ -731,10 +749,13 @@ function listViaGit(root, gitExecutable) {
     return null;
   }
 }
-function walkTree(root, skipped, wantAll) {
+function walkTree(root, skipped, wantAll, maxEntries) {
   const all = [];
   const found = [];
+  let visited = 0;
+  let exhausted = false;
   const walk = (dir, depth) => {
+    if (exhausted) return;
     if (depth > MAX_WALK_DEPTH) {
       skipped.push({
         path: relative2(root, dir).split(sep2).join("/") || ".",
@@ -745,7 +766,7 @@ function walkTree(root, skipped, wantAll) {
     }
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries = opendirSync(dir);
     } catch (err) {
       if (!isMissing(err)) {
         skipped.push({
@@ -756,31 +777,56 @@ function walkTree(root, skipped, wantAll) {
       }
       return;
     }
-    for (const entry of entries) {
-      const full = join2(dir, entry.name);
-      const rel = relative2(root, full).split(sep2).join("/");
-      if (entry.isSymbolicLink()) {
-        if (!SKIP_DIRS.has(entry.name)) {
-          skipped.push({ path: rel, reason: "symlink", detail: "symbolic links are not followed" });
+    try {
+      while (!exhausted) {
+        const entry = entries.readSync();
+        if (entry === null) break;
+        if (visited >= maxEntries) {
+          exhausted = true;
+          skipped.push({
+            path: relative2(root, dir).split(sep2).join("/") || ".",
+            reason: "directory-unreadable",
+            detail: `directory entry budget exceeded (${maxEntries} entries)`
+          });
+          break;
         }
-        continue;
-      }
-      if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(entry.name)) continue;
-        walk(full, depth + 1);
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      if (wantAll) all.push(rel);
-      let isCandidate = isEnvFile(entry.name) || CREDENTIAL_FILENAMES.has(entry.name) || CREDENTIAL_EXTENSIONS.has(extname(entry.name).toLowerCase());
-      if (!isCandidate && isWorthProbing(rel)) {
-        const probe = probeFileType(full);
-        if (probe.kind === "text") isCandidate = true;
-        else if (probe.kind === "unreadable") {
-          skipped.push({ path: rel, reason: "unreadable", detail: probe.detail });
+        visited++;
+        const full = join2(dir, entry.name);
+        const rel = relative2(root, full).split(sep2).join("/");
+        let metadata;
+        try {
+          metadata = lstatSync2(full);
+        } catch (err) {
+          if (!isMissing(err)) skipped.push({
+            path: rel,
+            reason: "unreadable",
+            detail: String(err instanceof Error ? err.message : err)
+          });
+          continue;
+        }
+        if (metadata.isSymbolicLink()) {
+          if (!SKIP_DIRS.has(entry.name)) {
+            skipped.push({ path: rel, reason: "symlink", detail: "symbolic links are not followed" });
+          }
+          continue;
         }
+        if (metadata.isDirectory()) {
+          if (SKIP_DIRS.has(entry.name)) continue;
+          walk(full, depth + 1);
+          continue;
+        }
+        if (!metadata.isFile()) continue;
+        if (wantAll) all.push(rel);
+        if (isCredentialName(entry.name) || isWorthProbing(rel)) found.push(rel);
       }
-      if (isCandidate) found.push(rel);
+    } catch (err) {
+      if (!isMissing(err)) skipped.push({
+        path: relative2(root, dir).split(sep2).join("/") || ".",
+        reason: "directory-unreadable",
+        detail: String(err instanceof Error ? err.message : err)
+      });
+    } finally {
+      entries.closeSync();
     }
   };
   walk(root, 0);
@@ -824,11 +870,44 @@ function isExampleContext(relPath) {
   if (/\.(test|spec)\.[jt]sx?$/i.test(name)) return true;
   return false;
 }
+function isCredentialName(name) {
+  return isEnvFile(name) || CREDENTIAL_FILENAMES.has(name) || CREDENTIAL_EXTENSIONS.has(extname(name).toLowerCase());
+}
+function readablePath(root, path, skipped) {
+  const rel = relative2(root, path);
+  if (!rel || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute2(rel)) {
+    skipped.push({ path: ".", reason: "unreadable", detail: "candidate path is outside the scan root" });
+    return false;
+  }
+  let current = root;
+  for (const segment of rel.split(sep2)) {
+    current = join2(current, segment);
+    const stat = lstatSync2(current);
+    if (stat.isSymbolicLink()) {
+      const linked = relative2(root, current).split(sep2).join("/");
+      if (!skipped.some((item) => item.path === linked && item.reason === "symlink")) {
+        skipped.push({ path: linked, reason: "symlink", detail: "symbolic links are not followed" });
+      }
+      return false;
+    }
+  }
+  const real = relative2(root, realpathSync2(path));
+  if (real === ".." || real.startsWith(`..${sep2}`) || isAbsolute2(real)) {
+    skipped.push({ path: rel.split(sep2).join("/"), reason: "unreadable", detail: "resolved path is outside the scan root" });
+    return false;
+  }
+  if (!lstatSync2(path).isFile()) {
+    skipped.push({ path: rel.split(sep2).join("/"), reason: "unreadable", detail: "not a regular file" });
+    return false;
+  }
+  return true;
+}
 function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root), limits = {}, honorIgnoreMarkers = true) {
+  root = realpathSync2(root);
   const skipped = [];
   const ignored = [];
   const fromGit = isGitRepo ? listViaGit(root, gitExecutable) : null;
-  const walked = walkTree(root, skipped, fromGit === null);
+  const walked = walkTree(root, skipped, fromGit === null, limits.maxEntries ?? MAX_WALK_ENTRIES);
   const listed = fromGit?.files ?? walked.all;
   const candidates = /* @__PURE__ */ new Set();
   let vendored = 0;
@@ -857,19 +936,23 @@ function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root
   let filesRead = 0;
   const maxBytes = limits.maxBytes ?? MAX_SCAN_BYTES;
   const maxFiles = limits.maxFiles ?? MAX_SCAN_FILES;
+  const credentials = [];
+  const sources = [];
+  const probes = [];
   for (const relPath of candidates) {
     if (!forced.has(relPath) && !shouldScan(relPath)) continue;
+    if (isCredentialName(basename(relPath))) credentials.push(relPath);
+    else if (isWorthProbing(relPath)) probes.push(relPath);
+    else sources.push(relPath);
+  }
+  for (const relPath of [...credentials, ...sources, ...probes]) {
     const absPath = join2(root, relPath);
     let content;
     try {
-      if (lstatSync2(absPath).isSymbolicLink()) {
-        if (!skipped.some((entry) => entry.path === relPath && entry.reason === "symlink")) {
-          skipped.push({ path: relPath, reason: "symlink", detail: "symbolic links are not followed" });
-        }
-        continue;
-      }
+      if (!readablePath(root, absPath, skipped)) continue;
       const size = statSync2(absPath).size;
-      if (size > MAX_FILE_BYTES) {
+      const needsProbe = isWorthProbing(relPath);
+      if (!needsProbe && size > MAX_FILE_BYTES) {
         skipped.push({
           path: relPath,
           reason: "too-large",
@@ -877,7 +960,8 @@ function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root
         });
         continue;
       }
-      if (filesRead >= maxFiles || bytesRead + size > maxBytes) {
+      const initialBytes = needsProbe ? Math.min(size, PROBE_BYTES) : size;
+      if (filesRead >= maxFiles || bytesRead + initialBytes > maxBytes) {
         skipped.push({
           path: relPath,
           reason: "too-large",
@@ -885,9 +969,30 @@ function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root
         });
         break;
       }
+      filesRead++;
+      if (needsProbe) {
+        const probe = probeFileType(absPath, initialBytes);
+        if (probe.kind === "unreadable") {
+          skipped.push({ path: relPath, reason: "unreadable", detail: probe.detail });
+          continue;
+        }
+        bytesRead += probe.bytes;
+        if (probe.kind === "binary") continue;
+        if (size > MAX_FILE_BYTES) {
+          skipped.push({
+            path: relPath,
+            reason: "too-large",
+            detail: `${Math.round(size / 1024)} KB, cap is ${MAX_FILE_BYTES / 1024} KB`
+          });
+          continue;
+        }
+        if (bytesRead + size > maxBytes) {
+          skipped.push({ path: relPath, reason: "too-large", detail: "scan read budget exceeded after file probe" });
+          break;
+        }
+      }
       const bytes = readFileSync2(absPath);
       bytesRead += bytes.length;
-      filesRead++;
       if (bytesRead > maxBytes) {
         skipped.push({ path: relPath, reason: "too-large", detail: "scan read budget exceeded during file read" });
         break;
@@ -961,6 +1066,8 @@ var BACKSLASH = 92;
 var DOLLAR = 36;
 var OPEN_BRACE = 123;
 var CLOSE_BRACE = 125;
+var LESS_THAN = 60;
+var GREATER_THAN = 62;
 var NEWLINE = 10;
 var SPACE = 32;
 function codesOf(src) {
@@ -997,11 +1104,102 @@ function endOfString(src, start, quote) {
   }
   return length;
 }
-function maskTemplate(src, out, start, maskStrings = true) {
+var REGEX_PREFIX_WORDS = /* @__PURE__ */ new Set(["return", "throw", "case", "delete", "void", "typeof", "instanceof", "in", "of", "new", "yield", "await", "else", "do"]);
+var CONTROL_WORDS = /* @__PURE__ */ new Set(["if", "while", "for", "with", "switch", "catch"]);
+var regexContext = () => ({ allowed: true, control: false, member: false, parentheses: [] });
+function valueEnded(context) {
+  context.allowed = false;
+  context.control = false;
+  context.member = false;
+}
+function regexAt(src, start, context, state) {
+  if (!context.allowed || start < state.failedUntil) return null;
+  let inClass = false;
+  for (let i = start + 1; i < src.length; i++) {
+    const ch = src[i];
+    if (ch === "\n" || ch === "\r") {
+      state.failedUntil = i;
+      return null;
+    }
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === "[") inClass = true;
+    else if (ch === "]") inClass = false;
+    else if (ch === "/" && !inClass) {
+      let end = i + 1;
+      while (end < src.length && /[A-Za-z]/.test(src[end])) end++;
+      valueEnded(context);
+      return { close: i, end };
+    }
+  }
+  state.failedUntil = src.length;
+  return null;
+}
+function advanceCode(src, at, context) {
+  const ch = src[at];
+  if (/\s/.test(ch)) return at + 1;
+  if (/[A-Za-z_$\u0080-￿]/.test(ch)) {
+    let end = at + 1;
+    while (end < src.length && /[\w$\u0080-￿]/.test(src[end])) end++;
+    const word = src.slice(at, end);
+    context.control = !context.member && CONTROL_WORDS.has(word);
+    context.allowed = !context.member && REGEX_PREFIX_WORDS.has(word);
+    context.member = false;
+    return end;
+  }
+  if (ch === "(") {
+    context.parentheses.push(context.control);
+    context.allowed = true;
+  } else if (ch === ")") context.allowed = context.parentheses.pop() ?? false;
+  else if (ch === "." || ch === "?" && src[at + 1] === ".") {
+    context.allowed = false;
+    context.control = false;
+    context.member = true;
+    return at + (ch === "?" ? 2 : 1);
+  } else if ((ch === "+" || ch === "-") && src[at + 1] === ch) {
+    context.control = false;
+    context.member = false;
+    return at + 2;
+  } else context.allowed = !/[\d\]}]/.test(ch);
+  context.control = false;
+  context.member = false;
+  return at + 1;
+}
+var JSX_START = /<(?:>|([A-Za-z_$][\w$.:-]*)(?=[\s/>])(?!\s*(?:,|=|extends\b)))/y;
+function jsxStartsAt(src, at) {
+  JSX_START.lastIndex = at;
+  const match = JSX_START.exec(src);
+  if (!match) return false;
+  const name = match[1];
+  if (!name || !/^[A-Z]/.test(name)) return true;
+  const after = at + 1 + name.length;
+  return !/^>\s*\(/.test(src.slice(after, after + 64));
+}
+function maskSource(src, maskStrings, jsx) {
   const length = src.length;
-  const stack = [{ kind: "literal", from: start + 1 }];
-  let i = start + 1;
-  while (i < length && stack.length > 0) {
+  const out = codesOf(src);
+  const state = { failedUntil: -1 };
+  const stack = [{ kind: "code", depth: 0, lexical: regexContext(), nested: false }];
+  const text = (from, to) => {
+    if (maskStrings) blank(out, from, to);
+  };
+  const expression = () => ({ kind: "code", depth: 1, lexical: regexContext(), nested: true });
+  const skipComment = (at) => {
+    const star = src.charCodeAt(at + 1) === STAR;
+    const close = star ? src.indexOf("*/", at + 2) : src.indexOf("\n", at);
+    const stop = close === -1 ? length : close + (star ? 2 : 0);
+    blank(out, at, stop);
+    return stop;
+  };
+  const elementClosed = (at) => {
+    const parent = stack[stack.length - 1];
+    if (parent?.kind === "children") parent.from = at;
+    else if (parent?.kind === "code") valueEnded(parent.lexical);
+  };
+  let i = 0;
+  while (i < length) {
     const frame = stack[stack.length - 1];
     const ch = src.charCodeAt(i);
     if (frame.kind === "literal") {
@@ -1010,141 +1208,155 @@ function maskTemplate(src, out, start, maskStrings = true) {
         continue;
       }
       if (ch === BACKTICK) {
-        if (maskStrings) blank(out, frame.from, i);
+        text(frame.from, i);
         stack.pop();
+        const parent = stack[stack.length - 1];
+        if (parent?.kind === "code") valueEnded(parent.lexical);
         i++;
         continue;
       }
       if (ch === DOLLAR && src.charCodeAt(i + 1) === OPEN_BRACE) {
-        if (maskStrings) blank(out, frame.from, i);
-        stack.push({ kind: "expression", depth: 1 });
+        text(frame.from, i);
+        stack.push(expression());
         i += 2;
         continue;
       }
       i++;
       continue;
     }
-    if (ch === SLASH) {
-      const next = src.charCodeAt(i + 1);
-      if (next === SLASH || next === STAR) {
-        const close = next === SLASH ? src.indexOf("\n", i) : src.indexOf("*/", i + 2);
-        const stop = close === -1 ? length : close + (next === STAR ? 2 : 0);
-        blank(out, i, stop);
-        i = stop;
+    if (frame.kind === "children") {
+      if (ch === OPEN_BRACE) {
+        text(frame.from, i);
+        stack.push(expression());
+        i++;
+        continue;
+      }
+      if (ch === LESS_THAN && src.charCodeAt(i + 1) === SLASH) {
+        text(frame.from, i);
+        stack.push({ kind: "tag", closing: true });
+        i += 2;
+        continue;
+      }
+      if (ch === LESS_THAN && jsxStartsAt(src, i)) {
+        text(frame.from, i);
+        stack.push({ kind: "tag", closing: false });
+        i++;
         continue;
       }
-    }
-    if (ch === DOUBLE_QUOTE || ch === SINGLE_QUOTE) {
-      const stop = endOfString(src, i, ch);
-      if (maskStrings) blank(out, i + 1, stop - 1);
-      i = stop;
-      continue;
-    }
-    if (ch === BACKTICK) {
-      stack.push({ kind: "literal", from: i + 1 });
       i++;
       continue;
     }
-    if (ch === OPEN_BRACE) frame.depth++;
-    else if (ch === CLOSE_BRACE) {
-      frame.depth--;
-      if (frame.depth === 0) {
-        stack.pop();
-        const parent = stack[stack.length - 1];
-        if (parent.kind === "literal") parent.from = i + 1;
+    if (frame.kind === "tag") {
+      if (ch === SLASH && (src.charCodeAt(i + 1) === SLASH || src.charCodeAt(i + 1) === STAR)) {
+        i = skipComment(i);
+        continue;
       }
-    }
-    i++;
-  }
-  const last = stack[stack.length - 1];
-  if (maskStrings && last?.kind === "literal") blank(out, last.from, length);
-  return i;
-}
-function maskJsComments(src) {
-  const length = src.length;
-  const out = codesOf(src);
-  let i = 0;
-  while (i < length) {
-    const ch = src.charCodeAt(i);
-    if (ch === SLASH) {
-      const next = src.charCodeAt(i + 1);
-      if (next === SLASH) {
-        const end = src.indexOf("\n", i);
-        const stop = end === -1 ? length : end;
-        blank(out, i, stop);
+      if (ch === DOUBLE_QUOTE || ch === SINGLE_QUOTE) {
+        const close = src.indexOf(src[i], i + 1);
+        const stop = close === -1 ? length : close + 1;
+        text(i + 1, close === -1 ? length : close);
         i = stop;
         continue;
       }
-      if (next === STAR) {
-        const close = src.indexOf("*/", i + 2);
-        const stop = close === -1 ? length : close + 2;
-        blank(out, i, stop);
-        i = stop;
+      if (ch === OPEN_BRACE) {
+        stack.push(expression());
+        i++;
         continue;
       }
-    }
-    if (ch === DOUBLE_QUOTE || ch === SINGLE_QUOTE) {
-      i = endOfString(src, i, ch);
-      continue;
-    }
-    if (ch === BACKTICK) {
-      i = maskTemplate(src, out, i, false);
+      if (ch === LESS_THAN && !frame.closing && jsxStartsAt(src, i)) {
+        stack.push({ kind: "tag", closing: false });
+        i++;
+        continue;
+      }
+      if (ch === SLASH && src.charCodeAt(i + 1) === GREATER_THAN && !frame.closing) {
+        stack.pop();
+        elementClosed(i + 2);
+        i += 2;
+        continue;
+      }
+      if (ch === GREATER_THAN) {
+        stack.pop();
+        if (frame.closing) {
+          if (stack[stack.length - 1]?.kind === "children") stack.pop();
+          elementClosed(i + 1);
+        } else {
+          stack.push({ kind: "children", from: i + 1 });
+        }
+        i++;
+        continue;
+      }
+      i++;
       continue;
     }
-    i++;
-  }
-  return stringOf(out);
-}
-function maskJsNoise(src) {
-  const length = src.length;
-  const out = codesOf(src);
-  let i = 0;
-  while (i < length) {
-    const ch = src.charCodeAt(i);
     if (ch === SLASH) {
       const next = src.charCodeAt(i + 1);
-      if (next === SLASH) {
-        const end = src.indexOf("\n", i);
-        const stop = end === -1 ? length : end;
-        blank(out, i, stop);
-        i = stop;
+      if (next === SLASH || next === STAR) {
+        i = skipComment(i);
         continue;
       }
-      if (next === STAR) {
-        const close = src.indexOf("*/", i + 2);
-        const stop = close === -1 ? length : close + 2;
-        blank(out, i, stop);
-        i = stop;
+      const regex = regexAt(src, i, frame.lexical, state);
+      if (regex) {
+        text(i + 1, regex.close);
+        i = regex.end;
         continue;
       }
     }
     if (ch === DOUBLE_QUOTE || ch === SINGLE_QUOTE) {
       const stop = endOfString(src, i, ch);
-      blank(out, i + 1, stop - 1);
+      text(i + 1, stop - 1);
+      valueEnded(frame.lexical);
       i = stop;
       continue;
     }
     if (ch === BACKTICK) {
-      i = maskTemplate(src, out, i);
+      stack.push({ kind: "literal", from: i + 1 });
+      i++;
       continue;
     }
-    i++;
+    const markup = ch === LESS_THAN && !jsx && /^<[A-Za-z_$][\w$.:-]*\s+[\w:-]+\s*=\s*['"{]/.test(src.slice(i, i + 256));
+    if ((jsx || markup) && ch === LESS_THAN && frame.lexical.allowed && jsxStartsAt(src, i)) {
+      stack.push({ kind: "tag", closing: false });
+      i++;
+      continue;
+    }
+    if (ch === OPEN_BRACE) frame.depth++;
+    else if (ch === CLOSE_BRACE) {
+      frame.depth--;
+      if (frame.nested && frame.depth === 0) {
+        stack.pop();
+        const parent = stack[stack.length - 1];
+        if (parent.kind === "literal" || parent.kind === "children") parent.from = i + 1;
+        i++;
+        continue;
+      }
+    }
+    i = advanceCode(src, i, frame.lexical);
   }
+  const last = stack[stack.length - 1];
+  if (last?.kind === "literal" || last?.kind === "children") text(last.from, length);
   return stringOf(out);
 }
+function maskJsComments(src, options = {}) {
+  return maskSource(src, false, options.jsx === true);
+}
+function maskJsNoise(src, options = {}) {
+  return maskSource(src, true, options.jsx === true);
+}
+var JSX_FILE = /\.(?:jsx|tsx|js|mjs|cjs)$/i;
+var maskOptionsOf = (file) => ({ jsx: typeof file.path === "string" && JSX_FILE.test(file.path) });
 var commentCache = /* @__PURE__ */ new WeakMap();
 var noiseCache = /* @__PURE__ */ new WeakMap();
 function commentsMaskedOf(file) {
   const hit = commentCache.get(file);
   if (hit !== void 0) return hit;
-  const masked = maskJsComments(file.content);
+  const masked = maskJsComments(file.content, maskOptionsOf(file));
   commentCache.set(file, masked);
   return masked;
 }
 function noiseMaskedOf(file) {
   const hit = noiseCache.get(file);
   if (hit !== void 0) return hit;
-  const masked = maskJsNoise(file.content);
+  const masked = maskJsNoise(file.content, maskOptionsOf(file));
   noiseCache.set(file, masked);
   return masked;
 }
@@ -1450,7 +1662,7 @@ function checkEnvFile(file) {
           `For anything the browser needs, use the anon key (NEXT_PUBLIC_SUPABASE_ANON_KEY) together with Row Level Security policies.`
         ],
         humanOnly: [
-          `Rotate the service_role key in your Supabase dashboard (Project Settings -> API). If your site has ever been deployed with this key, assume it is already compromised \u2014 renaming the variable does not revoke it.`
+          `Rotate the Supabase service_role key in your Supabase dashboard (Project Settings -> API). If your site has ever been deployed with this key, assume it is already compromised \u2014 renaming the variable does not revoke it.`
         ]
       });
       continue;
@@ -1532,7 +1744,8 @@ function pushServiceRoleJwts(findings, file, line, i, clientSide) {
         `Put it in .env as SUPABASE_SERVICE_ROLE_KEY (no public prefix) and read it via process.env on the server only.`
       ],
       humanOnly: [
-        `Rotate the key in your Supabase dashboard (Project Settings -> API) \u2014 the current one must be treated as compromised.`
+        // 与公开变量中的同类结果使用相同首句，汇总时合并为一个轮换步骤。
+        `Rotate the Supabase service_role key in your Supabase dashboard (Project Settings -> API) \u2014 the current one must be treated as compromised.`
       ]
     });
   }
@@ -1786,8 +1999,9 @@ var gitleakRule = {
         ],
         fix: [`Add ${path} to .gitignore.`, untrackStep(path)],
         humanOnly: [
-          `Rotate every credential in that file. This is the step people skip, and it is the only one that actually stops the leak.`,
-          `Removing it from history entirely requires rewriting the repo (git filter-repo or BFG). Do that only after rotating the keys \u2014 rotation is what matters, and history rewriting is disruptive enough that it should be a deliberate decision.`
+          // 人工步骤会被单独汇总，首句须写明文件并能独立执行。
+          `Rotate every credential in ${path}. This is the step people skip, and it is the only one that actually stops the leak.`,
+          `If you want ${path} gone from git history, rewrite the history with git filter-repo or BFG Repo-Cleaner after rotating the keys. Rotation is what matters; history rewriting is disruptive enough that it should be a deliberate decision.`
         ]
       });
       reportedTracked.add(path);
@@ -1829,8 +2043,8 @@ var gitleakRule = {
         ],
         fix: stillTracked ? [`Add ${path} to .gitignore.`, untrackStep(path)] : [`Confirm ${path} is in .gitignore so it does not come back.`],
         humanOnly: [
-          `Rotate every credential that was ever in this file. Do this first, and do not skip it \u2014 it is the only step that actually revokes access.`,
-          `Then, if you need the history cleaned, rewrite it with git filter-repo or BFG Repo-Cleaner. Do this deliberately: it rewrites every commit hash and disrupts anyone else working on the repo.`
+          `Rotate every credential that was ever in ${path}. Do this first, and do not skip it \u2014 it is the only step that actually revokes access.`,
+          `If you want ${path} gone from git history, rewrite the history with git filter-repo or BFG Repo-Cleaner after rotating the keys. Do this deliberately: it rewrites every commit hash and disrupts anyone else working on the repo.`
         ]
       });
     }
@@ -2460,8 +2674,8 @@ var supabaseRlsRule = {
           `Keep this in a migration rather than only in the dashboard, so the rule travels with your code.`
         ],
         humanOnly: [
-          `Check the real state first: open Table Editor in the Supabase dashboard and look for the "RLS disabled" badge on "${entry.table}". The repository cannot tell you whether RLS was turned on there.`,
-          `If this table has been live without RLS, assume its contents have already been read.`
+          // 后果说明并入同一步骤，汇总时不会变成脱离表名的独立条目。
+          `Check the real state first: open Table Editor in the Supabase dashboard and look for the "RLS disabled" badge on "${entry.table}". The repository cannot tell you whether RLS was turned on there. If the table has been live without RLS, assume its contents have already been read.`
         ]
       });
     }
@@ -2551,18 +2765,19 @@ function policyFindings(ctx, policies, live, keyOf, buckets) {
       ruleId: "supabase/permissive-policy",
       severity: "P1",
       confidence: modifiesAny && !needsReview ? "certain" : "likely",
-      title: needsReview ? `Policy "${p.name}" has an unrestricted condition on ${table}; other conditions require review` : opensRows ? `Policy "${p.name}" lets ${audience} ${verb} every row of ${table}` : `Policy "${p.name}" lets ${audience} write any values into ${table}`,
+      title: hasRestriction ? `Policy "${p.name}" has an unrestricted condition on ${table}; other conditions require review` : limitedCheck ? `Policy "${p.name}" lets ${audience} target any row of ${table} for updates; only the new values are checked` : opensRows ? `Policy "${p.name}" lets ${audience} ${verb} every row of ${table}` : `Policy "${p.name}" lets ${audience} write any values into ${table}`,
       file: p.file,
       line: p.line,
       excerpt: excerpt(p.file, p.line),
       why: [
         `This policy contains an always-true condition. Permissive policies combine with OR, while applicable restrictive policies combine with AND. Database grants, SELECT policies and WITH CHECK conditions may further limit access.`,
         ...hasRestriction ? ["A restrictive policy on this table may limit access; verify its command and role coverage."] : [],
-        ...limitedCheck ? ["The WITH CHECK condition is not known to be always true, so unrestricted updates are not established."] : [],
+        // PostgreSQL：USING 决定可更新的已有行，WITH CHECK 只约束写回的新行；带条件的更新还需通过 SELECT 策略。
+        ...limitedCheck ? ["USING is always true, so this policy does not limit which existing rows can be updated. WITH CHECK only validates the values written back: a caller may overwrite other users' rows, for example by setting the owner column to their own ID. Updates that filter or return rows must also pass SELECT policies, which may prevent this."] : [],
         ...p.command === "select" || p.command === "insert" ? [`Public read-only tables and open forms can be intentional. If this one is, keep it and consider restricting the columns the API exposes.`] : []
       ],
       fix: [
-        `Replace the condition with one that ties each row to its owner, e.g. USING ((select auth.uid()) = user_id)${p.command === "insert" || p.command === "update" || p.command === "all" ? " and WITH CHECK ((select auth.uid()) = user_id)" : ""}.`,
+        `Tie each row to its owner; adapt user_id to your schema. For ${p.command.toUpperCase()}, use ` + (p.command === "insert" ? "WITH CHECK ((select auth.uid()) = user_id)." : `USING ((select auth.uid()) = user_id)${p.command === "update" || p.command === "all" ? " and WITH CHECK ((select auth.uid()) = user_id)" : ""}.`),
         `If a broad policy is needed as a base, add an AS RESTRICTIVE policy alongside it to limit which rows it reaches.`,
         `Keep the change in a migration, so the rule travels with your code.`
       ],
@@ -2664,7 +2879,7 @@ function checkRealtimeRules(file, ctx) {
         ]
       ],
       fix: [
-        `Require sign-in and ownership instead, for example: ".read": "auth !== null && auth.uid === $uid" under a "$uid" node.`,
+        `Require sign-in and ownership for ${[openRead ? ".read" : "", openWrite ? ".write" : ""].filter(Boolean).join(" and ")}. For a per-user "$uid" node, use "auth !== null && auth.uid === $uid" for each of those rule values; adapt the path to your data model.`,
         `Test the new rules with the Firebase emulator before deploying.`,
         ...openWrite ? [`If this database has been open for a while, assume the data has already been copied or changed.`] : []
       ]
@@ -2718,6 +2933,18 @@ var WRITE_OPS = /* @__PURE__ */ new Set(["write", "create", "update", "delete"])
 function parseOps(raw) {
   return raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
 }
+function ownershipAdvice(product, rawOps) {
+  const prefix = `Replace the open or date-based condition for ${rawOps.trim()} with authentication and ownership checks. `;
+  if (product !== "Firestore") {
+    return prefix + "Bind request.auth.uid to the owner in the matched path or trusted metadata; use rules for your Firebase product and data model. Do not grant additional operations.";
+  }
+  const ops = new Set(parseOps(rawOps));
+  const checks = ["Require request.auth != null. Adapt userId to your ownership field."];
+  if (ops.has("create") || ops.has("write")) checks.push("For create, check request.resource.data.userId == request.auth.uid; no existing resource is available.");
+  if (ops.has("update") || ops.has("write")) checks.push("For update, check resource.data.userId == request.auth.uid and request.resource.data.userId == resource.data.userId to prevent ownership changes.");
+  if (["read", "get", "list", "delete", "write"].some((op) => ops.has(op))) checks.push("For read or delete operations already allowed here, check resource.data.userId == request.auth.uid.");
+  return prefix + checks.join(" ") + " Do not grant additional operations.";
+}
 function neutralizePathWildcards(content) {
   return content.replace(/\{[a-zA-Z_]\w*(?:\s*=\s*\*\*)?\}/g, (m) => "_".repeat(m.length));
 }
@@ -2816,7 +3043,7 @@ var firebaseRulesRule = {
           `Writes are still denied by default, so this is only a problem if the data is not meant to be public. If it is a public catalogue or announcements, ignore this \u2014 and consider adding "allow write: if false;" to make that intent explicit.`
         ],
         fix: canWrite ? [
-          `Decide who should actually have access. For per-user data the usual rule is: allow read, write: if request.auth != null && request.auth.uid == resource.data.userId;`,
+          ownershipAdvice(product, rawOps),
           `For data that is genuinely public, restrict it to reads only: allow read: if true; allow write: if false;`,
           `Test your rules with the Firebase emulator before deploying, so you do not lock yourself out.`,
           `If this database has been open for a while, assume the data has already been copied.`
@@ -2854,7 +3081,7 @@ var firebaseRulesRule = {
           `Neither state is what you want in production.`
         ],
         fix: [
-          `Replace the date check with a real authorisation rule. For per-user data: allow read, write: if request.auth != null && request.auth.uid == resource.data.userId;`,
+          ownershipAdvice(product, rawOps),
           `Test the new rules with the Firebase emulator before deploying.`,
           expired ? `Note that your app is currently denied access here, so fixing this also fixes whatever stopped working.` : `Do this before ${dateStr}, otherwise your app breaks on that date.`
         ]
@@ -2907,6 +3134,266 @@ function namePattern(names) {
   return [...names].map((name) => name.replace(/\$/g, "\\$")).join("|");
 }
 
+// src/rules/auth-values.ts
+function project(value, path) {
+  let current = value;
+  for (const property of path) {
+    if (current.kind === "envelope") current = property === "data" ? { kind: "data", field: current.field } : { kind: "opaque" };
+    else if (current.kind === "data") current = property === current.field ? { kind: "identity" } : { kind: "opaque" };
+    else break;
+  }
+  return current;
+}
+var limited = /* @__PURE__ */ new WeakSet();
+var cache2 = /* @__PURE__ */ new WeakMap();
+var reverseCache = /* @__PURE__ */ new WeakMap();
+var identityFlowLimited = (file) => limited.has(file);
+function bindingNames(pattern, path = []) {
+  const text = pattern.trim();
+  if (path.length > 8) return (text.match(/[A-Za-z_$][\w$]*/g) ?? []).map((name) => ({ name, path: null }));
+  if (/^[A-Za-z_$][\w$]*$/.test(text)) return [{ name: text, path }];
+  if (text.startsWith("{") && text.endsWith("}")) {
+    const parts = [];
+    let from = 1, depth = 0;
+    for (let i = 1; i < text.length - 1; i++) {
+      if ("{[(".includes(text[i])) depth++;
+      else if ("}])".includes(text[i])) depth--;
+      else if (text[i] === "," && depth === 0) {
+        parts.push(text.slice(from, i));
+        from = i + 1;
+      }
+    }
+    parts.push(text.slice(from, -1));
+    const result = [];
+    for (const part of parts) {
+      if (!part.trim()) continue;
+      const property = /^\s*([A-Za-z_$][\w$]*)(?:\s*:\s*([^=]+))?\s*$/.exec(part);
+      if (property) result.push(...bindingNames(property[2] ?? property[1], [...path, property[1]]));
+      else for (const name of part.match(/[A-Za-z_$][\w$]*/g) ?? []) result.push({ name, path: null });
+    }
+    return result;
+  }
+  return (text.match(/[A-Za-z_$][\w$]*/g) ?? []).map((name) => ({ name, path: null }));
+}
+function argumentExpressions(code, source, start, end, pairs) {
+  const result = [];
+  let from = start;
+  for (let i = start; i < end; i++) {
+    if (code[i] === ",") {
+      result.push(source.slice(from, i).trim());
+      from = i + 1;
+    }
+    const close = pairs.get(i);
+    if (close !== void 0) i = close;
+  }
+  if (from < end) result.push(source.slice(from, end).trim());
+  return result;
+}
+function authValuesOf(file, body, bodies, pairs) {
+  let contexts = cache2.get(file);
+  if (!contexts) {
+    contexts = /* @__PURE__ */ new Map();
+    cache2.set(file, contexts);
+  }
+  let found = contexts.get(body.start);
+  if (!found) {
+    found = new AuthValues(file, body, bodies, pairs);
+    contexts.set(body.start, found);
+  }
+  return found;
+}
+var AuthValues = class {
+  constructor(file, body, bodies, pairs) {
+    this.file = file;
+    const code = noiseMaskedOf(file);
+    const source = commentsMaskedOf(file);
+    let open = code.indexOf("(", body.declaration);
+    let close = pairs.get(open);
+    if (code.startsWith("=>", body.declaration)) {
+      const window = code.slice(Math.max(0, body.declaration - 300), body.declaration);
+      const before = window.trimEnd();
+      if (before.endsWith(")")) {
+        close = body.declaration - (window.length - before.length) - 1;
+        let reverse = reverseCache.get(file);
+        if (!reverse) {
+          reverse = new Map([...pairs].map(([left, right]) => [right, left]));
+          reverseCache.set(file, reverse);
+        }
+        open = reverse.get(close) ?? -1;
+      } else {
+        const single = /([A-Za-z_$][\w$]*)$/.exec(before)?.[1];
+        if (single) this.parameters.set(single, 0);
+        open = -1;
+      }
+    }
+    if (open >= 0 && close !== void 0 && close < body.start) {
+      argumentExpressions(code, code, open + 1, close, pairs).forEach((part, index) => {
+        const name = /^([A-Za-z_$][\w$]*)(?:\s*\??\s*:[^=]+)?$/.exec(part)?.[1];
+        if (name) this.parameters.set(name, index);
+      });
+    }
+    const text = code.slice(body.start + 1, body.end);
+    const endOf = (start) => {
+      const boundary = Math.min(body.end, start + 4001);
+      let previous = "";
+      for (let i = start; i < boundary; i++) {
+        if (code[i] === ";" || code[i] === "}") return i;
+        if (code[i] === "\n") {
+          let next = i + 1;
+          while (next < boundary && /\s/.test(code[next])) next++;
+          if (next === boundary && boundary < body.end) return boundary;
+          if (!/[.?+\-*/%&|^,:([`=]/.test(code[next] ?? "") && !/[=+\-*/%&|^?:,.]/.test(previous)) return i;
+          i = next - 1;
+          continue;
+        }
+        if (!/\s/.test(code[i])) previous = code[i];
+        const close2 = pairs.get(i);
+        if (close2 !== void 0) {
+          i = close2;
+          previous = code[close2];
+        }
+      }
+      return boundary;
+    };
+    for (const match2 of text.matchAll(/\b(?:if|for|while|switch|catch)\s*\(/g)) {
+      const close2 = pairs.get(body.start + 1 + match2.index + match2[0].length - 1);
+      if (close2 === void 0) continue;
+      let start = close2 + 1;
+      while (/\s/.test(code[start] ?? "")) start++;
+      this.conditions.push({ start, end: pairs.get(start) ?? endOf(start) });
+      if (this.conditions.length > 512) {
+        this.exhausted = true;
+        limited.add(file);
+        break;
+      }
+    }
+    let low = 0, high = bodies.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (bodies[middle].declaration <= body.start) low = middle + 1;
+      else high = middle;
+    }
+    const nested = [];
+    for (let i = low; i < bodies.length && bodies[i].declaration < body.end; i++) nested.push(bodies[i]);
+    let nestedIndex = 0;
+    let count = 0;
+    const declarations = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*|[\[{])|(?<![\w$.])([A-Za-z_$][\w$]*)\s*=(?!=|>)/g;
+    let match;
+    while ((match = declarations.exec(text)) !== null) {
+      if (this.exhausted) break;
+      const at = body.start + 1 + match.index;
+      while (nestedIndex < nested.length && nested[nestedIndex].end < at) nestedIndex++;
+      if (nested[nestedIndex] && at >= nested[nestedIndex].declaration && at < nested[nestedIndex].end) continue;
+      if (++count > 512) {
+        this.exhausted = true;
+        limited.add(file);
+        break;
+      }
+      let binding = match[1] ?? match[2];
+      let from = at + match[0].length;
+      if (match[1]) {
+        if (binding === "{" || binding === "[") {
+          const start = from - 1;
+          const close2 = pairs.get(start);
+          if (close2 === void 0) continue;
+          if (close2 - start > 4e3) {
+            this.exhausted = true;
+            limited.add(file);
+            break;
+          }
+          binding = code.slice(start, close2 + 1);
+          from = close2 + 1;
+        }
+        while (/\s/.test(code[from] ?? "")) from++;
+        if (code[from] === ":") {
+          const type = /^:[^=;\n]{1,120}/.exec(code.slice(from, from + 121));
+          if (type) from += type[0].length;
+        }
+        if (code[from] !== "=" || /[=>]/.test(code[from + 1] ?? "")) continue;
+        from++;
+      }
+      while (/\s/.test(code[from] ?? "")) from++;
+      declarations.lastIndex = from - body.start - 1;
+      const end = endOf(from);
+      for (const { name, path } of bindingNames(binding)) {
+        if (!this.assignments.has(name) && this.assignments.size >= 512) {
+          this.exhausted = true;
+          limited.add(file);
+          break;
+        }
+        const list = this.assignments.get(name) ?? [];
+        list.push({ at, expression: end - from <= 4e3 ? source.slice(from, end).trim() : "", projection: path, overLimit: end - from > 4e3 });
+        this.assignments.set(name, list);
+      }
+    }
+  }
+  file;
+  assignments = /* @__PURE__ */ new Map();
+  parameters = /* @__PURE__ */ new Map();
+  conditions = [];
+  exhausted = false;
+  value(expression, at, depth = 0) {
+    if (depth >= 8) limited.add(this.file);
+    if (this.exhausted || depth >= 8) return { kind: "opaque" };
+    const expr = expression.trim();
+    if (expr.length > 4e3) {
+      limited.add(this.file);
+      return { kind: "opaque" };
+    }
+    if (/^process\.env\.[A-Z_][A-Z0-9_]*$/.test(expr)) return { kind: "secret" };
+    const template = /^`[^`$]*\$\{([^{}`]{1,200})\}[^`$]*`$/.exec(expr);
+    if (template) return this.value(template[1], at, depth + 1).kind === "secret" ? { kind: "secret" } : { kind: "literal" };
+    if (/^(?:(?:true|false|null|undefined)\b|\d|['"`{\[])/.test(expr)) return { kind: "literal" };
+    const call = /^(?:await\s+)?((?:[A-Za-z_$][\w$]*\.)*(?:getUser|getClaims|getUserSession|getSession|getServerSession|safeGetSession|currentUser|verifyIdToken|auth))\s*\(/.exec(expr);
+    const callee = call?.[1];
+    const identityCall = callee && !/\.(?:body|query|headers|cookies)\b/.test(callee);
+    if (identityCall) {
+      if (!/^await\s+/.test(expr)) return { kind: "promise" };
+      const masked = maskJsNoise(expr);
+      let depth2 = 1, end = call[0].length;
+      for (; end < masked.length && depth2 > 0; end++) {
+        if (masked[end] === "(") depth2++;
+        else if (masked[end] === ")") depth2--;
+      }
+      if (depth2 !== 0 || masked.slice(end).trim() !== "") return { kind: "opaque" };
+      if (/\|\||&&|\?(?!\.)|\.then\s*\(/.test(expr) || /\.catch\s*\(/.test(expr)) return { kind: "opaque" };
+      if (/\.auth\.getSession\s*\($/.test(call[0])) return { kind: "opaque" };
+      const envelope = /\.auth\.(getUser|getClaims)\s*\($/.exec(call[0])?.[1];
+      if (envelope) return { kind: "envelope", field: envelope === "getUser" ? "user" : "claims" };
+      return { kind: "identity" };
+    }
+    if (/\.(?:body|query|headers|cookies|searchParams)\b|\.(?:json|text|formData)\s*\(/.test(expr)) return { kind: "input" };
+    const access = /^([A-Za-z_$][\w$]*)((?:\??\.[A-Za-z_$][\w$]*)*)$/.exec(expr);
+    if (!access) return { kind: "opaque" };
+    const name = access[1];
+    const list = this.assignments.get(name) ?? [];
+    let low = 0, high = list.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (list[middle].at < at) low = middle + 1;
+      else high = middle;
+    }
+    const assignment = list[low - 1];
+    let value;
+    if (assignment) {
+      if (assignment.overLimit) {
+        limited.add(this.file);
+        return { kind: "opaque" };
+      }
+      if (this.conditions.some((range) => range.start <= assignment.at && assignment.at <= range.end && !(range.start <= at && at <= range.end))) return { kind: "opaque" };
+      value = this.value(assignment.expression, assignment.at, depth + 1);
+      value = assignment.projection === null ? { kind: "opaque" } : project(value, assignment.projection);
+    } else if (this.parameters.has(name)) value = { kind: "parameter", parameters: [this.parameters.get(name)] };
+    else value = { kind: "unknown" };
+    return project(value, access[2].split(/\??\./).filter(Boolean));
+  }
+};
+function identityRequirement(value, allowParameters) {
+  if (value.kind === "identity") return [];
+  if (allowParameters && value.kind === "parameter") return value.parameters ?? [];
+  return null;
+}
+
 // src/rules/apiauth.ts
 var APP_ROUTER = /(?:^|\/)app\/api\/(?:.+\/)?route\.[mc]?[jt]sx?$/;
 var PAGES_ROUTER = /(?:^|\/)pages\/api\/.+\.[mc]?[jt]sx?$/;
@@ -3124,6 +3611,8 @@ var ACCESS_CHAIN = String.raw`[\w$]+(?:\??\.[\w$]+)*`;
 var NEGATED_IDENTITY = new RegExp(`^!\\s*${ACCESS_CHAIN}(?:\\s*\\([^=]*\\))?$`);
 var IDENTITY_IS_EMPTY = new RegExp(`^${ACCESS_CHAIN}\\s*={2,3}\\s*(?:null|undefined|false)$`);
 var IDENTITY_MISMATCH = new RegExp(`^${ACCESS_CHAIN}\\s*!={1,2}\\s*(?!(?:null|undefined|false)\\b)${ACCESS_CHAIN}$`);
+var COMPARED_VALUE = String.raw`(?!(?:null|undefined|true|false)\b)(?:${ACCESS_CHAIN}(?:\s*\([^()]{0,200}\))?|\`[^\`]{0,300}\`)`;
+var SECRET_MISMATCH = new RegExp(`^${COMPARED_VALUE}\\s*!={1,2}\\s*${COMPARED_VALUE}$`);
 var STOPS_REQUEST = /^(?:(?:return|throw|redirect|notFound)\b|error\s*\(\s*40[13]\b)/;
 var DENIED_STATUS = /\b(?:return|throw)\b[\s\S]{0,300}\bstatus(?:Code)?\s*[:(=]\s*(?:401|403)\b|\berror\s*\(\s*40[13]\b/i;
 function closingDelimiter(source, start, open, close) {
@@ -3153,7 +3642,7 @@ function rejectsMissingIdentity(term, returnsDeniedStatus) {
   const rejects = NEGATED_IDENTITY.test(term) || IDENTITY_IS_EMPTY.test(term) || IDENTITY_MISMATCH.test(term);
   return rejects && (AUTH_CONDITION.test(term) || returnsDeniedStatus);
 }
-function hasConditionalAuthGuard(code) {
+function hasConditionalAuthGuard(code, requireThrow = false, accept) {
   const starts = /\bif\s*\(/g;
   let match;
   while ((match = starts.exec(code)) !== null) {
@@ -3167,7 +3656,7 @@ function hasConditionalAuthGuard(code) {
     let stopsRequest = false;
     for (let i = 0; i < body.length; i++) {
       if (STOPS_REQUEST.test(body.slice(i, i + 16)) && (i === 0 || !/[\w$]/.test(body[i - 1]))) {
-        stopsRequest = true;
+        stopsRequest = !requireThrow || !/^return\b/.test(body.slice(i, i + 16));
         break;
       }
       if (/^if\s*\(/.test(body.slice(i, i + 16))) break;
@@ -3179,7 +3668,10 @@ function hasConditionalAuthGuard(code) {
     starts.lastIndex = statementStart + statement.length;
     if (!stopsRequest) continue;
     const returnsDeniedStatus = DENIED_STATUS.test(statement);
-    const negative = !/&&|\?(?!\.)/.test(condition) && condition.split("||").some((part) => rejectsMissingIdentity(part.trim(), returnsDeniedStatus));
+    const negative = !/&&|\?(?!\.)/.test(condition) && condition.split("||").some((part) => {
+      const term = part.trim();
+      return accept ? (NEGATED_IDENTITY.test(term) || IDENTITY_IS_EMPTY.test(term) || IDENTITY_MISMATCH.test(term) || SECRET_MISMATCH.test(term)) && accept(term) : rejectsMissingIdentity(term, returnsDeniedStatus);
+    });
     if (negative) return true;
   }
   return false;
@@ -3281,6 +3773,18 @@ function unguardedOpsOf(file) {
   }
   return hit;
 }
+function operationsInRange(ops, start, end) {
+  const lowerBound2 = (value) => {
+    let low = 0, high = ops.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (ops[middle].index < value) low = middle + 1;
+      else high = middle;
+    }
+    return low;
+  };
+  return ops.slice(lowerBound2(start + 1), lowerBound2(end));
+}
 var lineStartsCache = /* @__PURE__ */ new WeakMap();
 function lineStartsCached(file) {
   let hit = lineStartsCache.get(file);
@@ -3290,39 +3794,97 @@ function lineStartsCached(file) {
   }
   return hit;
 }
-function cachedByFile(check) {
-  const cache2 = /* @__PURE__ */ new WeakMap();
+function cachedByFile(check2) {
+  const cache3 = /* @__PURE__ */ new WeakMap();
   return (file) => {
-    let hit = cache2.get(file);
+    let hit = cache3.get(file);
     if (hit === void 0) {
-      hit = check(file);
-      cache2.set(file, hit);
+      hit = check2(file);
+      cache3.set(file, hit);
     }
     return hit;
   };
 }
-function unguardedOperations(file, ops, extra) {
+var localAuthNamesCache = /* @__PURE__ */ new WeakMap();
+var controlFlowLimited = /* @__PURE__ */ new WeakSet();
+function localAuthNames(file) {
+  const cached = localAuthNamesCache.get(file);
+  if (cached) return cached;
+  const names = new Set(bindingsOf(file).imports.filter((binding) => binding.spec && normalizeSpec(binding.spec, file.path)).map((binding) => binding.local));
+  const { declared, shadowed } = guardBindings(file);
+  for (const name of declared) names.add(name);
+  for (const name of shadowed) names.add(name);
+  localAuthNamesCache.set(file, names);
+  return names;
+}
+function unguardedOperations(file, ops, extra, requireThrow = false, observe) {
   if (ops.length === 0) return ops;
   const code = noiseMaskedOf(file);
   const pairs = delimiterPairs(code);
   const bodies = functionBodies(code, pairs);
   const declarations = new Map(bodies.map((body) => [body.declaration, body]));
   const functionStarts = new Set(bodies.map((body) => body.start));
+  const bodiesByStart = new Map(bodies.map((body) => [body.start, body]));
+  const localNames = localAuthNames(file);
   const guardEnds = /* @__PURE__ */ new Map();
   const guardNames = /* @__PURE__ */ new Map();
+  const guardRequirements = /* @__PURE__ */ new Map();
   const extraCalls = extra?.guards.size ? new RegExp(`^(${namePattern(extra.guards)})\\s*\\(`) : null;
   const blocks = [...pairs].filter(([start]) => code[start] === "{").map(([start, end]) => ({ start, end })).sort((a, b) => a.start - b.start);
   const active = [];
   let blockIndex = 0;
   const wrapperPattern = extra?.wrappers.size ? new RegExp(`(?<![\\w$.])(${namePattern(extra.wrappers)})\\s*\\(`, "g") : null;
   const wrappers = [
-    ...code.matchAll(/\b(withAuth|NextAuth)\s*\(/g),
+    ...[...code.matchAll(/\b(withAuth|NextAuth)\s*\(/g)].filter((match) => !localNames.has(match[1])),
     ...wrapperPattern ? code.matchAll(wrapperPattern) : []
   ].map((match) => {
     const open = match.index + match[0].length - 1;
     return { start: open, end: pairs.get(open) ?? open, name: match[1] };
   });
-  const guardEnd = (owner) => {
+  const skipSpace = (at) => {
+    while (/\s/.test(code[at] ?? "")) at++;
+    return at;
+  };
+  const blockAt = (at) => {
+    const start = skipSpace(at);
+    const end = pairs.get(start);
+    return code[start] === "{" && end !== void 0 ? { start, end } : null;
+  };
+  const denies = (block) => {
+    for (let i = block.start + 1; i < block.end; i++) {
+      if (i > 0 && /[\w$]/.test(code[i - 1])) continue;
+      const tail = code.slice(i, i + 400);
+      if (/^(?:if|for|while|switch|try)\b/.test(tail)) return false;
+      if (/^(?:throw|redirect|notFound)\b|^error\s*\(\s*40[13]\b/.test(tail)) return true;
+      if (/^return\b/.test(tail)) return !requireThrow && DENIED_STATUS.test(code.slice(i, statementEnd2(code, i, block.end, pairs)));
+      const end = pairs.get(i);
+      if (end !== void 0) i = end;
+    }
+    return false;
+  };
+  const checkedEnd = (block, fn, depth) => {
+    const cached = guardEnds.get(block.start);
+    if (cached !== void 0) return cached;
+    const result = guardEnd(block, fn, depth);
+    guardEnds.set(block.start, result);
+    return result;
+  };
+  const allProtected = (owner, children, fn, depth) => {
+    const required = /* @__PURE__ */ new Set();
+    for (const child of children) {
+      if (!Number.isFinite(checkedEnd(child, fn, depth + 1)) && !denies(child)) return false;
+      for (const argument of guardRequirements.get(child.start) ?? []) required.add(argument);
+    }
+    guardRequirements.set(owner.start, [...required]);
+    const name = children.map((child) => guardNames.get(child.start)).find(Boolean);
+    if (name) guardNames.set(owner.start, name);
+    return true;
+  };
+  const guardEnd = (owner, fn, depth = 0) => {
+    if (depth > 8) {
+      controlFlowLimited.add(file);
+      return Infinity;
+    }
     for (let i = owner.start + 1; i < owner.end; i++) {
       const nested = declarations.get(i);
       if (nested) {
@@ -3334,6 +3896,35 @@ function unguardedOperations(file, ops, extra) {
         continue;
       }
       if (i > 0 && /[\w$]/.test(code[i - 1])) continue;
+      if (/^try\s*\{/.test(code.slice(i, i + 32))) {
+        const attempted = blockAt(i + 3);
+        if (attempted) {
+          let cursor = skipSpace(attempted.end + 1);
+          const children = [attempted];
+          if (/^catch\b/.test(code.slice(cursor, cursor + 8))) {
+            cursor = skipSpace(cursor + 5);
+            if (code[cursor] === "(") cursor = skipSpace((pairs.get(cursor) ?? cursor) + 1);
+            const caught = blockAt(cursor);
+            if (!caught) {
+              i = attempted.end;
+              continue;
+            }
+            children.push(caught);
+            cursor = skipSpace(caught.end + 1);
+          }
+          let overrides = false;
+          if (/^finally\b/.test(code.slice(cursor, cursor + 10))) {
+            const final = blockAt(cursor + 7);
+            if (final) {
+              overrides = /\breturn\b/.test(code.slice(final.start + 1, final.end));
+              cursor = final.end + 1;
+            }
+          }
+          if (!overrides && allProtected(owner, children, fn, depth)) return cursor;
+          i = cursor - 1;
+          continue;
+        }
+      }
       const conditional = /^if\s*\(/.exec(code.slice(i, i + 32));
       if (conditional) {
         const open = i + conditional[0].length - 1;
@@ -3342,12 +3933,41 @@ function unguardedOperations(file, ops, extra) {
         let start = close2 + 1;
         while (/\s/.test(code[start] ?? "")) start++;
         const end = statementEnd2(code, start, owner.end, pairs);
-        if (end <= owner.end && hasConditionalAuthGuard(code.slice(i, end))) return end;
+        const required = /* @__PURE__ */ new Set();
+        const values = authValuesOf(file, fn, bodies, pairs);
+        const accepted = hasConditionalAuthGuard(code.slice(i, end), requireThrow, (term) => {
+          const mismatch = /^(.*?)\s*!={1,2}\s*(.*?)$/.exec(term);
+          if (mismatch && (values.value(mismatch[1], i).kind === "secret" || values.value(mismatch[2], i).kind === "secret")) return true;
+          const subject = term.replace(/^!\s*/, "").split(/\s*(?:={2,3}|!={1,2})\s*/)[0];
+          const value = values.value(subject, i);
+          const dependencies = identityRequirement(value, !!observe);
+          if (dependencies) {
+            dependencies.forEach((index) => required.add(index));
+            return true;
+          }
+          return !observe && value.kind === "unknown" && rejectsMissingIdentity(term, DENIED_STATUS.test(code.slice(i, end)));
+        });
+        if (end <= owner.end && accepted) {
+          guardRequirements.set(owner.start, [...required]);
+          return end;
+        }
+        const other = skipSpace(end);
+        if (/^else\b/.test(code.slice(other, other + 8))) {
+          const first = blockAt(start);
+          const second = blockAt(other + 4);
+          if (first && second) {
+            if (allProtected(owner, [first, second], fn, depth)) return second.end + 1;
+            i = second.end;
+            continue;
+          }
+        }
         i = Math.min(end, owner.end) - 1;
         continue;
       }
       const indirectCall = i > 0 && /[\w$.]/.test(code[i - 1]) ? null : extraCalls?.exec(code.slice(i, i + 100));
       const call = indirectCall ?? AUTH_ENFORCING_CALL.exec(code.slice(i, i + 100));
+      const callName = call?.[0].replace(/\s*\($/, "");
+      if (!indirectCall && call?.index === 0 && callName && localNames.has(callName)) continue;
       if (call?.index === 0 && !/^(?:withAuth|NextAuth)\b/i.test(call[0]) && !/\bfunction\s*$/.test(code.slice(Math.max(owner.start, i - 30), i))) {
         const prefixStart = Math.max(
           owner.start + 1,
@@ -3356,11 +3976,27 @@ function unguardedOperations(file, ops, extra) {
         );
         const prefix = code.slice(prefixStart, i).trim();
         if (/(?:&&|\|\||\?|:)\s*$/.test(code.slice(owner.start + 1, prefixStart))) continue;
-        const awaited = /^(?:await|(?:const|let|var)\s+[\w${},:\s]+?=\s*await)(?:\s+[\w$.]+\.)?$/.test(prefix);
+        const awaited = /^(?:await|(?:const|let|var)\s+[\w${},:\s]+?=\s*await)(?:\s+[\w$.]+\.)?$/.test(prefix) || requireThrow && /^return(?:\s+await)?$/.test(prefix);
         const synchronous = /^(?:assertAuth(?:enticated)?|constructEvent)\b/i.test(call[0]) && /^(?:(?:const|let|var)\s+[\w$]+\s*=\s*)?(?:[\w$]+\.)*$/.test(prefix);
         if (!awaited && !synchronous) continue;
         const close2 = pairs.get(i + call[0].length - 1);
         if (close2 !== void 0 && close2 < owner.end) {
+          if (/^\s*(?:\.|\?\.)/.test(code.slice(close2 + 1, close2 + 100))) continue;
+          const required = /* @__PURE__ */ new Set();
+          const requirements = indirectCall ? extra?.requirements?.get(indirectCall[1]) ?? [] : [];
+          const argumentsOfCall = requirements.length ? argumentExpressions(code, commentsMaskedOf(file), i + call[0].length, close2, pairs) : [];
+          let valid = true;
+          for (const argument of requirements) {
+            const origin = authValuesOf(file, fn, bodies, pairs).value(argumentsOfCall[argument] ?? "undefined", i);
+            const dependencies = identityRequirement(origin, !!observe);
+            if (!dependencies) {
+              valid = false;
+              break;
+            }
+            dependencies.forEach((index) => required.add(index));
+          }
+          if (!valid) continue;
+          guardRequirements.set(owner.start, [...required]);
           if (indirectCall) guardNames.set(owner.start, indirectCall[1]);
           return close2 + 1;
         }
@@ -3379,6 +4015,8 @@ function unguardedOperations(file, ops, extra) {
     while (active.length && active[active.length - 1].end < op.index) active.pop();
     const wrapper = wrappers.find((w) => w.start < op.index && w.end > op.index);
     if (wrapper) {
+      if (extra?.requirements?.get(wrapper.name)?.length) return true;
+      observe?.(op.index, []);
       if (extra?.wrappers.has(wrapper.name)) extra.onGuard(op.index, wrapper.name);
       return false;
     }
@@ -3389,10 +4027,11 @@ function unguardedOperations(file, ops, extra) {
       const block = active[index];
       let end = guardEnds.get(block.start);
       if (end === void 0) {
-        end = guardEnd(block);
+        end = guardEnd(block, bodiesByStart.get(active[ownerIndex].start));
         guardEnds.set(block.start, end);
       }
       if (end <= op.index) {
+        observe?.(op.index, guardRequirements.get(block.start) ?? []);
         const name = guardNames.get(block.start);
         if (name) extra?.onGuard(op.index, name);
         return false;
@@ -3605,7 +4244,7 @@ var definitionsCache = /* @__PURE__ */ new WeakMap();
 function guardDefinitions(file) {
   const cached = definitionsCache.get(file);
   if (cached) return cached;
-  const result = { locals: /* @__PURE__ */ new Map(), exports: /* @__PURE__ */ new Map() };
+  const result = { locals: /* @__PURE__ */ new Map(), exports: /* @__PURE__ */ new Map(), candidates: /* @__PURE__ */ new Map(), exportedCandidates: /* @__PURE__ */ new Map() };
   const code = noiseMaskedOf(file);
   const pairs = delimiterPairs(code);
   const openers = new Map([...pairs].map(([open, close]) => [close, open]));
@@ -3623,8 +4262,18 @@ function guardDefinitions(file) {
     const target = byDeclaration.get(nestedAt) ?? body;
     let at = target.end;
     for (let i = target.start + 1; i < target.end; i++) {
+      const conditional = /^if\s*\(/.exec(code.slice(i, i + 32));
+      if (conditional && (i === 0 || !/[\w$]/.test(code[i - 1]))) {
+        const close2 = pairs.get(i + conditional[0].length - 1);
+        if (close2 !== void 0) {
+          let start = close2 + 1;
+          while (/\s/.test(code[start] ?? "")) start++;
+          i = statementEnd2(code, start, target.end, pairs) - 1;
+          continue;
+        }
+      }
       if (code.startsWith("return", i) && !/[\w$]/.test(code[i - 1] ?? "") && !/[\w$]/.test(code[i + 6] ?? "")) {
-        at = i;
+        at = Math.min(target.end, statementEnd2(code, i, target.end, pairs));
         break;
       }
       const close = pairs.get(i);
@@ -3636,14 +4285,26 @@ function guardDefinitions(file) {
       wrapper: target !== body
     };
     const exported = !declaration.exported ? null : /\bexport\s+default\s+(?:async\s+)?$/.test(code.slice(Math.max(0, body.declaration - 80), body.declaration)) ? "default" : declaration.name;
-    candidates.push({ name: declaration.name, exported, definition, at });
+    candidates.push({ name: declaration.name, exported, definition, at, start: target.start });
+  }
+  const unguarded = /* @__PURE__ */ new Set();
+  const requirements = /* @__PURE__ */ new Map();
+  for (const wrapper of [false, true]) {
+    const ops = candidates.filter((candidate) => candidate.definition.wrapper === wrapper).map((candidate) => ({ index: candidate.at, writes: false })).sort((a, b) => a.index - b.index);
+    for (const hit of unguardedOperations(
+      file,
+      ops,
+      void 0,
+      !wrapper,
+      (index, required) => requirements.set(index, required)
+    )) unguarded.add(hit.index);
   }
-  const unguarded = new Set(unguardedOperations(
-    file,
-    candidates.map((candidate) => ({ index: candidate.at, writes: false })).sort((a, b) => a.index - b.index)
-  ).map((hit) => hit.index));
   for (const candidate of candidates) {
+    result.candidates.set(candidate.name, candidate);
+    if (candidate.exported) result.exportedCandidates.set(candidate.exported, candidate);
     if (unguarded.has(candidate.at)) continue;
+    candidate.definition.requiredArgs = requirements.get(candidate.at) ?? [];
+    if (candidate.definition.wrapper && candidate.definition.requiredArgs.length) continue;
     result.locals.set(candidate.name, candidate.definition);
     if (candidate.exported) result.exports.set(candidate.exported, candidate.definition);
   }
@@ -3657,23 +4318,33 @@ function bindingModule(spec, file, allFiles, scope) {
   const found = new Set(keys.flatMap((key) => moduleIndexOf(allFiles).get(moduleKey(key)) ?? []));
   return found.size === 1 ? [...found][0] : null;
 }
-function exportedGuard(file, name, allFiles, scope, depth = 0, seen = /* @__PURE__ */ new Set()) {
+function exportedGuard(file, name, allFiles, scope, state, depth = 0, seen = /* @__PURE__ */ new Set()) {
   const key = `${file.path}\0${name}`;
-  if (depth >= 8 || seen.has(key)) return null;
-  seen.add(key);
+  if (seen.has(key)) return null;
+  if (depth >= 8 || state.remaining-- <= 0) {
+    state.truncated = true;
+    return null;
+  }
+  seen = new Set(seen).add(key);
   const definitions = guardDefinitions(file);
+  const candidate = definitions.exportedCandidates.get(name);
+  if (candidate && guardBindings(file).shadowed.has(candidate.name)) return null;
   const direct = definitions.exports.get(name);
   if (direct) return direct;
+  if (candidate) return delegatedGuard(file, candidate, allFiles, scope, state, depth, seen);
   const bindings = bindingsOf(file);
   const exported = bindings.exports.find((binding) => binding.local === name);
   const follow = (spec, imported) => {
     const target = bindingModule(spec, file, allFiles, scope);
-    return target ? exportedGuard(target, imported, allFiles, scope, depth + 1, seen) : null;
+    return target ? exportedGuard(target, imported, allFiles, scope, state, depth + 1, seen) : null;
   };
   if (exported) {
     if (exported.spec) return follow(exported.spec, exported.imported);
+    if (guardBindings(file).shadowed.has(exported.imported)) return null;
     const local = definitions.locals.get(exported.imported);
     if (local) return local;
+    const candidate2 = definitions.candidates.get(exported.imported);
+    if (candidate2) return delegatedGuard(file, candidate2, allFiles, scope, state, depth, seen);
     const imported = bindings.imports.find((binding) => binding.local === exported.imported);
     if (imported?.spec) return follow(imported.spec, imported.imported);
   }
@@ -3683,22 +4354,100 @@ function exportedGuard(file, name, allFiles, scope, depth = 0, seen = /* @__PURE
   }
   return null;
 }
-function indirectGuardOperations(route, allFiles) {
-  const names = /* @__PURE__ */ new Map();
-  const code = noiseMaskedOf(route.file);
-  for (const binding of bindingsOf(route.file).imports) {
-    if (!binding.spec) continue;
-    const name = namePattern([binding.local]);
-    if (new RegExp(`\\b(?:const|let|var|function|class)\\s+${name}(?![\\w$])|[({,]\\s*${name}\\s*[,}):=]|(?<![\\w$])${name}\\s*=>`).test(code)) continue;
-    const target = bindingModule(binding.spec, route.file, allFiles, route.scope);
-    const definition = target ? exportedGuard(target, binding.imported, allFiles, route.scope) : null;
-    if (definition) names.set(binding.local, definition);
-  }
-  const protectedOps = /* @__PURE__ */ new Map();
-  if (names.size === 0) return protectedOps;
-  unguardedOperations(route.file, unguardedOpsOf(route.file), {
-    guards: new Set([...names].filter(([, definition]) => !definition.wrapper).map(([name]) => name)),
+var guardBindingCache = /* @__PURE__ */ new WeakMap();
+function guardBindings(file) {
+  const cached = guardBindingCache.get(file);
+  if (cached) return cached;
+  const code = noiseMaskedOf(file);
+  const declarations = code.replace(/\b(?:import|export)\s+(?:[A-Za-z_$][\w$]*\s*,\s*)?\{[^{}]{0,4000}\}/g, (text) => " ".repeat(text.length));
+  const shadowed = /* @__PURE__ */ new Set();
+  const declared = /* @__PURE__ */ new Set();
+  const called = /* @__PURE__ */ new Set();
+  for (const match of declarations.matchAll(/[({,]\s*([A-Za-z_$][\w$]*)\s*[,}):=]|(?<![\w$.])([A-Za-z_$][\w$]*)\s*=(?!=)|(?<![\w$])([A-Za-z_$][\w$]*)\s*=>/g)) {
+    if (match[2] && /\b(?:const|let|var)\s*$/.test(declarations.slice(Math.max(0, match.index - 40), match.index))) continue;
+    shadowed.add(match[1] ?? match[2] ?? match[3]);
+  }
+  for (const match of declarations.matchAll(/\b(?:const|let|var|function|class)\s+([A-Za-z_$][\w$]*)/g)) {
+    if (declared.has(match[1])) shadowed.add(match[1]);
+    declared.add(match[1]);
+  }
+  for (const match of code.matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)\s*\(/g)) {
+    if (!/\bfunction\s*\*?\s*$/.test(code.slice(Math.max(0, match.index - 40), match.index))) called.add(match[1]);
+  }
+  const result = { shadowed, declared, called };
+  guardBindingCache.set(file, result);
+  return result;
+}
+function namedGuard(file, name, allFiles, scope, state, depth, seen) {
+  const bindings = guardBindings(file);
+  if (bindings.shadowed.has(name)) return null;
+  const definitions = guardDefinitions(file);
+  const candidate = definitions.candidates.get(name);
+  if (candidate) {
+    const key = `${file.path}\0${name}`;
+    if (seen.has(key)) return null;
+    if (depth >= 8 || state.remaining-- <= 0) {
+      state.truncated = true;
+      return null;
+    }
+    return definitions.locals.get(name) ?? delegatedGuard(file, candidate, allFiles, scope, state, depth, new Set(seen).add(key));
+  }
+  if (bindings.declared.has(name)) return null;
+  const imported = bindingsOf(file).imports.find((binding) => binding.local === name);
+  if (!imported?.spec) return null;
+  const target = bindingModule(imported.spec, file, allFiles, scope);
+  return target ? exportedGuard(target, imported.imported, allFiles, scope, state, depth, seen) : null;
+}
+function delegatedGuard(file, candidate, allFiles, scope, state, depth, seen) {
+  const code = noiseMaskedOf(file);
+  const calls = /* @__PURE__ */ new Set();
+  for (const match of code.slice(candidate.start + 1, candidate.at).matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)\s*\(/g)) calls.add(match[1]);
+  const resolved = /* @__PURE__ */ new Map();
+  for (const name of calls) {
+    if (state.remaining <= 0) {
+      state.truncated = true;
+      break;
+    }
+    const guard = namedGuard(file, name, allFiles, scope, state, depth + 1, seen);
+    if (guard && !guard.wrapper) resolved.set(name, guard);
+  }
+  if (resolved.size === 0) return null;
+  let selected;
+  let requiredArgs = [];
+  unguardedOperations(file, [{ index: candidate.at, writes: false }], {
+    guards: new Set(resolved.keys()),
+    wrappers: /* @__PURE__ */ new Set(),
+    requirements: new Map([...resolved].map(([name, guard]) => [name, guard.requiredArgs ?? []])),
+    onGuard: (_index, name) => {
+      selected = resolved.get(name);
+    }
+  }, !candidate.definition.wrapper, (_index, required) => {
+    requiredArgs = required;
+  });
+  return selected ? { ...candidate.definition, requiredArgs, chain: [selected, ...selected.chain ?? []] } : null;
+}
+function indirectGuardOperations(route, ctx) {
+  const state = { remaining: 128, truncated: false };
+  const { called } = guardBindings(route.file);
+  const names = /* @__PURE__ */ new Map();
+  for (const name of called) {
+    if (state.remaining <= 0) {
+      state.truncated = true;
+      break;
+    }
+    const definition = namedGuard(route.file, name, ctx.files, route.scope, state, 0, /* @__PURE__ */ new Set());
+    if (definition) names.set(name, definition);
+  }
+  if (state.truncated) ctx.reportIncomplete(
+    "api/db-access-without-auth",
+    `${route.file.path} reached the authentication resolution limit (8 hops or 128 symbols); unresolved guards were not accepted`
+  );
+  const protectedOps = /* @__PURE__ */ new Map();
+  if (names.size === 0) return protectedOps;
+  unguardedOperations(route.file, unguardedOpsOf(route.file), {
+    guards: new Set([...names].filter(([, definition]) => !definition.wrapper).map(([name]) => name)),
     wrappers: new Set([...names].filter(([, definition]) => definition.wrapper).map(([name]) => name)),
+    requirements: new Map([...names].map(([name, guard]) => [name, guard.requiredArgs ?? []])),
     onGuard: (index, name) => {
       const definition = names.get(name);
       if (definition) protectedOps.set(index, definition);
@@ -4073,11 +4822,12 @@ var apiAuthRule = {
     const indirectByFile = /* @__PURE__ */ new Map();
     for (const route of routes) {
       const reachable = route.reachable;
-      let ops = unguardedOpsOf(route.file).filter((op) => reachable === void 0 || op.index > reachable.start && op.index < reachable.end);
+      const unguarded = unguardedOpsOf(route.file);
+      let ops = reachable === void 0 ? unguarded : operationsInRange(unguarded, reachable.start, reachable.end);
       if (ops.length === 0) continue;
       let indirectOps = indirectByFile.get(route.file);
       if (!indirectOps) {
-        indirectOps = indirectGuardOperations(route, ctx.files);
+        indirectOps = indirectGuardOperations(route, ctx);
         indirectByFile.set(route.file, indirectOps);
       }
       const unprotected = ops.filter((op) => !indirectOps.has(op.index));
@@ -4089,24 +4839,30 @@ var apiAuthRule = {
       const globalNote = globalGuard === null ? [] : [
         `${globalGuard} contains an authentication check that may cover ${url}. Its path conditions are written in code, so the scan cannot tell which routes it applies to; this finding is reported at lower confidence. Confirm that check runs for ${url}.`
       ];
+      const handlerCode = noiseMaskedOf(route.file).slice(reachable?.start ?? 0, reachable?.end);
+      if (/\.auth\s*\.\s*getSession\s*\(/.test(handlerCode)) globalNote.push(
+        "This handler checks supabase.auth.getSession(). On the server that reads the session from the cookie without verifying it, so a forged cookie passes; it is not counted as authentication. Use supabase.auth.getClaims() or getUser() instead."
+      );
       const admin = usesAdminClient(route, adminModules, ctx.files);
       const hit = ops.find((o) => o.writes) ?? ops[0];
       const indirect = indirectOps.get(hit.index);
       const line = lineNumberAt(lineStartsCached(route.file), hit.index);
       const excerpt = excerptFor(route.file, line);
-      const indirectEvidence = indirect ? [{
+      const indirectEvidence = indirect ? [indirect, ...indirect.chain ?? []].map((guard) => ({
         kind: "auth-helper",
-        file: indirect.file.path,
-        line: indirect.line,
-        description: "Local authentication helper recognized through imports; verify its runtime behaviour and caller coverage."
-      }] : [];
+        file: guard.file.path,
+        line: guard.line,
+        description: "Local authentication helper in the recognized delegation chain; verify runtime behaviour and caller coverage."
+      })) : [];
       if (indirect) globalNote.push("A local authentication helper or wrapper was recognized before this operation. This finding is retained for review because indirect control flow is not a proof of authorization.");
       if (admin) {
         const trace = adminEvidence(route, adminModules, ctx.files, line);
+        const evidence = [...trace.evidence ?? [], ...indirectEvidence];
         findings.push({
           ruleId: "api/admin-db-access-without-auth",
           ...trace,
-          evidence: [...trace.evidence ?? [], ...indirectEvidence],
+          evidence: evidence.slice(0, 24),
+          evidenceTruncated: trace.evidenceTruncated || evidence.length > 24,
           severity: "P0",
           // 管理员客户端缺少鉴权时使用确定置信度；可能受全局鉴权覆盖时降为疑似。
           confidence: globalGuard === null && !indirect ? "certain" : "likely",
@@ -4164,6 +4920,14 @@ var apiAuthRule = {
         });
       }
     }
+    for (const file of ctx.files) if (identityFlowLimited(file)) ctx.reportIncomplete(
+      "api/db-access-without-auth",
+      `${file.path} reached the identity flow limit (8 value hops, 4000 expression characters, or 512 assignments or branches per function)`
+    );
+    for (const file of ctx.files) if (controlFlowLimited.has(file)) ctx.reportIncomplete(
+      "api/db-access-without-auth",
+      `${file.path} reached the control-flow proof limit (8 nested branch or exception regions)`
+    );
     return findings;
   }
 };
@@ -4537,12 +5301,1434 @@ var corsRule = {
   }
 };
 
+// src/rules/request-input.ts
+var MAX_VALUE_HOPS = 8;
+var MAX_ASSIGNMENTS = 512;
+var MAX_EXPRESSION = 4e3;
+var REQUEST_OBJECT_NAMES = /^(?:req|request|event|evt|ctx|context)$/;
+var DESTRUCTURED_OBJECTS = /* @__PURE__ */ new Set(["request", "req", "event"]);
+var DESTRUCTURED_URLS = /* @__PURE__ */ new Set(["url"]);
+var DESTRUCTURED_COOKIES = /* @__PURE__ */ new Set(["cookies"]);
+var DESTRUCTURED_VALUES = /* @__PURE__ */ new Set(["params", "query", "body", "searchParams"]);
+var TRANSPARENT_CALLS = /* @__PURE__ */ new Set([
+  "json",
+  "formData",
+  "text",
+  "arrayBuffer",
+  "blob",
+  "get",
+  "getAll",
+  "String",
+  "trim",
+  "trimStart",
+  "trimEnd",
+  "toString",
+  "toLowerCase",
+  "toUpperCase",
+  "URL",
+  "URLSearchParams",
+  "decodeURIComponent",
+  "decodeURI",
+  "fromEntries",
+  "entries",
+  "readBody",
+  "readFormData",
+  "readRawBody",
+  "getQuery",
+  "getRouterParam",
+  "getRouterParams",
+  "getHeader",
+  "getHeaders",
+  "getRequestHeader",
+  "getRequestHeaders",
+  "getCookie",
+  "parseCookies",
+  "getRequestURL"
+]);
+var H3_READERS = "readBody|readFormData|readMultipartFormData|readRawBody|readValidatedBody|getQuery|getValidatedQuery|getRouterParams?|getValidatedRouterParams|getHeaders?|getRequestHeaders?|getCookie|parseCookies|getRequestURL";
+var LITERAL = String.raw`(?:'[^']*'|"[^"]*"|\x60[^\x60$]*\x60|-?\d+(?:\.\d+)?|null|undefined|true|false)`;
+var CLEAN_EXPRESSION = [
+  /^(?:await\s+)?(?:Number|parseInt|parseFloat|Boolean|BigInt|isNaN|Math\s*\.\s*\w+|Number\s*\.\s*\w+)\s*\(/,
+  /\.\s*length\s*$/,
+  /^(?:!|typeof\b)/,
+  /\.\s*(?:includes|test|has|startsWith|endsWith|some|every)\s*\([^?]*\)\s*$/,
+  new RegExp(String.raw`^[^?]*\?\s*${LITERAL}\s*:\s*${LITERAL}\s*$`),
+  // 带标签的模板由标签函数处理插值（Prisma.sql、sql、html），String.raw 除外。
+  /^(?:await\s+)?(?!String\s*\.\s*raw\b)[\w$]+(?:\s*\.\s*[\w$]+)*\s*\x60/
+];
+var URL_INPUT_ACCESS = /\??\.\s*(?:searchParams|pathname|search|hash)\b/;
+var URL_INPUT_KEYS = /* @__PURE__ */ new Set(["searchParams", "pathname", "search", "hash"]);
+var URL_ORIGIN_ACCESS = /^\s*\??\.\s*(?:origin|host|hostname|protocol|port)\b/;
+var URL_ORIGIN_KEYS = /* @__PURE__ */ new Set(["origin", "host", "hostname", "protocol", "port"]);
+function isComparison(expr) {
+  return !/\?/.test(expr) && !/=>/.test(expr) && /(?:===|!==|==|!=|<=|>=|\binstanceof\b)/.test(expr);
+}
+function parameterList(text) {
+  const parts = [];
+  let depth = 0, from = 0;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if ("{[(<".includes(ch)) depth++;
+    else if ("}])>".includes(ch)) depth--;
+    else if (ch === "," && depth === 0) {
+      parts.push(text.slice(from, i));
+      from = i + 1;
+    }
+  }
+  parts.push(text.slice(from));
+  return parts.map((part) => part.trim()).filter(Boolean);
+}
+function destructuredKeys(pattern) {
+  const inner = pattern.slice(1, pattern.lastIndexOf("}"));
+  const result = [];
+  for (const part of parameterList(inner)) {
+    const m = /^(?:\.\.\.)?\s*([A-Za-z_$][\w$]*)\s*(?::\s*([A-Za-z_$][\w$]*))?\s*(?:=[\s\S]*)?$/.exec(part);
+    if (m) result.push({ key: m[1], local: m[2] ?? m[1] });
+  }
+  return result;
+}
+function patternNames(pattern) {
+  const text = pattern.trim();
+  if (/^[A-Za-z_$][\w$]*$/.test(text)) return [text];
+  const stripped = text.replace(/[A-Za-z_$][\w$]*\s*:(?!:)/g, " ").replace(/=[^,}\]]*/g, " ");
+  return stripped.match(/[A-Za-z_$][\w$]*/g) ?? [];
+}
+function paramRoles(paramsText, paramsStart, allInput) {
+  const roles = { objects: /* @__PURE__ */ new Map(), urls: /* @__PURE__ */ new Map(), cookies: /* @__PURE__ */ new Map(), values: /* @__PURE__ */ new Map() };
+  let offset = 0;
+  for (const raw of parameterList(paramsText)) {
+    const at = paramsStart + Math.max(0, paramsText.indexOf(raw, offset));
+    offset = Math.max(offset, paramsText.indexOf(raw, offset) + raw.length);
+    const param = raw.startsWith("{") || raw.startsWith("[") ? raw.slice(0, matchingClose(raw) + 1) : raw.replace(/^\.\.\./, "").split(/[:=]/)[0].trim();
+    if (allInput) {
+      for (const name of patternNames(param)) roles.values.set(name, at);
+      continue;
+    }
+    if (param.startsWith("{")) {
+      for (const { key, local } of destructuredKeys(param)) {
+        if (DESTRUCTURED_OBJECTS.has(key)) roles.objects.set(local, at);
+        else if (DESTRUCTURED_URLS.has(key)) roles.urls.set(local, at);
+        else if (DESTRUCTURED_COOKIES.has(key)) roles.cookies.set(local, at);
+        else if (DESTRUCTURED_VALUES.has(key)) roles.values.set(local, at);
+      }
+    } else if (REQUEST_OBJECT_NAMES.test(param)) roles.objects.set(param, at);
+  }
+  return roles;
+}
+function matchingClose(text) {
+  let depth = 0;
+  for (let i = 0; i < text.length; i++) {
+    if ("{[".includes(text[i])) depth++;
+    else if ("}]".includes(text[i]) && --depth === 0) return i;
+  }
+  return text.length - 1;
+}
+function parametersOf(code, body, pairs, openers) {
+  const fn = /^function\s*\*?\s*(?:[\w$]+\s*)?\(/.exec(code.slice(body.declaration, body.declaration + 200));
+  if (fn) {
+    const open = body.declaration + fn[0].length - 1;
+    const close2 = pairs.get(open);
+    return close2 === void 0 ? null : { start: open + 1, end: close2 };
+  }
+  const window = code.slice(Math.max(0, body.declaration - 200), body.declaration);
+  const close = window.lastIndexOf(")");
+  if (close !== -1 && /^\s*(?::[^=;{()]*)?$/.test(window.slice(close + 1))) {
+    const absolute = body.declaration - window.length + close;
+    const open = openers.get(absolute);
+    return open === void 0 ? null : { start: open + 1, end: absolute };
+  }
+  const single = /([A-Za-z_$][\w$]*)\s*$/.exec(window);
+  return single ? { start: body.declaration - window.length + single.index, end: body.declaration - window.length + single.index + single[1].length } : null;
+}
+function expressionEnd(code, from, limit, pairs, truncated) {
+  const stop = Math.min(limit, from + MAX_EXPRESSION);
+  for (let i = from; i < stop; i++) {
+    const ch = code[i];
+    const close = pairs.get(i);
+    if (close !== void 0) {
+      if (close >= stop) {
+        truncated();
+        return stop;
+      }
+      i = close;
+      continue;
+    }
+    if (ch === ";" || ch === "," || ch === ")" || ch === "]" || ch === "}") return i;
+    if (ch === "\n") {
+      const before = code.slice(from, i).trimEnd();
+      const after = code.slice(i + 1, i + 80).trimStart();
+      if (before === "" || /[=+\-*/%&|^!?:,.([{<>]$/.test(before)) continue;
+      if (/^(?:[.?+\-*/%&|^,:<>=]|\?\?)/.test(after) && !/^(?:\+\+|--)/.test(after)) continue;
+      return i;
+    }
+  }
+  if (stop < limit && !/[;,)}\]\n]/.test(code[stop] ?? "")) truncated();
+  return stop;
+}
+function literalTable(text) {
+  const value = text.trim();
+  const item = new RegExp(`^${LITERAL}$`);
+  const property = new RegExp(`^(?:[A-Za-z_$][\\w$]*|'[^']*'|"[^"]*")\\s*:\\s*${LITERAL}$`);
+  if (!(value.startsWith("{") && value.endsWith("}")) && !(value.startsWith("[") && value.endsWith("]"))) return false;
+  return parameterList(value.slice(1, -1)).every((part) => (value[0] === "{" ? property : item).test(part));
+}
+function fixedTablesOf(code, source, pairs) {
+  const result = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const m of code.matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*/g)) {
+    const name = m[1];
+    if (seen.has(name)) {
+      result.delete(name);
+      continue;
+    }
+    seen.add(name);
+    const open = m.index + m[0].length;
+    const close = pairs.get(open);
+    if (!m[0].startsWith("const") || close === void 0 || close - open > MAX_EXPRESSION) continue;
+    if (literalTable(source.slice(open, close + 1))) result.set(name, m.index);
+  }
+  for (const m of code.matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)(?:\s*\.\s*[\w$]+|\s*\[[^\]]*\])?\s*(?:\+\+|--|[+*/%&|^-]?=(?![=>]))/g)) {
+    if (!/\bconst\s+$/.test(code.slice(Math.max(0, m.index - 20), m.index))) result.delete(m[1]);
+  }
+  for (const m of code.matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)\s*\.\s*(?:push|pop|shift|unshift|splice|sort|reverse|fill|copyWithin)\s*\(/g)) {
+    result.delete(m[1]);
+  }
+  for (const m of code.matchAll(/\b(?:Object\s*\.\s*(?:assign|defineProperty|defineProperties|setPrototypeOf)|Reflect\s*\.\s*(?:set|defineProperty|setPrototypeOf))\s*\(\s*([A-Za-z_$][\w$]*)\b/g)) {
+    result.delete(m[1]);
+  }
+  return result;
+}
+var InputFlow = class {
+  constructor(code, source, span, pairs, roles, fixedTables) {
+    this.code = code;
+    this.source = source;
+    this.span = span;
+    this.pairs = pairs;
+    this.fixedTables = fixedTables;
+    for (const [name, at] of roles.values) this.parameters.set(name, { level: "direct", origin: at, names: /* @__PURE__ */ new Set([name]), ownUrl: false });
+    this.sourcePattern = sourceRegex(roles);
+    const assignments = this.assignments().sort((a, b) => a.at - b.at);
+    const region = code.slice(span.start, span.end);
+    const functions = this.localFunctions(region, assignments);
+    const scopes = [span];
+    for (let i = span.start + 1; i < span.end; i++) {
+      const end = code[i] === "{" ? pairs.get(i) : void 0;
+      if (end !== void 0) scopes.push({ start: i, end });
+    }
+    const controls = [];
+    for (const m of region.matchAll(/\b(?:if|for|while|switch|catch)\s*\(|\belse\b/g)) {
+      const open = span.start + m.index + m[0].length - 1;
+      let start = m[0] === "else" ? open + 1 : (pairs.get(open) ?? open) + 1;
+      while (/\s/.test(code[start] ?? "")) start++;
+      controls.push({ start, end: pairs.get(start) ?? expressionEnd(code, start, span.end, pairs, () => {
+        this.limited = true;
+      }) });
+      if (controls.length >= MAX_ASSIGNMENTS) {
+        this.limited = true;
+        break;
+      }
+    }
+    for (const a of assignments) {
+      const owner = functions.filter((f) => f.start < a.at && a.at < f.end).at(-1);
+      if (owner) a.owner = owner;
+      a.scope = scopes.filter((s) => s.start < a.at && a.at < s.end).at(-1) ?? span;
+      if (a.owner && a.owner.start > a.scope.start) a.scope = a.owner;
+      a.controls = controls.filter((s) => s.start <= a.at && a.at <= s.end);
+      for (const name of a.names) {
+        const list = this.assignmentList.get(name) ?? [];
+        if (!list.some((item) => item.exprAt === a.exprAt)) list.push(a);
+        this.assignmentList.set(name, list);
+      }
+    }
+    const names = /* @__PURE__ */ new Set([...this.parameters.keys(), ...this.assignmentList.keys()]);
+    if (names.size) this.references = new RegExp(`(?<![\\w$.])(?:${namePattern(names)})(?![\\w$])`, "g");
+  }
+  code;
+  source;
+  span;
+  pairs;
+  fixedTables;
+  parameters = /* @__PURE__ */ new Map();
+  limited = false;
+  assignmentList = /* @__PURE__ */ new Map();
+  sourcePattern;
+  references = null;
+  values = /* @__PURE__ */ new Map();
+  strings = /* @__PURE__ */ new Map();
+  /** 只索引当前处理函数；未引用的具名闭包不影响外层值。 */
+  localFunctions(region, assignments) {
+    const offset = this.span.start;
+    const bodies = functionBodies(region, delimiterPairs(region)).map((f) => ({
+      declaration: f.declaration + offset,
+      start: f.start + offset,
+      end: f.end + offset
+    }));
+    for (const m of region.matchAll(/=>\s*(?!\s*\{)/g)) {
+      const start = offset + m.index + m[0].length;
+      const end = expressionEnd(this.code, start, this.span.end, this.pairs, () => {
+        this.limited = true;
+      });
+      bodies.push({ declaration: offset + m.index, start: start - 1, end });
+    }
+    if (bodies.length > MAX_ASSIGNMENTS) this.limited = true;
+    return bodies.slice(0, MAX_ASSIGNMENTS).sort((a, b) => a.start - b.start).map((f) => {
+      const binding = assignments.filter((a) => {
+        if (!a.declaration || a.exprAt > f.declaration || a.exprAt + a.expr.length < f.end) return false;
+        const prefix = this.code.slice(a.exprAt, f.declaration).trim();
+        return prefix === "" || prefix === "async" || /^(?:async\s*)?(?:\([^;{}]*\)|[\w$]+)\s*(?::[^=;{}]*)?$/.test(prefix);
+      }).sort((a, b) => b.exprAt - a.exprAt)[0];
+      const declared = /^function\s*\*?\s*([\w$]+)\s*\(/.exec(this.code.slice(f.declaration, f.start))?.[1];
+      const before = this.code.slice(this.span.start, f.declaration).trimEnd().replace(/\basync$/, "").trimEnd();
+      const name = binding?.names.length === 1 ? binding.names[0] : /[;{}]$/.test(before) ? declared : void 0;
+      if (/^\s*\)*\s*(?:\(|\.\s*(?:call|apply)\s*\()/.test(this.code.slice(f.end + 1, this.span.end))) {
+        return { ...f, usedAt: f.end };
+      }
+      if (!name) return { ...f, usedAt: f.end };
+      const start = binding?.at ?? f.declaration;
+      const reference = new RegExp(`(?<![\\w$.])${namePattern([name])}(?![\\w$])`, "g");
+      const use = [...region.matchAll(reference)].find((m) => offset + m.index < start || offset + m.index > f.end);
+      return { ...f, usedAt: use ? offset + use.index : Infinity };
+    });
+  }
+  /** 表达式是否携带请求输入；已转换为数值、布尔或查表结果的不算。 */
+  taintOf(expr, exprAt, depth = 0) {
+    if (expr.length > MAX_EXPRESSION) this.limited = true;
+    const text = expr.trim();
+    if (text === "" || CLEAN_EXPRESSION.some((pattern) => pattern.test(text)) || isComparison(text)) return null;
+    const lookup = new RegExp(`^([A-Za-z_$][\\w$]*)\\s*\\[[^\\]]*\\]\\s*(?:(?:\\?\\?|\\|\\|)\\s*${LITERAL})?\\s*$`).exec(text);
+    if (lookup && this.isFixedTable(lookup[1], exprAt)) return null;
+    const observed = expr.replace(/\[\s*['"][^'"]*['"]\s*\]/g, (part, offset) => {
+      const raw = this.source.slice(exprAt + offset, exprAt + offset + part.length);
+      const key = /^\[\s*['"]([A-Za-z_$][\w$]*)['"]\s*\]$/.exec(raw)?.[1];
+      return key ? `.${key}`.padEnd(part.length) : part;
+    });
+    let found = null;
+    if (this.sourcePattern) {
+      this.sourcePattern.lastIndex = 0;
+      for (const m of observed.matchAll(this.sourcePattern)) {
+        const after = observed.slice(m.index + m[0].length);
+        const ownUrl = m[1] === "url" || m[1] === "nextUrl";
+        if (ownUrl && URL_ORIGIN_ACCESS.test(after)) continue;
+        found = mergeTaint(found, {
+          level: "direct",
+          origin: exprAt + m.index,
+          names: /* @__PURE__ */ new Set(),
+          ownUrl: ownUrl && !URL_INPUT_ACCESS.test(after.slice(0, 40))
+        });
+      }
+    }
+    const refs = this.references && new RegExp(this.references.source, "g");
+    if (refs) {
+      refs.lastIndex = 0;
+      for (const m of expr.matchAll(refs)) {
+        const before = expr.slice(0, m.index).trimEnd();
+        const after = expr.slice(m.index + m[0].length);
+        if (/^\s*:(?!:)/.test(after) && /[{,]$/.test(before)) continue;
+        const t = this.valueOf(m[0], exprAt, depth);
+        if (!t) continue;
+        if (t.ownUrl && URL_ORIGIN_ACCESS.test(after)) continue;
+        found = mergeTaint(found, t.ownUrl && URL_INPUT_ACCESS.test(after.slice(0, 40)) ? { ...t, ownUrl: false } : t);
+      }
+    }
+    if (!found) return null;
+    if (found.ownUrl && URL_INPUT_ACCESS.test(text)) found.ownUrl = false;
+    const calls = [...text.replace(/\bJSON\s*\.\s*parse\s*\(/g, "(").matchAll(/([\w$]+)\s*\(/g)].map((m) => m[1]);
+    if (calls.some((name) => !TRANSPARENT_CALLS.has(name))) found.level = "derived";
+    return found;
+  }
+  /** 字符串拼接：无标签模板的插值或含字符串操作数的 + 拼接中携带请求输入。 */
+  builtOf(expr, exprAt, depth = 0) {
+    if (expr.length > MAX_EXPRESSION) this.limited = true;
+    const text = expr.trim();
+    const lead = expr.length - expr.trimStart().length;
+    if (text.startsWith("`")) return this.interpolationTaint(exprAt + lead, exprAt + lead + text.length, depth);
+    const operands = this.topLevelOperands(expr, exprAt);
+    if (operands.length < 2 || !operands.some((o) => /^['"\x60]/.test(o.text.trim()))) return null;
+    let found = null;
+    for (const operand of operands) {
+      const t = operand.text.trim().startsWith("`") ? this.interpolationTaint(operand.at, operand.at + operand.text.length, depth) : this.taintOf(operand.text, operand.at, depth);
+      if (t) found = mergeTaint(found, t);
+    }
+    return found;
+  }
+  /** 仅保留使用位置可见的赋值；无条件覆盖终止旧值，分支与追加赋值保留可能来源。 */
+  assignmentsFor(name, at) {
+    const list = this.assignmentList.get(name) ?? [];
+    const contains = (s, where) => s.start < where && where < s.end;
+    const bindingAt = (where) => list.filter((a) => a.declaration && a.at <= where && contains(a.scope, where)).sort((a, b) => b.scope.start - a.scope.start || b.at - a.at)[0];
+    const binding = bindingAt(at);
+    const result = [];
+    for (let i = list.length - 1; i >= 0; i--) {
+      const a = list[i];
+      if (a.at >= at || a.exprAt + a.expr.length >= at) continue;
+      if (a.declaration ? a !== binding : bindingAt(a.at) !== binding) continue;
+      const indirect = a.owner !== void 0 && !contains(a.owner, at);
+      if (indirect && a.owner.usedAt >= at) continue;
+      result.push(indirect ? { ...a, indirect: true } : a);
+      if (!indirect && !a.append && contains(a.scope, at) && a.controls.every((s) => contains(s, at))) break;
+    }
+    return result;
+  }
+  valueOf(name, at, depth = 0) {
+    const key = `${name}:${at}:${depth}`;
+    if (this.values.has(key)) return this.values.get(key);
+    const result = this.resolveValue(name, at, depth);
+    this.values.set(key, result);
+    return result;
+  }
+  resolveValue(name, at, depth) {
+    if (depth >= MAX_VALUE_HOPS) {
+      this.limited = true;
+      return null;
+    }
+    const assignments = this.assignmentsFor(name, at);
+    if (!assignments.length) return this.parameters.get(name) ?? null;
+    let found = null;
+    for (const a of assignments) {
+      const taint = this.builtOf(a.expr, a.exprAt, depth + 1) ?? this.taintOf(a.expr, a.exprAt, depth + 1);
+      if (!taint) continue;
+      const own = this.targetsOf(a, taint).find(([target]) => target === name);
+      if (own) found = mergeTaint(found, { ...taint, level: a.indirect ? "derived" : taint.level, ownUrl: own[1], names: /* @__PURE__ */ new Set([name, ...taint.names]) });
+    }
+    if (this.parameters.has(name) && assignments.every((a) => a.append || !a.scope || a.scope.start !== this.span.start || a.controls.length)) {
+      found = mergeTaint(found, this.parameters.get(name));
+    }
+    return found;
+  }
+  /** 保留有效拼接及别名的 SQL 文本证据，不借用已被覆盖的旧查询。 */
+  builtValue(name, at, depth = 0) {
+    const key = `${name}:${at}:${depth}`;
+    if (this.strings.has(key)) return this.strings.get(key);
+    const result = this.resolveBuiltValue(name, at, depth);
+    this.strings.set(key, result);
+    return result;
+  }
+  resolveBuiltValue(name, at, depth) {
+    if (depth >= MAX_VALUE_HOPS) {
+      this.limited = true;
+      return null;
+    }
+    let found = null;
+    let text = "";
+    const append = (part) => {
+      if (text.length + part.length + 1 > MAX_EXPRESSION) this.limited = true;
+      text = `${text}
+${part}`.slice(0, MAX_EXPRESSION);
+    };
+    for (const a of this.assignmentsFor(name, at)) {
+      append(this.source.slice(a.exprAt, a.exprAt + a.expr.length));
+      const alias = /^[A-Za-z_$][\w$]*$/.test(a.expr.trim()) ? this.builtValue(a.expr.trim(), a.exprAt, depth + 1) : null;
+      const t = this.builtOf(a.expr, a.exprAt, depth + 1) ?? alias ?? (a.append ? this.taintOf(a.expr, a.exprAt, depth + 1) : null);
+      if (alias) append(alias.text);
+      if (t) found = mergeTaint(found, a.indirect ? { ...t, level: "derived" } : t);
+    }
+    return found ? { ...found, names: /* @__PURE__ */ new Set([name, ...found.names]), text } : null;
+  }
+  isFixedTable(name, at) {
+    const assignments = this.assignmentsFor(name, at);
+    if (assignments.length) return assignments.every((a) => !a.append && literalTable(this.source.slice(a.exprAt, a.exprAt + a.expr.length))) && this.fixedTables.has(name);
+    return (this.fixedTables.get(name) ?? Infinity) < at && !this.parameters.has(name);
+  }
+  /** 顶层 + 拼接的各操作数；括号与模板插值内部的 + 不拆分。 */
+  operandsOf(expr, exprAt) {
+    return this.topLevelOperands(expr, exprAt);
+  }
+  /** 使用前是否检查过内容：条件中除存在性判断外的引用，或作为校验函数实参。 */
+  validatedBefore(names, at) {
+    if (names.size === 0) return false;
+    const region = this.code.slice(this.span.start, at);
+    const pattern = new RegExp(`(?<![\\w$.])(?:${namePattern(names)})(?![\\w$])`);
+    for (const m of region.matchAll(/\b(?:if|switch)\s*\(/g)) {
+      const open = this.span.start + m.index + m[0].length - 1;
+      const close = this.pairs.get(open);
+      if (close === void 0 || close > at) continue;
+      const condition = this.code.slice(open + 1, close);
+      const alternatives = namePattern(names);
+      const substantive = condition.replace(new RegExp(`!\\s*(?:${alternatives})(?![\\w$.(\\[])`, "g"), " ").replace(new RegExp(`(?<![\\w$.])(?:${alternatives})\\s*[!=]==?\\s*(?:null|undefined|''|""|0)`, "g"), " ").replace(new RegExp(`\\btypeof\\s+(?:${alternatives})\\b`, "g"), " ");
+      if (pattern.test(substantive)) return true;
+    }
+    const validator = /(?:\.\s*(?:test|match|includes|has|startsWith|endsWith|parse|safeParse)|(?<![\w$.])(?:valid\w*|sanitiz\w*|escape\w*|is[A-Z]\w*|assert\w*))\s*\(/gi;
+    for (const m of region.matchAll(validator)) {
+      const open = this.span.start + m.index + m[0].length - 1;
+      const close = this.pairs.get(open);
+      if (close !== void 0 && close <= at && pattern.test(this.code.slice(open + 1, close))) return true;
+    }
+    return false;
+  }
+  interpolationTaint(from, to, depth) {
+    let found = null;
+    for (let i = from; i < to - 1; i++) {
+      if (this.code[i] !== "$" || this.code[i + 1] !== "{") continue;
+      const close = this.pairs.get(i + 1);
+      if (close === void 0) continue;
+      const t = this.taintOf(this.code.slice(i + 2, close), i + 2, depth);
+      i = close;
+      if (t) found = mergeTaint(found, t);
+    }
+    return found;
+  }
+  topLevelOperands(expr, exprAt) {
+    const result = [];
+    let from = 0;
+    for (let i = 0; i < expr.length; i++) {
+      const close = this.pairs.get(exprAt + i);
+      if (close !== void 0) {
+        i = close - exprAt;
+        continue;
+      }
+      if (expr[i] === "+" && expr[i + 1] !== "+" && expr[i + 1] !== "=" && expr[i - 1] !== "+") {
+        result.push({ text: expr.slice(from, i), at: exprAt + from });
+        from = i + 1;
+      }
+    }
+    result.push({ text: expr.slice(from), at: exprAt + from });
+    return result;
+  }
+  /**
+   * 赋值目标及其是否仍只是本站 URL。从本站 URL 解构时按键区分：
+   * searchParams、pathname 等为可控输入，origin、host 等不可控，其余保持本站 URL。
+   */
+  targetsOf(a, taint) {
+    if (!taint.ownUrl || !a.pattern.trim().startsWith("{")) return a.names.map((name) => [name, taint.ownUrl]);
+    const targets = [];
+    for (const { key, local } of destructuredKeys(a.pattern.trim())) {
+      if (URL_ORIGIN_KEYS.has(key)) continue;
+      targets.push([local, !URL_INPUT_KEYS.has(key)]);
+    }
+    return targets;
+  }
+  assignments() {
+    const { code, span, pairs } = this;
+    const region = code.slice(span.start, span.end);
+    const found = [];
+    const push = (a) => {
+      if (found.length >= MAX_ASSIGNMENTS) {
+        this.limited = true;
+        return;
+      }
+      found.push(a);
+    };
+    for (const m of region.matchAll(/\b(?:const|let|var)\s+/g)) {
+      let at = span.start + m.index + m[0].length;
+      for (let guard = 0; guard < 16; guard++) {
+        let patternEnd;
+        if (code[at] === "{" || code[at] === "[") {
+          const close = pairs.get(at);
+          if (close === void 0) break;
+          patternEnd = close + 1;
+        } else {
+          const id = /^[A-Za-z_$][\w$]*/.exec(code.slice(at, at + 200));
+          if (!id) break;
+          patternEnd = at + id[0].length;
+        }
+        const pattern = code.slice(at, patternEnd);
+        const rest = code.slice(patternEnd, patternEnd + 400);
+        const forOf = /^\s+of\s+/.exec(rest);
+        if (forOf) {
+          const exprAt2 = patternEnd + forOf[0].length;
+          const end2 = expressionEnd(code, exprAt2, span.end, pairs, () => {
+            this.limited = true;
+          });
+          push({ at, pattern, names: patternNames(pattern), expr: code.slice(exprAt2, end2), exprAt: exprAt2, iterate: true, append: false, declaration: true });
+          break;
+        }
+        const eq = /^\s*(?::[^=;]{0,200}?)?=(?![=>])/.exec(rest);
+        if (!eq) break;
+        const exprAt = patternEnd + eq[0].length;
+        const end = expressionEnd(code, exprAt, span.end, pairs, () => {
+          this.limited = true;
+        });
+        push({ at, pattern, names: patternNames(pattern), expr: code.slice(exprAt, end), exprAt, iterate: false, append: false, declaration: true });
+        if (code[end] !== ",") break;
+        at = end + 1;
+        while (/\s/.test(code[at] ?? "")) at++;
+      }
+    }
+    for (const m of region.matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)\s*(\+?=)(?![=>])/g)) {
+      const before = region.slice(Math.max(0, m.index - 8), m.index);
+      if (/\b(?:const|let|var)\s+$/.test(before)) continue;
+      const exprAt = span.start + m.index + m[0].length;
+      const end = expressionEnd(code, exprAt, span.end, pairs, () => {
+        this.limited = true;
+      });
+      push({ at: span.start + m.index, pattern: m[1], names: [m[1]], expr: code.slice(exprAt, end), exprAt, iterate: false, append: m[2] === "+=" });
+    }
+    return found;
+  }
+};
+function sourceRegex(roles) {
+  const parts = [];
+  if (roles.objects.size > 0) {
+    const objects = namePattern(roles.objects.keys());
+    parts.push(
+      String.raw`(?<![\w$.])(?:${objects})(?:\s*\??\.\s*(?:request|event))?\s*\??\.\s*(json|formData|text|arrayBuffer|blob|body|query|params|url|nextUrl|headers|cookies|searchParams)\b`,
+      String.raw`(?<![\w$.])(?:${objects})\s*\??\.\s*context\s*\??\.\s*params\b`,
+      String.raw`\b(?:${H3_READERS})\s*(?:<[^()]{0,200}>\s*)?\(\s*(?:${objects})\b`
+    );
+  }
+  if (roles.urls.size > 0) {
+    parts.push(String.raw`(?<![\w$.])(?:${namePattern(roles.urls.keys())})\s*\??\.\s*(?:searchParams|pathname|search|hash)\b`);
+  }
+  if (roles.cookies.size > 0) {
+    parts.push(String.raw`(?<![\w$.])(?:${namePattern(roles.cookies.keys())})\s*\??\.\s*get(?:All)?\s*\(`);
+  }
+  return parts.length === 0 ? null : new RegExp(parts.join("|"), "g");
+}
+function mergeTaint(found, t) {
+  if (!found) return { level: t.level, origin: t.origin, names: new Set(t.names), ownUrl: t.ownUrl };
+  if (t.level === "derived") found.level = "derived";
+  if (found.ownUrl && !t.ownUrl) {
+    found.ownUrl = false;
+    found.origin = t.origin;
+  }
+  for (const n of t.names) found.names.add(n);
+  return found;
+}
+function hasInput(roles) {
+  return roles.objects.size + roles.urls.size + roles.cookies.size + roles.values.size > 0;
+}
+function lowerBound(values, value) {
+  let low = 0, high = values.length;
+  while (low < high) {
+    const middle = low + high >>> 1;
+    if (values[middle] < value) low = middle + 1;
+    else high = middle;
+  }
+  return low;
+}
+var HandlerFile = class {
+  constructor(code, source, pairs, lineStarts, candidates) {
+    this.code = code;
+    this.source = source;
+    this.pairs = pairs;
+    this.lineStarts = lineStarts;
+    this.candidates = candidates;
+    this.fixedTables = fixedTablesOf(code, source, pairs);
+  }
+  code;
+  source;
+  pairs;
+  lineStarts;
+  candidates;
+  flows = /* @__PURE__ */ new Map();
+  fixedTables;
+  get limited() {
+    for (const flow of this.flows.values()) if (flow.limited) return true;
+    return false;
+  }
+  /** 至少包含一个给定位置的处理函数；positions 必须已按升序排列。 */
+  handlersAround(positions) {
+    const result = [];
+    if (positions.length === 0) return result;
+    for (const candidate of this.candidates) {
+      const { body } = candidate;
+      const first = lowerBound(positions, body.start + 1);
+      if (first >= positions.length || positions[first] >= body.end) continue;
+      let flow = this.flows.get(candidate);
+      if (!flow) {
+        flow = new InputFlow(this.code, this.source, { start: body.start, end: body.end }, this.pairs, candidate.roles, this.fixedTables);
+        this.flows.set(candidate, flow);
+      }
+      result.push({ route: candidate.route, body, flow });
+    }
+    return result;
+  }
+};
+var handlerCache = /* @__PURE__ */ new WeakMap();
+function handlerFileOf(file) {
+  const cached = handlerCache.get(file);
+  if (cached !== void 0) return cached;
+  let result = null;
+  if (/\.[mc]?[jt]sx?$/.test(file.path)) {
+    const route = routeOf(file);
+    const routes = route === null ? serverActionRoutes(file) : [route];
+    if (routes.length > 0) {
+      const code = noiseMaskedOf(file);
+      const source = commentsMaskedOf(file);
+      const pairs = delimiterPairs(code);
+      const openers = /* @__PURE__ */ new Map();
+      for (const [open, close] of pairs) openers.set(close, open);
+      const bodies = functionBodies(code, pairs).sort((a, b) => a.start - b.start);
+      const starts = bodies.map((body) => body.start);
+      const candidates = [];
+      for (const r of routes) {
+        const reachable = r.reachable;
+        const from = reachable ? lowerBound(starts, reachable.start) : 0;
+        for (let i = from; i < bodies.length; i++) {
+          const body = bodies[i];
+          if (reachable && body.start >= reachable.end) break;
+          if (reachable && body.end > reachable.end) continue;
+          const action = r.action !== void 0 && reachable !== void 0 && body.start === reachable.start;
+          const params = parametersOf(code, body, pairs, openers);
+          if (!params) continue;
+          const roles = paramRoles(source.slice(params.start, params.end), params.start, action);
+          if (hasInput(roles)) candidates.push({ route: r, body, roles });
+        }
+      }
+      if (candidates.length > 0) result = new HandlerFile(code, source, pairs, lineStartsOf(file.content), candidates);
+    }
+  }
+  handlerCache.set(file, result);
+  return result;
+}
+function reportInputLimit(ctx, file, analysed) {
+  if (analysed.limited) ctx.reportIncomplete(
+    "request-input/tracking",
+    `${file.path} reached the request-input tracking limit (8 value hops, 512 assignments or control/function regions, 4000 expression characters, or bounded URL analysis)`
+  );
+}
+
+// src/rules/injection.ts
+var SQL_UNSAFE = /(?:\.\s*\$(?:queryRawUnsafe|executeRawUnsafe)|(?<![\w$.])Prisma\s*\.\s*raw|(?<![\w$.])sql\s*\.\s*(?:raw|unsafe))\s*\(/g;
+var SQL_RAW_FRAGMENT = /\.\s*(?:raw|whereRaw|orWhereRaw|andWhereRaw|havingRaw|orHavingRaw|orderByRaw|groupByRaw|joinRaw|fromRaw)\s*\(/g;
+var SQL_DRIVER = /\.\s*(?:query|execute|exec|prepare|run|all|get|unsafe|many|one|none|any|oneOrNone|manyOrNone)\s*\(/g;
+var SQL_CONDITION = /\.\s*(?:where|andWhere|orWhere|having|andHaving|orHaving)\s*\(/g;
+var LOOKS_LIKE_SQL = /\bselect\b[\s\S]*\bfrom\b|\binsert\s+into\b|\bdelete\s+from\b|\bupdate\s+[\w."`]+\s+set\b|\bwhere\b|\border\s+by\b/i;
+var LOOKS_LIKE_CONDITION = /[=<>]|\b(?:like|ilike|in|is|between)\b/i;
+var CHILD_PROCESS = /^(?:node:)?child_process$/;
+var SHELL_EXPORTS = /* @__PURE__ */ new Set(["exec", "execSync"]);
+var SPAWN_EXPORTS = /* @__PURE__ */ new Set(["spawn", "spawnSync", "execFile", "execFileSync"]);
+function commandCallees(file) {
+  const callees = { shell: /* @__PURE__ */ new Set(), spawn: /* @__PURE__ */ new Set(), commands: /* @__PURE__ */ new Set(), namespaces: /* @__PURE__ */ new Set() };
+  for (const binding of bindingsOf(file).imports) {
+    if (binding.spec !== void 0 && CHILD_PROCESS.test(binding.spec)) {
+      if (binding.imported === "default") callees.namespaces.add(binding.local);
+      else if (SHELL_EXPORTS.has(binding.imported)) callees.shell.add(binding.local);
+      else if (SPAWN_EXPORTS.has(binding.imported)) callees.spawn.add(binding.local);
+    } else if (binding.spec === "execa" && /^execaCommand(?:Sync)?$/.test(binding.imported)) {
+      callees.commands.add(binding.local);
+    }
+  }
+  const source = commentsMaskedOf(file);
+  for (const m of source.matchAll(/\bimport\s*\*\s*as\s+([A-Za-z_$][\w$]*)\s+from\s*['"](?:node:)?child_process['"]/g)) {
+    callees.namespaces.add(m[1]);
+  }
+  for (const m of source.matchAll(/\b(?:const|let|var)\s+(\{[^{}]{0,500}\}|[A-Za-z_$][\w$]*)\s*=\s*require\s*\(\s*['"](?:node:)?child_process['"]\s*\)/g)) {
+    const target = m[1];
+    if (!target.startsWith("{")) {
+      callees.namespaces.add(target);
+      continue;
+    }
+    for (const part of target.slice(1, -1).split(",")) {
+      const names = /^\s*([A-Za-z_$][\w$]*)\s*(?::\s*([A-Za-z_$][\w$]*))?\s*$/.exec(part);
+      if (!names) continue;
+      if (SHELL_EXPORTS.has(names[1])) callees.shell.add(names[2] ?? names[1]);
+      else if (SPAWN_EXPORTS.has(names[1])) callees.spawn.add(names[2] ?? names[1]);
+    }
+  }
+  for (const m of source.matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:[A-Za-z_$][\w$]*\s*\.\s*)?promisify\s*\(\s*(?:([A-Za-z_$][\w$]*)\s*\.\s*)?([A-Za-z_$][\w$]*)\s*\)/g)) {
+    const [, local, namespace, name] = m;
+    const viaNamespace = namespace !== void 0 && callees.namespaces.has(namespace);
+    if (namespace === void 0 && callees.shell.has(name) || viaNamespace && SHELL_EXPORTS.has(name)) callees.shell.add(local);
+    else if (namespace === void 0 && callees.spawn.has(name) || viaNamespace && SPAWN_EXPORTS.has(name)) callees.spawn.add(local);
+  }
+  return callees;
+}
+function sinksIn(code, pairs, callees) {
+  const sinks = /* @__PURE__ */ new Map();
+  const add = (regex, kind, mode) => {
+    regex.lastIndex = 0;
+    for (const m of code.matchAll(regex)) {
+      const open = m.index + m[0].length - 1;
+      const close = pairs.get(open);
+      if (close === void 0 || sinks.has(open)) continue;
+      sinks.set(open, { kind, at: m.index, open, close, mode });
+    }
+  };
+  if (callees.shell.size > 0) add(new RegExp(`(?<![\\w$.])(?:${namePattern(callees.shell)})\\s*\\(`, "g"), "command", "shell");
+  if (callees.spawn.size > 0) add(new RegExp(`(?<![\\w$.])(?:${namePattern(callees.spawn)})\\s*\\(`, "g"), "command", "spawn");
+  if (callees.commands.size > 0) add(new RegExp(`(?<![\\w$.])(?:${namePattern(callees.commands)})\\s*\\(`, "g"), "command", "execa");
+  if (callees.namespaces.size > 0) {
+    const ns = namePattern(callees.namespaces);
+    add(new RegExp(`(?<![\\w$.])(?:${ns})\\s*\\.\\s*(?:exec|execSync)\\s*\\(`, "g"), "command", "shell");
+    add(new RegExp(`(?<![\\w$.])(?:${ns})\\s*\\.\\s*(?:spawn|spawnSync|execFile|execFileSync)\\s*\\(`, "g"), "command", "spawn");
+  }
+  add(SQL_UNSAFE, "sql", "unsafe");
+  add(SQL_RAW_FRAGMENT, "sql", "fragment");
+  add(SQL_DRIVER, "sql", "driver");
+  add(SQL_CONDITION, "sql", "condition");
+  return [...sinks.values()].sort((a, b) => a.at - b.at);
+}
+function fixedProgram(expr, at, flow, source, depth = 0) {
+  if (depth >= 8) {
+    flow.limited = true;
+    return false;
+  }
+  const text = expr.trim();
+  const start = at + expr.length - expr.trimStart().length;
+  if (/^[A-Za-z_$][\w$]*$/.test(text)) {
+    const assignments = flow.assignmentsFor(text, at).filter((a) => !a.append);
+    return assignments.length > 0 && assignments.every((a) => fixedProgram(a.expr, a.exprAt, flow, source, depth + 1));
+  }
+  const raw = source.slice(start, start + text.length);
+  const prefix = /^["'`]([^"'`$\\]*)/.exec(raw)?.[1];
+  return prefix !== void 0 && /^\S+\s/.test(prefix);
+}
+function hitOf(sink, code, source, pairs, flow) {
+  const args = argumentExpressions(code, code, sink.open + 1, sink.close, pairs);
+  if (args.length === 0) return null;
+  const firstAt = sink.open + 1 + (code.slice(sink.open + 1, sink.close).length - code.slice(sink.open + 1, sink.close).trimStart().length);
+  const first = args[0];
+  const firstSource = source.slice(firstAt, firstAt + first.length);
+  if (sink.mode === "spawn") {
+    if (!/\bshell\s*:\s*true\b/.test(code.slice(sink.open, sink.close))) return null;
+    const taint = flow.taintOf(code.slice(sink.open + 1, sink.close), sink.open + 1) ?? flow.builtOf(first, firstAt);
+    return taint ? { taint } : null;
+  }
+  const built = flow.builtOf(first, firstAt);
+  const identifier = /^[A-Za-z_$][\w$]*$/.exec(first);
+  const builtVariable = identifier ? flow.builtValue(identifier[0], firstAt) : void 0;
+  const text = built ? firstSource : builtVariable?.text ?? null;
+  const stringTaint = built ?? builtVariable ?? null;
+  if (sink.mode === "execa") {
+    const shell = /\bshell\s*:\s*(?:true\b|['"][^'"]+['"])/.test(source.slice(sink.open, sink.close));
+    if (!shell && fixedProgram(first, firstAt, flow, source)) return null;
+    const taint = stringTaint ?? flow.taintOf(first, firstAt);
+    return taint ? { taint, executable: !shell } : null;
+  }
+  if (sink.mode === "shell" || sink.mode === "unsafe") {
+    const taint = stringTaint ?? flow.taintOf(first, firstAt);
+    return taint ? { taint } : null;
+  }
+  if (!stringTaint || text === null) return null;
+  if (sink.mode === "driver" && !LOOKS_LIKE_SQL.test(text)) return null;
+  if (sink.mode === "condition" && !LOOKS_LIKE_CONDITION.test(text)) return null;
+  return { taint: stringTaint };
+}
+function capitalised(text) {
+  return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+function findingFor(kind, route, file, line, originLine, certain, executable = false) {
+  const lowered = certain ? [] : [
+    "The value passes through other code or a check before it gets here, and the scan cannot tell whether that makes it safe. Confirm the value is restricted to what the query or command expects."
+  ];
+  const excerpt = (file.lines[line - 1] ?? "").trim();
+  if (kind === "sql") {
+    return {
+      ruleId: "injection/sql",
+      severity: "P1",
+      confidence: certain ? "certain" : "likely",
+      title: `${capitalised(route.url)} builds a SQL query from request input`,
+      file: file.path,
+      line,
+      excerpt,
+      why: [
+        `The query text is assembled from a value the caller controls (read on line ${originLine}). Whoever calls ${route.url} can change the query itself, not just the value it compares against \u2014 read other rows, skip filters, or change data.`,
+        ...lowered
+      ],
+      fix: [
+        "Pass values as parameters instead of splicing them into the SQL text: the tagged form (prisma.$queryRaw`\u2026 ${id}`, sql`\u2026 ${id}`) or placeholders ($1, ?) with a separate values array.",
+        "If a column name or sort direction has to vary, choose it from a fixed list in code instead of using the request value."
+      ]
+    };
+  }
+  return {
+    ruleId: "injection/command",
+    severity: "P1",
+    confidence: certain ? "certain" : "likely",
+    title: executable ? `${capitalised(route.url)} runs an executable selected by request input` : `${capitalised(route.url)} runs a shell command built from request input`,
+    file: file.path,
+    line,
+    excerpt,
+    why: [
+      executable ? `The caller can influence the executable name (read on line ${originLine}). Execa does not use a shell by default, but allowing a caller to choose the program can still run unintended code with server permissions.` : `The command line includes a value the caller controls (read on line ${originLine}) and is run through a shell. Characters such as ; | $( ) let a caller append their own commands, which run with your server's permissions.`,
+      ...lowered
+    ],
+    fix: [
+      executable ? "Use a fixed executable and pass request values in a separate argument array; do not accept a caller-supplied command line." : "Use execFile or spawn with an argument array and no shell option, so the value is passed as one argument and never parsed by a shell.",
+      "Check the value against a fixed list of allowed values before using it."
+    ]
+  };
+}
+var injectionRule = {
+  id: "injection/request-input",
+  severity: "P1",
+  check(ctx) {
+    const findings = [];
+    for (const file of ctx.files) {
+      const analysed = handlerFileOf(file);
+      if (!analysed) continue;
+      const { code, source, pairs, lineStarts } = analysed;
+      const sinks = sinksIn(code, pairs, commandCallees(file));
+      if (sinks.length === 0) continue;
+      const positions = sinks.map((sink) => sink.at);
+      const reported = /* @__PURE__ */ new Set();
+      for (const { route, body, flow } of analysed.handlersAround(positions)) {
+        for (let i = lowerBound(positions, body.start + 1); i < sinks.length && sinks[i].at < body.end; i++) {
+          const sink = sinks[i];
+          if (sink.close >= body.end || reported.has(sink.at)) continue;
+          const hit = hitOf(sink, code, source, pairs, flow);
+          if (!hit) continue;
+          reported.add(sink.at);
+          const certain = hit.taint.level === "direct" && !flow.validatedBefore(hit.taint.names, sink.at);
+          findings.push(findingFor(
+            sink.kind,
+            route,
+            file,
+            lineNumberAt(lineStarts, sink.at),
+            lineNumberAt(lineStarts, hit.taint.origin),
+            certain,
+            hit.executable
+          ));
+        }
+      }
+      reportInputLimit(ctx, file, analysed);
+    }
+    return findings;
+  }
+};
+
+// src/rules/outbound.ts
+var FETCH_CALL = /(?<![\w$.])(?:fetch|\$fetch|ofetch|axios|got|ky|needle)\s*(?:<[^()]{0,200}>\s*)?\(/g;
+var FETCH_METHOD = /(?<![\w$.])(?:axios|got|ky|needle|http|https|undici)\s*\.\s*(?:get|post|put|patch|delete|head|request|stream)\s*(?:<[^()]{0,200}>\s*)?\(/g;
+var REDIRECT_CALL = /(?<![\w$.])(?:redirect|permanentRedirect|sendRedirect)\s*\(|(?<![\w$.])(?:NextResponse|Response|res|reply|response|ctx|context|Astro)\s*\.\s*redirect\s*\(/g;
+function callsIn(code, pairs) {
+  const calls = [];
+  const add = (regex, kind) => {
+    regex.lastIndex = 0;
+    for (const m of code.matchAll(regex)) {
+      const open = m.index + m[0].length - 1;
+      const close = pairs.get(open);
+      if (close !== void 0) calls.push({ kind, at: m.index, open, close, name: m[0] });
+    }
+  };
+  add(FETCH_CALL, "ssrf");
+  add(FETCH_METHOD, "ssrf");
+  add(REDIRECT_CALL, "redirect");
+  return calls;
+}
+var HOST_OPEN = /^(?:X?|[a-z][\w+.-]*:\/\/[^/?#\\]*)$/i;
+var REDIRECT_OPEN = /^(?:\/|[/\\]{2}[^/?#\\]*)$/;
+function controlsStart(expr, at, flow, source, kind, depth = 0) {
+  const lead = expr.length - expr.trimStart().length;
+  const text = expr.trim();
+  const start = at + lead;
+  if (text === "") return null;
+  if (depth >= 8) {
+    flow.limited = true;
+    return null;
+  }
+  if (text.length > 4e3) {
+    flow.limited = true;
+    return null;
+  }
+  const open = (prefix) => HOST_OPEN.test(prefix) || kind === "redirect" && REDIRECT_OPEN.test(prefix);
+  const url = /^new\s+URL\s*\(/.exec(text);
+  if (url) {
+    const argsStart = start + url[0].length;
+    const close = matchingParen(text, url[0].length - 1);
+    if (close === null) return null;
+    if (close === text.length - 1) {
+      const first = splitTopLevel(text.slice(url[0].length, close))[0];
+      return first === void 0 ? null : controlsStart(first, argsStart, flow, source, "redirect", depth + 1);
+    }
+  }
+  if (text.startsWith("`")) return templateStart(text, start, flow, source, open);
+  const operands = flow.operandsOf(text, start);
+  if (operands.length > 1) {
+    let prefix = "";
+    for (const operand of operands) {
+      const inner = operand.text.trim();
+      if (/^['"]/.test(inner)) {
+        prefix += source.slice(operand.at + operand.text.indexOf(inner) + 1, operand.at + operand.text.indexOf(inner) + inner.length - 1);
+        continue;
+      }
+      const t2 = inner.startsWith("`") ? templateStart(inner, operand.at + operand.text.indexOf(inner), flow, source, open) : controlsStart(inner, operand.at + operand.text.indexOf(inner), flow, source, kind, depth + 1);
+      if (t2) return open(prefix) ? t2 : null;
+      prefix += "X";
+      if (!open(prefix)) return null;
+    }
+    return null;
+  }
+  if (/^[A-Za-z_$][\w$]*$/.test(text)) {
+    const assignments = flow.assignmentsFor(text, at).filter((a) => !a.append);
+    if (assignments.length === 0) {
+      const t2 = flow.valueOf(text, at);
+      return t2 && !t2.ownUrl ? t2 : null;
+    }
+    for (const a of assignments) {
+      const t2 = controlsStart(a.expr, a.exprAt, flow, source, kind, depth + 1);
+      if (t2) return { ...t2, level: a.indirect ? "derived" : t2.level, names: /* @__PURE__ */ new Set([...t2.names, text]) };
+    }
+    return null;
+  }
+  const t = flow.taintOf(text, start);
+  return t && !t.ownUrl ? t : null;
+}
+function templateStart(text, start, flow, source, open) {
+  let prefix = "";
+  for (let i = 1; i < text.length; i++) {
+    if (text[i] === "`") return null;
+    if (text[i] === "$" && text[i + 1] === "{") {
+      const close = matchingBrace(text, i + 1);
+      if (close === null) return null;
+      const t = flow.taintOf(text.slice(i + 2, close), start + i + 2);
+      if (t && !t.ownUrl) return open(prefix) ? t : null;
+      prefix += "X";
+      i = close;
+      continue;
+    }
+    prefix += source[start + i];
+    if (prefix.length > 200) {
+      flow.limited = true;
+      return null;
+    }
+  }
+  return null;
+}
+function matchingParen(text, open) {
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    if (text[i] === "(") depth++;
+    else if (text[i] === ")" && --depth === 0) return i;
+  }
+  return null;
+}
+function matchingBrace(text, open) {
+  let depth = 0;
+  for (let i = open; i < text.length; i++) {
+    if (text[i] === "{") depth++;
+    else if (text[i] === "}" && --depth === 0) return i;
+  }
+  return null;
+}
+function splitTopLevel(text) {
+  const parts = [];
+  let depth = 0, from = 0;
+  for (let i = 0; i < text.length; i++) {
+    if ("([{".includes(text[i])) depth++;
+    else if (")]}".includes(text[i])) depth--;
+    else if (text[i] === "," && depth === 0) {
+      parts.push(text.slice(from, i));
+      from = i + 1;
+    }
+  }
+  parts.push(text.slice(from));
+  return parts;
+}
+function targetOf(call, analysed) {
+  const { code, pairs } = analysed;
+  const args = argumentExpressions(code, code, call.open + 1, call.close, pairs);
+  if (args.length === 0) return null;
+  const positions = [];
+  let cursor = call.open + 1;
+  for (const arg of args) {
+    const found = code.indexOf(arg, cursor);
+    positions.push(found);
+    cursor = found + arg.length;
+  }
+  let index = 0;
+  if (call.kind === "redirect") {
+    if (/sendRedirect/.test(call.name)) index = 1;
+    else if (/^\d{3}$/.test(args[0]) && args.length > 1) index = 1;
+  }
+  const expr = args[index];
+  if (expr === void 0) return null;
+  if (call.kind === "ssrf" && expr.startsWith("{")) {
+    const property = /(?:^|[{,])\s*(?:url|baseURL|href)\s*:\s*/.exec(expr);
+    if (!property) {
+      const shorthand = /(?:^|[{,])\s*(url|baseURL|href)\s*(?=[,}])/.exec(expr);
+      return shorthand ? { expr: shorthand[1], at: positions[index] + shorthand.index + shorthand[0].length - shorthand[1].length } : null;
+    }
+    const valueAt = positions[index] + property.index + property[0].length;
+    const value = splitTopLevel(expr.slice(property.index + property[0].length))[0].replace(/\}\s*$/, "");
+    return { expr: value, at: valueAt };
+  }
+  return { expr, at: positions[index] };
+}
+function capitalised2(text) {
+  return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
+}
+function ssrfFinding(route, file, line, originLine) {
+  return {
+    ruleId: "ssrf/request-url",
+    severity: "P1",
+    confidence: "likely",
+    title: `${capitalised2(route.url)} sends a server request to an address the caller chooses`,
+    file: file.path,
+    line,
+    excerpt: (file.lines[line - 1] ?? "").trim(),
+    why: [
+      `The address of this outgoing request comes from request input (read on line ${originLine}). A caller can point your server at internal services, cloud metadata endpoints such as 169.254.169.254, or other hosts only your server can reach, and read the response or trigger actions there.`,
+      "Fetching a caller-supplied address can be the purpose of the route, as in a link preview or image proxy, so this is reported for review. Even then it needs a host allowlist."
+    ],
+    fix: [
+      "Build the address from a fixed origin in code and let the request choose only a path segment or query value.",
+      "If callers must supply full URLs, parse them with new URL(), allow only https and hosts on an explicit allowlist, and reject private, loopback, and link-local addresses after DNS resolution."
+    ]
+  };
+}
+function redirectFinding(route, file, line, originLine, certain) {
+  return {
+    ruleId: "redirect/open",
+    severity: "P2",
+    confidence: certain ? "certain" : "likely",
+    title: `${capitalised2(route.url)} redirects to an address taken from the request`,
+    file: file.path,
+    line,
+    excerpt: (file.lines[line - 1] ?? "").trim(),
+    why: [
+      `The redirect target comes from request input (read on line ${originLine}), and nothing fixes the site it points to. A link to your site can then send visitors anywhere, which makes phishing links look trustworthy and can hand tokens in the URL to another site.`,
+      ...certain ? [] : ["The value passes through other code or a check first; confirm that check rejects other sites, including //host and /\\host forms."]
+    ],
+    fix: [
+      "Accept only relative paths that start with a single / (reject //, /\\, and anything with a scheme), or compare the target against a fixed list.",
+      "When building an absolute URL, use new URL(path, yourOrigin) and redirect only if the result's origin equals yourOrigin."
+    ]
+  };
+}
+function check(ctx, kind) {
+  const findings = [];
+  for (const file of ctx.files) {
+    const analysed = handlerFileOf(file);
+    if (!analysed) continue;
+    const calls = callsIn(analysed.code, analysed.pairs).filter((call) => call.kind === kind).sort((a, b) => a.at - b.at);
+    if (calls.length === 0) continue;
+    const positions = calls.map((call) => call.at);
+    const reported = /* @__PURE__ */ new Set();
+    for (const { route, body, flow } of analysed.handlersAround(positions)) {
+      for (let i = lowerBound(positions, body.start + 1); i < calls.length && calls[i].at < body.end; i++) {
+        const call = calls[i];
+        if (call.close >= body.end || reported.has(call.at)) continue;
+        const target = targetOf(call, analysed);
+        if (!target) continue;
+        const taint = controlsStart(target.expr, target.at, flow, analysed.source, kind);
+        if (!taint) continue;
+        reported.add(call.at);
+        const line = lineNumberAt(analysed.lineStarts, call.at);
+        const originLine = lineNumberAt(analysed.lineStarts, taint.origin);
+        findings.push(kind === "ssrf" ? ssrfFinding(route, file, line, originLine) : redirectFinding(route, file, line, originLine, taint.level === "direct" && !flow.validatedBefore(taint.names, call.at)));
+      }
+    }
+    reportInputLimit(ctx, file, analysed);
+  }
+  return findings;
+}
+var ssrfRule = { id: "ssrf/request-url", severity: "P1", check: (ctx) => check(ctx, "ssrf") };
+var redirectRule = { id: "redirect/open", severity: "P2", check: (ctx) => check(ctx, "redirect") };
+
+// src/rules/verification.ts
+var LocalVerification = class {
+  code;
+  source;
+  pairs;
+  bodies;
+  constructor(file) {
+    this.code = noiseMaskedOf(file);
+    this.source = commentsMaskedOf(file);
+    this.pairs = delimiterPairs(this.code);
+    this.bodies = functionBodies(this.code, this.pairs);
+  }
+  owner(at) {
+    return this.bodies.filter((b) => b.start < at && at < b.end).sort((a, b) => b.start - a.start)[0];
+  }
+  skipSpace(at) {
+    while (/\s/.test(this.code[at] ?? "")) at++;
+    return at;
+  }
+  endOf(at, limit = this.code.length) {
+    if (this.code[at] === "{") return (this.pairs.get(at) ?? limit - 1) + 1;
+    for (let i = at; i < limit; i++) {
+      if (/[;\n}]/.test(this.code[i])) return i;
+      const end = this.pairs.get(i);
+      if (end !== void 0) i = end;
+    }
+    return limit;
+  }
+  /**
+   * 块的顶层有无条件退出即算退出，前面可以有记录日志等语句；
+   * 嵌套分支、函数中的 return 以及无花括号 if/else/循环控制的 return 不算。
+   */
+  exits(from, to) {
+    let at = this.skipSpace(from);
+    if (this.code[at] !== "{") return /^(?:return|throw)\b|^(?:redirect|notFound)\s*\(/.test(this.code.slice(at, to));
+    const end = Math.min(to, this.pairs.get(at) ?? to);
+    at = this.skipSpace(at + 1);
+    while (at < end) {
+      if (/^(?:return|throw)\b|^(?:redirect|notFound)\s*\(/.test(this.code.slice(at, at + 32))) return true;
+      const next = this.statementEnd(at, end);
+      if (next <= at) return false;
+      at = this.skipSpace(next);
+    }
+    return false;
+  }
+  /** 跳过完整语句；分支、循环和函数内的退出不提升为外层退出。 */
+  statementEnd(at, limit, depth = 0) {
+    if (depth >= 64) return limit;
+    if (this.code[at] === "{") return (this.pairs.get(at) ?? limit - 1) + 1;
+    const control = /^(if|for(?:\s+await)?|while|with|switch)\s*\(/.exec(this.code.slice(at, at + 80));
+    if (control) {
+      const close = this.pairs.get(at + control[0].length - 1);
+      if (close === void 0) return limit;
+      let end = this.statementEnd(this.skipSpace(close + 1), limit, depth + 1);
+      const next = this.skipSpace(end);
+      if (control[1] === "if" && /^else\b/.test(this.code.slice(next, next + 5))) {
+        end = this.statementEnd(this.skipSpace(next + 4), limit, depth + 1);
+      }
+      return end;
+    }
+    if (/^(?:try|do)\b/.test(this.code.slice(at, at + 8))) return limit;
+    for (let i = at; i < limit; i++) {
+      if (this.code[i] === ";") return i + 1;
+      const close = this.pairs.get(i);
+      if (close !== void 0) {
+        i = close;
+        continue;
+      }
+      if (this.code[i] !== "\n") continue;
+      const before = this.code.slice(at, i).trimEnd();
+      const after = this.code.slice(i + 1, limit).trimStart();
+      if (!before || /[=+\-*/%&|^!?:,.([{<>]$/.test(before)) continue;
+      if (/^[.?+\-*/%&|^,:<>=([{`]/.test(after)) continue;
+      if (/\b(?:const|let|var|function|async|await|new|yield)$/.test(before)) continue;
+      return i + 1;
+    }
+    return limit;
+  }
+  /** 验证与使用须在同一函数，且不能依赖可选分支或被吞掉的异常。 */
+  enforcedBefore(from, to) {
+    const owner = this.owner(from);
+    if (from >= to || owner !== this.owner(to)) return false;
+    const start = owner ? owner.start + 1 : 0;
+    for (let i = start; i < from; i++) {
+      const conditional = /^(?:if|for|while|switch)\s*\(/.exec(this.code.slice(i, i + 32));
+      if (conditional && !/[\w$]/.test(this.code[i - 1] ?? "")) {
+        const close = this.pairs.get(i + conditional[0].length - 1);
+        if (close !== void 0) {
+          const body = this.skipSpace(close + 1);
+          const end2 = this.endOf(body);
+          if (from < end2 && to >= end2) return false;
+        }
+      }
+      const end = this.pairs.get(i);
+      if (end === void 0) continue;
+      if (end < from) {
+        i = end;
+        continue;
+      }
+      if (end >= to) continue;
+      if (this.code[i] !== "{" || !/\btry\s*$/.test(this.code.slice(Math.max(start, i - 16), i))) return false;
+      let next = this.skipSpace(end + 1);
+      if (/^catch\b/.test(this.code.slice(next))) {
+        next = this.skipSpace(next + 5);
+        if (this.code[next] === "(") next = this.skipSpace((this.pairs.get(next) ?? next) + 1);
+        const caughtEnd = this.endOf(next);
+        if (!this.exits(next, caughtEnd)) return false;
+        next = this.skipSpace(caughtEnd);
+      }
+      if (/^finally\b/.test(this.code.slice(next))) return false;
+    }
+    const boundary = Math.max(
+      start,
+      this.code.lastIndexOf(";", from - 1) + 1,
+      this.code.lastIndexOf("\n", from - 1) + 1,
+      this.code.lastIndexOf("{", from - 1) + 1
+    );
+    return !/[?]|&&|\|\|/.test(this.code.slice(boundary, from));
+  }
+  /** 找出当前函数中最后一次赋值；未知或条件覆盖同样会使旧证明失效。 */
+  assignment(name, at) {
+    const escaped = name.replace(/\$/g, "\\$");
+    const pattern = new RegExp(`(?<![\\w$.])(?:const\\s+|let\\s+|var\\s+)?${escaped}((?:\\s*\\.[\\w$]+|\\s*\\[[^\\]]*\\])*)\\s*(?::[^=;{}\\n]{0,100})?=(?![=>])`, "g");
+    let result = null;
+    for (const m of this.code.slice(0, at).matchAll(pattern)) {
+      if (this.owner(m.index) !== this.owner(at)) continue;
+      const from = this.skipSpace(m.index + m[0].length);
+      const end = this.endOf(from);
+      if (end <= at) result = { at: m.index, from, end, expression: this.code.slice(from, end).trim(), member: m[1].length > 0 };
+    }
+    return result;
+  }
+};
+
+// src/rules/session.ts
+var GET_SESSION = /\.auth\s*\.\s*getSession\s*\(/g;
+function verifiedSession(file, context, sessionAt, names) {
+  const { code, pairs, bodies } = context;
+  const body = context.owner(sessionAt);
+  if (!body) return false;
+  const client = /([\w$.]+)\s*$/.exec(code.slice(body.start, sessionAt))?.[1];
+  if (!client) return false;
+  const values = authValuesOf(file, body, bodies, pairs);
+  const reads = new RegExp(`(?<![\\w$.])(?:${namePattern(names)})(?![\\w$]|\\s*:)`, "g");
+  const verification = /\b(?:const|let)\s+(\{[^;=]{1,500}\}|[A-Za-z_$][\w$]*)\s*=\s*await\s+([\w$.]+)\.auth\.(?:getUser|getClaims)\s*\(/g;
+  for (const call of code.matchAll(verification)) {
+    if (call[2] !== client || context.owner(call.index) !== body) continue;
+    const close = pairs.get(call.index + call[0].length - 1);
+    if (close === void 0) continue;
+    if (code.slice(call.index + call[0].length, close).trim() !== "") continue;
+    const guardAt = context.skipSpace(code[close + 1] === ";" ? close + 2 : close + 1);
+    const condition = /^if\s*\(/.exec(code.slice(guardAt));
+    if (!condition) continue;
+    const conditionClose = pairs.get(guardAt + condition[0].length - 1);
+    if (conditionClose === void 0) continue;
+    const branchAt = context.skipSpace(conditionClose + 1);
+    const branchEnd = context.endOf(branchAt);
+    if (!context.exits(branchAt, branchEnd) || !context.enforcedBefore(call.index, guardAt)) continue;
+    const test = code.slice(guardAt + condition[0].length, conditionClose).trim();
+    const errorNames = call[1].startsWith("{") ? destructuredKeys(call[1]).filter((k) => k.key === "error").map((k) => k.local) : [`${call[1]}.error`];
+    if (/&&|\?(?!\.)/.test(test) || !test.split("||").some((term) => {
+      const t = term.trim();
+      return errorNames.includes(t) || t.startsWith("!") && identityRequirement(values.value(t.slice(1), guardAt), false) !== null;
+    })) continue;
+    const sessionClose = pairs.get(code.indexOf("(", sessionAt)) ?? code.indexOf(")", sessionAt);
+    let before = code.slice(sessionClose + 1, branchEnd);
+    before = before.replace(/\bif\s*\(\s*!\s*([\w$.?]+)\s*\)\s*(?:return|throw|redirect)\b[^;\n]*/g, (text, subject) => {
+      const rest = text.slice(text.indexOf(")") + 1).replace(/\b[\w$]+\s*:/g, "");
+      return names.some((n) => subject === n || subject.startsWith(`${n}.`)) && !new RegExp(reads.source).test(rest) ? " ".repeat(text.length) : text;
+    });
+    if (new RegExp(reads.source).test(before)) continue;
+    if (!context.enforcedBefore(guardAt, body.end - 1)) continue;
+    return true;
+  }
+  return false;
+}
+var SERVER_PATH = [
+  /(?:^|\/)(?:middleware|proxy)\.[mc]?[jt]s$/,
+  /(?:^|\/)app\/(?:.+\/)?(?:page|layout|template|default)\.[mc]?[jt]sx?$/,
+  /\.server\.[mc]?[jt]s$/,
+  /(?:^|\/)server\/.+\.[mc]?[jt]s$/
+];
+function isServerFile(file) {
+  if (!/\.[mc]?[jt]sx?$/.test(file.path)) return false;
+  if (/^\s*(?:(?:'use strict'|"use strict");?\s*)?['"]use client['"]/.test(commentsMaskedOf(file))) return false;
+  return SERVER_PATH.some((pattern) => pattern.test(file.path)) || routeOf(file) !== null || serverActionRoutes(file).length > 0;
+}
+var sessionRule = {
+  id: "auth/unverified-session",
+  severity: "P1",
+  appliesTo(file) {
+    return file.content.includes("getSession") && isServerFile(file);
+  },
+  check(file) {
+    const code = noiseMaskedOf(file);
+    const context = new LocalVerification(file);
+    const { pairs, bodies } = context;
+    const lineStarts = lineStartsOf(file.content);
+    const findings = [];
+    for (const m of code.matchAll(GET_SESSION)) {
+      const body = bodies.filter((b) => b.start < m.index && m.index < b.end).sort((a, b) => b.start - a.start)[0];
+      const start = body?.start ?? 0;
+      const end = body?.end ?? code.length;
+      const statement = code.slice(Math.max(start, m.index - 300), m.index);
+      const declaration = /\b(?:const|let|var)\s+((?:\{[^;=]*\})|[A-Za-z_$][\w$]*)\s*(?::[^=;]{0,200})?=\s*(?:await\s+)?\(?\s*(?:await\s+)?[\w$.?\s]*$/.exec(statement);
+      if (!declaration) continue;
+      const names = patternNames(declaration[1]);
+      if (names.length === 0) continue;
+      const refs = new RegExp(`(?<![\\w$.])(?:${namePattern(names)})(?![\\w$])`);
+      const after = code.slice(m.index, end);
+      let decides = false;
+      for (const condition of after.matchAll(/\bif\s*\(/g)) {
+        const open = m.index + condition.index + condition[0].length - 1;
+        const close = pairs.get(open);
+        if (close !== void 0 && refs.test(code.slice(open + 1, close))) {
+          decides = true;
+          break;
+        }
+      }
+      const readsUser = new RegExp(`(?<![\\w$.])(?:${namePattern(names)})(?:\\??\\.\\s*(?:session|data))*\\??\\.\\s*user\\b`).test(after);
+      if (!decides && !readsUser) continue;
+      if (verifiedSession(file, context, m.index, names)) continue;
+      const line = lineNumberAt(lineStarts, m.index);
+      findings.push({
+        ruleId: "auth/unverified-session",
+        severity: "P1",
+        confidence: decides ? "certain" : "likely",
+        title: "Server code trusts supabase.auth.getSession() to identify the user",
+        file: file.path,
+        line,
+        excerpt: (file.lines[line - 1] ?? "").trim(),
+        why: [
+          "On the server, getSession() reads the session straight from the request cookie without verifying it. Anyone can put a forged or expired session in their cookies, so a check based on it can be passed by a caller who is not signed in.",
+          decides ? "The result is used in a condition here, so it decides who gets through." : "The user from this session is read here, so an unverified user id may be trusted."
+        ],
+        fix: [
+          "Use supabase.auth.getClaims() (verifies the token signature) or supabase.auth.getUser() (asks the Auth server) to decide who the caller is.",
+          "Keep getSession() only where you need the access token itself, not to decide access."
+        ]
+      });
+    }
+    return findings;
+  }
+};
+
+// src/rules/webhook.ts
+var STRIPE_EVENT = /(?:\bcase\s*|\.type\s*[!=]==?\s*)['"`]((?:checkout\.session|payment_intent|customer\.subscription|customer|invoice|charge|setup_intent|payment_method|subscription_schedule|account|payout|refund|checkout)\.[a-z_.]+)['"`]|['"`]((?:checkout\.session|payment_intent|customer\.subscription|invoice|charge)\.[a-z_.]+)['"`]\s*[!=]==?\s*[\w$.]+\.type\b/;
+function verifiedEvent(context, name, at) {
+  const assignment = context.assignment(name, at);
+  if (!assignment || assignment.member || !context.enforcedBefore(assignment.at, at)) return false;
+  const call = /^(?:(await)\s+)?[\w$.]+\.(constructEvent(?:Async)?|retrieve|parseEventNotification)\s*\(/.exec(assignment.expression);
+  if (!call || call[2] !== "constructEvent" && !call[1]) return false;
+  if (call[2] === "retrieve" && !/\.events\s*\.\s*retrieve/.test(call[0])) return false;
+  const close = context.pairs.get(assignment.from + call[0].length - 1);
+  return close !== void 0 && context.code.slice(close + 1, assignment.end).trim() === "";
+}
+function eventName(context, event) {
+  if (event[0].startsWith(".")) return /([A-Za-z_$][\w$]*)\s*$/.exec(context.code.slice(0, event.index))?.[1] ?? null;
+  if (!event[0].startsWith("case")) return /([A-Za-z_$][\w$]*)\.type\b/.exec(event[0])?.[1] ?? null;
+  let name = null;
+  for (const m of context.code.slice(0, event.index).matchAll(/\bswitch\s*\(\s*([A-Za-z_$][\w$]*)\.type\s*\)\s*\{/g)) {
+    const end = context.pairs.get(m.index + m[0].length - 1);
+    if (end !== void 0 && end > event.index && context.owner(m.index) === context.owner(event.index)) name = m[1];
+  }
+  return name;
+}
+var READS_BODY = /\.\s*(?:json|text|arrayBuffer|formData)\s*\(|\breq(?:uest)?\s*\.\s*body\b|\b(?:readBody|readRawBody)\s*\(|\bbuffer\s*\(\s*req\b/;
+var webhookRule = {
+  id: "webhook/unverified-signature",
+  severity: "P1",
+  appliesTo(file) {
+    return /stripe/i.test(file.content) && routeOf(file) !== null;
+  },
+  check(file) {
+    const route = routeOf(file);
+    if (!route) return [];
+    const context = new LocalVerification(file);
+    const { source, code } = context;
+    const findings = [];
+    const reported = /* @__PURE__ */ new Set();
+    for (const event of source.matchAll(new RegExp(STRIPE_EVENT.source, "g"))) {
+      if (code[event.index] !== source[event.index]) continue;
+      const owner = context.owner(event.index);
+      const name = eventName(context, event);
+      if (name && verifiedEvent(context, name, event.index)) continue;
+      const key = owner?.start ?? 0;
+      if (reported.has(key)) continue;
+      reported.add(key);
+      const line = lineNumberAt(lineStartsOf(file.content), event.index);
+      const region = code.slice(owner?.start ?? 0, owner?.end ?? code.length);
+      const readsBody = READS_BODY.test(region);
+      const customCheck = /\bverifyHeader\s*\(/.test(region) || /\bcreateHmac\s*\(/.test(region) && /\btimingSafeEqual\s*\(/.test(region);
+      findings.push({
+        ruleId: "webhook/unverified-signature",
+        severity: "P1",
+        confidence: readsBody && !customCheck ? "certain" : "likely",
+        title: customCheck ? `Review custom Stripe signature verification in ${route.url}` : `${route.url} acts on Stripe events without verifying the signature`,
+        file: file.path,
+        line,
+        excerpt: (file.lines[line - 1] ?? "").trim(),
+        why: [
+          `This route handles ${event[1] ?? event[2]} and similar events, but the scan could not link this event to a signature-verification result. Without effective verification, callers can submit made-up events and trigger the handler.`,
+          ...customCheck ? ["A custom signature check is present; confirm it checks the raw body and rejects invalid signatures before processing this event."] : [],
+          ...readsBody ? [] : ["The event does not appear to come from the request body here; confirm where it is read and whether it is verified there."]
+        ],
+        fix: [
+          "Read the raw body (await request.text() in a route handler) and pass it to stripe.webhooks.constructEvent(body, request.headers.get('stripe-signature'), process.env.STRIPE_WEBHOOK_SECRET) before handling the event. Return 400 when it throws.",
+          "Do not parse the body as JSON before verifying; any change to the raw body makes verification fail."
+        ]
+      });
+    }
+    return findings;
+  }
+};
+
 // src/rules/index.ts
-var FILE_RULES = [secretsRule, exposureRule, firebaseRulesRule, corsRule];
-var PROJECT_RULES = [gitleakRule, supabaseRlsRule, apiAuthRule];
+var FILE_RULES = [secretsRule, exposureRule, firebaseRulesRule, corsRule, sessionRule, webhookRule];
+var PROJECT_RULES = [gitleakRule, supabaseRlsRule, apiAuthRule, injectionRule, ssrfRule, redirectRule];
 var RULE_IDS = [
   "api/admin-db-access-without-auth",
   "api/db-write-without-auth",
+  "auth/unverified-session",
   "cors/reflected-origin-with-credentials",
   "cors/wildcard-with-credentials",
   "exposure/private-name-in-public-env",
@@ -4552,9 +6738,14 @@ var RULE_IDS = [
   "firebase/test-mode-rules",
   "gitleak/env-in-history",
   "gitleak/env-tracked",
+  "injection/command",
+  "injection/sql",
+  "redirect/open",
+  "ssrf/request-url",
   "supabase/permissive-policy",
   "supabase/public-bucket-listing",
   "supabase/rls-not-enabled",
+  "webhook/unverified-signature",
   // 凭据规则 ID 从共享格式表生成。
   ...SECRET_PATTERNS.map((p) => `secrets/hardcoded/${p.id}`)
 ];
@@ -4782,7 +6973,7 @@ var RULE_CATALOG = [
     "P0",
     "certain",
     "Server routes and Next.js Server Functions in Next.js, SvelteKit (endpoints and form actions), Nuxt, Remix/React Router, and Astro, including workspace applications.",
-    "Syntactic guards only; runtime authentication and business authorization are not verified. Local auth imports/re-exports (up to eight hops), SvelteKit hooks and Nuxt middleware may lower confidence, without removing findings."
+    "Syntactic guards only; runtime authentication and business authorization are not verified. Local calls, identity arguments, branches and exception paths are analysed within documented limits. Local auth evidence, SvelteKit hooks and Nuxt middleware may lower confidence without removing findings; exceeded limits disclose incomplete coverage."
   ),
   rule(
     "api/db-write-without-auth",
@@ -4792,6 +6983,14 @@ var RULE_CATALOG = [
     "Server routes and Next.js Server Functions in Next.js, SvelteKit (endpoints and form actions), Nuxt, Remix/React Router, and Astro.",
     "Session-scoped clients and indirect guards may need manual review."
   ),
+  rule(
+    "auth/unverified-session",
+    "Server code trusting supabase.auth.getSession()",
+    "P1",
+    "varies",
+    "Server routes, Server Functions, middleware and proxy modules, Next.js server components, *.server modules, and server directories that call supabase.auth.getSession(): a result used in a condition is certain; reading its user is reported for review. Exemption requires a checked, awaited identity from the same client before trusted session use.",
+    "Only the receiving variable in the same function is followed; results passed to helpers are not tracked."
+  ),
   rule(
     "cors/reflected-origin-with-credentials",
     "Reflected origin with credentials",
@@ -4864,6 +7063,30 @@ var RULE_CATALOG = [
     "Tracked environment files; templates and public-only values are treated separately.",
     "Unrecognized private values are heuristic findings, not verified credentials."
   ),
+  rule(
+    "injection/command",
+    "Shell command built from request input",
+    "P1",
+    "varies",
+    "exec, execSync, and spawn/execFile with shell: true in supported server handlers. Execa command strings are checked for a caller-chosen executable, or shell interpolation when shell is enabled. Direct request input is certain; values passing through other calls or content checks require review.",
+    "Only flows inside one function are followed; values passed to helpers, other files, or validated elsewhere are not tracked."
+  ),
+  rule(
+    "injection/sql",
+    "SQL query built from request input",
+    "P1",
+    "varies",
+    "Untagged template or string concatenation in Prisma $queryRawUnsafe/$executeRawUnsafe, Prisma.raw, sql.raw/sql.unsafe, knex *Raw methods, driver query/execute calls, and query-builder where clauses, in server routes and Next.js Server Functions. Tagged templates and placeholders are not reported.",
+    "Only flows inside one function are followed; values passed to helpers, other files, or validated elsewhere are not tracked. Driver calls are reported only when the text looks like SQL."
+  ),
+  rule(
+    "redirect/open",
+    "Redirect to an address taken from the request",
+    "P2",
+    "varies",
+    "redirect, permanentRedirect, NextResponse.redirect, Response.redirect, res.redirect, and sendRedirect in server routes and Next.js Server Functions, when request input decides the start of the target (a whole value, a leading /, or the host). Request input used directly is certain; values that pass through other calls or checks require review.",
+    "Only flows inside one function are followed. The request's own URL and fixed paths followed by input are not reported; helper-built targets are not tracked."
+  ),
   rule(
     "supabase/permissive-policy",
     "Row Level Security policy with an always-true condition",
@@ -4880,6 +7103,14 @@ var RULE_CATALOG = [
     "Public buckets declared in migrations or supabase/config.toml, paired with a SELECT policy on storage.objects that is always true or filters only by that bucket.",
     "Buckets created from the dashboard or at runtime are not visible; restrictive policies may limit listing and lower confidence."
   ),
+  rule(
+    "ssrf/request-url",
+    "Server request to an address the caller chooses",
+    "P1",
+    "likely",
+    "fetch, $fetch/ofetch, axios, got, ky, needle, and Node http(s) calls in server routes and Next.js Server Functions, when request input decides the scheme or host of the address.",
+    "Only flows inside one function are followed. Fetching caller-supplied URLs can be intended, and allowlists or network controls are not verified."
+  ),
   rule(
     "supabase/rls-not-enabled",
     "Table without RLS in migrations",
@@ -4888,6 +7119,14 @@ var RULE_CATALOG = [
     "Supabase SQL migrations, replayed by application scope.",
     "Migration state is not deployed database state; grants and policy correctness are outside this check."
   ),
+  rule(
+    "webhook/unverified-signature",
+    "Stripe webhook events handled without signature verification",
+    "P1",
+    "varies",
+    "Server routes that branch on Stripe event types without an enforced constructEvent or awaited event-retrieval result for the handled value. Request-body handling is certain; custom signature checks remain likely.",
+    "Only Stripe is recognized. Unused calls do not verify events; custom HMAC and shared-helper verification require review."
+  ),
   ...SECRET_PATTERNS.map((pattern) => ({
     ...rule(
       `secrets/hardcoded/${pattern.id}`,