canship 0.5.0 → 0.6.0

package/dist/index.js

@@ -817,8 +817,7 @@ function walkTree(root, skipped, wantAll, maxEntries) {
         }
         if (!metadata.isFile()) continue;
         if (wantAll) all.push(rel);
-        const isCandidate = isEnvFile(entry.name) || CREDENTIAL_FILENAMES.has(entry.name) || CREDENTIAL_EXTENSIONS.has(extname(entry.name).toLowerCase()) || isWorthProbing(rel);
-        if (isCandidate) found.push(rel);
+        if (isCredentialName(entry.name) || isWorthProbing(rel)) found.push(rel);
       }
     } catch (err) {
       if (!isMissing(err)) skipped.push({
@@ -871,6 +870,9 @@ 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)) {
@@ -934,8 +936,16 @@ 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 {
@@ -1056,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) {
@@ -1094,19 +1106,19 @@ function endOfString(src, start, quote) {
 }
 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: [], failedUntil: -1 });
+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) {
-  if (!context.allowed || start < context.failedUntil || src[start + 1] === "=") return null;
+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") {
-      context.failedUntil = i;
+      state.failedUntil = i;
       return null;
     }
     if (ch === "\\") {
@@ -1122,15 +1134,15 @@ function regexAt(src, start, context) {
       return { close: i, end };
     }
   }
-  context.failedUntil = src.length;
+  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-\uffff]/.test(ch)) {
+  if (/[A-Za-z_$\u0080-￿]/.test(ch)) {
     let end = at + 1;
-    while (end < src.length && /[\w$\u0080-\uffff]/.test(src[end])) end++;
+    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);
@@ -1155,11 +1167,39 @@ function advanceCode(src, at, context) {
   context.member = false;
   return at + 1;
 }
-function maskTemplate(src, out, start, maskStrings = true) {
+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") {
@@ -1168,171 +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 === "expression") valueEnded(parent.lexical);
+        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, lexical: regexContext() });
+        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;
       }
-      const regex = regexAt(src, i, frame.lexical);
-      if (regex) {
-        if (maskStrings) blank(out, i + 1, regex.close);
-        i = regex.end;
+      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);
-      valueEnded(frame.lexical);
-      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 = advanceCode(src, i, frame.lexical);
-  }
-  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;
-  const lexical = regexContext();
-  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 === SLASH) {
-      const regex = regexAt(src, i, lexical);
-      if (regex) {
-        i = regex.end;
+      if (ch === LESS_THAN && !frame.closing && jsxStartsAt(src, i)) {
+        stack.push({ kind: "tag", closing: false });
+        i++;
         continue;
       }
-    }
-    if (ch === DOUBLE_QUOTE || ch === SINGLE_QUOTE) {
-      i = endOfString(src, i, ch);
-      valueEnded(lexical);
-      continue;
-    }
-    if (ch === BACKTICK) {
-      i = maskTemplate(src, out, i, false);
-      valueEnded(lexical);
-      continue;
-    }
-    i = advanceCode(src, i, lexical);
-  }
-  return stringOf(out);
-}
-function maskJsNoise(src) {
-  const length = src.length;
-  const out = codesOf(src);
-  let i = 0;
-  const lexical = regexContext();
-  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 (ch === SLASH && src.charCodeAt(i + 1) === GREATER_THAN && !frame.closing) {
+        stack.pop();
+        elementClosed(i + 2);
+        i += 2;
         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 === 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;
     }
     if (ch === SLASH) {
-      const regex = regexAt(src, i, lexical);
+      const next = src.charCodeAt(i + 1);
+      if (next === SLASH || next === STAR) {
+        i = skipComment(i);
+        continue;
+      }
+      const regex = regexAt(src, i, frame.lexical, state);
       if (regex) {
-        blank(out, i + 1, regex.close);
+        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);
-      valueEnded(lexical);
+      text(i + 1, stop - 1);
+      valueEnded(frame.lexical);
       i = stop;
       continue;
     }
     if (ch === BACKTICK) {
-      i = maskTemplate(src, out, i);
-      valueEnded(lexical);
+      stack.push({ kind: "literal", from: i + 1 });
+      i++;
+      continue;
+    }
+    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;
     }
-    i = advanceCode(src, i, lexical);
+    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;
 }
@@ -1638,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;
@@ -1720,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.`
       ]
     });
   }
@@ -1974,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);
@@ -2017,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.`
         ]
       });
     }
@@ -2648,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.`
         ]
       });
     }
@@ -2739,14 +2765,15 @@ 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: [
@@ -3108,6 +3135,15 @@ function namePattern(names) {
 }
 
 // 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();
@@ -3305,8 +3341,10 @@ var AuthValues = class {
       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|getUserSession|getSession|getServerSession|safeGetSession|currentUser|verifyIdToken|auth))\s*\(/.exec(expr);
+    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) {
@@ -3319,7 +3357,10 @@ var AuthValues = class {
       }
       if (depth2 !== 0 || masked.slice(end).trim() !== "") return { kind: "opaque" };
       if (/\|\||&&|\?(?!\.)|\.then\s*\(/.test(expr) || /\.catch\s*\(/.test(expr)) return { kind: "opaque" };
-      return { kind: /\.auth\.getUser\s*\(/.test(expr) ? "envelope" : "identity" };
+      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);
@@ -3341,14 +3382,10 @@ var AuthValues = class {
       }
       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);
-      if (assignment.projection === null) value = { kind: "opaque" };
-      else if (assignment.projection.length && value.kind === "envelope") value = {
-        kind: assignment.projection.join(".") === "data.user" ? "identity" : "opaque"
-      };
+      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" };
-    if (value.kind === "envelope") return { kind: /^\??\.data\??\.user$/.test(access[2]) ? "identity" : "envelope" };
-    return value;
+    return project(value, access[2].split(/\??\./).filter(Boolean));
   }
 };
 function identityRequirement(value, allowParameters) {
@@ -3574,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) {
@@ -3631,7 +3670,7 @@ function hasConditionalAuthGuard(code, requireThrow = false, accept) {
     const returnsDeniedStatus = DENIED_STATUS.test(statement);
     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)) && accept(term) : rejectsMissingIdentity(term, returnsDeniedStatus);
+      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;
   }
@@ -3735,7 +3774,7 @@ function unguardedOpsOf(file) {
   return hit;
 }
 function operationsInRange(ops, start, end) {
-  const lowerBound = (value) => {
+  const lowerBound2 = (value) => {
     let low = 0, high = ops.length;
     while (low < high) {
       const middle = low + high >>> 1;
@@ -3744,7 +3783,7 @@ function operationsInRange(ops, start, end) {
     }
     return low;
   };
-  return ops.slice(lowerBound(start + 1), lowerBound(end));
+  return ops.slice(lowerBound2(start + 1), lowerBound2(end));
 }
 var lineStartsCache = /* @__PURE__ */ new WeakMap();
 function lineStartsCached(file) {
@@ -3755,12 +3794,12 @@ function lineStartsCached(file) {
   }
   return hit;
 }
-function cachedByFile(check) {
+function cachedByFile(check2) {
   const cache3 = /* @__PURE__ */ new WeakMap();
   return (file) => {
     let hit = cache3.get(file);
     if (hit === void 0) {
-      hit = check(file);
+      hit = check2(file);
       cache3.set(file, hit);
     }
     return hit;
@@ -4800,6 +4839,10 @@ 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);
@@ -5258,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",
@@ -5273,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}`)
 ];
@@ -5513,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",
@@ -5585,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",
@@ -5601,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",
@@ -5609,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}`,