canship 0.3.1 → 0.4.0

package/dist/cli.js

@@ -12,7 +12,8 @@ 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 +24,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",
@@ -134,7 +179,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;
@@ -1364,15 +1409,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 +1503,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 +1691,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 +1838,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 +2252,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 +2307,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 +2371,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,22 +2471,249 @@ 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: [
+        `Replace the condition with one that ties each row to its owner, e.g. USING ((select auth.uid()) = user_id)${p.command === "insert" || p.command === "update" || p.command === "all" ? " and WITH CHECK ((select auth.uid()) = user_id)" : ""}.`,
+        `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 instead, for example: ".read": "auth !== null && auth.uid === $uid" under a "$uid" node.`,
+        `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);
@@ -2147,57 +2721,44 @@ function parseOps(raw) {
 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 +2769,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 +2786,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",
@@ -2299,27 +2866,266 @@ 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/apiauth.ts
 var APP_ROUTER = /(?:^|\/)app\/api\/(?:.+\/)?route\.[mc]?[jt]sx?$/;
 var PAGES_ROUTER = /(?:^|\/)pages\/api\/.+\.[mc]?[jt]sx?$/;
-function isApiRoute(path) {
-  return APP_ROUTER.test(routePathOf(path)) || PAGES_ROUTER.test(path);
+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;
+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, "/");
 }
-var AUTH_ENDPOINT_NAMES = /^\/api\/auth\/(?:sign[-_]?in|sign[-_]?up|sign[-_]?out|log[-_]?in|log[-_]?out|register|session|verify|confirm|reset(?:[-_]password)?|forgot(?:[-_]password)?|magic[-_]?link|otp)$/;
-var AUTH_CALLBACK = /^\/api\/auth\/callback(?:\/[^/]+)?$/;
-function isAuthEndpoint(url) {
-  return AUTH_ENDPOINT_NAMES.test(url) || AUTH_CALLBACK.test(url);
+function routeOf(file) {
+  const path = routePathOf(file.path);
+  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$/, "");
+    const url = nuxt[2] === "api" ? `/api/${rest}` : `/${rest}`;
+    return { file, framework: "nuxt", url: url.replace(/\/$/, "") || "/", scope: nuxt[1] ?? "" };
+  }
+  const remix = REMIX_ROUTE.exec(path);
+  if (remix && REMIX_EXPORT.test(noiseMaskedOf(file))) {
+    return { file, framework: "remix", url: remixRouteUrl(remix[2]), scope: remix[1] ?? "" };
+  }
+  const astro = ASTRO_ENDPOINT.exec(path);
+  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 routeUrl(path) {
-  const m = /(?:^|\/)(?:app|pages)\/(api\/.*)$/.exec(routePathOf(path));
+function nextRouteUrl(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}`;
 }
