canship 0.3.2 → 0.5.0

package/dist/cli.js

@@ -1,18 +1,20 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { isAbsolute as isAbsolute2, relative as relative_, resolve as resolve2 } from "path";
-import { existsSync as existsSync3, realpathSync as realpathSync2, statSync as statSync5, writeFileSync as writeFileSync2 } from "fs";
+import { isAbsolute as isAbsolute3, relative as relative_, resolve as resolve2 } from "path";
+import { existsSync as existsSync3, realpathSync as realpathSync3, statSync as statSync5, writeFileSync as writeFileSync2 } from "fs";
 
 // src/rules/patterns.ts
 var IRRELEVANT_HOSTS = /^(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\]|host\.docker\.internal|.*\.?example\.(?:com|org|net)|.*\.(?:test|invalid|localhost))$/i;
 var JWT_SOURCE = String.raw`eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}`;
 var SB_SECRET_SOURCE = String.raw`sb_secret_[A-Za-z0-9_-]{8,}`;
+var PRIVATE_KEY_BEGIN_SOURCE = String.raw`-----BEGIN (?:(?:RSA|EC|DSA|OPENSSH|ENCRYPTED|PGP) )?PRIVATE KEY(?: BLOCK)?-----`;
 var SECRET_PATTERNS = [
   {
     id: "openai",
     name: "OpenAI API key",
-    pattern: /\bsk-(?!ant-)(?:proj-)?[A-Za-z0-9_-]{20,}\b/g,
+    // OpenRouter 密钥同样以 sk- 开头，由下方的专用格式识别。
+    pattern: /\bsk-(?!ant-|or-v1-)(?:proj-)?[A-Za-z0-9_-]{20,}\b/g,
     impact: "Anyone with this key can spend your OpenAI credit. Leaked keys are typically abused within minutes of going public.",
     rotateAt: "https://platform.openai.com/api-keys"
   },
@@ -23,6 +25,50 @@ var SECRET_PATTERNS = [
     impact: "Anyone with this key can spend your Anthropic credit.",
     rotateAt: "https://console.anthropic.com/settings/keys"
   },
+  // 以下前缀取自各服务官方文档；除 Replicate 外文档未给出长度，只设最小长度以排除示例占位符。
+  {
+    id: "openrouter",
+    name: "OpenRouter API key",
+    pattern: /\bsk-or-v1-[A-Za-z0-9]{32,}\b/g,
+    impact: "Anyone with this key can spend your OpenRouter credit on any model it routes to, up to the key's limit.",
+    rotateAt: "https://openrouter.ai/settings/keys"
+  },
+  {
+    id: "groq",
+    name: "Groq API key",
+    pattern: /\bgsk_[A-Za-z0-9]{40,}\b/g,
+    impact: "Anyone with this key can run models on your Groq account and use up its rate limits and billing.",
+    rotateAt: "https://console.groq.com/keys"
+  },
+  {
+    id: "huggingface",
+    name: "Hugging Face access token",
+    pattern: /\bhf_[A-Za-z0-9]{30,}\b/g,
+    impact: "Depending on its scope, this token can read your private models and datasets, push to your repositories, and spend on paid inference.",
+    rotateAt: "https://huggingface.co/settings/tokens"
+  },
+  {
+    id: "replicate",
+    name: "Replicate API token",
+    // 官方文档：共 40 个字符，始终以 r8_ 开头。
+    pattern: /\br8_[A-Za-z0-9]{37}\b/g,
+    impact: "Anyone with this token can run paid predictions on your Replicate account and read your models and predictions.",
+    rotateAt: "https://replicate.com/account/api-tokens"
+  },
+  {
+    id: "xai",
+    name: "xAI API key",
+    pattern: /\bxai-[A-Za-z0-9]{40,}\b/g,
+    impact: "Anyone with this key can call Grok models on your xAI account and spend its credit.",
+    rotateAt: "https://console.x.ai"
+  },
+  {
+    id: "perplexity",
+    name: "Perplexity API key",
+    pattern: /\bpplx-[A-Za-z0-9]{40,}\b/g,
+    impact: "Anyone with this key can run Perplexity API requests billed to your account.",
+    rotateAt: "https://console.perplexity.ai"
+  },
   {
     id: "aws-access-key-id",
     name: "AWS access key ID",
@@ -88,7 +134,7 @@ var SECRET_PATTERNS = [
     id: "private-key",
     name: "Private key file contents",
     rotateLabel: "private key",
-    pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/g,
+    pattern: new RegExp(PRIVATE_KEY_BEGIN_SOURCE, "g"),
     impact: "A private key in source code can be used to impersonate your server, decrypt traffic, or log into your machines."
   },
   {
@@ -134,7 +180,7 @@ function isPlaceholder(secret) {
   if (LONG_PLACEHOLDER_SEGMENT.test(secret)) return true;
   if (namesItselfTwice(secret)) return true;
   if (PLACEHOLDER_SHAPE.test(secret)) return true;
-  const body = lower.replace(/^(sk-ant-|sk-proj-|sk-|rk_live_|sk_live_|akia|aiza|sg\.|gh[pousr]_)/, "");
+  const body = lower.replace(/^(sk-ant-|sk-proj-|sk-or-v1-|sk-|rk_live_|sk_live_|akia|aiza|sg\.|gh[pousr]_|gsk_|hf_|r8_|xai-|pplx-)/, "");
   if (body.length >= 8) {
     const distinct = new Set(body.replace(/[^a-z0-9]/g, "")).size;
     if (distinct <= 3) return true;
@@ -169,13 +215,29 @@ function redactSecret(secret) {
   return `${head}\u2026(${secret.length} chars)\u2026${tail}`;
 }
 function redactLine(line, secret) {
-  const trimmed = line.trim();
+  const trimmed = redactPrivateKeys(line.trim());
   if (!secret) return trimmed;
   return trimmed.split(secret).join(redactSecret(secret));
 }
 var JWT_SHAPED = new RegExp(String.raw`\b${JWT_SOURCE}\b`, "g");
+function redactPrivateKeys(text) {
+  const starts = new RegExp(PRIVATE_KEY_BEGIN_SOURCE, "g");
+  const parts = [];
+  let from = 0;
+  let match;
+  while ((match = starts.exec(text)) !== null) {
+    const closing = match[0].replace("BEGIN ", "END ");
+    const end = text.indexOf(closing, starts.lastIndex);
+    parts.push(text.slice(from, match.index), "[REDACTED PRIVATE KEY]");
+    from = end === -1 ? text.length : end + closing.length;
+    starts.lastIndex = from;
+    if (end === -1) break;
+  }
+  parts.push(text.slice(from));
+  return parts.join("");
+}
 function redactAll(text) {
-  let out = text;
+  let out = redactPrivateKeys(text);
   for (const pat of SECRET_PATTERNS) {
     const re = new RegExp(pat.pattern.source, pat.pattern.flags);
     out = out.replace(re, (match) => redactSecret(match));
@@ -190,8 +252,8 @@ function truncate(s, max = 120) {
 import { basename as basename2 } from "path";
 
 // src/walker.ts
-import { readdirSync, readFileSync as readFileSync2, statSync as statSync2, lstatSync as lstatSync2, openSync, readSync, closeSync } from "fs";
-import { join as join2, relative as relative2, sep as sep2, extname, basename } from "path";
+import { opendirSync, readFileSync as readFileSync2, statSync as statSync2, lstatSync as lstatSync2, realpathSync as realpathSync2, openSync, readSync, closeSync } from "fs";
+import { join as join2, relative as relative2, isAbsolute as isAbsolute2, sep as sep2, extname, basename } from "path";
 
 // src/git.ts
 import { execFileSync } from "child_process";
@@ -428,6 +490,7 @@ function execGitBatch(executable, root, args, input, options = {}) {
 var MAX_FILE_BYTES = 2 * 1024 * 1024;
 var MAX_SCAN_BYTES = 128 * 1024 * 1024;
 var MAX_SCAN_FILES = 1e4;
+var MAX_WALK_ENTRIES = 5e4;
 var MAX_WALK_DEPTH = 16;
 var SKIP_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -604,16 +667,16 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".sqlite3",
   ".mo"
 ]);
-function probeFileType(absPath) {
+function probeFileType(absPath, limit) {
   let fd = null;
   try {
     fd = openSync(absPath, "r");
-    const buf = Buffer.alloc(PROBE_BYTES);
-    const read = readSync(fd, buf, 0, PROBE_BYTES, 0);
+    const buf = Buffer.alloc(limit);
+    const read = readSync(fd, buf, 0, limit, 0);
     const head = buf.subarray(0, read);
     const hasTextBom = head.length >= 2 && head[0] === 255 && head[1] === 254 || head.length >= 2 && head[0] === 254 && head[1] === 255 || head.length >= 3 && head[0] === 239 && head[1] === 187 && head[2] === 191;
-    if (hasTextBom) return { kind: "text" };
-    return head.includes(0) ? { kind: "binary" } : { kind: "text" };
+    if (hasTextBom) return { kind: "text", bytes: read };
+    return { kind: head.includes(0) ? "binary" : "text", bytes: read };
   } catch (err) {
     return {
       kind: "unreadable",
@@ -686,10 +749,13 @@ function listViaGit(root, gitExecutable) {
     return null;
   }
 }
-function walkTree(root, skipped, wantAll) {
+function walkTree(root, skipped, wantAll, maxEntries) {
   const all = [];
   const found = [];
+  let visited = 0;
+  let exhausted = false;
   const walk = (dir, depth) => {
+    if (exhausted) return;
     if (depth > MAX_WALK_DEPTH) {
       skipped.push({
         path: relative2(root, dir).split(sep2).join("/") || ".",
@@ -700,7 +766,7 @@ function walkTree(root, skipped, wantAll) {
     }
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries = opendirSync(dir);
     } catch (err) {
       if (!isMissing(err)) {
         skipped.push({
@@ -711,31 +777,57 @@ function walkTree(root, skipped, wantAll) {
       }
       return;
     }
-    for (const entry of entries) {
-      const full = join2(dir, entry.name);
-      const rel = relative2(root, full).split(sep2).join("/");
-      if (entry.isSymbolicLink()) {
-        if (!SKIP_DIRS.has(entry.name)) {
-          skipped.push({ path: rel, reason: "symlink", detail: "symbolic links are not followed" });
+    try {
+      while (!exhausted) {
+        const entry = entries.readSync();
+        if (entry === null) break;
+        if (visited >= maxEntries) {
+          exhausted = true;
+          skipped.push({
+            path: relative2(root, dir).split(sep2).join("/") || ".",
+            reason: "directory-unreadable",
+            detail: `directory entry budget exceeded (${maxEntries} entries)`
+          });
+          break;
         }
-        continue;
-      }
-      if (entry.isDirectory()) {
-        if (SKIP_DIRS.has(entry.name)) continue;
-        walk(full, depth + 1);
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      if (wantAll) all.push(rel);
-      let isCandidate = isEnvFile(entry.name) || CREDENTIAL_FILENAMES.has(entry.name) || CREDENTIAL_EXTENSIONS.has(extname(entry.name).toLowerCase());
-      if (!isCandidate && isWorthProbing(rel)) {
-        const probe = probeFileType(full);
-        if (probe.kind === "text") isCandidate = true;
-        else if (probe.kind === "unreadable") {
-          skipped.push({ path: rel, reason: "unreadable", detail: probe.detail });
+        visited++;
+        const full = join2(dir, entry.name);
+        const rel = relative2(root, full).split(sep2).join("/");
+        let metadata;
+        try {
+          metadata = lstatSync2(full);
+        } catch (err) {
+          if (!isMissing(err)) skipped.push({
+            path: rel,
+            reason: "unreadable",
+            detail: String(err instanceof Error ? err.message : err)
+          });
+          continue;
+        }
+        if (metadata.isSymbolicLink()) {
+          if (!SKIP_DIRS.has(entry.name)) {
+            skipped.push({ path: rel, reason: "symlink", detail: "symbolic links are not followed" });
+          }
+          continue;
         }
+        if (metadata.isDirectory()) {
+          if (SKIP_DIRS.has(entry.name)) continue;
+          walk(full, depth + 1);
+          continue;
+        }
+        if (!metadata.isFile()) continue;
+        if (wantAll) all.push(rel);
+        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 (isCandidate) found.push(rel);
+    } catch (err) {
+      if (!isMissing(err)) skipped.push({
+        path: relative2(root, dir).split(sep2).join("/") || ".",
+        reason: "directory-unreadable",
+        detail: String(err instanceof Error ? err.message : err)
+      });
+    } finally {
+      entries.closeSync();
     }
   };
   walk(root, 0);
@@ -779,11 +871,41 @@ function isExampleContext(relPath) {
   if (/\.(test|spec)\.[jt]sx?$/i.test(name)) return true;
   return false;
 }
+function readablePath(root, path, skipped) {
+  const rel = relative2(root, path);
+  if (!rel || rel === ".." || rel.startsWith(`..${sep2}`) || isAbsolute2(rel)) {
+    skipped.push({ path: ".", reason: "unreadable", detail: "candidate path is outside the scan root" });
+    return false;
+  }
+  let current = root;
+  for (const segment of rel.split(sep2)) {
+    current = join2(current, segment);
+    const stat = lstatSync2(current);
+    if (stat.isSymbolicLink()) {
+      const linked = relative2(root, current).split(sep2).join("/");
+      if (!skipped.some((item) => item.path === linked && item.reason === "symlink")) {
+        skipped.push({ path: linked, reason: "symlink", detail: "symbolic links are not followed" });
+      }
+      return false;
+    }
+  }
+  const real = relative2(root, realpathSync2(path));
+  if (real === ".." || real.startsWith(`..${sep2}`) || isAbsolute2(real)) {
+    skipped.push({ path: rel.split(sep2).join("/"), reason: "unreadable", detail: "resolved path is outside the scan root" });
+    return false;
+  }
+  if (!lstatSync2(path).isFile()) {
+    skipped.push({ path: rel.split(sep2).join("/"), reason: "unreadable", detail: "not a regular file" });
+    return false;
+  }
+  return true;
+}
 function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root), limits = {}, honorIgnoreMarkers = true) {
+  root = realpathSync2(root);
   const skipped = [];
   const ignored = [];
   const fromGit = isGitRepo ? listViaGit(root, gitExecutable) : null;
-  const walked = walkTree(root, skipped, fromGit === null);
+  const walked = walkTree(root, skipped, fromGit === null, limits.maxEntries ?? MAX_WALK_ENTRIES);
   const listed = fromGit?.files ?? walked.all;
   const candidates = /* @__PURE__ */ new Set();
   let vendored = 0;
@@ -817,14 +939,10 @@ function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root
     const absPath = join2(root, relPath);
     let content;
     try {
-      if (lstatSync2(absPath).isSymbolicLink()) {
-        if (!skipped.some((entry) => entry.path === relPath && entry.reason === "symlink")) {
-          skipped.push({ path: relPath, reason: "symlink", detail: "symbolic links are not followed" });
-        }
-        continue;
-      }
+      if (!readablePath(root, absPath, skipped)) continue;
       const size = statSync2(absPath).size;
-      if (size > MAX_FILE_BYTES) {
+      const needsProbe = isWorthProbing(relPath);
+      if (!needsProbe && size > MAX_FILE_BYTES) {
         skipped.push({
           path: relPath,
           reason: "too-large",
@@ -832,7 +950,8 @@ function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root
         });
         continue;
       }
-      if (filesRead >= maxFiles || bytesRead + size > maxBytes) {
+      const initialBytes = needsProbe ? Math.min(size, PROBE_BYTES) : size;
+      if (filesRead >= maxFiles || bytesRead + initialBytes > maxBytes) {
         skipped.push({
           path: relPath,
           reason: "too-large",
@@ -840,9 +959,30 @@ function collectFiles(root, isGitRepo, gitExecutable = resolveGitExecutable(root
         });
         break;
       }
+      filesRead++;
+      if (needsProbe) {
+        const probe = probeFileType(absPath, initialBytes);
+        if (probe.kind === "unreadable") {
+          skipped.push({ path: relPath, reason: "unreadable", detail: probe.detail });
+          continue;
+        }
+        bytesRead += probe.bytes;
+        if (probe.kind === "binary") continue;
+        if (size > MAX_FILE_BYTES) {
+          skipped.push({
+            path: relPath,
+            reason: "too-large",
+            detail: `${Math.round(size / 1024)} KB, cap is ${MAX_FILE_BYTES / 1024} KB`
+          });
+          continue;
+        }
+        if (bytesRead + size > maxBytes) {
+          skipped.push({ path: relPath, reason: "too-large", detail: "scan read budget exceeded after file probe" });
+          break;
+        }
+      }
       const bytes = readFileSync2(absPath);
       bytesRead += bytes.length;
-      filesRead++;
       if (bytesRead > maxBytes) {
         skipped.push({ path: relPath, reason: "too-large", detail: "scan read budget exceeded during file read" });
         break;
@@ -952,6 +1092,69 @@ function endOfString(src, start, quote) {
   }
   return length;
 }
+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 });
+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;
+  let inClass = false;
+  for (let i = start + 1; i < src.length; i++) {
+    const ch = src[i];
+    if (ch === "\n" || ch === "\r") {
+      context.failedUntil = i;
+      return null;
+    }
+    if (ch === "\\") {
+      i++;
+      continue;
+    }
+    if (ch === "[") inClass = true;
+    else if (ch === "]") inClass = false;
+    else if (ch === "/" && !inClass) {
+      let end = i + 1;
+      while (end < src.length && /[A-Za-z]/.test(src[end])) end++;
+      valueEnded(context);
+      return { close: i, end };
+    }
+  }
+  context.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)) {
+    let end = at + 1;
+    while (end < src.length && /[\w$\u0080-\uffff]/.test(src[end])) end++;
+    const word = src.slice(at, end);
+    context.control = !context.member && CONTROL_WORDS.has(word);
+    context.allowed = !context.member && REGEX_PREFIX_WORDS.has(word);
+    context.member = false;
+    return end;
+  }
+  if (ch === "(") {
+    context.parentheses.push(context.control);
+    context.allowed = true;
+  } else if (ch === ")") context.allowed = context.parentheses.pop() ?? false;
+  else if (ch === "." || ch === "?" && src[at + 1] === ".") {
+    context.allowed = false;
+    context.control = false;
+    context.member = true;
+    return at + (ch === "?" ? 2 : 1);
+  } else if ((ch === "+" || ch === "-") && src[at + 1] === ch) {
+    context.control = false;
+    context.member = false;
+    return at + 2;
+  } else context.allowed = !/[\d\]}]/.test(ch);
+  context.control = false;
+  context.member = false;
+  return at + 1;
+}
 function maskTemplate(src, out, start, maskStrings = true) {
   const length = src.length;
   const stack = [{ kind: "literal", from: start + 1 }];
@@ -967,12 +1170,14 @@ function maskTemplate(src, out, start, maskStrings = true) {
       if (ch === BACKTICK) {
         if (maskStrings) blank(out, frame.from, i);
         stack.pop();
+        const parent = stack[stack.length - 1];
+        if (parent?.kind === "expression") 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 });
+        stack.push({ kind: "expression", depth: 1, lexical: regexContext() });
         i += 2;
         continue;
       }
@@ -988,10 +1193,17 @@ function maskTemplate(src, out, start, maskStrings = true) {
         i = stop;
         continue;
       }
+      const regex = regexAt(src, i, frame.lexical);
+      if (regex) {
+        if (maskStrings) blank(out, i + 1, regex.close);
+        i = regex.end;
+        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;
     }
@@ -1009,7 +1221,7 @@ function maskTemplate(src, out, start, maskStrings = true) {
         if (parent.kind === "literal") parent.from = i + 1;
       }
     }
-    i++;
+    i = advanceCode(src, i, frame.lexical);
   }
   const last = stack[stack.length - 1];
   if (maskStrings && last?.kind === "literal") blank(out, last.from, length);
@@ -1019,6 +1231,7 @@ 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) {
@@ -1038,15 +1251,24 @@ function maskJsComments(src) {
         continue;
       }
     }
+    if (ch === SLASH) {
+      const regex = regexAt(src, i, lexical);
+      if (regex) {
+        i = regex.end;
+        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++;
+    i = advanceCode(src, i, lexical);
   }
   return stringOf(out);
 }
@@ -1054,6 +1276,7 @@ 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) {
@@ -1073,17 +1296,27 @@ function maskJsNoise(src) {
         continue;
       }
     }
+    if (ch === SLASH) {
+      const regex = regexAt(src, i, lexical);
+      if (regex) {
+        blank(out, 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);
       i = stop;
       continue;
     }
     if (ch === BACKTICK) {
       i = maskTemplate(src, out, i);
+      valueEnded(lexical);
       continue;
     }
-    i++;
+    i = advanceCode(src, i, lexical);
   }
   return stringOf(out);
 }
@@ -1364,15 +1597,13 @@ function parseEnv(file) {
 var exposureRule = {
   id: "exposure/public-env",
   severity: "P0",
-  appliesTo(file) {
-    const name = basename3(file.path);
-    if (isEnvFile(name)) return true;
-    return /\.(ts|tsx|js|jsx|mjs|cjs|svelte|vue|astro)$/.test(name);
+  appliesTo() {
+    return true;
   },
   /** 使用有界缓冲区保留结果，超限时记录扫描缺口。 */
   check(file, ctx) {
     const name = basename3(file.path);
-    const findings = isEnvFile(name) ? checkEnvFile(file) : checkSourceFile(file);
+    const findings = isEnvFile(name) ? checkEnvFile(file) : FRONTEND_SOURCE.test(name) ? checkSourceFile(file) : checkOtherFile(file);
     if (!findings.overflow) return findings.items;
     ctx.reportIncomplete(
       "exposure/public-env",
@@ -1460,38 +1691,46 @@ function checkEnvFile(file) {
   }
   return findings;
 }
+var FRONTEND_SOURCE = /\.(ts|tsx|js|jsx|mjs|cjs|svelte|vue|astro)$/;
+function checkOtherFile(file) {
+  const findings = new FindingBuffer();
+  file.lines.forEach((line, i) => pushServiceRoleJwts(findings, file, line, i, false));
+  return findings;
+}
+function pushServiceRoleJwts(findings, file, line, i, clientSide) {
+  JWT_SHAPED2.lastIndex = 0;
+  const jwtMatches = line.match(JWT_SHAPED2);
+  if (!jwtMatches) return;
+  for (const jwt of jwtMatches) {
+    if (!isSupabaseServiceRole(jwt)) continue;
+    findings.push({
+      ruleId: "exposure/supabase-service-role-in-client",
+      severity: "P0",
+      confidence: "certain",
+      title: clientSide ? "Your Supabase admin key is hardcoded in a client component" : "Your Supabase admin key is hardcoded in source code",
+      file: file.path,
+      line: i + 1,
+      excerpt: redactLine(line, jwt),
+      why: [
+        `This is the service_role key \u2014 it bypasses every Row Level Security policy and is effectively your database root password.`,
+        clientSide ? `This file starts with 'use client', so it is shipped to the browser in full. Any visitor can read this key.` : `Hardcoding it in source means it is in your git history, and it will be bundled anywhere this file is imported from client code.`
+      ],
+      fix: [
+        `Remove the key from the source file entirely.`,
+        `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.`
+      ]
+    });
+  }
+}
 function checkSourceFile(file) {
   const findings = new FindingBuffer();
   const clientSide = isClientCode(file);
   const commentless = commentsMaskedOf(file).split(/\r?\n/);
   file.lines.forEach((line, i) => {
-    JWT_SHAPED2.lastIndex = 0;
-    const jwtMatches = line.match(JWT_SHAPED2);
-    if (jwtMatches) {
-      for (const jwt of jwtMatches) {
-        if (!isSupabaseServiceRole(jwt)) continue;
-        findings.push({
-          ruleId: "exposure/supabase-service-role-in-client",
-          severity: "P0",
-          confidence: "certain",
-          title: clientSide ? "Your Supabase admin key is hardcoded in a client component" : "Your Supabase admin key is hardcoded in source code",
-          file: file.path,
-          line: i + 1,
-          excerpt: redactLine(line, jwt),
-          why: [
-            `This is the service_role key \u2014 it bypasses every Row Level Security policy and is effectively your database root password.`,
-            clientSide ? `This file starts with 'use client', so it is shipped to the browser in full. Any visitor can read this key.` : `Hardcoding it in source means it is in your git history, and it will be bundled anywhere this file is imported from client code.`
-          ],
-          fix: [
-            `Remove the key from the source file entirely.`,
-            `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.`
-          ]
-        });
-      }
-    }
+    pushServiceRoleJwts(findings, file, line, i, clientSide);
     const envRef = /(?:process\.env|import\.meta\.env)(?:\.([A-Z_][A-Z0-9_]*)|\[\s*['"]([A-Z_][A-Z0-9_]*)['"]\s*\])/g;
     let m;
     while ((m = envRef.exec(commentless[i] ?? "")) !== null) {
@@ -1640,6 +1879,8 @@ function historicalEvidence(root, gitExecutable, entry) {
     "log",
     "--no-ext-diff",
     "--no-textconv",
+    "--no-renames",
+    "--diff-filter=d",
     "--all",
     "--format=%H",
     `--max-count=${MAX_HISTORY_REVISIONS + 1}`,
@@ -1785,6 +2026,194 @@ var gitleakRule = {
   }
 };
 
+// src/rules/sqlpolicy.ts
+var MAX_STATEMENT = 4e3;
+function statementEnd(masked, from, onTruncated) {
+  const limit = Math.min(masked.length, from + MAX_STATEMENT);
+  const semicolon = masked.slice(from, limit).indexOf(";");
+  if (semicolon === -1 && limit < masked.length && masked[limit] !== ";") onTruncated?.();
+  return semicolon === -1 ? limit : from + semicolon;
+}
+function parenthesized(masked, open, end) {
+  let depth = 0;
+  for (let i = open; i < end; i++) {
+    if (masked[i] === "(") depth++;
+    else if (masked[i] === ")" && --depth === 0) return { from: open + 1, to: i };
+  }
+  return null;
+}
+function normalizeExpression(text) {
+  const parts = [];
+  for (let i = 0; i < text.length; ) {
+    const ch = text[i];
+    if (ch === "'") {
+      const start2 = i++;
+      let closed = false;
+      while (i < text.length) {
+        if (text[i++] !== "'") continue;
+        if (text[i] === "'") {
+          i++;
+          continue;
+        }
+        closed = true;
+        break;
+      }
+      if (!closed) return "";
+      parts.push(text.slice(start2, i));
+    } else if (text.startsWith("--", i)) {
+      const end2 = text.indexOf("\n", i + 2);
+      i = end2 === -1 ? text.length : end2;
+    } else if (text.startsWith("/*", i)) {
+      let depth = 1;
+      i += 2;
+      while (i < text.length && depth > 0) {
+        if (text.startsWith("/*", i)) {
+          depth++;
+          i += 2;
+        } else if (text.startsWith("*/", i)) {
+          depth--;
+          i += 2;
+        } else i++;
+      }
+      if (depth !== 0) return "";
+    } else {
+      if (!/\s/.test(ch)) parts.push(ch.toLowerCase());
+      i++;
+    }
+  }
+  const out = parts.join("");
+  let start = 0;
+  let end = out.length;
+  while (out[start] === "(") start++;
+  while (end > start && out[end - 1] === ")") end--;
+  return start === out.length - end ? out.slice(start, end) : out;
+}
+function isAlwaysTrue(expression) {
+  const e = normalizeExpression(expression);
+  if (e === "true") return true;
+  const numbers = /^(\d+)=(\d+)$/.exec(e);
+  if (numbers) return numbers[1] === numbers[2];
+  const strings = /^'((?:[^']|'')*)'='((?:[^']|'')*)'$/.exec(e);
+  return strings !== null && strings[1] === strings[2];
+}
+function bucketOnlyCondition(expression) {
+  return /^(?:(?:storage\.)?objects\.)?bucket_id='((?:[^']|'')*)'$/.exec(normalizeExpression(expression))?.[1]?.replace(/''/g, "'") ?? null;
+}
+function unquoteIdent(ident) {
+  const quoted = /^"(.*)"$/.exec(ident);
+  return quoted ? quoted[1].replace(/""/g, '"') : ident.toLowerCase();
+}
+var IDENT = String.raw`(?:"[^"]+"|[a-z_][\w$]*)`;
+var TARGET = String.raw`(${IDENT})\s+on\s+(?:(${IDENT})\s*\.\s*)?(${IDENT})`;
+var CREATE_POLICY = new RegExp(String.raw`\bcreate\s+policy\s+${TARGET}`, "gid");
+var DROP_POLICY = new RegExp(String.raw`\bdrop\s+policy\s+(?:if\s+exists\s+)?${TARGET}`, "gid");
+var ALTER_POLICY = new RegExp(String.raw`\balter\s+policy\s+${TARGET}`, "gid");
+function identAt(source, match, group) {
+  const range = match.indices?.[group];
+  return range ? unquoteIdent(source.slice(range[0], range[1])) : void 0;
+}
+function policyClauses(masked, source, from, end) {
+  const text = masked.slice(from, end);
+  const clauses = {};
+  const firstExpression = text.search(/\busing\s*\(|\bwith\s+check\s*\(/i);
+  const head = firstExpression === -1 ? text : text.slice(0, firstExpression);
+  const rename = /\brename\s+to\s+("[^"]+"|[a-z_][\w$]*)/id.exec(head);
+  if (rename) {
+    const [start, stop] = rename.indices[1];
+    clauses.renamedTo = unquoteIdent(source.slice(from + start, from + stop));
+    return clauses;
+  }
+  const as = /\bas\s+(permissive|restrictive)\b/i.exec(head);
+  if (as) clauses.restrictive = as[1].toLowerCase() === "restrictive";
+  const command = /\bfor\s+(all|select|insert|update|delete)\b/i.exec(head);
+  if (command) clauses.command = command[1].toLowerCase();
+  const roles = /\bto\s+([\s\S]+)$/i.exec(head);
+  if (roles) clauses.roles = roles[1].split(",").map((role) => unquoteIdent(role.trim())).filter(Boolean);
+  for (const [key, pattern] of [["using", /\busing\s*\(/i], ["check", /\bwith\s+check\s*\(/i]]) {
+    const at = text.search(pattern);
+    if (at === -1) continue;
+    const open = from + at + text.slice(at).indexOf("(");
+    const range = parenthesized(masked, open, end);
+    if (range) clauses[key] = source.slice(range.from, range.to);
+  }
+  return clauses;
+}
+function literal(source) {
+  const m = /^\s*'((?:[^']|'')*)'/.exec(source);
+  return m ? m[1].replace(/''/g, "'") : null;
+}
+function topLevelValues(masked, from, to) {
+  const values = [];
+  let depth = 0;
+  let start = from;
+  for (let i = from; i < to; i++) {
+    const ch = masked[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "," && depth === 0) {
+      values.push({ from: start, to: i });
+      start = i + 1;
+    }
+  }
+  values.push({ from: start, to });
+  return values;
+}
+var INSERT_BUCKETS = /\binsert\s+into\s+storage\s*\.\s*buckets\s*\(([^()]{0,500})\)\s*values\s*/gi;
+var UPDATE_BUCKETS = /\bupdate\s+storage\s*\.\s*buckets\s+set\b/gi;
+function bucketDeclarations(masked, source, onTruncated) {
+  const found = [];
+  let m;
+  INSERT_BUCKETS.lastIndex = 0;
+  while ((m = INSERT_BUCKETS.exec(masked)) !== null) {
+    const columns = m[1].split(",").map((c) => unquoteIdent(c.trim()));
+    const publicIndex = columns.indexOf("public");
+    const idIndex = columns.indexOf("id") !== -1 ? columns.indexOf("id") : columns.indexOf("name");
+    const end = statementEnd(masked, m.index, onTruncated);
+    let at = m.index + m[0].length;
+    while (at < end) {
+      while (at < end && /[\s,]/.test(masked[at])) at++;
+      if (masked[at] !== "(") break;
+      const tuple = parenthesized(masked, at, end);
+      if (!tuple) break;
+      const values = topLevelValues(masked, tuple.from, tuple.to);
+      const id = idIndex === -1 ? null : literal(source.slice(values[idIndex]?.from ?? 0, values[idIndex]?.to ?? 0));
+      const isPublic = publicIndex !== -1 && source.slice(values[publicIndex]?.from ?? 0, values[publicIndex]?.to ?? 0).trim().toLowerCase() === "true";
+      if (id !== null) found.push({ id, public: isPublic, at: m.index });
+      at = tuple.to + 1;
+    }
+    INSERT_BUCKETS.lastIndex = Math.max(INSERT_BUCKETS.lastIndex, end);
+  }
+  UPDATE_BUCKETS.lastIndex = 0;
+  while ((m = UPDATE_BUCKETS.exec(masked)) !== null) {
+    const end = statementEnd(masked, m.index, onTruncated);
+    const statement = masked.slice(m.index, end);
+    const setPublic = /\bpublic\s*=\s*(true|false)\b/i.exec(statement);
+    const where = /\bwhere\s+(?:id|name)\s*=/i.exec(statement);
+    const id = where ? literal(source.slice(m.index + where.index + where[0].length, end)) : null;
+    if (setPublic && id !== null) found.push({ id, public: setPublic[1].toLowerCase() === "true", at: m.index });
+    UPDATE_BUCKETS.lastIndex = Math.max(UPDATE_BUCKETS.lastIndex, end);
+  }
+  return found.sort((a, b) => a.at - b.at);
+}
+function configPublicBuckets(toml) {
+  const found = [];
+  let current = null;
+  toml.split(/\r?\n/).forEach((raw, index) => {
+    const line = raw.replace(/#.*$/, "").trim();
+    const section = /^\[\s*storage\.buckets\.("?)([^"\]]+)\1\s*\]$/.exec(line);
+    if (section) {
+      current = { id: section[2], line: index + 1 };
+      return;
+    }
+    if (line.startsWith("[")) {
+      current = null;
+      return;
+    }
+    if (current && /^public\s*=\s*true$/i.test(line)) found.push(current);
+  });
+  return found;
+}
+
 // src/rules/supabase.ts
 var INTERNAL_SCHEMAS = /* @__PURE__ */ new Set([
   "auth",
@@ -2011,6 +2440,10 @@ var supabaseRlsRule = {
     ).sort((a, b) => a.path.localeCompare(b.path));
     for (const file of sqlFiles) {
       const sql = maskSqlNoise(file.content);
+      const truncatedStatement = () => ctx.reportIncomplete(
+        "supabase/policy-parse-limit",
+        `${file.path} contains a policy or bucket statement longer than the 4000-character parse limit`
+      );
       const scope = replayScopeOf(file, projectScopeOf(file.path, projectScopes));
       const sqlLines = lineStartsOf(sql);
       let m;
@@ -2062,11 +2495,62 @@ var supabaseRlsRule = {
           line: lineNumberAt(sqlLines, m.index)
         });
       }
+      for (const [pattern, kind] of [
+        [CREATE_POLICY, "policy"],
+        [DROP_POLICY, "policy-drop"],
+        [ALTER_POLICY, "policy-alter"]
+      ]) {
+        pattern.lastIndex = 0;
+        while ((m = pattern.exec(sql)) !== null) {
+          const end = statementEnd(sql, m.index, truncatedStatement);
+          events.push({
+            kind,
+            policy: identAt(file.content, m, 1),
+            schema: m[2] ? unquote(m[2]) : "public",
+            table: unquote(m[3]),
+            ...kind === "policy-drop" ? {} : { clauses: policyClauses(sql, file.content, m.index + m[0].length, end) },
+            file: file.path,
+            scope,
+            at: m.index,
+            line: lineNumberAt(sqlLines, m.index)
+          });
+        }
+      }
+      for (const bucket of bucketDeclarations(sql, file.content, truncatedStatement)) {
+        events.push({
+          kind: "bucket",
+          bucket: { id: bucket.id, public: bucket.public },
+          schema: "storage",
+          table: "buckets",
+          file: file.path,
+          scope,
+          at: bucket.at,
+          line: lineNumberAt(sqlLines, bucket.at)
+        });
+      }
     }
     const fileOrder = new Map(sqlFiles.map((f, i) => [f.path, i]));
     events.sort((a, b) => fileOrder.get(a.file) - fileOrder.get(b.file) || a.at - b.at);
     const live = /* @__PURE__ */ new Map();
     const keyOf = (scope, schema, table) => JSON.stringify([scope, schema, table]);
+    const policies = /* @__PURE__ */ new Map();
+    const policyKey = (scope, schema, table, name) => JSON.stringify([scope, schema, table, name]);
+    const byTable = /* @__PURE__ */ new Map();
+    const setPolicy = (k, p) => {
+      policies.set(k, p);
+      const tableKey = keyOf(p.scope, p.schema, p.table);
+      const set = byTable.get(tableKey) ?? /* @__PURE__ */ new Set();
+      set.add(k);
+      byTable.set(tableKey, set);
+    };
+    const deletePolicy = (k) => {
+      const p = policies.get(k);
+      if (!p) return;
+      policies.delete(k);
+      byTable.get(keyOf(p.scope, p.schema, p.table))?.delete(k);
+    };
+    const policiesOn = (key) => [...byTable.get(key) ?? []].map((k) => [k, policies.get(k)]);
+    const buckets = /* @__PURE__ */ new Map();
     for (const ev of events) {
       const scope = ev.scope;
       const key = keyOf(scope, ev.schema, ev.table);
@@ -2075,15 +2559,66 @@ var supabaseRlsRule = {
         live.set(key, { schema: ev.schema, table: ev.table, file: ev.file, line: ev.line, rls: false });
       } else if (ev.kind === "drop") {
         live.delete(key);
+        for (const [k] of policiesOn(key)) deletePolicy(k);
       } else if (ev.kind === "rename") {
         const cur = live.get(key);
         if (cur) {
           live.delete(key);
           live.set(keyOf(scope, ev.schema, ev.renamedTo), { ...cur, table: ev.renamedTo });
         }
-      } else {
+        for (const [k, p] of policiesOn(key)) {
+          deletePolicy(k);
+          setPolicy(policyKey(scope, ev.schema, ev.renamedTo, p.name), { ...p, table: ev.renamedTo });
+        }
+      } else if (ev.kind === "enable-rls" || ev.kind === "disable-rls") {
         const cur = live.get(key);
         if (cur) cur.rls = ev.kind === "enable-rls";
+      } else if (ev.kind === "policy") {
+        const c = ev.clauses ?? {};
+        setPolicy(policyKey(scope, ev.schema, ev.table, ev.policy), {
+          name: ev.policy,
+          scope,
+          schema: ev.schema,
+          table: ev.table,
+          file: ev.file,
+          line: ev.line,
+          restrictive: c.restrictive ?? false,
+          command: c.command ?? "all",
+          roles: c.roles ?? ["public"],
+          ...c.using === void 0 ? {} : { using: c.using },
+          ...c.check === void 0 ? {} : { check: c.check }
+        });
+      } else if (ev.kind === "policy-drop") {
+        deletePolicy(policyKey(scope, ev.schema, ev.table, ev.policy));
+      } else if (ev.kind === "policy-alter") {
+        const k = policyKey(scope, ev.schema, ev.table, ev.policy);
+        const cur = policies.get(k);
+        const c = ev.clauses ?? {};
+        if (cur) {
+          const next = {
+            ...cur,
+            ...c.roles ? { roles: c.roles } : {},
+            // 角色或条件改变时，证据位置跟随实际修改；单纯改名保留原条件位置。
+            ...c.roles !== void 0 || c.using !== void 0 || c.check !== void 0 ? { file: ev.file, line: ev.line } : {},
+            ...c.using === void 0 ? {} : { using: c.using },
+            ...c.check === void 0 ? {} : { check: c.check }
+          };
+          deletePolicy(k);
+          const name = c.renamedTo ?? cur.name;
+          setPolicy(policyKey(scope, ev.schema, ev.table, name), { ...next, name });
+        }
+      } else if (ev.kind === "bucket") {
+        buckets.set(JSON.stringify([scope, ev.bucket.id]), { public: ev.bucket.public, file: ev.file, line: ev.line });
+      }
+    }
+    for (const file of ctx.files) {
+      if (!/(?:^|\/)supabase\/config\.toml$/.test(file.path)) continue;
+      const projectScope = projectScopeOf(file.path, projectScopes);
+      if (!activeScopes.has(projectScope)) continue;
+      const scope = replayScopeOf(file, projectScope);
+      for (const bucket of configPublicBuckets(file.content)) {
+        const k = JSON.stringify([scope, bucket.id]);
+        if (!buckets.has(k)) buckets.set(k, { public: true, file: file.path, line: bucket.line });
       }
     }
     const findings = [];
@@ -2124,80 +2659,306 @@ var supabaseRlsRule = {
         `${unreported} further ${unreported === 1 ? "table has" : "tables have"} no Row Level Security in your migrations beyond the ${MAX_FINDINGS_PER_FILE} listed; they were not reported individually`
       );
     }
+    findings.push(...policyFindings(ctx, [...policies.values()], live, keyOf, buckets));
     return findings;
   }
 };
+var PRIVILEGED_ROLES = /* @__PURE__ */ new Set(["service_role", "postgres", "supabase_admin"]);
+function audienceOf(roles) {
+  if (roles.includes("public") || roles.includes("anon")) return "anyone, signed in or not,";
+  if (roles.includes("authenticated")) return "any signed-in user";
+  return `the ${roles.join(", ")} role${roles.length === 1 ? "" : "s"}`;
+}
+function policyFindings(ctx, policies, live, keyOf, buckets) {
+  const lines = new Map(ctx.files.map((file) => [file.path, file.lines]));
+  const excerpt = (file, line) => lines.get(file)?.[line - 1]?.trim() ?? null;
+  const findings = [];
+  let unreported = 0;
+  const push = (finding) => {
+    if (findings.length >= MAX_FINDINGS_PER_FILE) unreported++;
+    else findings.push(finding);
+  };
+  const publicBuckets = /* @__PURE__ */ new Map();
+  for (const [key, bucket] of buckets) {
+    if (!bucket.public) continue;
+    const [scope, id] = JSON.parse(key);
+    const ids = publicBuckets.get(scope) ?? [];
+    ids.push(id);
+    publicBuckets.set(scope, ids);
+  }
+  const restrictiveCommands = /* @__PURE__ */ new Map();
+  for (const policy of policies) {
+    if (!policy.restrictive) continue;
+    const key = keyOf(policy.scope, policy.schema, policy.table);
+    const commands = restrictiveCommands.get(key) ?? /* @__PURE__ */ new Set();
+    commands.add(policy.command);
+    restrictiveCommands.set(key, commands);
+  }
+  for (const p of policies) {
+    if (p.restrictive || p.roles.every((role) => PRIVILEGED_ROLES.has(role))) continue;
+    if (live.get(keyOf(p.scope, p.schema, p.table))?.rls === false) continue;
+    const table = `${renderIdent(p.schema)}.${renderIdent(p.table)}`;
+    const audience = audienceOf(p.roles);
+    const restrictions = restrictiveCommands.get(keyOf(p.scope, p.schema, p.table));
+    const hasRestriction = restrictions !== void 0 && (p.command === "all" || restrictions.has("all") || restrictions.has(p.command));
+    if (p.schema === "storage" && p.table === "objects" && (p.command === "select" || p.command === "all") && p.using !== void 0) {
+      const onlyBucket = bucketOnlyCondition(p.using);
+      const everyBucket = isAlwaysTrue(p.using);
+      const listable = (publicBuckets.get(p.scope) ?? []).filter((id) => everyBucket || onlyBucket === id);
+      for (const id of listable) {
+        push({
+          ruleId: "supabase/public-bucket-listing",
+          severity: "P2",
+          confidence: hasRestriction ? "likely" : "certain",
+          title: hasRestriction ? `Policy "${p.name}" permits listing the public "${id}" bucket, subject to restrictive policies` : `Policy "${p.name}" lets ${audience} list every file in the public "${id}" bucket`,
+          file: p.file,
+          line: p.line,
+          excerpt: excerpt(p.file, p.line),
+          why: [
+            `Files in a public bucket can already be downloaded by anyone who has their URL, without any policy. This SELECT policy on storage.objects adds something else: it lets callers list the bucket's contents.`,
+            `Listing reveals every file name, including files uploaded by other users that were only meant to be reachable by someone who already had the link.`,
+            ...hasRestriction ? ["Restrictive policies also apply with AND; their conditions and role coverage require review."] : []
+          ],
+          fix: [
+            `If the app only serves files by URL, drop this policy: public object URLs keep working without it.`,
+            `If the app really needs listing, make the bucket private and scope the policy to the owner, e.g. USING (bucket_id = '${id.replace(/'/g, "''")}' AND owner_id = (select auth.uid()::text)).`
+          ]
+        });
+      }
+    }
+    const usingTrue = p.using !== void 0 && isAlwaysTrue(p.using);
+    const checkTrue = p.check !== void 0 && isAlwaysTrue(p.check);
+    const opensRows = usingTrue && p.command !== "insert";
+    const opensWrites = checkTrue && (p.command === "insert" || p.command === "update" || p.command === "all");
+    if (!opensRows && !opensWrites) continue;
+    const modifiesAny = usingTrue && (p.command === "update" || p.command === "delete" || p.command === "all");
+    const limitedCheck = (p.command === "update" || p.command === "all") && p.check !== void 0 && !checkTrue;
+    const needsReview = hasRestriction || limitedCheck;
+    const verb = { all: "read, change and delete", select: "read", insert: "insert any data into", update: "change", delete: "delete" }[p.command];
+    push({
+      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}`,
+      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."] : [],
+        ...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: [
+        `Tie each row to its owner; adapt user_id to your schema. For ${p.command.toUpperCase()}, use ` + (p.command === "insert" ? "WITH CHECK ((select auth.uid()) = user_id)." : `USING ((select auth.uid()) = user_id)${p.command === "update" || p.command === "all" ? " and WITH CHECK ((select auth.uid()) = user_id)" : ""}.`),
+        `If a broad policy is needed as a base, add an AS RESTRICTIVE policy alongside it to limit which rows it reaches.`,
+        `Keep the change in a migration, so the rule travels with your code.`
+      ],
+      humanOnly: [
+        `Check the policy in the Supabase dashboard (Authentication -> Policies); a policy changed there is not visible in the repository.`
+      ]
+    });
+  }
+  if (unreported > 0) {
+    ctx.reportIncomplete(
+      "supabase/permissive-policy",
+      `${unreported} further permissive ${unreported === 1 ? "policy was" : "policies were"} not reported individually`
+    );
+  }
+  return findings;
+}
 
 // src/rules/firebase.ts
 import { basename as basename5 } from "path";
 function isRulesFile(file) {
   return basename5(file.path).toLowerCase().endsWith(".rules");
 }
+function isRealtimeRulesFile(file) {
+  if (!/\.(?:json|rules)$/i.test(file.path)) return false;
+  if (!/"\.(?:read|write)"/.test(file.content)) return false;
+  return /^\s*\{\s*"rules"\s*:\s*\{/.test(commentsMaskedOf(file));
+}
+function booleanConstant(value) {
+  if (value === void 0) return null;
+  let decoded;
+  try {
+    decoded = JSON.parse(value);
+  } catch {
+    return null;
+  }
+  if (typeof decoded === "boolean") return decoded;
+  if (typeof decoded !== "string") return null;
+  const match = /^\s*(?:\(\s*)*(true|false)(?:\s*\))*\s*$/.exec(decoded);
+  if (!match || [...decoded.matchAll(/\(/g)].length !== [...decoded.matchAll(/\)/g)].length) return null;
+  return match[1] === "true";
+}
+function grantsEveryone(value) {
+  return booleanConstant(value) === true;
+}
+function deniesEveryone(value) {
+  return booleanConstant(value) === false;
+}
+function decodeKey(token) {
+  try {
+    return JSON.parse(token);
+  } catch {
+    return token.replace(/^"|"$/g, "");
+  }
+}
+function checkRealtimeRules(file, ctx) {
+  const text = commentsMaskedOf(file);
+  try {
+    JSON.parse(text);
+  } catch {
+    ctx.reportIncomplete("firebase/open-rules", `${file.path} contains invalid Realtime Database rule JSON; rules were not evaluated`);
+    return [];
+  }
+  const lineStarts = lineStartsOf(text);
+  const findings = [];
+  const stack = [];
+  let pendingKey = null;
+  const report = (node) => {
+    const read = node.rules.get(".read");
+    const write = node.rules.get(".write");
+    const openRead = grantsEveryone(read?.value);
+    const openWrite = grantsEveryone(write?.value);
+    if (!openRead && !openWrite) return;
+    if (!openWrite && deniesEveryone(write?.value)) return;
+    if (findings.length >= MAX_FINDINGS_PER_FILE) {
+      ctx.reportIncomplete(
+        "firebase/open-rules",
+        `${file.path} holds more than ${MAX_FINDINGS_PER_FILE} open rules; the rest were not reported`
+      );
+      return;
+    }
+    const segments = stack.slice(2).map((entry) => entry.key).concat(stack.length >= 2 ? [node.key] : []);
+    const path = `/${segments.join("/")}`.replace(/\/{2,}/g, "/");
+    const at = (openWrite ? write : read).index;
+    const line = lineNumberAt(lineStarts, at);
+    const ops = openRead && openWrite ? "read and write" : openWrite ? "write" : "read";
+    findings.push({
+      ruleId: "firebase/open-rules",
+      severity: "P1",
+      confidence: openWrite ? "certain" : "likely",
+      title: openWrite ? `Your Realtime Database rules let anyone ${ops} ${path === "/" ? "your entire database" : path}` : `Your Realtime Database rules make ${path === "/" ? "your entire database" : path} publicly readable`,
+      file: file.path,
+      line,
+      excerpt: (file.lines[line - 1] ?? "").trim(),
+      why: [
+        `This rule grants ${ops} access to everyone, with no sign-in required. The Firebase client SDK talks to your database straight from the browser, so these rules are the only access control that exists.`,
+        `Realtime Database rules cascade: access granted at ${path} also applies to everything beneath it, and a stricter rule deeper down cannot take it back.`,
+        ...openWrite ? [] : [
+          `If this data is meant to be public, add ".write": false next to it to make that intent explicit.`
+        ]
+      ],
+      fix: [
+        `Require sign-in and ownership for ${[openRead ? ".read" : "", openWrite ? ".write" : ""].filter(Boolean).join(" and ")}. For a per-user "$uid" node, use "auth !== null && auth.uid === $uid" for each of those rule values; adapt the path to your data model.`,
+        `Test the new rules with the Firebase emulator before deploying.`,
+        ...openWrite ? [`If this database has been open for a while, assume the data has already been copied or changed.`] : []
+      ]
+    });
+  };
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === '"') {
+      let j = i + 1;
+      while (j < text.length && text[j] !== '"') j += text[j] === "\\" ? 2 : 1;
+      const token = text.slice(i, j + 1);
+      let k = j + 1;
+      while (k < text.length && /\s/.test(text[k])) k++;
+      if (text[k] === ":" && pendingKey === null) pendingKey = { key: decodeKey(token), index: i };
+      else if (pendingKey !== null) {
+        stack[stack.length - 1]?.rules.set(pendingKey.key, { value: token, index: pendingKey.index });
+        pendingKey = null;
+      }
+      i = j + 1;
+      continue;
+    }
+    if (ch === "{") {
+      stack.push({ key: pendingKey?.key ?? "", rules: /* @__PURE__ */ new Map() });
+      pendingKey = null;
+    } else if (ch === "}") {
+      const node = stack.pop();
+      if (node) report(node);
+    } else if (pendingKey !== null && /[A-Za-z0-9-]/.test(ch)) {
+      let j = i;
+      while (j < text.length && /[A-Za-z0-9.+-]/.test(text[j])) j++;
+      stack[stack.length - 1]?.rules.set(pendingKey.key, { value: text.slice(i, j), index: pendingKey.index });
+      pendingKey = null;
+      i = j;
+      continue;
+    }
+    i++;
+  }
+  return findings.sort((a, b) => (a.line ?? 0) - (b.line ?? 0));
+}
 function productOf(path) {
   const name = basename5(path).toLowerCase();
   if (name.includes("storage")) return "Storage";
   if (name.includes("firestore")) return "Firestore";
   return "Firebase";
 }
-var ALLOW_IF_TRUE = /\ballow\s+([a-z,\s]+?)\s*:\s*if\s+true\s*;/gi;
+var OPS = String.raw`([a-z]{1,16}(?:\s*,\s*[a-z]{1,16}){0,8})`;
+var ALLOW_IF_TRUE = new RegExp(String.raw`\ballow\s+${OPS}\s*:\s*if\s+true\s*;`, "gi");
+var ALLOW_IF_FALSE = new RegExp(String.raw`\ballow\s+${OPS}\s*:\s*if\s+false\s*;`, "gi");
 var WRITE_OPS = /* @__PURE__ */ new Set(["write", "create", "update", "delete"]);
 function parseOps(raw) {
   return raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
 }
+function ownershipAdvice(product, rawOps) {
+  const prefix = `Replace the open or date-based condition for ${rawOps.trim()} with authentication and ownership checks. `;
+  if (product !== "Firestore") {
+    return prefix + "Bind request.auth.uid to the owner in the matched path or trusted metadata; use rules for your Firebase product and data model. Do not grant additional operations.";
+  }
+  const ops = new Set(parseOps(rawOps));
+  const checks = ["Require request.auth != null. Adapt userId to your ownership field."];
+  if (ops.has("create") || ops.has("write")) checks.push("For create, check request.resource.data.userId == request.auth.uid; no existing resource is available.");
+  if (ops.has("update") || ops.has("write")) checks.push("For update, check resource.data.userId == request.auth.uid and request.resource.data.userId == resource.data.userId to prevent ownership changes.");
+  if (["read", "get", "list", "delete", "write"].some((op) => ops.has(op))) checks.push("For read or delete operations already allowed here, check resource.data.userId == request.auth.uid.");
+  return prefix + checks.join(" ") + " Do not grant additional operations.";
+}
 function neutralizePathWildcards(content) {
   return content.replace(/\{[a-zA-Z_]\w*(?:\s*=\s*\*\*)?\}/g, (m) => "_".repeat(m.length));
 }
-function enclosingMatchBlock(neutralized, index) {
-  const matchStart = neutralized.slice(0, index).lastIndexOf("match ");
-  if (matchStart < 0) return neutralized;
-  const braceStart = neutralized.indexOf("{", matchStart);
-  if (braceStart < 0 || braceStart > index) return neutralized;
-  let depth = 0;
-  for (let i = braceStart; i < neutralized.length; i++) {
-    if (neutralized[i] === "{") depth++;
-    else if (neutralized[i] === "}") {
-      depth--;
-      if (depth === 0) return neutralized.slice(braceStart, i + 1);
-    }
-  }
-  return neutralized.slice(braceStart);
-}
-function ownStatements(block) {
-  let out = "";
-  let i = 0;
-  while (i < block.length) {
-    const rest = block.slice(i);
-    const nested = /^\s*match\s+[^{]*\{/.exec(rest);
-    if (nested && i > 0) {
-      let depth = 0;
-      let j = i + nested[0].length - 1;
-      for (; j < block.length; j++) {
-        if (block[j] === "{") depth++;
-        else if (block[j] === "}") {
-          depth--;
-          if (depth === 0) {
-            j++;
-            break;
-          }
-        }
-      }
-      i = j;
-      continue;
+function matchBlocksOf(neutralized) {
+  const blocks = [];
+  const stack = [];
+  let lastDelimiter = -1;
+  for (let i = 0; i < neutralized.length; i++) {
+    const ch = neutralized[i];
+    if (ch === "{") {
+      stack.push({ open: i, isMatch: /^\s*match\b/.test(neutralized.slice(lastDelimiter + 1, i)) });
+      lastDelimiter = i;
+    } else if (ch === "}") {
+      const top = stack.pop();
+      if (top?.isMatch) blocks.push({ open: top.open, close: i });
+      lastDelimiter = i;
+    } else if (ch === ";") {
+      lastDelimiter = i;
+    }
+  }
+  for (const top of stack) if (top.isMatch) blocks.push({ open: top.open, close: neutralized.length });
+  return blocks.sort((a, b) => a.open - b.open);
+}
+function innermostBlocks(blocks, positions) {
+  const owners = [];
+  const active = [];
+  let next = 0;
+  for (const at of positions) {
+    while (next < blocks.length && blocks[next].open < at) {
+      while (active.length && blocks[active[active.length - 1]].close < blocks[next].open) active.pop();
+      active.push(next++);
     }
-    out += block[i];
-    i++;
+    while (active.length && blocks[active[active.length - 1]].close < at) active.pop();
+    owners.push(active.length ? active[active.length - 1] : -1);
   }
-  return out;
+  return owners;
 }
-function blockDeniesWrites(block) {
-  const denial = /\ballow\s+([a-z,\s]+?)\s*:\s*if\s+false\s*;/gi;
-  let m;
-  while ((m = denial.exec(block)) !== null) {
-    if (parseOps(m[1] ?? "").some((op) => WRITE_OPS.has(op))) return true;
-  }
-  return false;
-}
-var TEST_MODE = /\ballow\s+([a-z,\s]+?)\s*:\s*if\s+request\.time\s*<\s*timestamp\.date\(\s*(\d{4})\s*,\s*(\d{1,2})\s*,\s*(\d{1,2})\s*\)\s*;/gi;
+var TEST_MODE = new RegExp(
+  String.raw`\ballow\s+${OPS}\s*:\s*if\s+request\.time\s*<\s*timestamp\.date\(\s*(\d{4})\s*,\s*(\d{1,2})\s*,\s*(\d{1,2})\s*\)\s*;`,
+  "gi"
+);
 function describeOps(raw) {
   const ops = parseOps(raw);
   if (ops.includes("write") && ops.includes("read")) return "read and write";
@@ -2208,9 +2969,10 @@ var firebaseRulesRule = {
   id: "firebase/open-rules",
   severity: "P1",
   appliesTo(file) {
-    return isRulesFile(file);
+    return isRulesFile(file) || isRealtimeRulesFile(file);
   },
   check(file, ctx) {
+    if (isRealtimeRulesFile(file)) return checkRealtimeRules(file, ctx);
     const findings = [];
     const product = productOf(file.path);
     const capReached = () => {
@@ -2224,13 +2986,18 @@ var firebaseRulesRule = {
     const content = noiseMaskedOf(file);
     const neutralized = neutralizePathWildcards(content);
     const contentLines = lineStartsOf(content);
-    ALLOW_IF_TRUE.lastIndex = 0;
+    const blocks = matchBlocksOf(neutralized);
+    const denials = [...neutralized.matchAll(ALLOW_IF_FALSE)].filter((d) => parseOps(d[1] ?? "").some((op) => WRITE_OPS.has(op)));
+    const denyingBlocks = new Set(innermostBlocks(blocks, denials.map((d) => d.index)));
+    const opens = [...content.matchAll(ALLOW_IF_TRUE)];
+    const openOwners = innermostBlocks(blocks, opens.map((o) => o.index));
     let m;
-    while ((m = ALLOW_IF_TRUE.exec(content)) !== null) {
+    for (const [index, open] of opens.entries()) {
+      m = open;
       if (capReached()) break;
       const rawOps = m[1] ?? "";
       const canWrite = parseOps(rawOps).some((op) => WRITE_OPS.has(op));
-      if (!canWrite && blockDeniesWrites(ownStatements(enclosingMatchBlock(neutralized, m.index)))) continue;
+      if (!canWrite && denyingBlocks.has(openOwners[index])) continue;
       const ops = describeOps(rawOps);
       findings.push({
         ruleId: "firebase/open-rules",
@@ -2249,7 +3016,7 @@ var firebaseRulesRule = {
           `Writes are still denied by default, so this is only a problem if the data is not meant to be public. If it is a public catalogue or announcements, ignore this \u2014 and consider adding "allow write: if false;" to make that intent explicit.`
         ],
         fix: canWrite ? [
-          `Decide who should actually have access. For per-user data the usual rule is: allow read, write: if request.auth != null && request.auth.uid == resource.data.userId;`,
+          ownershipAdvice(product, rawOps),
           `For data that is genuinely public, restrict it to reads only: allow read: if true; allow write: if false;`,
           `Test your rules with the Firebase emulator before deploying, so you do not lock yourself out.`,
           `If this database has been open for a while, assume the data has already been copied.`
@@ -2287,7 +3054,7 @@ var firebaseRulesRule = {
           `Neither state is what you want in production.`
         ],
         fix: [
-          `Replace the date check with a real authorisation rule. For per-user data: allow read, write: if request.auth != null && request.auth.uid == resource.data.userId;`,
+          ownershipAdvice(product, rawOps),
           `Test the new rules with the Firebase emulator before deploying.`,
           expired ? `Note that your app is currently denied access here, so fixing this also fixes whatever stopped working.` : `Do this before ${dateStr}, otherwise your app breaks on that date.`
         ]
@@ -2299,9 +3066,309 @@ var firebaseRulesRule = {
 
 // src/rules/apiauth.ts
 import { posix } from "path";
+
+// src/rules/bindings.ts
+var cache = /* @__PURE__ */ new WeakMap();
+function bindingsOf(file) {
+  const cached = cache.get(file);
+  if (cached) return cached;
+  const source = commentsMaskedOf(file);
+  const code = noiseMaskedOf(file);
+  const result = { imports: [], exports: [], stars: [] };
+  const lists = /\b(import|export)\s+(type\s+)?\{([^{}]{0,4000})\}(?:\s*from\s*['"]([^'"\r\n]{1,1024})['"])?/g;
+  for (const match of source.matchAll(lists)) {
+    if (match[2] || code.slice(match.index, match.index + match[1].length) !== match[1]) continue;
+    if (match[1] === "import" && !match[4]) continue;
+    for (const part of match[3].split(",")) {
+      const names = /^\s*([A-Za-z_$][\w$]*)(?:\s+as\s+([A-Za-z_$][\w$]*))?\s*$/.exec(part);
+      if (!names) continue;
+      const imported = names[1];
+      const local = names[2] ?? imported;
+      const target = match[1] === "import" ? result.imports : result.exports;
+      target.push({
+        imported,
+        local,
+        ...match[4] ? { spec: match[4] } : {}
+      });
+    }
+  }
+  for (const match of source.matchAll(/\bimport\s+([A-Za-z_$][\w$]*)\s+from\s*['"]([^'"\r\n]{1,1024})['"]/g)) {
+    if (code.slice(match.index, match.index + 6) === "import" && match[1] !== "type") {
+      result.imports.push({ local: match[1], imported: "default", spec: match[2] });
+    }
+  }
+  for (const match of source.matchAll(/\bexport\s*\*\s*from\s*['"]([^'"\r\n]{1,1024})['"]/g)) {
+    if (code.slice(match.index, match.index + 6) === "export") result.stars.push(match[1]);
+  }
+  cache.set(file, result);
+  return result;
+}
+function namePattern(names) {
+  return [...names].map((name) => name.replace(/\$/g, "\\$")).join("|");
+}
+
+// src/rules/auth-values.ts
+var limited = /* @__PURE__ */ new WeakSet();
+var cache2 = /* @__PURE__ */ new WeakMap();
+var reverseCache = /* @__PURE__ */ new WeakMap();
+var identityFlowLimited = (file) => limited.has(file);
+function bindingNames(pattern, path = []) {
+  const text = pattern.trim();
+  if (path.length > 8) return (text.match(/[A-Za-z_$][\w$]*/g) ?? []).map((name) => ({ name, path: null }));
+  if (/^[A-Za-z_$][\w$]*$/.test(text)) return [{ name: text, path }];
+  if (text.startsWith("{") && text.endsWith("}")) {
+    const parts = [];
+    let from = 1, depth = 0;
+    for (let i = 1; i < text.length - 1; i++) {
+      if ("{[(".includes(text[i])) depth++;
+      else if ("}])".includes(text[i])) depth--;
+      else if (text[i] === "," && depth === 0) {
+        parts.push(text.slice(from, i));
+        from = i + 1;
+      }
+    }
+    parts.push(text.slice(from, -1));
+    const result = [];
+    for (const part of parts) {
+      if (!part.trim()) continue;
+      const property = /^\s*([A-Za-z_$][\w$]*)(?:\s*:\s*([^=]+))?\s*$/.exec(part);
+      if (property) result.push(...bindingNames(property[2] ?? property[1], [...path, property[1]]));
+      else for (const name of part.match(/[A-Za-z_$][\w$]*/g) ?? []) result.push({ name, path: null });
+    }
+    return result;
+  }
+  return (text.match(/[A-Za-z_$][\w$]*/g) ?? []).map((name) => ({ name, path: null }));
+}
+function argumentExpressions(code, source, start, end, pairs) {
+  const result = [];
+  let from = start;
+  for (let i = start; i < end; i++) {
+    if (code[i] === ",") {
+      result.push(source.slice(from, i).trim());
+      from = i + 1;
+    }
+    const close = pairs.get(i);
+    if (close !== void 0) i = close;
+  }
+  if (from < end) result.push(source.slice(from, end).trim());
+  return result;
+}
+function authValuesOf(file, body, bodies, pairs) {
+  let contexts = cache2.get(file);
+  if (!contexts) {
+    contexts = /* @__PURE__ */ new Map();
+    cache2.set(file, contexts);
+  }
+  let found = contexts.get(body.start);
+  if (!found) {
+    found = new AuthValues(file, body, bodies, pairs);
+    contexts.set(body.start, found);
+  }
+  return found;
+}
+var AuthValues = class {
+  constructor(file, body, bodies, pairs) {
+    this.file = file;
+    const code = noiseMaskedOf(file);
+    const source = commentsMaskedOf(file);
+    let open = code.indexOf("(", body.declaration);
+    let close = pairs.get(open);
+    if (code.startsWith("=>", body.declaration)) {
+      const window = code.slice(Math.max(0, body.declaration - 300), body.declaration);
+      const before = window.trimEnd();
+      if (before.endsWith(")")) {
+        close = body.declaration - (window.length - before.length) - 1;
+        let reverse = reverseCache.get(file);
+        if (!reverse) {
+          reverse = new Map([...pairs].map(([left, right]) => [right, left]));
+          reverseCache.set(file, reverse);
+        }
+        open = reverse.get(close) ?? -1;
+      } else {
+        const single = /([A-Za-z_$][\w$]*)$/.exec(before)?.[1];
+        if (single) this.parameters.set(single, 0);
+        open = -1;
+      }
+    }
+    if (open >= 0 && close !== void 0 && close < body.start) {
+      argumentExpressions(code, code, open + 1, close, pairs).forEach((part, index) => {
+        const name = /^([A-Za-z_$][\w$]*)(?:\s*\??\s*:[^=]+)?$/.exec(part)?.[1];
+        if (name) this.parameters.set(name, index);
+      });
+    }
+    const text = code.slice(body.start + 1, body.end);
+    const endOf = (start) => {
+      const boundary = Math.min(body.end, start + 4001);
+      let previous = "";
+      for (let i = start; i < boundary; i++) {
+        if (code[i] === ";" || code[i] === "}") return i;
+        if (code[i] === "\n") {
+          let next = i + 1;
+          while (next < boundary && /\s/.test(code[next])) next++;
+          if (next === boundary && boundary < body.end) return boundary;
+          if (!/[.?+\-*/%&|^,:([`=]/.test(code[next] ?? "") && !/[=+\-*/%&|^?:,.]/.test(previous)) return i;
+          i = next - 1;
+          continue;
+        }
+        if (!/\s/.test(code[i])) previous = code[i];
+        const close2 = pairs.get(i);
+        if (close2 !== void 0) {
+          i = close2;
+          previous = code[close2];
+        }
+      }
+      return boundary;
+    };
+    for (const match2 of text.matchAll(/\b(?:if|for|while|switch|catch)\s*\(/g)) {
+      const close2 = pairs.get(body.start + 1 + match2.index + match2[0].length - 1);
+      if (close2 === void 0) continue;
+      let start = close2 + 1;
+      while (/\s/.test(code[start] ?? "")) start++;
+      this.conditions.push({ start, end: pairs.get(start) ?? endOf(start) });
+      if (this.conditions.length > 512) {
+        this.exhausted = true;
+        limited.add(file);
+        break;
+      }
+    }
+    let low = 0, high = bodies.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (bodies[middle].declaration <= body.start) low = middle + 1;
+      else high = middle;
+    }
+    const nested = [];
+    for (let i = low; i < bodies.length && bodies[i].declaration < body.end; i++) nested.push(bodies[i]);
+    let nestedIndex = 0;
+    let count = 0;
+    const declarations = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*|[\[{])|(?<![\w$.])([A-Za-z_$][\w$]*)\s*=(?!=|>)/g;
+    let match;
+    while ((match = declarations.exec(text)) !== null) {
+      if (this.exhausted) break;
+      const at = body.start + 1 + match.index;
+      while (nestedIndex < nested.length && nested[nestedIndex].end < at) nestedIndex++;
+      if (nested[nestedIndex] && at >= nested[nestedIndex].declaration && at < nested[nestedIndex].end) continue;
+      if (++count > 512) {
+        this.exhausted = true;
+        limited.add(file);
+        break;
+      }
+      let binding = match[1] ?? match[2];
+      let from = at + match[0].length;
+      if (match[1]) {
+        if (binding === "{" || binding === "[") {
+          const start = from - 1;
+          const close2 = pairs.get(start);
+          if (close2 === void 0) continue;
+          if (close2 - start > 4e3) {
+            this.exhausted = true;
+            limited.add(file);
+            break;
+          }
+          binding = code.slice(start, close2 + 1);
+          from = close2 + 1;
+        }
+        while (/\s/.test(code[from] ?? "")) from++;
+        if (code[from] === ":") {
+          const type = /^:[^=;\n]{1,120}/.exec(code.slice(from, from + 121));
+          if (type) from += type[0].length;
+        }
+        if (code[from] !== "=" || /[=>]/.test(code[from + 1] ?? "")) continue;
+        from++;
+      }
+      while (/\s/.test(code[from] ?? "")) from++;
+      declarations.lastIndex = from - body.start - 1;
+      const end = endOf(from);
+      for (const { name, path } of bindingNames(binding)) {
+        if (!this.assignments.has(name) && this.assignments.size >= 512) {
+          this.exhausted = true;
+          limited.add(file);
+          break;
+        }
+        const list = this.assignments.get(name) ?? [];
+        list.push({ at, expression: end - from <= 4e3 ? source.slice(from, end).trim() : "", projection: path, overLimit: end - from > 4e3 });
+        this.assignments.set(name, list);
+      }
+    }
+  }
+  file;
+  assignments = /* @__PURE__ */ new Map();
+  parameters = /* @__PURE__ */ new Map();
+  conditions = [];
+  exhausted = false;
+  value(expression, at, depth = 0) {
+    if (depth >= 8) limited.add(this.file);
+    if (this.exhausted || depth >= 8) return { kind: "opaque" };
+    const expr = expression.trim();
+    if (expr.length > 4e3) {
+      limited.add(this.file);
+      return { kind: "opaque" };
+    }
+    if (/^process\.env\.[A-Z_][A-Z0-9_]*$/.test(expr)) return { kind: "secret" };
+    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 callee = call?.[1];
+    const identityCall = callee && !/\.(?:body|query|headers|cookies)\b/.test(callee);
+    if (identityCall) {
+      if (!/^await\s+/.test(expr)) return { kind: "promise" };
+      const masked = maskJsNoise(expr);
+      let depth2 = 1, end = call[0].length;
+      for (; end < masked.length && depth2 > 0; end++) {
+        if (masked[end] === "(") depth2++;
+        else if (masked[end] === ")") depth2--;
+      }
+      if (depth2 !== 0 || masked.slice(end).trim() !== "") return { kind: "opaque" };
+      if (/\|\||&&|\?(?!\.)|\.then\s*\(/.test(expr) || /\.catch\s*\(/.test(expr)) return { kind: "opaque" };
+      return { kind: /\.auth\.getUser\s*\(/.test(expr) ? "envelope" : "identity" };
+    }
+    if (/\.(?:body|query|headers|cookies|searchParams)\b|\.(?:json|text|formData)\s*\(/.test(expr)) return { kind: "input" };
+    const access = /^([A-Za-z_$][\w$]*)((?:\??\.[A-Za-z_$][\w$]*)*)$/.exec(expr);
+    if (!access) return { kind: "opaque" };
+    const name = access[1];
+    const list = this.assignments.get(name) ?? [];
+    let low = 0, high = list.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (list[middle].at < at) low = middle + 1;
+      else high = middle;
+    }
+    const assignment = list[low - 1];
+    let value;
+    if (assignment) {
+      if (assignment.overLimit) {
+        limited.add(this.file);
+        return { kind: "opaque" };
+      }
+      if (this.conditions.some((range) => range.start <= assignment.at && assignment.at <= range.end && !(range.start <= at && at <= range.end))) return { kind: "opaque" };
+      value = this.value(assignment.expression, assignment.at, depth + 1);
+      if (assignment.projection === null) value = { kind: "opaque" };
+      else if (assignment.projection.length && value.kind === "envelope") value = {
+        kind: assignment.projection.join(".") === "data.user" ? "identity" : "opaque"
+      };
+    } 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;
+  }
+};
+function identityRequirement(value, allowParameters) {
+  if (value.kind === "identity") return [];
+  if (allowParameters && value.kind === "parameter") return value.parameters ?? [];
+  return null;
+}
+
+// src/rules/apiauth.ts
 var APP_ROUTER = /(?:^|\/)app\/api\/(?:.+\/)?route\.[mc]?[jt]sx?$/;
 var PAGES_ROUTER = /(?:^|\/)pages\/api\/.+\.[mc]?[jt]sx?$/;
+var APP_ROUTE_FILE = /(?:^|\/)app\/(?:.+\/)?route\.[mc]?[jt]sx?$/;
+var NEXT_METHODS = "GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS";
+var NEXT_METHOD_EXPORT = new RegExp(
+  String.raw`\bexport\s+(?:async\s+)?function\s+(?:${NEXT_METHODS})\b|\bexport\s+const\s+(?:${NEXT_METHODS})\b|` + // export { handler as GET } 与 Auth.js 的 export const { GET, POST } = handlers；长度有界以免回溯。
+  String.raw`\bexport\s+(?:const\s*)?\{[^{}]{0,500}\b(?:${NEXT_METHODS})\b`
+);
 var SVELTEKIT_ENDPOINT = /^(.*?\/)?src\/routes\/(?:(.*)\/)?\+server\.[mc]?[jt]s$/;
+var SVELTEKIT_PAGE_SERVER = /^(.*?\/)?src\/routes\/(?:(.*)\/)?\+page\.server\.[mc]?[jt]s$/;
+var SVELTEKIT_ACTIONS = /\bexport\s+const\s+actions\b\s*(?::[^=;{}]{0,200})?=\s*\{/;
 var NUXT_ROUTE = /^(.*?\/)?server\/(api|routes)\/(.+)\.[mc]?[jt]s$/;
 var H3_HANDLER = /\b(?:defineEventHandler|eventHandler|defineCachedEventHandler|defineLazyEventHandler)\s*\(/;
 var NUXT_METHOD_SUFFIX = /\.(?:get|post|put|patch|delete|head|options|connect|trace)$/i;
@@ -2309,17 +3376,154 @@ var REMIX_ROUTE = /^(.*?\/)?app\/routes\/(.+)\.[mc]?[jt]sx?$/;
 var REMIX_EXPORT = /\bexport\s+(?:async\s+)?function\s+(?:loader|action)\b|\bexport\s+const\s+(?:loader|action)\b/;
 var ASTRO_ENDPOINT = /^(.*?\/)?src\/pages\/(.+)\.[mc]?[jt]s$/;
 var ASTRO_EXPORT = /\bexport\s+(?:async\s+)?function\s+(?:GET|POST|PUT|PATCH|DELETE|ALL)\b|\bexport\s+const\s+(?:GET|POST|PUT|PATCH|DELETE|ALL)\b/;
+function isAstroEndpoint(file) {
+  const code = noiseMaskedOf(file);
+  return ASTRO_EXPORT.test(code) && !/\bexport\s+default\b/.test(code);
+}
+function serverActionRoutes(file) {
+  if (!/use server/.test(file.content) || !/\.[mc]?[jt]sx?$/.test(file.path)) return [];
+  const code = noiseMaskedOf(file);
+  const source = commentsMaskedOf(file);
+  const fileLevel = startsWithDirective(source, 0, "use server");
+  const pairs = delimiterPairs(code);
+  const openers = /* @__PURE__ */ new Map();
+  for (const [open, close] of pairs) openers.set(close, open);
+  const exportedList = /* @__PURE__ */ new Set();
+  for (const m of code.matchAll(/\bexport\s*\{([^{}]{0,1000})\}/g)) {
+    for (const part of m[1].split(",")) {
+      const name = /^\s*([A-Za-z_$][\w$]*)/.exec(part)?.[1];
+      if (name) exportedList.add(name);
+    }
+  }
+  const scope = /^(.*?\/)?(?:src|app|lib|actions|server|utils)\//.exec(file.path)?.[1] ?? "";
+  const routes = [];
+  for (const body of functionBodies(code, pairs)) {
+    const inline = startsWithDirective(source, body.start + 1, "use server");
+    const declared = declarationOf(code, body, openers);
+    const exported = fileLevel && declared !== null && (declared.exported || exportedList.has(declared.name));
+    if (!inline && !exported) continue;
+    const name = declared?.name ?? "anonymous";
+    routes.push({
+      file,
+      framework: "next",
+      url: `the server action ${name}`,
+      scope,
+      reachable: { start: body.start, end: body.end },
+      action: name
+    });
+  }
+  return routes;
+}
+function startsWithDirective(source, from, directive) {
+  let i = from;
+  while (i < source.length) {
+    while (i < source.length && /\s/.test(source[i])) i++;
+    const quote = source[i++];
+    if (quote !== "'" && quote !== '"') return false;
+    const start = i;
+    while (i < source.length && source[i] !== quote && !/[\r\n]/.test(source[i])) {
+      if (source[i] === "\\") i++;
+      i++;
+    }
+    if (source[i] !== quote) return false;
+    const value = source.slice(start, i++);
+    let newline = false;
+    while (i < source.length && /\s/.test(source[i])) {
+      if (/[\r\n]/.test(source[i])) newline = true;
+      i++;
+    }
+    const next = source[i];
+    const terminated = next === ";" || next === "}" || next === void 0 || newline && !/[([.`+\-*/%?:,<>=!&|^]/.test(next);
+    if (!terminated) return false;
+    if (value === directive) return true;
+    if (next === ";") i++;
+  }
+  return false;
+}
+function declarationOf(code, body, openers) {
+  if (/^function\s*\(/.test(code.slice(body.declaration, body.declaration + 40)) && /\bexport\s+default\s+(?:async\s+)?$/.test(code.slice(Math.max(0, body.declaration - 80), body.declaration))) {
+    return { name: "default", exported: true };
+  }
+  const named = /^function\s*\*?\s*([A-Za-z_$][\w$]*)/.exec(code.slice(body.declaration, body.declaration + 200));
+  if (named) {
+    const before = code.slice(Math.max(0, body.declaration - 40), body.declaration);
+    return { name: named[1], exported: /\bexport\s+(?:default\s+)?(?:async\s+)?$/.test(before) };
+  }
+  let i = body.declaration - 1;
+  const skipSpace = () => {
+    while (i >= 0 && /\s/.test(code[i])) i--;
+  };
+  const readWord = () => {
+    const end = i + 1;
+    while (i >= 0 && /[\w$]/.test(code[i])) i--;
+    return code.slice(i + 1, end);
+  };
+  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 open = openers.get(body.declaration - window.length + close);
+    if (open === void 0) return null;
+    i = open - 1;
+  } else {
+    skipSpace();
+    if (readWord() === "") return null;
+  }
+  skipSpace();
+  const maybeAsync = i;
+  if (readWord() !== "async") i = maybeAsync;
+  skipSpace();
+  if (code[i] !== "=" || code[i - 1] === "=" || code[i - 1] === "!") return null;
+  i--;
+  skipSpace();
+  let name = readWord();
+  skipSpace();
+  if (code[i] === ":") {
+    i--;
+    skipSpace();
+    name = readWord();
+    skipSpace();
+  }
+  if (name === "" || !/^(?:const|let|var)$/.test(readWord())) return null;
+  skipSpace();
+  return { name, exported: readWord() === "export" };
+}
+var AUTH_ACTION_NAMES = /^(?:sign[_-]?(?:in|up|out)|log[_-]?(?:in|out)|register|reset[_-]?password|forgot[_-]?password|verify(?:[_-]?(?:email|otp))?|confirm(?:[_-]?email)?|send[_-]?magic[_-]?link)(?:action)?$/i;
 function routePathOf(path) {
   return path.replace(/(^|\/)\([^/]+\)(?=\/)/g, "$1").replace(/\/{2,}/g, "/");
 }
 function routeOf(file) {
   const path = routePathOf(file.path);
-  if (APP_ROUTER.test(path) || PAGES_ROUTER.test(file.path)) {
-    const scope = /^(.*?)(?:src\/)?(?:app|pages)\/api\//.exec(path)?.[1] ?? "";
+  if (PAGES_ROUTER.test(file.path) && ASTRO_ENDPOINT.test(path) && isAstroEndpoint(file)) {
+    const astro2 = ASTRO_ENDPOINT.exec(path);
+    return { file, framework: "astro", url: `/${astro2[2].replace(/(?:^|\/)index$/, "")}`, scope: astro2[1] ?? "" };
+  }
+  if (PAGES_ROUTER.test(file.path)) {
+    const scope = /^(.*?)(?:src\/)?pages\/api\//.exec(path)?.[1] ?? "";
     return { file, framework: "next", url: nextRouteUrl(path), scope };
   }
+  if (APP_ROUTE_FILE.test(path)) {
+    const app = nextAppRoute(path);
+    const code = noiseMaskedOf(file);
+    const handler = APP_ROUTER.test(path) || NEXT_METHOD_EXPORT.test(code) && !REMIX_EXPORT.test(code);
+    if (app && handler) return app.url === null ? null : { file, framework: "next", url: app.url, scope: app.scope };
+  }
   const svelte = SVELTEKIT_ENDPOINT.exec(path);
   if (svelte) return { file, framework: "sveltekit", url: `/${svelte[2] ?? ""}`, scope: svelte[1] ?? "" };
+  const page = SVELTEKIT_PAGE_SERVER.exec(path);
+  if (page) {
+    const code = noiseMaskedOf(file);
+    const actions = SVELTEKIT_ACTIONS.exec(code);
+    if (!actions) return null;
+    const open = actions.index + actions[0].length - 1;
+    const close = closingDelimiter(code, open, "{", "}");
+    return {
+      file,
+      framework: "sveltekit",
+      url: `/${page[2] ?? ""}`,
+      scope: page[1] ?? "",
+      reachable: { start: open, end: close ?? code.length }
+    };
+  }
   const nuxt = NUXT_ROUTE.exec(path);
   if (nuxt && H3_HANDLER.test(noiseMaskedOf(file))) {
     const rest = nuxt[3].replace(NUXT_METHOD_SUFFIX, "").replace(/(?:^|\/)index$/, "");
@@ -2331,14 +3535,21 @@ function routeOf(file) {
     return { file, framework: "remix", url: remixRouteUrl(remix[2]), scope: remix[1] ?? "" };
   }
   const astro = ASTRO_ENDPOINT.exec(path);
-  if (astro && ASTRO_EXPORT.test(noiseMaskedOf(file))) {
+  if (astro && isAstroEndpoint(file)) {
     const rest = astro[2].replace(/(?:^|\/)index$/, "");
     return { file, framework: "astro", url: `/${rest}`, scope: astro[1] ?? "" };
   }
   return null;
 }
+function nextAppRoute(path) {
+  const m = /^(.*?\/)?src\/app\/(.+)$/.exec(path) ?? /^(.*?\/)?app\/(.+)$/.exec(path);
+  if (!m) return null;
+  const segments = m[2].split("/").slice(0, -1);
+  const url = segments.some((segment) => segment.startsWith("_")) ? null : `/${segments.map((segment) => segment.replace(/^%5F/i, "_")).join("/")}`;
+  return { scope: m[1] ?? "", url };
+}
 function nextRouteUrl(path) {
-  const m = /(?:^|\/)(?:app|pages)\/(api\/.*)$/.exec(path);
+  const m = /(?:^|\/)pages\/(api\/.*)$/.exec(path);
   if (!m) return `/${path}`;
   const url = m[1].replace(/\/route\.[mc]?[jt]sx?$/, "").replace(/\/index\.[mc]?[jt]sx?$/, "").replace(/\.[mc]?[jt]sx?$/, "");
   return `/${url}`;
@@ -2354,6 +3565,7 @@ var AUTH_CALLBACK = /^(?:\/api)?\/auth\/callback(?:\/[^/]+)?$/;
 var PROVIDER_CALLBACK = /^(?:\/api)?\/(?:auth|oauth|login|sign-?in)\/[^/]+\/callback$/;
 var OAUTH_HANDLER = /\bdefineOAuth\w*EventHandler\s*\(/;
 function isAuthEndpoint(route) {
+  if (route.action !== void 0) return AUTH_ACTION_NAMES.test(route.action);
   return AUTH_ENDPOINT_NAMES.test(route.url) || AUTH_CALLBACK.test(route.url) || PROVIDER_CALLBACK.test(route.url) || OAUTH_HANDLER.test(noiseMaskedOf(route.file));
 }
 var AUTH_ENFORCING_CALL = /\b(?:NextAuth|require(?:Auth|User|Session|Admin)\w*|withAuth|verifyAuth|ensureAuth|assertAuth(?:enticated)?|verifyIdToken|constructEvent)\s*\(/i;
@@ -2391,7 +3603,7 @@ function rejectsMissingIdentity(term, returnsDeniedStatus) {
   const rejects = NEGATED_IDENTITY.test(term) || IDENTITY_IS_EMPTY.test(term) || IDENTITY_MISMATCH.test(term);
   return rejects && (AUTH_CONDITION.test(term) || returnsDeniedStatus);
 }
-function hasConditionalAuthGuard(code) {
+function hasConditionalAuthGuard(code, requireThrow = false, accept) {
   const starts = /\bif\s*\(/g;
   let match;
   while ((match = starts.exec(code)) !== null) {
@@ -2405,7 +3617,7 @@ function hasConditionalAuthGuard(code) {
     let stopsRequest = false;
     for (let i = 0; i < body.length; i++) {
       if (STOPS_REQUEST.test(body.slice(i, i + 16)) && (i === 0 || !/[\w$]/.test(body[i - 1]))) {
-        stopsRequest = true;
+        stopsRequest = !requireThrow || !/^return\b/.test(body.slice(i, i + 16));
         break;
       }
       if (/^if\s*\(/.test(body.slice(i, i + 16))) break;
@@ -2417,7 +3629,10 @@ function hasConditionalAuthGuard(code) {
     starts.lastIndex = statementStart + statement.length;
     if (!stopsRequest) continue;
     const returnsDeniedStatus = DENIED_STATUS.test(statement);
-    const negative = !/&&|\?(?!\.)/.test(condition) && condition.split("||").some((part) => rejectsMissingIdentity(part.trim(), returnsDeniedStatus));
+    const negative = !/&&|\?(?!\.)/.test(condition) && condition.split("||").some((part) => {
+      const term = part.trim();
+      return accept ? (NEGATED_IDENTITY.test(term) || IDENTITY_IS_EMPTY.test(term) || IDENTITY_MISMATCH.test(term)) && accept(term) : rejectsMissingIdentity(term, returnsDeniedStatus);
+    });
     if (negative) return true;
   }
   return false;
@@ -2501,7 +3716,7 @@ function functionBodies(code, pairs) {
   }
   return bodies;
 }
-function statementEnd(code, start, limit, pairs) {
+function statementEnd2(code, start, limit, pairs) {
   if (code[start] === "{") return (pairs.get(start) ?? limit) + 1;
   for (let i = start; i < limit; i++) {
     if (code[i] === ";" || code[i] === "\n") return i + 1;
@@ -2510,22 +3725,127 @@ function statementEnd(code, start, limit, pairs) {
   }
   return limit;
 }
-function unguardedOperations(file, ops) {
+var unguardedCache = /* @__PURE__ */ new WeakMap();
+function unguardedOpsOf(file) {
+  let hit = unguardedCache.get(file);
+  if (hit === void 0) {
+    hit = unguardedOperations(file, findDataOps(file));
+    unguardedCache.set(file, hit);
+  }
+  return hit;
+}
+function operationsInRange(ops, start, end) {
+  const lowerBound = (value) => {
+    let low = 0, high = ops.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (ops[middle].index < value) low = middle + 1;
+      else high = middle;
+    }
+    return low;
+  };
+  return ops.slice(lowerBound(start + 1), lowerBound(end));
+}
+var lineStartsCache = /* @__PURE__ */ new WeakMap();
+function lineStartsCached(file) {
+  let hit = lineStartsCache.get(file);
+  if (hit === void 0) {
+    hit = lineStartsOf(file.content);
+    lineStartsCache.set(file, hit);
+  }
+  return hit;
+}
+function cachedByFile(check) {
+  const cache3 = /* @__PURE__ */ new WeakMap();
+  return (file) => {
+    let hit = cache3.get(file);
+    if (hit === void 0) {
+      hit = check(file);
+      cache3.set(file, hit);
+    }
+    return hit;
+  };
+}
+var localAuthNamesCache = /* @__PURE__ */ new WeakMap();
+var controlFlowLimited = /* @__PURE__ */ new WeakSet();
+function localAuthNames(file) {
+  const cached = localAuthNamesCache.get(file);
+  if (cached) return cached;
+  const names = new Set(bindingsOf(file).imports.filter((binding) => binding.spec && normalizeSpec(binding.spec, file.path)).map((binding) => binding.local));
+  const { declared, shadowed } = guardBindings(file);
+  for (const name of declared) names.add(name);
+  for (const name of shadowed) names.add(name);
+  localAuthNamesCache.set(file, names);
+  return names;
+}
+function unguardedOperations(file, ops, extra, requireThrow = false, observe) {
   if (ops.length === 0) return ops;
   const code = noiseMaskedOf(file);
   const pairs = delimiterPairs(code);
   const bodies = functionBodies(code, pairs);
   const declarations = new Map(bodies.map((body) => [body.declaration, body]));
   const functionStarts = new Set(bodies.map((body) => body.start));
+  const bodiesByStart = new Map(bodies.map((body) => [body.start, body]));
+  const localNames = localAuthNames(file);
   const guardEnds = /* @__PURE__ */ new Map();
+  const guardNames = /* @__PURE__ */ new Map();
+  const guardRequirements = /* @__PURE__ */ new Map();
+  const extraCalls = extra?.guards.size ? new RegExp(`^(${namePattern(extra.guards)})\\s*\\(`) : null;
   const blocks = [...pairs].filter(([start]) => code[start] === "{").map(([start, end]) => ({ start, end })).sort((a, b) => a.start - b.start);
   const active = [];
   let blockIndex = 0;
-  const wrappers = [...code.matchAll(/\b(?:withAuth|NextAuth)\s*\(/g)].map((match) => {
+  const wrapperPattern = extra?.wrappers.size ? new RegExp(`(?<![\\w$.])(${namePattern(extra.wrappers)})\\s*\\(`, "g") : null;
+  const wrappers = [
+    ...[...code.matchAll(/\b(withAuth|NextAuth)\s*\(/g)].filter((match) => !localNames.has(match[1])),
+    ...wrapperPattern ? code.matchAll(wrapperPattern) : []
+  ].map((match) => {
     const open = match.index + match[0].length - 1;
-    return { start: open, end: pairs.get(open) ?? open };
+    return { start: open, end: pairs.get(open) ?? open, name: match[1] };
   });
-  const guardEnd = (owner) => {
+  const skipSpace = (at) => {
+    while (/\s/.test(code[at] ?? "")) at++;
+    return at;
+  };
+  const blockAt = (at) => {
+    const start = skipSpace(at);
+    const end = pairs.get(start);
+    return code[start] === "{" && end !== void 0 ? { start, end } : null;
+  };
+  const denies = (block) => {
+    for (let i = block.start + 1; i < block.end; i++) {
+      if (i > 0 && /[\w$]/.test(code[i - 1])) continue;
+      const tail = code.slice(i, i + 400);
+      if (/^(?:if|for|while|switch|try)\b/.test(tail)) return false;
+      if (/^(?:throw|redirect|notFound)\b|^error\s*\(\s*40[13]\b/.test(tail)) return true;
+      if (/^return\b/.test(tail)) return !requireThrow && DENIED_STATUS.test(code.slice(i, statementEnd2(code, i, block.end, pairs)));
+      const end = pairs.get(i);
+      if (end !== void 0) i = end;
+    }
+    return false;
+  };
+  const checkedEnd = (block, fn, depth) => {
+    const cached = guardEnds.get(block.start);
+    if (cached !== void 0) return cached;
+    const result = guardEnd(block, fn, depth);
+    guardEnds.set(block.start, result);
+    return result;
+  };
+  const allProtected = (owner, children, fn, depth) => {
+    const required = /* @__PURE__ */ new Set();
+    for (const child of children) {
+      if (!Number.isFinite(checkedEnd(child, fn, depth + 1)) && !denies(child)) return false;
+      for (const argument of guardRequirements.get(child.start) ?? []) required.add(argument);
+    }
+    guardRequirements.set(owner.start, [...required]);
+    const name = children.map((child) => guardNames.get(child.start)).find(Boolean);
+    if (name) guardNames.set(owner.start, name);
+    return true;
+  };
+  const guardEnd = (owner, fn, depth = 0) => {
+    if (depth > 8) {
+      controlFlowLimited.add(file);
+      return Infinity;
+    }
     for (let i = owner.start + 1; i < owner.end; i++) {
       const nested = declarations.get(i);
       if (nested) {
@@ -2533,10 +3853,39 @@ function unguardedOperations(file, ops) {
         continue;
       }
       if (code.startsWith("=>", i)) {
-        i = statementEnd(code, i + 2, owner.end, pairs) - 1;
+        i = statementEnd2(code, i + 2, owner.end, pairs) - 1;
         continue;
       }
       if (i > 0 && /[\w$]/.test(code[i - 1])) continue;
+      if (/^try\s*\{/.test(code.slice(i, i + 32))) {
+        const attempted = blockAt(i + 3);
+        if (attempted) {
+          let cursor = skipSpace(attempted.end + 1);
+          const children = [attempted];
+          if (/^catch\b/.test(code.slice(cursor, cursor + 8))) {
+            cursor = skipSpace(cursor + 5);
+            if (code[cursor] === "(") cursor = skipSpace((pairs.get(cursor) ?? cursor) + 1);
+            const caught = blockAt(cursor);
+            if (!caught) {
+              i = attempted.end;
+              continue;
+            }
+            children.push(caught);
+            cursor = skipSpace(caught.end + 1);
+          }
+          let overrides = false;
+          if (/^finally\b/.test(code.slice(cursor, cursor + 10))) {
+            const final = blockAt(cursor + 7);
+            if (final) {
+              overrides = /\breturn\b/.test(code.slice(final.start + 1, final.end));
+              cursor = final.end + 1;
+            }
+          }
+          if (!overrides && allProtected(owner, children, fn, depth)) return cursor;
+          i = cursor - 1;
+          continue;
+        }
+      }
       const conditional = /^if\s*\(/.exec(code.slice(i, i + 32));
       if (conditional) {
         const open = i + conditional[0].length - 1;
@@ -2544,12 +3893,42 @@ function unguardedOperations(file, ops) {
         if (close2 === void 0) return Infinity;
         let start = close2 + 1;
         while (/\s/.test(code[start] ?? "")) start++;
-        const end = statementEnd(code, start, owner.end, pairs);
-        if (end <= owner.end && hasConditionalAuthGuard(code.slice(i, end))) return end;
+        const end = statementEnd2(code, start, owner.end, pairs);
+        const required = /* @__PURE__ */ new Set();
+        const values = authValuesOf(file, fn, bodies, pairs);
+        const accepted = hasConditionalAuthGuard(code.slice(i, end), requireThrow, (term) => {
+          const mismatch = /^(.*?)\s*!={1,2}\s*(.*?)$/.exec(term);
+          if (mismatch && (values.value(mismatch[1], i).kind === "secret" || values.value(mismatch[2], i).kind === "secret")) return true;
+          const subject = term.replace(/^!\s*/, "").split(/\s*(?:={2,3}|!={1,2})\s*/)[0];
+          const value = values.value(subject, i);
+          const dependencies = identityRequirement(value, !!observe);
+          if (dependencies) {
+            dependencies.forEach((index) => required.add(index));
+            return true;
+          }
+          return !observe && value.kind === "unknown" && rejectsMissingIdentity(term, DENIED_STATUS.test(code.slice(i, end)));
+        });
+        if (end <= owner.end && accepted) {
+          guardRequirements.set(owner.start, [...required]);
+          return end;
+        }
+        const other = skipSpace(end);
+        if (/^else\b/.test(code.slice(other, other + 8))) {
+          const first = blockAt(start);
+          const second = blockAt(other + 4);
+          if (first && second) {
+            if (allProtected(owner, [first, second], fn, depth)) return second.end + 1;
+            i = second.end;
+            continue;
+          }
+        }
         i = Math.min(end, owner.end) - 1;
         continue;
       }
-      const call = AUTH_ENFORCING_CALL.exec(code.slice(i, i + 100));
+      const indirectCall = i > 0 && /[\w$.]/.test(code[i - 1]) ? null : extraCalls?.exec(code.slice(i, i + 100));
+      const call = indirectCall ?? AUTH_ENFORCING_CALL.exec(code.slice(i, i + 100));
+      const callName = call?.[0].replace(/\s*\($/, "");
+      if (!indirectCall && call?.index === 0 && callName && localNames.has(callName)) continue;
       if (call?.index === 0 && !/^(?:withAuth|NextAuth)\b/i.test(call[0]) && !/\bfunction\s*$/.test(code.slice(Math.max(owner.start, i - 30), i))) {
         const prefixStart = Math.max(
           owner.start + 1,
@@ -2558,11 +3937,30 @@ function unguardedOperations(file, ops) {
         );
         const prefix = code.slice(prefixStart, i).trim();
         if (/(?:&&|\|\||\?|:)\s*$/.test(code.slice(owner.start + 1, prefixStart))) continue;
-        const awaited = /^(?:await|(?:const|let|var)\s+[\w${},:\s]+?=\s*await)(?:\s+[\w$.]+\.)?$/.test(prefix);
+        const awaited = /^(?:await|(?:const|let|var)\s+[\w${},:\s]+?=\s*await)(?:\s+[\w$.]+\.)?$/.test(prefix) || requireThrow && /^return(?:\s+await)?$/.test(prefix);
         const synchronous = /^(?:assertAuth(?:enticated)?|constructEvent)\b/i.test(call[0]) && /^(?:(?:const|let|var)\s+[\w$]+\s*=\s*)?(?:[\w$]+\.)*$/.test(prefix);
         if (!awaited && !synchronous) continue;
         const close2 = pairs.get(i + call[0].length - 1);
-        if (close2 !== void 0 && close2 < owner.end) return close2 + 1;
+        if (close2 !== void 0 && close2 < owner.end) {
+          if (/^\s*(?:\.|\?\.)/.test(code.slice(close2 + 1, close2 + 100))) continue;
+          const required = /* @__PURE__ */ new Set();
+          const requirements = indirectCall ? extra?.requirements?.get(indirectCall[1]) ?? [] : [];
+          const argumentsOfCall = requirements.length ? argumentExpressions(code, commentsMaskedOf(file), i + call[0].length, close2, pairs) : [];
+          let valid = true;
+          for (const argument of requirements) {
+            const origin = authValuesOf(file, fn, bodies, pairs).value(argumentsOfCall[argument] ?? "undefined", i);
+            const dependencies = identityRequirement(origin, !!observe);
+            if (!dependencies) {
+              valid = false;
+              break;
+            }
+            dependencies.forEach((index) => required.add(index));
+          }
+          if (!valid) continue;
+          guardRequirements.set(owner.start, [...required]);
+          if (indirectCall) guardNames.set(owner.start, indirectCall[1]);
+          return close2 + 1;
+        }
       }
       const close = pairs.get(i);
       if (close !== void 0) i = close;
@@ -2576,7 +3974,13 @@ function unguardedOperations(file, ops) {
       active.push(block);
     }
     while (active.length && active[active.length - 1].end < op.index) active.pop();
-    if (wrappers.some((w) => w.start < op.index && w.end > op.index)) return false;
+    const wrapper = wrappers.find((w) => w.start < op.index && w.end > op.index);
+    if (wrapper) {
+      if (extra?.requirements?.get(wrapper.name)?.length) return true;
+      observe?.(op.index, []);
+      if (extra?.wrappers.has(wrapper.name)) extra.onGuard(op.index, wrapper.name);
+      return false;
+    }
     let ownerIndex = active.length - 1;
     while (ownerIndex >= 0 && !functionStarts.has(active[ownerIndex].start)) ownerIndex--;
     if (ownerIndex < 0) return true;
@@ -2584,15 +3988,35 @@ function unguardedOperations(file, ops) {
       const block = active[index];
       let end = guardEnds.get(block.start);
       if (end === void 0) {
-        end = guardEnd(block);
+        end = guardEnd(block, bodiesByStart.get(active[ownerIndex].start));
         guardEnds.set(block.start, end);
       }
-      if (end <= op.index) return false;
+      if (end <= op.index) {
+        observe?.(op.index, guardRequirements.get(block.start) ?? []);
+        const name = guardNames.get(block.start);
+        if (name) extra?.onGuard(op.index, name);
+        return false;
+      }
     }
     return true;
   });
 }
 var CLIENT_CONSTRUCTOR = /\b(?:createClient|createServerClient)\s*(?:<[^()]{0,200}>\s*)?\(/;
+var constructorCache = /* @__PURE__ */ new WeakMap();
+function clientConstructorAt(file) {
+  const cached = constructorCache.get(file);
+  if (cached !== void 0) return cached ?? void 0;
+  const code = noiseMaskedOf(file);
+  const direct = CLIENT_CONSTRUCTOR.exec(code)?.index;
+  if (direct !== void 0) {
+    constructorCache.set(file, direct);
+    return direct;
+  }
+  const aliases = bindingsOf(file).imports.filter((binding) => /^@supabase\/(?:supabase-js|ssr)$/.test(binding.spec ?? "") && ["createClient", "createServerClient"].includes(binding.imported)).map((binding) => binding.local);
+  const found = aliases.length === 0 ? void 0 : new RegExp(`(?<![\\w$.])(?:${namePattern(aliases)})\\s*(?:<[^()]{0,200}>\\s*)?\\(`).exec(code)?.index;
+  constructorCache.set(file, found ?? null);
+  return found;
+}
 var SERVICE_ROLE_ENV = /\bSUPABASE_SERVICE_ROLE(?:_KEY)?\b|\bSERVICE_ROLE_KEY\b|\bSUPABASE_SECRET_KEY\b/;
 var SERVICE_ROLE_LITERAL = new RegExp(String.raw`['"\`](${JWT_SOURCE}|${SB_SECRET_SOURCE})['"\`]`, "g");
 var ENV_BRACKET_ACCESS = /(?:process\.env|import\.meta\.env)\s*\[\s*['"]([^'"]+)['"]\s*\]/g;
@@ -2607,10 +4031,11 @@ function referencesServiceRole(code, source) {
 }
 var NUXT_SUPABASE_ADMIN = /\bserverSupabaseServiceRole\s*(?:<[^()]{0,200}>\s*)?\(/;
 var NUXT_SUPABASE_SESSION = /\bserverSupabaseClient\s*(?:<[^()]{0,200}>\s*)?\(/;
-function buildsAdminClient(file) {
+var buildsAdminClient = cachedByFile(buildsAdminClientUncached);
+function buildsAdminClientUncached(file) {
   const code = noiseMaskedOf(file);
   if (NUXT_SUPABASE_ADMIN.test(code)) return true;
-  if (!CLIENT_CONSTRUCTOR.test(code)) return false;
+  if (clientConstructorAt(file) === void 0) return false;
   const source = commentsMaskedOf(file);
   if (referencesServiceRole(code, source)) return true;
   SERVICE_ROLE_LITERAL.lastIndex = 0;
@@ -2620,11 +4045,12 @@ function buildsAdminClient(file) {
   }
   return false;
 }
-function buildsSessionClient(file) {
+var buildsSessionClient = cachedByFile(buildsSessionClientUncached);
+function buildsSessionClientUncached(file) {
   const code = noiseMaskedOf(file);
   if (NUXT_SUPABASE_ADMIN.test(code)) return false;
   if (NUXT_SUPABASE_SESSION.test(code)) return true;
-  if (!CLIENT_CONSTRUCTOR.test(code)) return false;
+  if (clientConstructorAt(file) === void 0) return false;
   if (referencesServiceRole(code, commentsMaskedOf(file))) return false;
   return /\bcookies\b/.test(code);
 }
@@ -2666,10 +4092,13 @@ function usesSessionClient(route, sessionModules, allFiles) {
   return buildsSessionClient(route.file) || importsAnyOf(route, sessionModules, allFiles) || autoImportsAnyOf(route, sessionModules);
 }
 function autoImportsAnyOf(route, modules) {
-  if (route.framework !== "nuxt") return false;
+  return autoImportedModule(route, modules) !== void 0;
+}
+function autoImportedModule(route, modules) {
+  if (route.framework !== "nuxt") return void 0;
   const utils = `${route.scope}server/utils/`;
   const code = noiseMaskedOf(route.file);
-  return modules.some((module) => module.path.startsWith(utils) && exportedNames(module).some((name) => new RegExp(`(?<![\\w$.])${name.replace(/\$/g, "\\$")}\\s*\\(`).test(code)));
+  return modules.find((module) => module.path.startsWith(utils) && exportedNames(module).some((name) => new RegExp(`(?<![\\w$.])${name.replace(/\$/g, "\\$")}\\s*\\(`).test(code)));
 }
 function exportedNames(file) {
   const names = noiseMaskedOf(file).matchAll(
@@ -2677,7 +4106,7 @@ function exportedNames(file) {
   );
   return [...names].map((m) => m[1]);
 }
-function importedModules(file, allFiles, aliasScope) {
+function importedEdges(file, allFiles, aliasScope) {
   const found = [];
   const source = commentsMaskedOf(file);
   const code = noiseMaskedOf(file);
@@ -2688,8 +4117,11 @@ function importedModules(file, allFiles, aliasScope) {
     const target = normalizeSpec(m[1], file.path);
     if (!target) continue;
     const index = moduleIndexOf(allFiles);
+    const append = (targets) => {
+      for (const to of targets) found.push({ from: file, to, line: lineNumberAt(lineStartsCached(file), m.index) });
+    };
     if (!target.alias) {
-      found.push(...index.get(target.key) ?? []);
+      append(index.get(target.key) ?? []);
     } else {
       const prefix = aliasScope;
       for (const key of [
@@ -2697,32 +4129,298 @@ function importedModules(file, allFiles, aliasScope) {
         moduleKey(`${prefix}src/${target.key}`),
         moduleKey(`${prefix}app/${target.key}`)
       ]) {
-        found.push(...index.get(key) ?? []);
+        append(index.get(key) ?? []);
       }
     }
   }
   return found;
 }
+var importsCache = /* @__PURE__ */ new WeakMap();
 function importsAnyOf(route, modules, allFiles) {
-  if (modules.length === 0) return false;
+  return importChain(route, modules, allFiles) !== null;
+}
+function importChain(route, modules, allFiles) {
+  if (modules.length === 0) return null;
+  const byFile = importsCache.get(modules) ?? /* @__PURE__ */ new WeakMap();
+  importsCache.set(modules, byFile);
+  const byScope = byFile.get(route.file) ?? /* @__PURE__ */ new Map();
+  byFile.set(route.file, byScope);
+  const cached = byScope.get(route.scope);
+  if (cached !== void 0) return cached;
+  const result = importChainUncached(route, modules, allFiles);
+  byScope.set(route.scope, result);
+  return result;
+}
+function importChainUncached(route, modules, allFiles) {
   const targetPaths = new Set(modules.map((file) => file.path));
-  const visited = /* @__PURE__ */ new Set();
-  const aliasScope = route.scope;
-  const queue = importedModules(route.file, allFiles, aliasScope);
-  while (queue.length > 0) {
-    const file = queue.pop();
-    if (targetPaths.has(file.path)) return true;
-    if (visited.has(file.path)) continue;
-    visited.add(file.path);
-    queue.push(...importedModules(file, allFiles, aliasScope));
+  const visited = /* @__PURE__ */ new Set([route.file.path]);
+  const parents = /* @__PURE__ */ new Map();
+  const queue = [route.file];
+  for (let i = 0; i < queue.length; i++) {
+    for (const edge of importedEdges(queue[i], allFiles, route.scope)) {
+      if (visited.has(edge.to.path)) continue;
+      visited.add(edge.to.path);
+      parents.set(edge.to.path, edge);
+      if (targetPaths.has(edge.to.path)) {
+        const chain = [];
+        let current = edge;
+        while (current) {
+          chain.push(current);
+          current = parents.get(current.from.path);
+        }
+        return chain.reverse();
+      }
+      queue.push(edge.to);
+    }
   }
-  return false;
+  return null;
+}
+function adminEvidence(route, modules, allFiles, line) {
+  const chain = buildsAdminClient(route.file) ? [] : importChain(route, modules, allFiles);
+  const evidence = [{
+    kind: "operation",
+    file: route.file.path,
+    line,
+    description: "Data operation selected for authentication review."
+  }];
+  for (const edge of (chain ?? []).slice(0, 22)) evidence.push({
+    kind: "import",
+    file: edge.from.path,
+    line: edge.line,
+    description: `Statically imports ${edge.to.path}.`
+  });
+  const target = chain?.at(-1)?.to ?? (buildsAdminClient(route.file) ? route.file : autoImportedModule(route, modules));
+  if (target) {
+    const at = clientConstructorAt(target) ?? NUXT_SUPABASE_ADMIN.exec(noiseMaskedOf(target))?.index;
+    evidence.push({
+      kind: "admin-client",
+      file: target.path,
+      line: at === void 0 ? null : lineNumberAt(lineStartsCached(target), at),
+      description: "Admin-client construction detected in this module; imports are not proof of runtime data flow."
+    });
+  }
+  return { evidence, evidenceTruncated: (chain?.length ?? 0) > 22 };
+}
+var definitionsCache = /* @__PURE__ */ new WeakMap();
+function guardDefinitions(file) {
+  const cached = definitionsCache.get(file);
+  if (cached) return cached;
+  const result = { locals: /* @__PURE__ */ new Map(), exports: /* @__PURE__ */ new Map(), candidates: /* @__PURE__ */ new Map(), exportedCandidates: /* @__PURE__ */ new Map() };
+  const code = noiseMaskedOf(file);
+  const pairs = delimiterPairs(code);
+  const openers = new Map([...pairs].map(([open, close]) => [close, open]));
+  const bodies = functionBodies(code, pairs);
+  const byDeclaration = new Map(bodies.map((body) => [body.declaration, body]));
+  const candidates = [];
+  let until = -1;
+  for (const body of bodies) {
+    if (body.start < until) continue;
+    until = body.end;
+    const declaration = declarationOf(code, body, openers);
+    if (!declaration) continue;
+    const returned = /\breturn\s+(?:async\s+)?(?:function\b|(?:\([^)]{0,200}\)|[A-Za-z_$][\w$]*)\s*=>)/.exec(code.slice(body.start + 1, body.end));
+    const nestedAt = returned ? body.start + 1 + returned.index + (returned[0].includes("=>") ? returned[0].lastIndexOf("=>") : returned[0].lastIndexOf("function")) : -1;
+    const target = byDeclaration.get(nestedAt) ?? body;
+    let at = target.end;
+    for (let i = target.start + 1; i < target.end; i++) {
+      const conditional = /^if\s*\(/.exec(code.slice(i, i + 32));
+      if (conditional && (i === 0 || !/[\w$]/.test(code[i - 1]))) {
+        const close2 = pairs.get(i + conditional[0].length - 1);
+        if (close2 !== void 0) {
+          let start = close2 + 1;
+          while (/\s/.test(code[start] ?? "")) start++;
+          i = statementEnd2(code, start, target.end, pairs) - 1;
+          continue;
+        }
+      }
+      if (code.startsWith("return", i) && !/[\w$]/.test(code[i - 1] ?? "") && !/[\w$]/.test(code[i + 6] ?? "")) {
+        at = Math.min(target.end, statementEnd2(code, i, target.end, pairs));
+        break;
+      }
+      const close = pairs.get(i);
+      if (close !== void 0) i = close;
+    }
+    const definition = {
+      file,
+      line: lineNumberAt(lineStartsCached(file), body.declaration),
+      wrapper: target !== body
+    };
+    const exported = !declaration.exported ? null : /\bexport\s+default\s+(?:async\s+)?$/.test(code.slice(Math.max(0, body.declaration - 80), body.declaration)) ? "default" : declaration.name;
+    candidates.push({ name: declaration.name, exported, definition, at, start: target.start });
+  }
+  const unguarded = /* @__PURE__ */ new Set();
+  const requirements = /* @__PURE__ */ new Map();
+  for (const wrapper of [false, true]) {
+    const ops = candidates.filter((candidate) => candidate.definition.wrapper === wrapper).map((candidate) => ({ index: candidate.at, writes: false })).sort((a, b) => a.index - b.index);
+    for (const hit of unguardedOperations(
+      file,
+      ops,
+      void 0,
+      !wrapper,
+      (index, required) => requirements.set(index, required)
+    )) unguarded.add(hit.index);
+  }
+  for (const candidate of candidates) {
+    result.candidates.set(candidate.name, candidate);
+    if (candidate.exported) result.exportedCandidates.set(candidate.exported, candidate);
+    if (unguarded.has(candidate.at)) continue;
+    candidate.definition.requiredArgs = requirements.get(candidate.at) ?? [];
+    if (candidate.definition.wrapper && candidate.definition.requiredArgs.length) continue;
+    result.locals.set(candidate.name, candidate.definition);
+    if (candidate.exported) result.exports.set(candidate.exported, candidate.definition);
+  }
+  definitionsCache.set(file, result);
+  return result;
+}
+function bindingModule(spec, file, allFiles, scope) {
+  const target = normalizeSpec(spec, file.path);
+  if (!target) return null;
+  const keys = target.alias ? [`${scope}${target.key}`, `${scope}src/${target.key}`, `${scope}app/${target.key}`] : [target.key];
+  const found = new Set(keys.flatMap((key) => moduleIndexOf(allFiles).get(moduleKey(key)) ?? []));
+  return found.size === 1 ? [...found][0] : null;
+}
+function exportedGuard(file, name, allFiles, scope, state, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  const key = `${file.path}\0${name}`;
+  if (seen.has(key)) return null;
+  if (depth >= 8 || state.remaining-- <= 0) {
+    state.truncated = true;
+    return null;
+  }
+  seen = new Set(seen).add(key);
+  const definitions = guardDefinitions(file);
+  const candidate = definitions.exportedCandidates.get(name);
+  if (candidate && guardBindings(file).shadowed.has(candidate.name)) return null;
+  const direct = definitions.exports.get(name);
+  if (direct) return direct;
+  if (candidate) return delegatedGuard(file, candidate, allFiles, scope, state, depth, seen);
+  const bindings = bindingsOf(file);
+  const exported = bindings.exports.find((binding) => binding.local === name);
+  const follow = (spec, imported) => {
+    const target = bindingModule(spec, file, allFiles, scope);
+    return target ? exportedGuard(target, imported, allFiles, scope, state, depth + 1, seen) : null;
+  };
+  if (exported) {
+    if (exported.spec) return follow(exported.spec, exported.imported);
+    if (guardBindings(file).shadowed.has(exported.imported)) return null;
+    const local = definitions.locals.get(exported.imported);
+    if (local) return local;
+    const candidate2 = definitions.candidates.get(exported.imported);
+    if (candidate2) return delegatedGuard(file, candidate2, allFiles, scope, state, depth, seen);
+    const imported = bindings.imports.find((binding) => binding.local === exported.imported);
+    if (imported?.spec) return follow(imported.spec, imported.imported);
+  }
+  if (name !== "default") for (const spec of bindings.stars) {
+    const found = follow(spec, name);
+    if (found) return found;
+  }
+  return null;
+}
+var guardBindingCache = /* @__PURE__ */ new WeakMap();
+function guardBindings(file) {
+  const cached = guardBindingCache.get(file);
+  if (cached) return cached;
+  const code = noiseMaskedOf(file);
+  const declarations = code.replace(/\b(?:import|export)\s+(?:[A-Za-z_$][\w$]*\s*,\s*)?\{[^{}]{0,4000}\}/g, (text) => " ".repeat(text.length));
+  const shadowed = /* @__PURE__ */ new Set();
+  const declared = /* @__PURE__ */ new Set();
+  const called = /* @__PURE__ */ new Set();
+  for (const match of declarations.matchAll(/[({,]\s*([A-Za-z_$][\w$]*)\s*[,}):=]|(?<![\w$.])([A-Za-z_$][\w$]*)\s*=(?!=)|(?<![\w$])([A-Za-z_$][\w$]*)\s*=>/g)) {
+    if (match[2] && /\b(?:const|let|var)\s*$/.test(declarations.slice(Math.max(0, match.index - 40), match.index))) continue;
+    shadowed.add(match[1] ?? match[2] ?? match[3]);
+  }
+  for (const match of declarations.matchAll(/\b(?:const|let|var|function|class)\s+([A-Za-z_$][\w$]*)/g)) {
+    if (declared.has(match[1])) shadowed.add(match[1]);
+    declared.add(match[1]);
+  }
+  for (const match of code.matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)\s*\(/g)) {
+    if (!/\bfunction\s*\*?\s*$/.test(code.slice(Math.max(0, match.index - 40), match.index))) called.add(match[1]);
+  }
+  const result = { shadowed, declared, called };
+  guardBindingCache.set(file, result);
+  return result;
+}
+function namedGuard(file, name, allFiles, scope, state, depth, seen) {
+  const bindings = guardBindings(file);
+  if (bindings.shadowed.has(name)) return null;
+  const definitions = guardDefinitions(file);
+  const candidate = definitions.candidates.get(name);
+  if (candidate) {
+    const key = `${file.path}\0${name}`;
+    if (seen.has(key)) return null;
+    if (depth >= 8 || state.remaining-- <= 0) {
+      state.truncated = true;
+      return null;
+    }
+    return definitions.locals.get(name) ?? delegatedGuard(file, candidate, allFiles, scope, state, depth, new Set(seen).add(key));
+  }
+  if (bindings.declared.has(name)) return null;
+  const imported = bindingsOf(file).imports.find((binding) => binding.local === name);
+  if (!imported?.spec) return null;
+  const target = bindingModule(imported.spec, file, allFiles, scope);
+  return target ? exportedGuard(target, imported.imported, allFiles, scope, state, depth, seen) : null;
+}
+function delegatedGuard(file, candidate, allFiles, scope, state, depth, seen) {
+  const code = noiseMaskedOf(file);
+  const calls = /* @__PURE__ */ new Set();
+  for (const match of code.slice(candidate.start + 1, candidate.at).matchAll(/(?<![\w$.])([A-Za-z_$][\w$]*)\s*\(/g)) calls.add(match[1]);
+  const resolved = /* @__PURE__ */ new Map();
+  for (const name of calls) {
+    if (state.remaining <= 0) {
+      state.truncated = true;
+      break;
+    }
+    const guard = namedGuard(file, name, allFiles, scope, state, depth + 1, seen);
+    if (guard && !guard.wrapper) resolved.set(name, guard);
+  }
+  if (resolved.size === 0) return null;
+  let selected;
+  let requiredArgs = [];
+  unguardedOperations(file, [{ index: candidate.at, writes: false }], {
+    guards: new Set(resolved.keys()),
+    wrappers: /* @__PURE__ */ new Set(),
+    requirements: new Map([...resolved].map(([name, guard]) => [name, guard.requiredArgs ?? []])),
+    onGuard: (_index, name) => {
+      selected = resolved.get(name);
+    }
+  }, !candidate.definition.wrapper, (_index, required) => {
+    requiredArgs = required;
+  });
+  return selected ? { ...candidate.definition, requiredArgs, chain: [selected, ...selected.chain ?? []] } : null;
+}
+function indirectGuardOperations(route, ctx) {
+  const state = { remaining: 128, truncated: false };
+  const { called } = guardBindings(route.file);
+  const names = /* @__PURE__ */ new Map();
+  for (const name of called) {
+    if (state.remaining <= 0) {
+      state.truncated = true;
+      break;
+    }
+    const definition = namedGuard(route.file, name, ctx.files, route.scope, state, 0, /* @__PURE__ */ new Set());
+    if (definition) names.set(name, definition);
+  }
+  if (state.truncated) ctx.reportIncomplete(
+    "api/db-access-without-auth",
+    `${route.file.path} reached the authentication resolution limit (8 hops or 128 symbols); unresolved guards were not accepted`
+  );
+  const protectedOps = /* @__PURE__ */ new Map();
+  if (names.size === 0) return protectedOps;
+  unguardedOperations(route.file, unguardedOpsOf(route.file), {
+    guards: new Set([...names].filter(([, definition]) => !definition.wrapper).map(([name]) => name)),
+    wrappers: new Set([...names].filter(([, definition]) => definition.wrapper).map(([name]) => name)),
+    requirements: new Map([...names].map(([name, guard]) => [name, guard.requiredArgs ?? []])),
+    onGuard: (index, name) => {
+      const definition = names.get(name);
+      if (definition) protectedOps.set(index, definition);
+    }
+  });
+  return protectedOps;
 }
 var SUPABASE_TABLE = /\.from\(\s*['"`][^'"`]+['"`]\s*\)\s*\.?\s*(\w+)?/g;
 var SUPABASE_ADMIN_API = /\bauth\s*\.\s*admin\s*\.\s*(\w+)\s*\(/g;
 var SUPABASE_WRITES = /* @__PURE__ */ new Set(["insert", "update", "upsert", "delete"]);
-var PRISMA_OP = /\bprisma\s*\.\s*\$?(\w+)\s*\.\s*(findMany|findFirst|findUnique|findUniqueOrThrow|create|createMany|update|updateMany|upsert|delete|deleteMany)\s*\(/g;
-var PRISMA_RAW = /\bprisma\s*\.\s*\$(queryRaw|executeRaw)/g;
+var PRISMA_OP = /\b(?:prisma|db)\s*\.\s*\$?(\w+)\s*\.\s*(findMany|findFirst|findUnique|findUniqueOrThrow|create|createMany|update|updateMany|upsert|delete|deleteMany)\s*\(/g;
+var PRISMA_RAW = /\b(?:prisma|db)\s*\.\s*\$(queryRaw|executeRaw)/g;
 var PRISMA_WRITES = /^(?:create|createMany|update|updateMany|upsert|delete|deleteMany)$/;
 var DRIZZLE_OP = /\bdb\s*\.\s*(select|insert|update|delete)\s*\(/g;
 var MONGO_OP = /\.(?:deleteMany|deleteOne|updateMany|updateOne|insertMany|insertOne|findOneAndDelete|findOneAndUpdate)\s*\(/g;
@@ -2765,20 +4463,29 @@ function findDataOps(file) {
   }
   return hits.sort((a, b) => a.index - b.index);
 }
-var MIDDLEWARE_FILE = /(?:^|\/)(?:src\/)?middleware\.[mc]?[jt]s$/;
+var NEXT_MIDDLEWARE_FILE = /(?:^|\/)(?:src\/)?(?:middleware|proxy)\.[mc]?[jt]s$/;
+var ASTRO_MIDDLEWARE_FILE = /(?:^|\/)src\/middleware(?:\/index)?\.[mc]?[jt]s$/;
+function isMiddlewareFile(path, framework) {
+  return framework === "astro" ? ASTRO_MIDDLEWARE_FILE.test(path) : NEXT_MIDDLEWARE_FILE.test(path);
+}
+function isAnyMiddlewareFile(path) {
+  return NEXT_MIDDLEWARE_FILE.test(path) || ASTRO_MIDDLEWARE_FILE.test(path);
+}
 function middlewareScopeOf(path) {
-  return path.replace(/(?:src\/)?middleware\.[mc]?[jt]s$/, "");
+  return path.replace(/(?:src\/)?(?:middleware(?:\/index)?|proxy)\.[mc]?[jt]s$/, "");
 }
-function middlewareFor(ctx, routePath) {
-  let best = null;
+function middlewaresFor(ctx, routePath, framework) {
+  let best = [];
   let bestDepth = -1;
   for (const file of ctx.files) {
-    if (!MIDDLEWARE_FILE.test(file.path)) continue;
+    if (!isMiddlewareFile(file.path, framework)) continue;
     const scope = middlewareScopeOf(file.path);
     if (!routePath.startsWith(scope)) continue;
     if (scope.length > bestDepth) {
-      best = file;
+      best = [file];
       bestDepth = scope.length;
+    } else if (scope.length === bestDepth) {
+      best.push(file);
     }
   }
   return best;
@@ -2812,14 +4519,14 @@ function sliceQuoted(text) {
   }
   return null;
 }
-function topLevelMatcherValueStart(objectText) {
-  const candidates = [1];
+function topLevelMemberStarts(text, container) {
+  const starts = [1];
   let quote = null;
   let braces = 0;
   let brackets = 0;
   let parentheses = 0;
-  for (let i = 0; i < objectText.length; i++) {
-    const ch = objectText[i];
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
     if (quote !== null) {
       if (ch === "\\") i++;
       else if (ch === quote) quote = null;
@@ -2832,18 +4539,41 @@ function topLevelMatcherValueStart(objectText) {
     else if (ch === "]") brackets--;
     else if (ch === "(") parentheses++;
     else if (ch === ")") parentheses--;
-    else if (ch === "," && braces === 1 && brackets === 0 && parentheses === 0) {
-      candidates.push(i + 1);
+    else if (ch === "," && parentheses === 0 && (container === "{" ? braces === 1 && brackets === 0 : brackets === 1 && braces === 0)) {
+      starts.push(i + 1);
     }
   }
-  for (const start of candidates) {
+  return starts;
+}
+function topLevelPropertyStart(objectText, name) {
+  const property = new RegExp(`^(?:${name}|['"]${name}['"])\\s*:\\s*`);
+  for (const start of topLevelMemberStarts(objectText, "{")) {
     let cursor = start;
     while (/\s/.test(objectText[cursor] ?? "")) cursor++;
-    const property = /^(?:matcher|['"]matcher['"])\s*:\s*/.exec(objectText.slice(cursor));
-    if (property) return cursor + property[0].length;
+    const match = property.exec(objectText.slice(cursor));
+    if (match) return cursor + match[0].length;
   }
   return null;
 }
+function quotedValue(text) {
+  const quoted = sliceQuoted(text);
+  return quoted === null || quoted.length < 3 ? null : quoted.slice(1, -1);
+}
+function matcherEntry(text) {
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{")) {
+    const object = sliceDelimited(trimmed, "{", "}");
+    if (object === null) return null;
+    if (topLevelPropertyStart(object, "has") !== null || topLevelPropertyStart(object, "missing") !== null) {
+      return { conditional: true };
+    }
+    const source = topLevelPropertyStart(object, "source");
+    const pattern2 = source === null ? null : quotedValue(object.slice(source));
+    return pattern2 === null ? null : { pattern: pattern2 };
+  }
+  const pattern = quotedValue(trimmed);
+  return pattern === null ? null : { pattern };
+}
 function extractMatcherConfig(file) {
   const code = noiseMaskedOf(file);
   const declaration = /\bexport\s+const\s+config\b/.exec(code);
@@ -2857,13 +4587,28 @@ function extractMatcherConfig(file) {
   const masked = commentsMaskedOf(file);
   const objectText = sliceDelimited(masked.slice(objectStart), "{", "}");
   if (objectText === null) return { kind: "unreadable" };
-  const valueStart = topLevelMatcherValueStart(objectText);
+  const valueStart = topLevelPropertyStart(objectText, "matcher");
   if (valueStart === null) return { kind: "absent" };
   const rest = objectText.slice(valueStart);
-  const raw = rest.startsWith("[") ? sliceBracketed(rest) : sliceQuoted(rest);
-  if (raw === null) return { kind: "unreadable" };
-  const patterns = [...raw.matchAll(/['"`]([^'"`]+)['"`]/g)].map((m) => m[1]);
-  return patterns.length === 0 ? { kind: "unreadable" } : { kind: "patterns", patterns };
+  if (!rest.startsWith("[")) {
+    const entry = matcherEntry(rest);
+    return entry === null ? { kind: "unreadable" } : "pattern" in entry ? { kind: "patterns", patterns: [entry.pattern] } : { kind: "patterns", patterns: [] };
+  }
+  const array = sliceBracketed(rest);
+  if (array === null) return { kind: "unreadable" };
+  const patterns = [];
+  let conditional = 0;
+  const starts = topLevelMemberStarts(array, "[");
+  for (const [index, start] of starts.entries()) {
+    const member = array.slice(start, index + 1 < starts.length ? starts[index + 1] - 1 : array.length - 1);
+    if (member.trim() === "") continue;
+    const entry = matcherEntry(member);
+    if (entry === null) continue;
+    if ("pattern" in entry) patterns.push(entry.pattern);
+    else conditional++;
+  }
+  if (patterns.length === 0 && conditional === 0) return { kind: "unreadable" };
+  return { kind: "patterns", patterns };
 }
 var MAX_MATCHER_LENGTH = 300;
 function withoutGroupPrefix(body) {
@@ -2954,9 +4699,10 @@ function matcherToRegex(pattern) {
     return null;
   }
 }
-function middlewareCovers(ctx, routePath, url) {
-  const mw = middlewareFor(ctx, routePath);
-  if (!mw) return false;
+function middlewareCovers(ctx, route) {
+  return middlewaresFor(ctx, route.file.path, route.framework).some((mw) => covers(ctx, mw, route.url));
+}
+function covers(ctx, mw, url) {
   if (!hasAuthSignal(mw)) return false;
   const { config, readable } = compiledMatchersOf(mw);
   if (config.kind === "absent") return true;
@@ -2967,6 +4713,7 @@ function middlewareCovers(ctx, routePath, url) {
     );
     return true;
   }
+  if (config.patterns.length === 0) return false;
   if (readable.length === 0) return true;
   return readable.some((re) => re.test(url));
 }
@@ -3015,9 +4762,12 @@ var apiAuthRule = {
   id: "api/db-access-without-auth",
   severity: "P0",
   check(ctx) {
-    const routes = ctx.files.map(routeOf).filter((route) => route !== null);
+    const routes = ctx.files.flatMap((file) => {
+      const route = routeOf(file);
+      return route === null ? serverActionRoutes(file) : [route];
+    });
     if (routes.length === 0) return [];
-    for (const middlewareFile of ctx.files.filter((f) => MIDDLEWARE_FILE.test(f.path))) {
+    for (const middlewareFile of ctx.files.filter((f) => isAnyMiddlewareFile(f.path))) {
       const config = extractMatcherConfig(middlewareFile);
       const refused = config.kind === "patterns" ? config.patterns.filter((p) => matcherToRegex(p) === null) : [];
       if (refused.length > 0) {
@@ -3030,34 +4780,57 @@ var apiAuthRule = {
     const adminModules = ctx.files.filter(buildsAdminClient);
     const sessionModules = ctx.files.filter(buildsSessionClient);
     const findings = [];
+    const indirectByFile = /* @__PURE__ */ new Map();
     for (const route of routes) {
-      const ops = unguardedOperations(route.file, findDataOps(route.file));
+      const reachable = route.reachable;
+      const unguarded = unguardedOpsOf(route.file);
+      let ops = reachable === void 0 ? unguarded : operationsInRange(unguarded, reachable.start, reachable.end);
       if (ops.length === 0) continue;
+      let indirectOps = indirectByFile.get(route.file);
+      if (!indirectOps) {
+        indirectOps = indirectGuardOperations(route, ctx);
+        indirectByFile.set(route.file, indirectOps);
+      }
+      const unprotected = ops.filter((op) => !indirectOps.has(op.index));
+      if (unprotected.length > 0) ops = unprotected;
       const url = route.url;
       if (isAuthEndpoint(route)) continue;
-      if ((route.framework === "next" || route.framework === "astro") && middlewareCovers(ctx, route.file.path, url)) continue;
+      if ((route.framework === "next" || route.framework === "astro") && route.action === void 0 && middlewareCovers(ctx, route)) continue;
       const globalGuard = globalGuardFor(ctx, route);
       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 admin = usesAdminClient(route, adminModules, ctx.files);
       const hit = ops.find((o) => o.writes) ?? ops[0];
-      const line = lineNumberAt(lineStartsOf(route.file.content), hit.index);
+      const indirect = indirectOps.get(hit.index);
+      const line = lineNumberAt(lineStartsCached(route.file), hit.index);
       const excerpt = excerptFor(route.file, line);
+      const indirectEvidence = indirect ? [indirect, ...indirect.chain ?? []].map((guard) => ({
+        kind: "auth-helper",
+        file: guard.file.path,
+        line: guard.line,
+        description: "Local authentication helper in the recognized delegation chain; verify runtime behaviour and caller coverage."
+      })) : [];
+      if (indirect) globalNote.push("A local authentication helper or wrapper was recognized before this operation. This finding is retained for review because indirect control flow is not a proof of authorization.");
       if (admin) {
+        const trace = adminEvidence(route, adminModules, ctx.files, line);
+        const evidence = [...trace.evidence ?? [], ...indirectEvidence];
         findings.push({
           ruleId: "api/admin-db-access-without-auth",
+          ...trace,
+          evidence: evidence.slice(0, 24),
+          evidenceTruncated: trace.evidenceTruncated || evidence.length > 24,
           severity: "P0",
           // 管理员客户端缺少鉴权时使用确定置信度；可能受全局鉴权覆盖时降为疑似。
-          confidence: globalGuard === null ? "certain" : "likely",
-          title: `Anyone can call ${url} and it queries your database as admin`,
+          confidence: globalGuard === null && !indirect ? "certain" : "likely",
+          title: indirect ? `Review indirect authentication for admin database access in ${url}` : `Anyone can call ${url} and it queries your database as admin`,
           file: route.file.path,
           line,
           excerpt,
           why: [
             ...globalNote,
             `This route references a recognized admin client. Such clients can bypass normal per-user access checks; verify the effective credentials and granted permissions.`,
-            `The scan did not recognize an authentication guard protecting this operation or applicable middleware. Indirect wrappers and deployment-level controls may not be recognized; verify them before exposing this route.`,
+            indirect ? "A local guard was recognized, but its runtime enforcement and business authorization still require verification." : `The scan did not recognize an authentication guard protecting this operation or applicable middleware. Indirect wrappers and deployment-level controls may not be recognized; verify them before exposing this route.`,
             `If ${url} is reachable without authentication, callers can trigger the admin-backed operations implemented by this handler.`,
             `If this endpoint is meant to be public \u2014 handing out a guest session, taking a waitlist signup \u2014 then the problem is not that it is open, it is that it is open *and* holds the admin key. Give it a client that can only do the one thing it needs.`
           ],
@@ -3079,13 +4852,20 @@ var apiAuthRule = {
           severity: "P1",
           // 公开写入可能是业务设计，保留疑似置信度。
           confidence: "likely",
-          title: `${url} writes to your database with no sign-in check`,
+          // Server Action 的名称以小写开头，放在句首时首字母大写。
+          title: indirect ? `Review indirect authentication for database writes in ${url}` : `${url.charAt(0).toUpperCase()}${url.slice(1)} writes to your database with no sign-in check`,
           file: route.file.path,
           line,
           excerpt,
+          ...indirect ? { evidence: [{
+            kind: "operation",
+            file: route.file.path,
+            line,
+            description: "Data write using a local authentication helper."
+          }, ...indirectEvidence] } : {},
           why: [
             ...globalNote,
-            `This route changes data, and the scan did not recognize an authentication guard before the operation. Indirect guards and runtime controls require manual verification.`,
+            indirect ? "This route changes data after a local authentication helper; verify that it rejects unauthorized callers." : `This route changes data, and the scan did not recognize an authentication guard before the operation. Indirect guards and runtime controls require manual verification.`,
             `If this route is publicly reachable and no other control rejects the caller, unauthenticated requests can trigger this write.`,
             `If this is a public form \u2014 a waitlist, a contact box \u2014 that may be intentional. It is still worth rate limiting, because an open write endpoint is what gets a database filled with spam overnight.`
           ],
@@ -3097,6 +4877,14 @@ var apiAuthRule = {
         });
       }
     }
+    for (const file of ctx.files) if (identityFlowLimited(file)) ctx.reportIncomplete(
+      "api/db-access-without-auth",
+      `${file.path} reached the identity flow limit (8 value hops, 4000 expression characters, or 512 assignments or branches per function)`
+    );
+    for (const file of ctx.files) if (controlFlowLimited.has(file)) ctx.reportIncomplete(
+      "api/db-access-without-auth",
+      `${file.path} reached the control-flow proof limit (8 nested branch or exception regions)`
+    );
     return findings;
   }
 };
@@ -3360,21 +5148,37 @@ function collectCredentialLines(file) {
   }
   return lines;
 }
-function nearestOrigin(origins, credLine) {
-  let best = Infinity;
-  let closest = [];
-  for (const o of origins) {
-    const d = Math.abs(o.line - credLine);
-    if (d < best) {
-      best = d;
-      closest = [o];
-    } else if (d === best) {
-      closest.push(o);
+function indexOrigins(origins) {
+  const byLine = /* @__PURE__ */ new Map();
+  for (const { mark, order } of origins) {
+    const entry = byLine.get(mark.line);
+    if (entry === void 0) byLine.set(mark.line, { line: mark.line, kinds: /* @__PURE__ */ new Set([mark.kind]), first: mark, order });
+    else {
+      entry.kinds.add(mark.kind);
+      if (order < entry.order) {
+        entry.first = mark;
+        entry.order = order;
+      }
     }
   }
-  if (best > PAIRING_DISTANCE || closest.length === 0) return null;
-  const kinds = new Set(closest.map((o) => o.kind));
-  return kinds.size === 1 ? closest[0] : null;
+  return [...byLine.values()].sort((a, b) => a.line - b.line);
+}
+function nearestOrigin(lines, credLine) {
+  let lo = 0;
+  let hi = lines.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (lines[mid].line < credLine) lo = mid + 1;
+    else hi = mid;
+  }
+  const below = lo > 0 ? lines[lo - 1] : void 0;
+  const above = lines[lo];
+  const best = Math.min(below ? credLine - below.line : Infinity, above ? above.line - credLine : Infinity);
+  if (best > PAIRING_DISTANCE) return null;
+  const closest = [below, above].filter((entry) => entry !== void 0 && Math.abs(entry.line - credLine) === best);
+  const kinds = new Set(closest.flatMap((entry) => [...entry.kinds]));
+  if (kinds.size !== 1) return null;
+  return closest.reduce((a, b) => b.order < a.order ? b : a).first;
 }
 var corsRule = {
   id: "cors/credentialed-cross-origin",
@@ -3390,9 +5194,17 @@ var corsRule = {
     const scopes = optionScopes(file, [...origins, ...credentialLines].filter((mark) => mark.mode === "option").map((mark) => mark.at));
     const findings = [];
     const reported = /* @__PURE__ */ new Set();
+    const groupOf = (mark) => mark.mode === "header" ? "header" : `option:${scopes.get(mark.at)}`;
+    const grouped = /* @__PURE__ */ new Map();
+    origins.forEach((mark, order) => {
+      const group = grouped.get(groupOf(mark)) ?? [];
+      group.push({ mark, order });
+      grouped.set(groupOf(mark), group);
+    });
+    const indexes = new Map([...grouped].map(([group, marks]) => [group, indexOrigins(marks)]));
     for (const credential of credentialLines) {
-      const candidates = origins.filter((origin2) => origin2.mode === credential.mode && (credential.mode === "header" || scopes.get(origin2.at) === scopes.get(credential.at)));
-      const origin = nearestOrigin(candidates, credential.line);
+      if (reported.size === 2) break;
+      const origin = nearestOrigin(indexes.get(groupOf(credential)) ?? [], credential.line);
       if (!origin) continue;
       if (origin.kind !== "reflected" && origin.kind !== "wildcard") continue;
       if (reported.has(origin.kind)) continue;
@@ -3461,6 +5273,8 @@ var RULE_IDS = [
   "firebase/test-mode-rules",
   "gitleak/env-in-history",
   "gitleak/env-tracked",
+  "supabase/permissive-policy",
+  "supabase/public-bucket-listing",
   "supabase/rls-not-enabled",
   // 凭据规则 ID 从共享格式表生成。
   ...SECRET_PATTERNS.map((p) => `secrets/hardcoded/${p.id}`)
@@ -3526,6 +5340,15 @@ function sanitize(findings, files) {
     file: f.file === null ? null : clean(f.file),
     // 先脱敏再截断，避免截断导致凭据特征失效。
     excerpt: f.excerpt === null ? null : truncate(clean(f.excerpt)),
+    ...f.evidence ? {
+      evidence: f.evidence.slice(0, 24).map((step) => ({
+        kind: step.kind,
+        file: clean(step.file),
+        line: step.line,
+        description: clean(step.description)
+      })),
+      evidenceTruncated: f.evidenceTruncated === true || f.evidence.length > 24
+    } : {},
     fix: f.fix.map(clean),
     ...f.humanOnly ? { humanOnly: f.humanOnly.map(clean) } : {}
   }));
@@ -3694,6 +5517,9 @@ var gray = wrap(90, 39);
 var BLOCKING = /* @__PURE__ */ new Set(["P0", "P1"]);
 
 // src/report/shared.ts
+function changeViewNotice(view) {
+  return `Changed-file view: ${view.changedFiles} changed files; ${view.hiddenFindings} findings hidden. Full scan: ${view.totalFindings} findings, ${view.totalBlocking} blocking. Scan scope and exit status are unchanged.`;
+}
 function plural(n, word) {
   return n === 1 ? word : `${word}s`;
 }
@@ -3753,12 +5579,14 @@ function renderReport(result, opts) {
     `${INDENT}${bold("canship")} ${dim(`scanned ${result.filesScanned} ${plural(result.filesScanned, "file")} in ${result.durationMs}ms`)}`
   );
   out.push(`${INDENT}${dim(opts.root)}`);
+  if (result.changeView) out.push(`${INDENT}${yellow(changeViewNotice(result.changeView))}`);
   out.push("");
   if (findings.length === 0) {
     out.push(...renderClean(result, opts));
     return out.join("\n");
   }
-  const { blocking, minor: confirmedMinor, unsure } = verdictOf(findings);
+  const { blocking: visibleBlocking, minor: confirmedMinor, unsure } = verdictOf(findings);
+  const blocking = result.changeView?.totalBlocking ?? visibleBlocking;
   if (blocking > 0) {
     out.push(`${INDENT}${red(bold(`\u2717 ${blocking} critical ${plural(blocking, "issue")} \u2014 do not deploy`))}`);
   } else if (confirmedMinor > 0) {
@@ -3800,6 +5628,11 @@ function renderFinding(f, index) {
     out.push("");
     out.push(`${INDENT}${INDENT}${gray(f.excerpt)}`);
   }
+  if (f.evidence?.length) {
+    out.push("", `${INDENT}${INDENT}${bold("Evidence (static relationships):")}`);
+    for (const step of f.evidence) out.push(`${INDENT}${INDENT}  ${locationOf(step)} \u2014 ${step.description}`);
+    if (f.evidenceTruncated) out.push(`${INDENT}${INDENT}  Additional dependency steps omitted.`);
+  }
   out.push("");
   for (const line of wrapText(f.why.join("\n\n"), 76)) {
     out.push(line === "" ? "" : `${INDENT}${INDENT}${line}`);
@@ -3854,6 +5687,8 @@ function renderClean(result, opts) {
   if (result.partial) {
     const headline = opts.hiddenLikely > 0 ? `! No certain findings \u2014 ${opts.hiddenLikely} lower-confidence ${plural(opts.hiddenLikely, "finding")} hidden, and not everything was checked` : "! No findings \u2014 but not everything was checked";
     out.push(`${INDENT}${yellow(bold(headline))}`);
+  } else if ((result.changeView?.hiddenFindings ?? 0) > 0) {
+    out.push(`${INDENT}${yellow(bold("! No visible findings in changed files \u2014 other findings still exist"))}`);
   } else if (opts.hiddenLikely > 0) {
     out.push(
       `${INDENT}${yellow(bold(`! No certain findings \u2014 ${opts.hiddenLikely} lower-confidence ${plural(opts.hiddenLikely, "finding")} hidden`))}`
@@ -3874,9 +5709,9 @@ function renderClean(result, opts) {
   out.push(`${INDENT}${dim("  \xB7 Server-side secrets exposed to the browser via public env prefixes")}`);
   out.push(`${INDENT}${dim("  \xB7 Supabase service_role keys reachable from the client")}`);
   out.push(`${INDENT}${dim("  \xB7 .env files committed to git, including in history")}`);
-  out.push(`${INDENT}${dim("  \xB7 Supabase tables with no Row Level Security")}`);
+  out.push(`${INDENT}${dim("  \xB7 Supabase tables with no Row Level Security, or policies open to everyone")}`);
   out.push(`${INDENT}${dim("  \xB7 Firebase rules left open to anyone")}`);
-  out.push(`${INDENT}${dim("  \xB7 API routes that query your database with no sign-in check")}`);
+  out.push(`${INDENT}${dim("  \xB7 API routes and server actions that query your database with no sign-in check")}`);
   out.push(`${INDENT}${dim("  \xB7 CORS that lets other sites act as your signed-in visitors")}`);
   out.push("");
   out.push(`${INDENT}${dim("It does not check rate limiting, injection, or whether the checks it")}`);
@@ -4013,8 +5848,12 @@ function renderInstruction(f, index) {
   const location = defuseMarkers(locationOf(f));
   lines.push(`${index}. ${location} \u2014 ${defuseMarkers(f.title)}`);
   if (f.excerpt) lines.push(`   Found: ${defuseMarkers(f.excerpt)}`);
+  for (const step of f.evidence ?? []) {
+    lines.push(`   Static evidence: ${defuseMarkers(locationOf(step))} \u2014 ${defuseMarkers(step.description)}`);
+  }
+  if (f.evidenceTruncated) lines.push("   Additional dependency steps omitted.");
   for (const step of f.fix) {
-    lines.push(`   - ${step}`);
+    lines.push(`   - ${defuseMarkers(step)}`);
   }
   return lines.join("\n");
 }
@@ -4025,6 +5864,7 @@ function renderFixPrompt(findings, ctx) {
   const baselineSuppressed = ctx?.baselineSuppressed ?? 0;
   const silenced = ctx?.silenced ?? [];
   const suppressedNotes = [
+    ctx?.changeView ? changeViewNotice(ctx.changeView) : null,
     !ctx?.ignoredFiles?.length ? null : `Note: ${ctx.ignoredFiles.length} file(s) excluded by canship-ignore-file: ${defuseMarkers(ctx.ignoredFiles.join(", "))}. Their contents were not checked. Do not treat this as a clean result.`,
     baselineSuppressed === 0 ? null : `Note: ${baselineSuppressed} ${baselineSuppressed === 1 ? "finding was" : "findings were"} hidden by a baseline. Those problems still exist and are not listed below. Re-run without --baseline to see them.`,
     silenced.length === 0 ? null : `Note: ${silenced.length} ${silenced.length === 1 ? "finding was" : "findings were"} silenced by a canship-ignore-next-line marker in the source, at ${defuseMarkers(silenced.join(", "))}. Those problems still exist and are not listed below.`,
@@ -4088,7 +5928,7 @@ function renderFixPrompt(findings, ctx) {
     for (const { step } of humanSteps) {
       if (seen.has(step)) continue;
       seen.add(step);
-      out.push(`- ${step}`);
+      out.push(`- ${defuseMarkers(step)}`);
     }
     out.push("");
     out.push("Until these are done, the exposure is still live \u2014 the code fix alone does not close it.");
@@ -4122,6 +5962,7 @@ function renderFinding2(f, index) {
   </header>
   <div class="loc">${esc(location)}${f.confidence === "likely" ? ' <span class="tag">lower confidence</span>' : ""}</div>
   ${f.excerpt ? `<pre><code>${esc(f.excerpt)}</code></pre>` : ""}
+  ${f.evidence?.length ? `<h4>Evidence (static relationships)</h4><ol>${f.evidence.map((step) => `<li><code>${esc(locationOf(step))}</code> \u2014 ${esc(step.description)}</li>`).join("")}</ol>${f.evidenceTruncated ? "<p>Additional dependency steps omitted.</p>" : ""}` : ""}
   <div class="why">${linkify(paragraphs(f.why))}</div>
   ${fixList}
   ${humanList}
@@ -4132,14 +5973,15 @@ function renderHtml(result, opts) {
   const hiddenLikely = opts.hiddenLikely ?? 0;
   const baselineSuppressed = opts.baselineSuppressed ?? 0;
   const baselineStale = opts.baselineStale ?? 0;
-  const { blocking: certain, minor, unsure } = verdictOf(findings);
+  const { blocking, minor, unsure } = verdictOf(findings);
+  const certain = result.changeView?.totalBlocking ?? blocking;
   const verdict = findings.length === 0 ? result.filesScanned === 0 ? (
     // 未扫描文件时不显示通过结论。
     `<div class="verdict warn">No files were scanned &mdash; nothing was checked</div>`
   ) : result.partial ? (
     // 扫描不完整时不得显示正常通过。
     hiddenLikely > 0 ? `<div class="verdict warn">No certain findings &mdash; ${hiddenLikely} lower-confidence ${plural(hiddenLikely, "finding")} hidden, and not everything was checked</div>` : `<div class="verdict warn">No findings &mdash; but not everything was checked</div>`
-  ) : hiddenLikely > 0 ? `<div class="verdict warn">No certain findings &mdash; ${hiddenLikely} lower-confidence ${plural(hiddenLikely, "finding")} hidden</div>` : (
+  ) : (result.changeView?.hiddenFindings ?? 0) > 0 ? `<div class="verdict warn">No visible findings in changed files &mdash; other findings still exist</div>` : hiddenLikely > 0 ? `<div class="verdict warn">No certain findings &mdash; ${hiddenLikely} lower-confidence ${plural(hiddenLikely, "finding")} hidden</div>` : (
     // 基线抑制结果时明确说明，避免误报为项目无问题。
     baselineSuppressed > 0 ? `<div class="verdict warn">No new findings &mdash; ${baselineSuppressed} ${plural(baselineSuppressed, "finding")} accepted by the baseline</div>` : `<div class="verdict clean">No exposed credentials found</div>`
   ) : certain > 0 ? `<div class="verdict bad">${certain} critical ${plural(certain, "issue")} &mdash; do not deploy</div>` : minor > 0 ? `<div class="verdict warn">${minor} ${plural(minor, "thing")} to fix &mdash; nothing exposed</div>` : `<div class="verdict warn">${unsure} possible ${plural(unsure, "issue")} to review</div>`;
@@ -4152,7 +5994,7 @@ function renderHtml(result, opts) {
            gitignored or build output that canship skips. If the project lives in a
            subdirectory, point canship at it: <code>npx canship ./app</code>.</p>
          </div>`
-  ) : hiddenLikely > 0 ? `<div class="clean-note">
+  ) : (result.changeView?.hiddenFindings ?? 0) > 0 ? '<div class="clean-note">This view hides existing findings. Re-run without --changed-since for the full report.</div>' : hiddenLikely > 0 ? `<div class="clean-note">
              <p><strong>This is not a finding-free result.</strong> The default report hides
              ${hiddenLikely} lower-confidence ${plural(hiddenLikely, "finding")}.</p>
              <p>Re-run with <code>--all --report</code> to include ${hiddenLikely === 1 ? "it" : "them"} in the report.</p>
@@ -4162,7 +6004,7 @@ function renderHtml(result, opts) {
              <p>Those problems still exist. Re-run without <code>--baseline</code> to see ${baselineSuppressed === 1 ? "it" : "them"}.</p>
            </div>` : `<div class="clean-note">
            <p>canship checked for hardcoded API keys, server secrets exposed to the browser,
-            Supabase tables without Row Level Security, open Firebase rules, API routes that reach
+            Supabase tables without Row Level Security or with policies open to everyone, open Firebase rules, API routes and server actions that reach
             the database with no sign-in check, CORS that lets other sites use your visitors&rsquo;
            sessions, and <code>.env</code> files committed to git.</p>
            <p><strong>A clean result means those checks passed &mdash; not that your app is secure.</strong>
@@ -4265,6 +6107,7 @@ function renderHtml(result, opts) {
   <h1>canship report</h1>
   <div class="meta">${esc(opts.root)}<br>${esc(opts.generatedAt)} &middot; ${result.filesScanned} ${plural(result.filesScanned, "file")} scanned in ${result.durationMs}ms</div>
   ${verdict}
+  ${result.changeView ? `<p class="opted-out">${esc(changeViewNotice(result.changeView))}</p>` : ""}
   <div class="notice">
     Credential values canship recognises are masked in this report. One in a format it has no
     pattern for can still appear inside a quoted line, and this report lists your
@@ -4410,6 +6253,7 @@ function applyBaseline(findings, baseline) {
 var INFORMATION_URI = "https://github.com/Tasomei/canship";
 function suppressionNotes(result, opts) {
   const notes = [];
+  if (result.changeView) notes.push({ level: "warning", message: { text: changeViewNotice(result.changeView) } });
   const baseline = opts.baselineSuppressed ?? 0;
   const hidden = opts.hiddenLikely ?? 0;
   if (baseline > 0) {
@@ -4487,7 +6331,18 @@ function resultsOf(findings) {
         }
       }
     ],
-    partialFingerprints: { canshipFindingV2: fingerprintOf(f) }
+    partialFingerprints: { canshipFindingV2: fingerprintOf(f) },
+    ...f.evidence?.length ? {
+      relatedLocations: f.evidence.map((step, index) => ({
+        id: index + 1,
+        message: { text: step.description },
+        physicalLocation: {
+          artifactLocation: { uri: step.file.split("/").map((part) => encodeURIComponent(part)).join("/") },
+          ...step.line === null ? {} : { region: { startLine: step.line } }
+        }
+      })),
+      properties: { evidenceTruncated: f.evidenceTruncated ?? false }
+    } : {}
   }));
 }
 function renderSarif(result, opts) {
@@ -4550,7 +6405,8 @@ function createJsonReport(result, options) {
     baselineSuppressed: options.baselineSuppressed,
     baselineStale: options.baselineStale,
     excerptsOmitted: options.excerptsOmitted ?? false,
-    findings: result.findings
+    findings: result.findings,
+    ...result.changeView ? { changeView: result.changeView } : {}
   };
 }
 
@@ -4652,15 +6508,15 @@ var RULE_CATALOG = [
     "Admin database access without a recognized auth guard",
     "P0",
     "certain",
-    "Server routes in Next.js, SvelteKit, Nuxt, Remix/React Router, and Astro, including workspace applications.",
-    "Syntactic guards only; runtime authentication and business authorization are not verified. Guards in SvelteKit hooks or Nuxt server middleware lower confidence."
+    "Server routes and Next.js Server Functions in Next.js, SvelteKit (endpoints and form actions), Nuxt, Remix/React Router, and Astro, including workspace applications.",
+    "Syntactic guards only; runtime authentication and business authorization are not verified. Local calls, identity arguments, branches and exception paths are analysed within documented limits. Local auth evidence, SvelteKit hooks and Nuxt middleware may lower confidence without removing findings; exceeded limits disclose incomplete coverage."
   ),
   rule(
     "api/db-write-without-auth",
     "Database write without a recognized auth guard",
     "P1",
     "likely",
-    "Server routes in Next.js, SvelteKit, Nuxt, Remix/React Router, and Astro.",
+    "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(
@@ -4700,7 +6556,7 @@ var RULE_CATALOG = [
     "Supabase admin credential exposed in source or public env",
     "P0",
     "certain",
-    "Recognized service_role JWTs in source; Supabase admin credentials in public environment variables.",
+    "Recognized service_role JWTs in scanned text files, including configuration and non-JavaScript source; Supabase admin credentials in public environment variables.",
     "Source presence is observable; actual browser delivery and key validity are not verified."
   ),
   rule(
@@ -4708,7 +6564,7 @@ var RULE_CATALOG = [
     "Unconditional Firebase access",
     "P1",
     "varies",
-    "Firebase .rules files: unconditional writes are certain; public reads require review.",
+    "Firebase .rules files and Realtime Database JSON rules: unconditional writes are certain; public reads require review.",
     "Public reads may be intentional; runtime rules and business authorization are not verified."
   ),
   rule(
@@ -4735,6 +6591,22 @@ var RULE_CATALOG = [
     "Tracked environment files; templates and public-only values are treated separately.",
     "Unrecognized private values are heuristic findings, not verified credentials."
   ),
+  rule(
+    "supabase/permissive-policy",
+    "Row Level Security policy with an always-true condition",
+    "P1",
+    "varies",
+    "Supabase SQL migrations, replayed by application scope: permissive policies whose USING or WITH CHECK is always true (true, 1=1, 'a'='a'). Changing or deleting any row is certain; reading or inserting any row requires review.",
+    "Missing clauses and dashboard changes are not checked; matching restrictive policies and nontrivial WITH CHECK conditions lower confidence."
+  ),
+  rule(
+    "supabase/public-bucket-listing",
+    "Public storage bucket whose contents can be listed",
+    "P2",
+    "varies",
+    "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(
     "supabase/rls-not-enabled",
     "Table without RLS in migrations",
@@ -4766,8 +6638,53 @@ function renderRuleCatalog() {
   ).join("\n\n") + "\n\nExample and fixture contexts may lower confidence. No credential validity or deployed configuration is verified.\n";
 }
 
+// src/changes.ts
+var ChangeViewError = class extends Error {
+};
+function changedFilesSince(root, ref) {
+  if (!ref || ref.length > 1024 || /[\0\r\n]/.test(ref)) throw new ChangeViewError("Invalid changed-since reference.");
+  const git2 = resolveGitExecutable(root);
+  if (!git2 || !hasContainedGitMetadata(root)) throw new ChangeViewError("Changed-file views require a readable local Git repository.");
+  try {
+    const baseCommit = execGitSync(git2, root, ["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]).trim();
+    const mergeBase = execGitSync(git2, root, ["merge-base", baseCommit, "HEAD"]).trim();
+    const hash = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+    if (!hash.test(baseCommit) || !hash.test(mergeBase)) throw new Error("Invalid object ID");
+    const tracked = execGitSync(git2, root, [
+      "diff",
+      "--no-ext-diff",
+      "--no-textconv",
+      "--no-renames",
+      "--relative",
+      "--name-only",
+      "-z",
+      mergeBase,
+      "--",
+      "."
+    ]);
+    const untracked = execGitSync(git2, root, ["ls-files", "--others", "--exclude-standard", "-z", "--", "."]);
+    const paths = new Set((tracked + untracked).split("\0").filter(Boolean).map(cleanForOutput));
+    return { baseCommit, mergeBase, paths };
+  } catch {
+    throw new ChangeViewError("Cannot compute changed files. Check that the base commit and merge history are available locally.");
+  }
+}
+function changedFileView(result, changed) {
+  const findings = result.findings.filter((finding) => finding.file === null || finding.evidenceTruncated || changed.paths.has(finding.file) || finding.evidence?.some((step) => changed.paths.has(step.file)));
+  const verdict = verdictOf(result.findings);
+  return { ...result, findings, changeView: {
+    baseCommit: changed.baseCommit,
+    mergeBase: changed.mergeBase,
+    changedFiles: changed.paths.size,
+    hiddenFindings: result.findings.length - findings.length,
+    totalFindings: result.findings.length,
+    totalBlocking: verdict.blocking,
+    totalLikely: verdict.unsure
+  } };
+}
+
 // src/cli.ts
-var VERSION = true ? "0.3.2" : "0.0.0-dev";
+var VERSION = true ? "0.5.0" : "0.0.0-dev";
 function finish(code) {
   process.exitCode = code;
 }
@@ -4786,7 +6703,7 @@ function optionalValue(arg, name, fallback) {
 function insideProject(root, relative3) {
   const target = resolve2(root, relative3);
   const inside = relative_(realPathOf(root), realPathOf(target));
-  if (inside === "" || inside.startsWith("..") || isAbsolute2(inside)) {
+  if (inside === "" || inside.startsWith("..") || isAbsolute3(inside)) {
     argumentError(
       `${CONFIG_FILENAME}: "baseline" must stay inside the project, and ${relative3} does not`
     );
@@ -4798,7 +6715,7 @@ function realPathOf(path) {
   const rest = [];
   for (let depth = 0; depth < MAX_REAL_PATH_DEPTH; depth++) {
     try {
-      const real = realpathSync2(at);
+      const real = realpathSync3(at);
       return rest.length === 0 ? real : resolve2(real, ...rest);
     } catch {
       const parent = resolve2(at, "..");
@@ -4836,10 +6753,16 @@ function parseArgs(argv) {
     help: false,
     version: false,
     listRules: false,
-    noExcerpts: false
+    noExcerpts: false,
+    changedSince: null
   };
   const positional = [];
   for (const arg of argv) {
+    if (arg.startsWith("--changed-since=")) {
+      if (args.changedSince !== null || arg === "--changed-since=") argumentError("--changed-since requires one non-empty reference");
+      args.changedSince = arg.slice("--changed-since=".length);
+      continue;
+    }
     const list = (name) => {
       if (!arg.startsWith(`${name}=`)) return null;
       const value = arg.slice(name.length + 1);
@@ -4957,6 +6880,8 @@ var HELP = `
                       markers; use with --no-config for untrusted projects
         --list-rules  List rule IDs, scope, and limits; add --json for structured output
         --no-excerpts Omit source excerpts from every report; paths and descriptions remain
+        --changed-since=REF  Show changed-file findings since the local merge base;
+                             scan scope and exit status remain unchanged
     -h, --help        Show this help
     -v, --version     Show version
 
@@ -5005,6 +6930,10 @@ async function main() {
 `);
     return finish(3);
   }
+  if (args.changedSince !== null && (args.baselineWrite !== null || args.baselineWriteDefault)) {
+    argumentError("--changed-since cannot be combined with --baseline-write");
+  }
+  const changed = args.changedSince === null ? null : changedFilesSince(args.root, args.changedSince);
   let config;
   try {
     config = args.noConfig ? {} : loadConfig(args.root).config;
@@ -5097,10 +7026,13 @@ ${cleanForOutput(String(err))}
   }
   const displayRoot = cleanForOutput(args.root);
   if (args.noExcerpts) result = { ...result, findings: result.findings.map((finding) => ({ ...finding, excerpt: null })) };
+  const fullResult = result;
+  if (changed) result = changedFileView(result, changed);
   const shown = showAll ? result.findings : result.findings.filter((f) => f.confidence === "certain");
   const hiddenLikely = showAll ? 0 : result.findings.filter((f) => f.confidence === "likely").length;
   if (args.fixPrompt) {
     const prompt = renderFixPrompt(shown, {
+      ...result.changeView ? { changeView: result.changeView } : {},
       partial: result.partial,
       filesScanned: result.filesScanned,
       hiddenLikely,
@@ -5207,13 +7139,13 @@ ${cleanForOutput(String(err))}
       return finish(3);
     }
   }
-  if (verdictOf(result.findings).blocking > 0) return finish(1);
-  if (result.findings.length > 0) return finish(2);
+  if (verdictOf(fullResult.findings).blocking > 0) return finish(1);
+  if (fullResult.findings.length > 0) return finish(2);
   if (result.partial && !bestEffort) return finish(3);
   return finish(0);
 }
 main().catch((err) => {
-  if (err instanceof ArgumentError) process.stderr.write(`canship: ${err.message}
+  if (err instanceof ArgumentError || err instanceof ChangeViewError) process.stderr.write(`canship: ${err.message}
 `);
   else process.stderr.write(`${red("canship: unexpected error")}
 ${cleanForOutput(String(err))}