-var AUTH_ENFORCING_CALL = /\b(?:NextAuth|require(?:Auth|User|Session|Admin)|withAuth|verifyAuth|ensureAuth|assertAuth(?:enticated)?|verifyIdToken|constructEvent)\s*\(/i;
-var AUTH_CONDITION = /\b(?:session|token|user|authorization|bearer|jwt|auth|signature|CRON_SECRET|WEBHOOK_SECRET|REVALIDATE_SECRET|ADMIN_SECRET)\b|\blocals\s*\.\s*user\b|\b(?:getUser|getSession|getServerSession|currentUser|getAuth|isAuthenticated|checkAuth|verifyAuth|ensureAuth|verifyIdToken|timingSafeEqual)\s*\(/i;
+function remixRouteUrl(name) {
+  const LITERAL_DOT = "\0";
+  const segments = name.replace(/\/route$/, "").replace(/\[\.\]/g, LITERAL_DOT).split(/[./]/).filter((segment) => segment !== "" && !segment.startsWith("_")).map((segment) => segment.replace(/_$/, "").replace(/[[\]]/g, "").split(LITERAL_DOT).join("."));
+  if (segments[segments.length - 1] === "index") segments.pop();
+  return `/${segments.join("/")}`;
+}
+var AUTH_ENDPOINT_NAMES = /^(?:\/api)?\/auth\/(?:sign[-_]?in|sign[-_]?up|sign[-_]?out|log[-_]?in|log[-_]?out|register|session|verify|confirm|reset(?:[-_]password)?|forgot(?:[-_]password)?|magic[-_]?link|otp)$/;
+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;
+var AUTH_CONDITION = /\b(?:session|token|user|userid|user_id|authorization|bearer|jwt|auth|signature|CRON_SECRET|WEBHOOK_SECRET|REVALIDATE_SECRET|ADMIN_SECRET)\b|\blocals\s*\.\s*user\b|\b(?:getUser|getSession|getServerSession|currentUser|getAuth|isAuthenticated|checkAuth|verifyAuth|ensureAuth|verifyIdToken|timingSafeEqual)\s*\(/i;
+var ACCESS_CHAIN = String.raw`[\w$]+(?:\??\.[\w$]+)*`;
+var NEGATED_IDENTITY = new RegExp(`^!\\s*${ACCESS_CHAIN}(?:\\s*\\([^=]*\\))?$`);
+var IDENTITY_IS_EMPTY = new RegExp(`^${ACCESS_CHAIN}\\s*={2,3}\\s*(?:null|undefined|false)$`);
+var IDENTITY_MISMATCH = new RegExp(`^${ACCESS_CHAIN}\\s*!={1,2}\\s*(?!(?:null|undefined|false)\\b)${ACCESS_CHAIN}$`);
+var STOPS_REQUEST = /^(?:(?:return|throw|redirect|notFound)\b|error\s*\(\s*40[13]\b)/;
+var DENIED_STATUS = /\b(?:return|throw)\b[\s\S]{0,300}\bstatus(?:Code)?\s*[:(=]\s*(?:401|403)\b|\berror\s*\(\s*40[13]\b/i;
 function closingDelimiter(source, start, open, close) {
   let depth = 0;
   for (let i = start; i < source.length; i++) {
@@ -2343,6 +3149,10 @@ function controlledStatement(source, afterCondition) {
   const end = semicolon === -1 ? Math.min(source.length, start + 400) : Math.min(semicolon + 1, start + 400);
   return source.slice(start, end);
 }
+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) {
   const starts = /\bif\s*\(/g;
   let match;
@@ -2356,7 +3166,7 @@ function hasConditionalAuthGuard(code) {
     const pairs = delimiterPairs(body);
     let stopsRequest = false;
     for (let i = 0; i < body.length; i++) {
-      if (/^(?:return|throw|redirect|notFound)\b/.test(body.slice(i, i + 16)) && (i === 0 || !/[\w$]/.test(body[i - 1]))) {
+      if (STOPS_REQUEST.test(body.slice(i, i + 16)) && (i === 0 || !/[\w$]/.test(body[i - 1]))) {
         stopsRequest = true;
         break;
       }
@@ -2368,19 +3178,55 @@ function hasConditionalAuthGuard(code) {
     while (/\s/.test(code[statementStart] ?? "")) statementStart++;
     starts.lastIndex = statementStart + statement.length;
     if (!stopsRequest) continue;
-    const returnsDeniedStatus = /\b(?:return|throw)\b[\s\S]{0,300}\bstatus\s*[:(=]\s*(?:401|403)\b/i.test(statement);
-    const negative = !/&&|\?/.test(condition) && condition.split("||").some((part) => {
-      const term = part.trim();
-      const rejects = /^!\s*[\w$.]+(?:\s*\([^=]*\))?$/.test(term) || /^[\w$.]+\s*={2,3}\s*(?:null|undefined|false)$/.test(term) || /^[\w$.]+\s*!={1,2}\s*(?!(?:null|undefined|false)\b)[\w$.]+$/.test(term);
-      return rejects && (AUTH_CONDITION.test(term) || returnsDeniedStatus);
-    });
+    const returnsDeniedStatus = DENIED_STATUS.test(statement);
+    const negative = !/&&|\?(?!\.)/.test(condition) && condition.split("||").some((part) => rejectsMissingIdentity(part.trim(), returnsDeniedStatus));
     if (negative) return true;
   }
   return false;
 }
+function containsConditionalAuthCheck(code) {
+  const pairs = delimiterPairs(code);
+  for (const match of code.matchAll(/\bif\s*\(/g)) {
+    const open = match.index + match[0].length - 1;
+    const close = pairs.get(open);
+    if (close === void 0) continue;
+    let start = close + 1;
+    while (/\s/.test(code[start] ?? "")) start++;
+    let bodyStart = start;
+    let bodyEnd;
+    if (code[start] === "{") {
+      bodyStart = start + 1;
+      bodyEnd = pairs.get(start) ?? Math.min(code.length, start + 600);
+    } else {
+      const semicolon = code.slice(start, start + 400).indexOf(";");
+      bodyEnd = semicolon === -1 ? Math.min(code.length, start + 400) : start + semicolon + 1;
+    }
+    let stop = -1;
+    for (let i = bodyStart; i < bodyEnd; i++) {
+      const window = code.slice(i, i + 16);
+      if (STOPS_REQUEST.test(window) && (i === 0 || !/[\w$]/.test(code[i - 1]))) {
+        stop = i;
+        break;
+      }
+      if (/^if\s*\(/.test(window)) break;
+      const end = pairs.get(i);
+      if (end !== void 0) i = end;
+    }
+    if (stop === -1) continue;
+    const returnsDeniedStatus = DENIED_STATUS.test(code.slice(stop, stop + 400));
+    const condition = code.slice(open + 1, close);
+    if (condition.split(/\|\||&&/).some((part) => rejectsMissingIdentity(part.trim(), returnsDeniedStatus))) return true;
+  }
+  return false;
+}
+var authSignalCache = /* @__PURE__ */ new WeakMap();
 function hasAuthSignal(file) {
+  const cached = authSignalCache.get(file);
+  if (cached !== void 0) return cached;
   const code = noiseMaskedOf(file);
-  return AUTH_ENFORCING_CALL.test(code) || hasConditionalAuthGuard(code);
+  const found = AUTH_ENFORCING_CALL.test(code) || hasConditionalAuthGuard(code);
+  authSignalCache.set(file, found);
+  return found;
 }
 function delimiterPairs(code) {
   const pairs = /* @__PURE__ */ new Map();
@@ -2417,7 +3263,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;
@@ -2426,7 +3272,36 @@ 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;
+}
+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 cache2 = /* @__PURE__ */ new WeakMap();
+  return (file) => {
+    let hit = cache2.get(file);
+    if (hit === void 0) {
+      hit = check(file);
+      cache2.set(file, hit);
+    }
+    return hit;
+  };
+}
+function unguardedOperations(file, ops, extra) {
   if (ops.length === 0) return ops;
   const code = noiseMaskedOf(file);
   const pairs = delimiterPairs(code);
@@ -2434,12 +3309,18 @@ function unguardedOperations(file, ops) {
   const declarations = new Map(bodies.map((body) => [body.declaration, body]));
   const functionStarts = new Set(bodies.map((body) => body.start));
   const guardEnds = /* @__PURE__ */ new Map();
+  const guardNames = /* @__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),
+    ...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) => {
     for (let i = owner.start + 1; i < owner.end; i++) {
@@ -2449,7 +3330,7 @@ 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;
@@ -2460,12 +3341,13 @@ 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);
+        const end = statementEnd2(code, start, owner.end, pairs);
         if (end <= owner.end && hasConditionalAuthGuard(code.slice(i, end))) return end;
         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));
       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,
@@ -2478,7 +3360,10 @@ function unguardedOperations(file, ops) {
         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 (indirectCall) guardNames.set(owner.start, indirectCall[1]);
+          return close2 + 1;
+        }
       }
       const close = pairs.get(i);
       if (close !== void 0) i = close;
@@ -2492,7 +3377,11 @@ 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?.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;
@@ -2503,12 +3392,31 @@ function unguardedOperations(file, ops) {
         end = guardEnd(block);
         guardEnds.set(block.start, end);
       }
-      if (end <= op.index) return false;
+      if (end <= op.index) {
+        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 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;
@@ -2521,9 +3429,13 @@ function referencesServiceRole(code, source) {
   }
   return false;
 }
-function buildsAdminClient(file) {
+var NUXT_SUPABASE_ADMIN = /\bserverSupabaseServiceRole\s*(?:<[^()]{0,200}>\s*)?\(/;
+var NUXT_SUPABASE_SESSION = /\bserverSupabaseClient\s*(?:<[^()]{0,200}>\s*)?\(/;
+var buildsAdminClient = cachedByFile(buildsAdminClientUncached);
+function buildsAdminClientUncached(file) {
   const code = noiseMaskedOf(file);
-  if (!CLIENT_CONSTRUCTOR.test(code)) return false;
+  if (NUXT_SUPABASE_ADMIN.test(code)) return true;
+  if (clientConstructorAt(file) === void 0) return false;
   const source = commentsMaskedOf(file);
   if (referencesServiceRole(code, source)) return true;
   SERVICE_ROLE_LITERAL.lastIndex = 0;
@@ -2533,9 +3445,12 @@ function buildsAdminClient(file) {
   }
   return false;
 }
-function buildsSessionClient(file) {
+var buildsSessionClient = cachedByFile(buildsSessionClientUncached);
+function buildsSessionClientUncached(file) {
   const code = noiseMaskedOf(file);
-  if (!CLIENT_CONSTRUCTOR.test(code)) return false;
+  if (NUXT_SUPABASE_ADMIN.test(code)) return false;
+  if (NUXT_SUPABASE_SESSION.test(code)) return true;
+  if (clientConstructorAt(file) === void 0) return false;
   if (referencesServiceRole(code, commentsMaskedOf(file))) return false;
   return /\bcookies\b/.test(code);
 }
@@ -2564,19 +3479,34 @@ function normalizeSpec(spec, fromPath) {
       alias: false
     };
   }
-  const alias = /^[@~#]\/(.+)$/.exec(spec);
+  const lib = /^\$lib\/(.+)$/.exec(spec);
+  if (lib) return { key: moduleKey(`src/lib/${lib[1]}`), alias: true };
+  const alias = /^(?:[@~#]|~~|@@)\/(.+)$/.exec(spec);
   return alias ? { key: moduleKey(alias[1]), alias: true } : null;
 }
 function usesAdminClient(route, adminModules, allFiles) {
-  return buildsAdminClient(route) || importsAnyOf(route, adminModules, allFiles);
+  return buildsAdminClient(route.file) || importsAnyOf(route, adminModules, allFiles) || autoImportsAnyOf(route, adminModules);
 }
 function usesSessionClient(route, sessionModules, allFiles) {
-  return buildsSessionClient(route) || importsAnyOf(route, sessionModules, allFiles);
+  if (route.framework === "sveltekit" && /\blocals\s*\.\s*supabase\b/.test(noiseMaskedOf(route.file))) return true;
+  return buildsSessionClient(route.file) || importsAnyOf(route, sessionModules, allFiles) || autoImportsAnyOf(route, sessionModules);
+}
+function autoImportsAnyOf(route, modules) {
+  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.find((module) => module.path.startsWith(utils) && exportedNames(module).some((name) => new RegExp(`(?<![\\w$.])${name.replace(/\$/g, "\\$")}\\s*\\(`).test(code)));
 }
-function moduleScopeOf(routePath) {
-  return /^(.*?)(?:src\/)?(?:app|pages)\/api\//.exec(routePathOf(routePath))?.[1] ?? "";
+function exportedNames(file) {
+  const names = noiseMaskedOf(file).matchAll(
+    /\bexport\s+(?:async\s+)?(?:function\s*\*?\s*|const\s+|let\s+|var\s+)([A-Za-z_$][\w$]*)/g
+  );
+  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);
@@ -2587,40 +3517,200 @@ 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 [
         moduleKey(`${prefix}${target.key}`),
-        moduleKey(`${prefix}src/${target.key}`)
+        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 = moduleScopeOf(route.path);
-  const queue = importedModules(route, 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() };
+  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++) {
+      if (code.startsWith("return", i) && !/[\w$]/.test(code[i - 1] ?? "") && !/[\w$]/.test(code[i + 6] ?? "")) {
+        at = i;
+        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 });
+  }
+  const unguarded = new Set(unguardedOperations(
+    file,
+    candidates.map((candidate) => ({ index: candidate.at, writes: false })).sort((a, b) => a.index - b.index)
+  ).map((hit) => hit.index));
+  for (const candidate of candidates) {
+    if (unguarded.has(candidate.at)) 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, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  const key = `${file.path}\0${name}`;
+  if (depth >= 8 || seen.has(key)) return null;
+  seen.add(key);
+  const definitions = guardDefinitions(file);
+  const direct = definitions.exports.get(name);
+  if (direct) return direct;
+  const bindings = bindingsOf(file);
+  const exported = bindings.exports.find((binding) => binding.local === name);
+  const follow = (spec, imported) => {
+    const target = bindingModule(spec, file, allFiles, scope);
+    return target ? exportedGuard(target, imported, allFiles, scope, depth + 1, seen) : null;
+  };
+  if (exported) {
+    if (exported.spec) return follow(exported.spec, exported.imported);
+    const local = definitions.locals.get(exported.imported);
+    if (local) return local;
+    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;
+}
+function indirectGuardOperations(route, allFiles) {
+  const names = /* @__PURE__ */ new Map();
+  const code = noiseMaskedOf(route.file);
+  for (const binding of bindingsOf(route.file).imports) {
+    if (!binding.spec) continue;
+    const name = namePattern([binding.local]);
+    if (new RegExp(`\\b(?:const|let|var|function|class)\\s+${name}(?![\\w$])|[({,]\\s*${name}\\s*[,}):=]|(?<![\\w$])${name}\\s*=>`).test(code)) continue;
+    const target = bindingModule(binding.spec, route.file, allFiles, route.scope);
+    const definition = target ? exportedGuard(target, binding.imported, allFiles, route.scope) : null;
+    if (definition) names.set(binding.local, definition);
+  }
+  const protectedOps = /* @__PURE__ */ new Map();
+  if (names.size === 0) return protectedOps;
+  unguardedOperations(route.file, unguardedOpsOf(route.file), {
+    guards: new Set([...names].filter(([, definition]) => !definition.wrapper).map(([name]) => name)),
+    wrappers: new Set([...names].filter(([, definition]) => definition.wrapper).map(([name]) => name)),
+    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;
@@ -2663,20 +3753,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;
@@ -2710,14 +3809,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;
@@ -2730,18 +3829,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);
@@ -2755,13 +3877,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) {
@@ -2852,11 +3989,12 @@ 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 = extractMatcherConfig(mw);
+  const { config, readable } = compiledMatchersOf(mw);
   if (config.kind === "absent") return true;
   if (config.kind === "unreadable") {
     ctx.reportIncomplete(
@@ -2865,11 +4003,40 @@ function middlewareCovers(ctx, routePath, url) {
     );
     return true;
   }
-  const parsed = config.patterns.map(matcherToRegex);
-  const readable = parsed.filter((re) => re !== null);
+  if (config.patterns.length === 0) return false;
   if (readable.length === 0) return true;
   return readable.some((re) => re.test(url));
 }
+var matcherCache = /* @__PURE__ */ new WeakMap();
+function compiledMatchersOf(file) {
+  const cached = matcherCache.get(file);
+  if (cached !== void 0) return cached;
+  const config = extractMatcherConfig(file);
+  const readable = config.kind === "patterns" ? config.patterns.map(matcherToRegex).filter((re) => re !== null) : [];
+  const compiled = { config, readable };
+  matcherCache.set(file, compiled);
+  return compiled;
+}
+function globalGuardFor(ctx, route) {
+  const relative3 = (file) => file.path.startsWith(route.scope) ? file.path.slice(route.scope.length) : null;
+  const candidates = ctx.files.filter((file) => {
+    const path = relative3(file);
+    if (path === null) return false;
+    if (route.framework === "sveltekit") return /^src\/hooks\.server\.[mc]?[jt]s$/.test(path);
+    if (route.framework === "nuxt") return /^server\/middleware\/.+\.[mc]?[jt]s$/.test(path);
+    return false;
+  });
+  return candidates.find(containsAuthCheck)?.path ?? null;
+}
+var authCheckCache = /* @__PURE__ */ new WeakMap();
+function containsAuthCheck(file) {
+  const cached = authCheckCache.get(file);
+  if (cached !== void 0) return cached;
+  const code = noiseMaskedOf(file);
+  const found = AUTH_ENFORCING_CALL.test(code) || containsConditionalAuthCheck(code);
+  authCheckCache.set(file, found);
+  return found;
+}
 var SECRET_SHAPED = /['"`]([A-Za-z0-9_\-.]{32,})['"`]/g;
 function excerptFor(file, line) {
   const raw = (file.lines[line - 1] ?? "").trim();
@@ -2885,9 +4052,12 @@ var apiAuthRule = {
   id: "api/db-access-without-auth",
   severity: "P0",
   check(ctx) {
-    const routes = ctx.files.filter((f) => isApiRoute(f.path));
+    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) {
@@ -2900,29 +4070,54 @@ 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, findDataOps(route));
+      const reachable = route.reachable;
+      let ops = unguardedOpsOf(route.file).filter((op) => reachable === void 0 || op.index > reachable.start && op.index < reachable.end);
       if (ops.length === 0) continue;
-      const url = routeUrl(route.path);
-      if (isAuthEndpoint(url)) continue;
-      if (middlewareCovers(ctx, route.path, url)) continue;
+      let indirectOps = indirectByFile.get(route.file);
+      if (!indirectOps) {
+        indirectOps = indirectGuardOperations(route, ctx.files);
+        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") && 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.content), hit.index);
-      const excerpt = excerptFor(route, line);
+      const indirect = indirectOps.get(hit.index);
+      const line = lineNumberAt(lineStartsCached(route.file), hit.index);
+      const excerpt = excerptFor(route.file, line);
+      const indirectEvidence = indirect ? [{
+        kind: "auth-helper",
+        file: indirect.file.path,
+        line: indirect.line,
+        description: "Local authentication helper recognized through imports; verify its 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);
         findings.push({
           ruleId: "api/admin-db-access-without-auth",
+          ...trace,
+          evidence: [...trace.evidence ?? [], ...indirectEvidence],
           severity: "P0",
-          // 管理员客户端缺少鉴权时使用确定置信度。
-          confidence: "certain",
-          title: `Anyone can call ${url} and it queries your database as admin`,
-          file: route.path,
+          // 管理员客户端缺少鉴权时使用确定置信度；可能受全局鉴权覆盖时降为疑似。
+          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.`
           ],
@@ -2944,12 +4139,20 @@ var apiAuthRule = {
           severity: "P1",
           // 公开写入可能是业务设计，保留疑似置信度。
           confidence: "likely",
-          title: `${url} writes to your database with no sign-in check`,
-          file: route.path,
+          // 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: [
-            `This route changes data, and the scan did not recognize an authentication guard before the operation. Indirect guards and runtime controls require manual verification.`,
+            ...globalNote,
+            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.`
           ],
@@ -2992,7 +4195,7 @@ function headerExpression(content, start) {
   return content.slice(start, end);
 }
 var CORS_ORIGIN_OPTION = /\borigin\s*:\s*/gi;
-var CORS_ORIGIN_PROPERTY_START = /\borigin\s*:\s*(?:async\s+)?(?:(function)\s*(?:[A-Za-z_$][\w$]*)?\s*)?\(/gi;
+var CORS_ORIGIN_PROPERTY_START = /\borigin\s*:\s*(?:async\s+)?(?:(function)\s*(?:[A-Za-z_$][\w$]*\s*)?)?\(/gi;
 var CORS_ORIGIN_METHOD_START = /\borigin\s*\(/gi;
 function closingParameterList(source, open) {
   let depth = 0;
@@ -3114,8 +4317,14 @@ function callbackAnswer(params, body) {
 var ORIGIN_IS_CHECKED = /\bincludes\s*\(|\bindexOf\s*\(|===|!==|==|!=|\.test\s*\(|\.some\s*\(|\bstartsWith\s*\(|\.match\s*\(|\.has\s*\(|\bif\b|\?|\ballow(?:ed|list)?\b|\bwhitelist\b/i;
 var ACAC_HEADER = /['"]Access-Control-Allow-Credentials['"][\s\S]{0,40}?\btrue\b/gi;
 var CORS_CREDENTIALS_OPTION = /\bcredentials\s*:\s*true\b/g;
+var TRAILING_PUNCTUATION = /[\s;,)}\]!]/;
+function trimTrailingPunctuation(text) {
+  let end = text.length;
+  while (end > 0 && TRAILING_PUNCTUATION.test(text[end - 1])) end--;
+  return text.slice(0, end);
+}
 function classifyOrigin(raw) {
-  let v = raw.trim().replace(/[\s;,)}\]!]+$/, "");
+  let v = trimTrailingPunctuation(raw.trim());
   const opening = v[0];
   if (opening === '"' || opening === "'" || opening === "`") {
     const close = v.indexOf(opening, 1);
@@ -3218,21 +4427,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",
@@ -3248,9 +4473,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;
@@ -3319,6 +4552,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}`)
@@ -3384,6 +4619,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) } : {}
   }));
@@ -3552,6 +4796,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`;
 }
@@ -3611,12 +4858,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) {
@@ -3658,6 +4907,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}`);
@@ -3712,6 +4966,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`))}`
@@ -3732,9 +4988,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")}`);
@@ -3871,8 +5127,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");
 }
@@ -3883,6 +5143,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.`,
@@ -3946,7 +5207,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.");
@@ -3980,6 +5241,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}
@@ -3990,14 +5252,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>`;
@@ -4010,7 +5273,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>
@@ -4020,7 +5283,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>
@@ -4123,6 +5386,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
@@ -4268,6 +5532,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) {
@@ -4345,7 +5610,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) {
@@ -4408,7 +5684,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 } : {}
   };
 }
 
@@ -4510,15 +5787,15 @@ var RULE_CATALOG = [
     "Admin database access without a recognized auth guard",
     "P0",
     "certain",
-    "Next.js App/Pages API handlers, including workspace applications.",
-    "Syntactic guards only; runtime authentication and business authorization are not verified."
+    "Server routes and Next.js Server Functions in Next.js, SvelteKit (endpoints and form actions), Nuxt, Remix/React Router, and Astro, including workspace applications.",
+    "Syntactic guards only; runtime authentication and business authorization are not verified. Local auth imports/re-exports (up to eight hops), SvelteKit hooks and Nuxt middleware may lower confidence, without removing findings."
   ),
   rule(
     "api/db-write-without-auth",
     "Database write without a recognized auth guard",
     "P1",
     "likely",
-    "Next.js App/Pages API handlers.",
+    "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(
@@ -4558,7 +5835,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(
@@ -4566,7 +5843,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(
@@ -4593,6 +5870,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",
@@ -4624,8 +5917,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.1" : "0.0.0-dev";
+var VERSION = true ? "0.4.0" : "0.0.0-dev";
 function finish(code) {
   process.exitCode = code;
 }
@@ -4694,10 +6032,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);
@@ -4815,6 +6159,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
 
@@ -4863,6 +6209,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;
@@ -4955,10 +6305,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,
@@ -5065,13 +6418,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))}