xploitscan-shared-rules 1.2.1 → 1.3.0

package/dist/index.js

@@ -10,11 +10,381 @@ function getSnippet(content, line, contextLines = 2) {
   }).join("\n");
 }
 
+// src/ast/parse.ts
+import { parse } from "@babel/parser";
+var MAX_CACHE = 256;
+var cache = /* @__PURE__ */ new Map();
+function cacheKey(filename, contentHash) {
+  return `${filename}:${contentHash}`;
+}
+function quickHash(s) {
+  let h = 5381;
+  const step = Math.max(1, Math.floor(s.length / 32));
+  for (let i = 0; i < s.length; i += step) {
+    h = (h << 5) + h + s.charCodeAt(i) | 0;
+  }
+  return h * 31 + s.length | 0;
+}
+function pickLanguage(filename) {
+  if (/\.tsx$/i.test(filename)) return "tsx";
+  if (/\.jsx$/i.test(filename)) return "jsx";
+  if (/\.(ts|cts|mts)$/i.test(filename)) return "ts";
+  if (/\.(js|cjs|mjs)$/i.test(filename)) return "js";
+  return null;
+}
+function parseFile(content, filename) {
+  const lang = pickLanguage(filename);
+  if (!lang) return null;
+  if (!content || content.length === 0) return null;
+  const key = cacheKey(filename, quickHash(content));
+  if (cache.has(key)) return cache.get(key) ?? null;
+  const plugins = [];
+  if (lang === "ts" || lang === "tsx") plugins.push("typescript");
+  if (lang === "jsx" || lang === "tsx") plugins.push("jsx");
+  plugins.push("decorators-legacy", "classProperties", "dynamicImport", "topLevelAwait");
+  let ast = null;
+  try {
+    ast = parse(content, {
+      sourceType: "unambiguous",
+      allowImportExportEverywhere: true,
+      allowReturnOutsideFunction: true,
+      allowAwaitOutsideFunction: true,
+      allowUndeclaredExports: true,
+      errorRecovery: true,
+      plugins
+    });
+  } catch {
+    cache.set(key, null);
+    if (cache.size > MAX_CACHE) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey !== void 0) cache.delete(firstKey);
+    }
+    return null;
+  }
+  const entry = { ast, language: lang };
+  cache.set(key, entry);
+  if (cache.size > MAX_CACHE) {
+    const firstKey = cache.keys().next().value;
+    if (firstKey !== void 0) cache.delete(firstKey);
+  }
+  return entry;
+}
+
+// src/ast/taint.ts
+import _traverse from "@babel/traverse";
+var traverse = typeof _traverse === "function" ? _traverse : _traverse.default;
+var TAINTED_PROP_SUFFIXES = /* @__PURE__ */ new Set([
+  "body",
+  "query",
+  "params",
+  "headers",
+  "cookies",
+  "queryStringParameters",
+  "pathParameters",
+  "rawBody",
+  "searchParams"
+]);
+var TAINTED_REQUEST_OBJECTS = /* @__PURE__ */ new Set([
+  "req",
+  "request",
+  "ctx",
+  // Koa
+  "context",
+  // Koa alt
+  "event"
+  // Lambda
+]);
+function buildTaintMap(parsed) {
+  const tainted = /* @__PURE__ */ new Set();
+  function reachesRequestIdent(node) {
+    if (!node) return false;
+    if (node.type === "Identifier") return TAINTED_REQUEST_OBJECTS.has(node.name);
+    if (node.type === "MemberExpression") {
+      if (node.property.type === "Identifier" && node.property.name === "request" && node.object.type === "Identifier" && TAINTED_REQUEST_OBJECTS.has(node.object.name)) {
+        return true;
+      }
+      return reachesRequestIdent(node.object);
+    }
+    return false;
+  }
+  function nodeIsTaintedSource(node) {
+    if (!node) return false;
+    if (node.type === "MemberExpression") {
+      const prop = node.property;
+      const propName = prop.type === "Identifier" ? prop.name : prop.type === "StringLiteral" ? prop.value : "";
+      if (TAINTED_PROP_SUFFIXES.has(propName)) {
+        const obj = node.object;
+        if (obj.type === "Identifier" && TAINTED_REQUEST_OBJECTS.has(obj.name)) {
+          return true;
+        }
+        if (reachesRequestIdent(obj)) return true;
+        if (nodeIsTaintedSource(obj)) return true;
+      }
+      if (node.object.type === "Identifier" && node.object.name === "process" && prop.type === "Identifier" && prop.name === "argv") {
+        return true;
+      }
+      if (nodeIsTaintedSource(node.object)) return true;
+      return false;
+    }
+    if (node.type === "CallExpression") {
+      const callee = node.callee;
+      if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "get" && nodeIsTaintedSource(callee.object)) {
+        return true;
+      }
+      const BODY_READERS = /* @__PURE__ */ new Set(["json", "formData", "text", "arrayBuffer", "blob"]);
+      if (callee.type === "MemberExpression" && callee.property.type === "Identifier" && BODY_READERS.has(callee.property.name)) {
+        const obj = callee.object;
+        if (obj.type === "Identifier" && TAINTED_REQUEST_OBJECTS.has(obj.name)) {
+          return true;
+        }
+        if (reachesRequestIdent(obj)) return true;
+      }
+    }
+    if (node.type === "AwaitExpression") {
+      return nodeIsTaintedSource(node.argument);
+    }
+    return false;
+  }
+  function exprIsTainted(node) {
+    if (!node) return false;
+    if (nodeIsTaintedSource(node)) return true;
+    if (node.type === "Identifier") return tainted.has(node.name);
+    if (node.type === "TemplateLiteral") {
+      return node.expressions.some((e) => exprIsTainted(e));
+    }
+    if (node.type === "BinaryExpression" && node.operator === "+") {
+      return exprIsTainted(node.left) || exprIsTainted(node.right);
+    }
+    if (node.type === "LogicalExpression" && (node.operator === "||" || node.operator === "??")) {
+      return exprIsTainted(node.left) || exprIsTainted(node.right);
+    }
+    if (node.type === "ConditionalExpression") {
+      return exprIsTainted(node.consequent) || exprIsTainted(node.alternate);
+    }
+    if (node.type === "MemberExpression") {
+      return exprIsTainted(node.object);
+    }
+    if (node.type === "CallExpression") {
+      if (nodeIsTaintedSource(node)) return true;
+      if (node.callee.type === "MemberExpression") {
+        if (exprIsTainted(node.callee.object)) return true;
+        const obj = node.callee.object;
+        const prop = node.callee.property;
+        if (prop.type === "Identifier" && obj.type === "Identifier" && obj.name === "path" && ["join", "resolve", "normalize", "format", "parse", "relative"].includes(prop.name)) {
+          return node.arguments.some((a) => a.type !== "SpreadElement" && exprIsTainted(a));
+        }
+        if (prop.type === "Identifier" && obj.type === "Identifier" && obj.name === "Buffer" && ["from", "concat", "alloc", "allocUnsafe"].includes(prop.name)) {
+          return node.arguments.some((a) => a.type !== "SpreadElement" && exprIsTainted(a));
+        }
+      }
+      if (node.callee.type === "Identifier") {
+        if (["String", "Number", "Boolean", "URL", "URLSearchParams"].includes(node.callee.name)) {
+          return node.arguments.some((a) => a.type !== "SpreadElement" && exprIsTainted(a));
+        }
+      }
+    }
+    if (node.type === "AwaitExpression") {
+      return exprIsTainted(node.argument);
+    }
+    return false;
+  }
+  traverse(parsed.ast, {
+    VariableDeclarator(path) {
+      const node = path.node;
+      if (node.type !== "VariableDeclarator") return;
+      const init = node.init;
+      if (!init) return;
+      if (node.id.type === "Identifier") {
+        if (exprIsTainted(init)) {
+          tainted.add(node.id.name);
+        }
+      }
+      if (node.id.type === "ObjectPattern") {
+        const isTainted2 = nodeIsTaintedSource(init) || init.type === "Identifier" && tainted.has(init.name);
+        if (isTainted2) {
+          for (const prop of node.id.properties) {
+            if (prop.type === "ObjectProperty") {
+              if (prop.value.type === "Identifier") tainted.add(prop.value.name);
+            } else if (prop.type === "RestElement") {
+              if (prop.argument.type === "Identifier") tainted.add(prop.argument.name);
+            }
+          }
+        }
+      }
+    },
+    AssignmentExpression(path) {
+      const node = path.node;
+      if (node.type !== "AssignmentExpression") return;
+      if (node.operator !== "=" && node.operator !== "||=" && node.operator !== "??=") return;
+      if (node.left.type !== "Identifier") return;
+      if (exprIsTainted(node.right)) {
+        tainted.add(node.left.name);
+      }
+    }
+  });
+  const isTainted = (node) => {
+    if (!node) return false;
+    if (node.type === "Identifier") return tainted.has(node.name);
+    if (nodeIsTaintedSource(node)) return true;
+    if (node.type === "TemplateLiteral") {
+      return node.expressions.some((e) => isTainted(e));
+    }
+    if (node.type === "BinaryExpression" && node.operator === "+") {
+      return isTainted(node.left) || isTainted(node.right);
+    }
+    if (node.type === "LogicalExpression" && (node.operator === "||" || node.operator === "??" || node.operator === "&&")) {
+      return isTainted(node.left) || isTainted(node.right);
+    }
+    if (node.type === "ConditionalExpression") {
+      return isTainted(node.consequent) || isTainted(node.alternate);
+    }
+    if (node.type === "AwaitExpression") {
+      return isTainted(node.argument);
+    }
+    if (node.type === "MemberExpression") {
+      return isTainted(node.object);
+    }
+    if (node.type === "CallExpression") {
+      if (node.callee.type === "MemberExpression") {
+        if (isTainted(node.callee.object)) return true;
+        const obj = node.callee.object;
+        const prop = node.callee.property;
+        if (prop.type === "Identifier" && obj.type === "Identifier" && obj.name === "path" && ["join", "resolve", "normalize", "format", "relative", "parse"].includes(prop.name)) {
+          return node.arguments.some((a) => a.type !== "SpreadElement" && isTainted(a));
+        }
+        if (prop.type === "Identifier" && obj.type === "Identifier" && obj.name === "Buffer" && ["from", "concat", "alloc", "allocUnsafe"].includes(prop.name)) {
+          return node.arguments.some((a) => a.type !== "SpreadElement" && isTainted(a));
+        }
+      }
+      if (node.callee.type === "Identifier") {
+        if (["String", "Number", "Boolean", "URL", "URLSearchParams"].includes(node.callee.name)) {
+          return node.arguments.some((a) => a.type !== "SpreadElement" && isTainted(a));
+        }
+      }
+    }
+    return false;
+  };
+  return {
+    isTainted,
+    isTaintedIdent: (name) => tainted.has(name),
+    taintedNames: () => Array.from(tainted)
+  };
+}
+
+// src/ast/traverse.ts
+import _traverse2 from "@babel/traverse";
+var traverse2 = typeof _traverse2 === "function" ? _traverse2 : _traverse2.default;
+function visitBinary(parsed, visit) {
+  traverse2(parsed.ast, {
+    BinaryExpression(path) {
+      const line = path.node.loc?.start.line ?? 1;
+      visit(path.node, line);
+    }
+  });
+}
+function visitCalls(parsed, matchCallee, visit) {
+  traverse2(parsed.ast, {
+    CallExpression(path) {
+      const node = path.node;
+      if (!matchCallee(node.callee)) return;
+      const line = node.loc?.start.line ?? 1;
+      visit(node, line);
+    }
+  });
+}
+function isCalleeNamed(callee, name) {
+  if (callee.type === "Identifier") return callee.name === name;
+  if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+    return callee.property.name === name;
+  }
+  if (callee.type === "OptionalMemberExpression" && callee.property.type === "Identifier") {
+    return callee.property.name === name;
+  }
+  return false;
+}
+function isMethodCall(callee, objName, methodName) {
+  if (callee.type !== "MemberExpression" && callee.type !== "OptionalMemberExpression") {
+    return false;
+  }
+  if (callee.property.type !== "Identifier") return false;
+  if (callee.property.name !== methodName) return false;
+  if (callee.object.type !== "Identifier") return false;
+  return callee.object.name === objName;
+}
+function getObjectProperty(node, key) {
+  for (const prop of node.properties) {
+    if (prop.type === "ObjectProperty") {
+      if (prop.key.type === "Identifier" && prop.key.name === key) {
+        return { value: prop.value };
+      }
+      if (prop.key.type === "StringLiteral" && prop.key.value === key) {
+        return { value: prop.value };
+      }
+    }
+  }
+  return null;
+}
+function callSpreads(call, matcher) {
+  for (const arg of call.arguments) {
+    if (arg.type === "SpreadElement") {
+      if (matcher(arg.argument)) return true;
+    }
+    if (arg.type === "ObjectExpression") {
+      for (const prop of arg.properties) {
+        if (prop.type === "SpreadElement") {
+          if (matcher(prop.argument)) return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
 // src/rules.ts
 var TEST_FILE_PATTERN = /(?:\.test\.|\.spec\.|__tests__|__mocks__|\.stories\.|\.story\.|\/test\/|\/tests\/|\/fixtures?\/|\/mocks?\/|\.mock\.|test-utils|testing|\.cy\.|\.e2e\.)/i;
 function isTestFile(filePath) {
   return TEST_FILE_PATTERN.test(filePath);
 }
+var SERVER_SIDE_PATH_RE = new RegExp(
+  [
+    // Directory-style anchors — match with OR without leading slash so
+    // relative paths (`routes/users.js`) work as well as absolute.
+    "(?:^|/)api/",
+    "(?:^|/)routes?/",
+    "(?:^|/)controllers?/",
+    "(?:^|/)endpoints?/",
+    "(?:^|/)handlers?/",
+    "(?:^|/)middleware/",
+    "(?:^|/)webhooks?/",
+    "(?:^|/)services?/",
+    "(?:^|/)lambda/",
+    "(?:^|/)functions?/",
+    "(?:^|/)pages/api/",
+    "(?:^|/)app/.*/route\\.(?:m?[jt]sx?|cjs)$",
+    // Bare-filename anchors (with or without leading directory).
+    // Allows compound names like webhook-handler.js, cron-runner.js,
+    // user-service.ts via the optional (?:[-_]\w+)* suffix group.
+    "(?:^|/)(?:api|routes?|controllers?|endpoints?|handlers?|middleware|webhooks?|services?|server|app|index|main|lambda|function|ingest|runner|worker|resolvers?)(?:[-_]\\w+)*\\.(?:m?[jt]sx?|cjs|py|rb|go)$",
+    // Common functional names that imply request handling.
+    "(?:^|/)(?:auth|login|logout|signup|signin|register|password|reset|callback|oauth|admin|dashboard|profile|account|checkout|payment|webhook|audit|cron|search|upload|download|errors?|create-?\\w*|update-?\\w*|delete-?\\w*)(?:[-_]\\w+)*\\.(?:m?[jt]sx?|cjs|py|rb|go)$"
+  ].join("|"),
+  "i"
+);
+function isServerSideFile(filePath) {
+  if (isTestFile(filePath)) return false;
+  return SERVER_SIDE_PATH_RE.test(filePath);
+}
+var CONFIG_FILE_PATTERN = new RegExp(
+  [
+    "\\.config\\.(?:m?[jt]sx?|cjs)$",
+    "(?:^|/)config\\.(?:m?[jt]sx?|cjs|py|rb|json|ya?ml)$",
+    "(?:^|/)settings\\.(?:m?[jt]sx?|cjs|py)$",
+    "(?:^|/)\\.env(?:\\.|$)",
+    "(?:^|/)(?:knex|drizzle|next|vite|rollup|webpack|tailwind|postcss|jest|vitest|tsup|babel)\\.config\\.(?:m?[jt]sx?|cjs)$",
+    "(?:^|/)(?:db|database|connection|pool)\\.(?:config\\.)?(?:m?[jt]sx?|cjs|py|rb)$"
+  ].join("|"),
+  "i"
+);
 function isCommentLine(content, matchIndex) {
   const lineStart = content.lastIndexOf("\n", matchIndex - 1) + 1;
   const lineText = content.substring(lineStart, content.indexOf("\n", matchIndex)).trimStart();
@@ -23,7 +393,7 @@ function isCommentLine(content, matchIndex) {
 function isInsideFixMessage(content, matchIndex) {
   const lineStart = content.lastIndexOf("\n", matchIndex - 1) + 1;
   const lineText = content.substring(lineStart, content.indexOf("\n", matchIndex));
-  return /(?:fix|description|message|suggestion|hint|help|example|doc|comment)\s*[:=(]/i.test(lineText) || /return\s*["'`].*(?:Use|Replace|Add|Move|Set|Enable|Disable|Never|Don't|Do not|Instead)/i.test(lineText);
+  return /(?:fix|description|message|suggestion|hint|help|example|doc|comment)\s*[:=(]/i.test(lineText) || /return\s*["'`].*\b(?:Use|Replace|Add|Move|Set|Enable|Disable|Never|Don't|Do not|Instead)\b/i.test(lineText);
 }
 function findMatches(content, pattern, rule, filePath, fixTemplate) {
   const matches = [];
@@ -47,6 +417,23 @@ function findMatches(content, pattern, rule, filePath, fixTemplate) {
   }
   return matches;
 }
+function astMatch(content, filePath, line, rule, fix) {
+  return {
+    rule: rule.id,
+    title: rule.title,
+    severity: rule.severity,
+    category: rule.category,
+    file: filePath,
+    line,
+    snippet: getSnippet(content, line),
+    fix
+  };
+}
+function tryParse(content, filePath) {
+  const parsed = parseFile(content, filePath);
+  if (!parsed) return null;
+  return { parsed, taint: buildTaintMap(parsed) };
+}
 var hardcodedSecrets = {
   id: "VC001",
   title: "Hardcoded API Key or Secret",
@@ -70,6 +457,17 @@ var hardcodedSecrets = {
       /sk-[a-zA-Z0-9]{20,}T3BlbkFJ[a-zA-Z0-9]{20,}/g,
       // Generic tokens in assignments — require standalone word and longer min length
       /(?:^|[\s,({])(?:token|secret|password|passwd|pwd)\s*[:=]\s*["'`]([a-zA-Z0-9_\-!@#$%^&*]{20,})["'`]/gim,
+      // SCREAMING_CASE identifiers ending in SECRET/TOKEN/KEY/PASSWORD
+      // (OAUTH_CLIENT_SECRET, JWT_PRIVATE_KEY, STRIPE_WEBHOOK_SECRET, etc.)
+      // that are assigned a string literal, not an env var or function call.
+      /[A-Z][A-Z0-9_]*_(?:SECRET|TOKEN|KEY|PASSWORD|PASSWD)\s*[:=]\s*["'`]([a-zA-Z0-9_\-!@#$%^&*.\/]{12,})["'`]/g,
+      // camelCase / snake_case object properties that look like credentials:
+      // apiKey: "...", webhookUrl: "https://...", accountSid: "...", authToken: "..."
+      // password: "..." caught here separately with a lower threshold (many
+      // real passwords are 8-16 chars, below the 12-char floor of the
+      // generic `secret = "..."` pattern).
+      /\b(?:apiKey|api_key|authToken|auth_token|webhookUrl|webhook_url|accountSid|account_sid|clientSecret|client_secret|refreshToken|refresh_token)\s*:\s*["'`]([a-zA-Z0-9_\-!@#$%^&*.\/:\-]{12,})["'`]/gi,
+      /\b(?:password|passwd|pwd)\s*:\s*["'`]([a-zA-Z0-9_\-!@#$%^&*.\/:\-]{8,})["'`]/gi,
       // Private keys
       /-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----/g,
       // Database URLs with credentials
@@ -82,19 +480,49 @@ var hardcodedSecrets = {
       "Supabase key detected. Service role keys bypass Row Level Security and grant full database read/write access. Move to a server-side environment variable immediately.",
       "OpenAI API key detected \u2014 grants full API access and can incur charges. Rotate at platform.openai.com \u2192 API Keys.",
       "Hardcoded token or password detected. Move to an environment variable and rotate the credential if it has been committed to version control.",
+      "Named secret constant detected (XXX_SECRET / XXX_TOKEN / XXX_KEY). Move to an environment variable: `const NAME = process.env.NAME;`. Rotate the credential if this file has been committed to version control.",
+      "Credential assigned to a config object property. Move to an environment variable \u2014 `apiKey: process.env.API_KEY` \u2014 and rotate the value if this file has been committed.",
+      "Hardcoded password detected in a config object. Move to an environment variable (`password: process.env.DB_PASSWORD`) and rotate the password if this file has been committed.",
       "Private key found in source code. If this has been committed to version control, consider the key compromised \u2014 generate a new key pair and revoke the old one.",
       "Database credentials in connection string. An attacker with this URL has full database access. Move to an environment variable, restrict network access, and rotate the password."
     ];
+    const minLen = [
+      12,
+      // [0] generic API key
+      16,
+      // [1] AWS — already rigid in the regex, length floor is defensive
+      20,
+      // [2] Stripe
+      50,
+      // [3] Supabase JWT
+      40,
+      // [4] OpenAI
+      20,
+      // [5] generic tokens with {20,} in the regex
+      12,
+      // [6] SCREAMING_CASE named constants
+      12,
+      // [7] camelCase config props (apiKey/webhookUrl/etc.)
+      8,
+      // [8] password: "..." — lower floor per the pattern comment above
+      0,
+      // [9] private keys — no length check
+      0
+      // [10] DB URLs — no length check
+    ];
     const matches = [];
     for (let pi = 0; pi < patterns.length; pi++) {
       const pattern = patterns[pi];
       const rawMatches = findMatches(content, pattern, hardcodedSecrets, filePath, () => fixMessages[pi]);
+      const floor = minLen[pi] ?? 12;
       for (const rm of rawMatches) {
         const lineText = content.split("\n")[rm.line - 1] || "";
         const trimmed = lineText.trimStart();
         if (trimmed.startsWith("//") || trimmed.startsWith("#")) continue;
-        const secretMatch = lineText.match(/[:=]\s*["'`]([^"'`]*)["'`]/);
-        if (secretMatch && secretMatch[1].length < 12) continue;
+        if (floor > 0) {
+          const secretMatch = lineText.match(/[:=]\s*["'`]([^"'`]*)["'`]/);
+          if (secretMatch && secretMatch[1].length < floor) continue;
+        }
         matches.push(rm);
       }
     }
@@ -130,8 +558,7 @@ var missingAuthMiddleware = {
   category: "Authentication",
   description: "API routes without authentication checks allow unauthorized access.",
   check(content, filePath) {
-    const isApiRoute = /(?:\/api\/|routes?\/|controllers?\/|endpoints?\/)/.test(filePath) || filePath.includes("server.");
-    if (!isApiRoute) return [];
+    if (!isServerSideFile(filePath)) return [];
     const routePatterns = [
       // Express/Hono style
       /\.(get|post|put|patch|delete)\s*\(\s*["'`][^"'`]+["'`]\s*,\s*(?:async\s+)?\(?(?:req|c|ctx)/gi,
@@ -144,35 +571,36 @@ var missingAuthMiddleware = {
     if (isAuthRoute) return [];
     const isWebhookRoute = /\/webhook/i.test(filePath);
     if (isWebhookRoute) return [];
+    const codeOnly = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1").replace(/^\s*#.*$/gm, "");
     const authPatterns = [
-      /auth/i,
-      /session/i,
-      /jwt/i,
-      /bearer/i,
-      /middleware/i,
-      /getUser/i,
-      /currentUser/i,
-      /isAuthenticated/i,
-      /requireAuth/i,
-      /requireUser/i,
-      /requireUserForApi/i,
-      /clerk/i,
+      /\bgetUser\b/i,
+      /\bcurrentUser\b/i,
+      /\bisAuthenticated\b/i,
+      /\brequireAuth\b/i,
+      /\brequireUser\b/i,
+      /\brequireUserForApi\b/i,
+      /\bwithAuth\b/i,
+      /\bgetServerSession\b/i,
+      /\bgetToken\b/i,
+      /\bverifyToken\b/i,
+      /\bvalidateToken\b/i,
+      /\bcheckApiKey\b/i,
+      /\bverifyCronSecret\b/i,
+      /\bverifySecret\b/i,
       /supabase\.auth/i,
-      /getServerSession/i,
-      /getToken/i,
-      /protect/i,
-      /guard/i,
-      /verifyToken/i,
-      /validateToken/i,
-      /withAuth/i,
-      /passport/i,
       /firebase\.auth/i,
-      /cognito/i,
-      /verifyCronSecret/i,
-      /verifySecret/i,
-      /checkApiKey/i
+      /\bclerk\b/i,
+      /\bpassport\b/i,
+      /\bcognito\b/i,
+      /\bauth\(\)/i,
+      /req\.user\b/i,
+      /req\.session\.\w+/i,
+      /\bjwt\.verify\b/i,
+      /\bbearer\s/i,
+      /\b(?:protect|guard)\(/i,
+      /\.use\([^)]*(?:auth|session|protect|requireAuth)/i
     ];
-    const hasAuth = authPatterns.some((p) => p.test(content));
+    const hasAuth = authPatterns.some((p) => p.test(codeOnly));
     if (hasAuth) return [];
     const matches = [];
     for (const pattern of routePatterns) {
@@ -347,6 +775,37 @@ var xssVulnerability = {
         matches.push(m);
       }
     }
+    if (!/\.(?:send|end|write)\s*\(/.test(content) || !/\$\{/.test(content)) {
+      return matches;
+    }
+    const ctx = tryParse(content, filePath);
+    if (!ctx) return matches;
+    const { parsed, taint } = ctx;
+    visitCalls(
+      parsed,
+      (callee) => {
+        if (callee.type !== "MemberExpression") return false;
+        if (callee.property.type !== "Identifier") return false;
+        return ["send", "end", "write"].includes(callee.property.name);
+      },
+      (call, line) => {
+        const first = call.arguments[0];
+        if (!first || first.type !== "TemplateLiteral") return;
+        const literalParts = first.quasis.map((q) => q.value.raw).join("");
+        if (!/<\/?\w+/.test(literalParts)) return;
+        if (!taint.isTainted(first)) return;
+        if (matches.some((m) => m.line === line)) return;
+        matches.push(
+          astMatch(
+            content,
+            filePath,
+            line,
+            xssVulnerability,
+            "Never echo user-supplied HTML back to the browser unescaped. Sanitize with DOMPurify, use a templating engine that auto-escapes, or set `res.type('text/plain')` if you never intended HTML."
+          )
+        );
+      }
+    );
     return matches;
   }
 };
@@ -800,7 +1259,7 @@ var prototypePollution = {
   title: "Prototype Pollution Risk",
   severity: "high",
   category: "Injection",
-  description: "Parsing JSON from localStorage, URL params, or external sources and merging it into objects without validation can lead to prototype pollution, allowing attackers to inject __proto__ or constructor properties.",
+  description: "Deep-merging or Object.assign-ing attacker-controlled data (request bodies, parsed localStorage, query params) into a host object can pollute Object.prototype via keys like __proto__ and constructor.prototype.",
   check(content, filePath) {
     const matches = [];
     const storageParsePatterns = [
@@ -808,26 +1267,70 @@ var prototypePollution = {
       /JSON\.parse\s*\(\s*window\.localStorage/g
     ];
     const hasValidation = /schema|validate|sanitize|whitelist|allowedKeys|pick\(|Object\.freeze|zod|yup|joi|ajv/i.test(content);
-    if (hasValidation) return [];
-    const hasUnsafeMerge = /Object\.assign\s*\([^)]*JSON\.parse|\.\.\.JSON\.parse|\{.*\.\.\.(?:stored|saved|cached|parsed|data)/i.test(content);
-    if (hasUnsafeMerge) {
-      matches.push(...findMatches(
-        content,
-        /Object\.assign\s*\([^)]*JSON\.parse|\.\.\.JSON\.parse/g,
-        prototypePollution,
-        filePath,
-        () => "Validate parsed data against an expected schema before merging into objects. Use Object.freeze(), a validation library (Zod, Yup), or manually check for __proto__ and constructor keys."
-      ));
-    }
-    for (const p of storageParsePatterns) {
-      matches.push(...findMatches(
-        content,
-        p,
-        prototypePollution,
-        filePath,
-        () => "Validate localStorage data against an expected schema before using it. Malicious extensions or XSS can modify localStorage values."
-      ));
+    if (!hasValidation) {
+      const hasUnsafeMerge = /Object\.assign\s*\([^)]*JSON\.parse|\.\.\.JSON\.parse|\{.*\.\.\.(?:stored|saved|cached|parsed|data)/i.test(content);
+      if (hasUnsafeMerge) {
+        matches.push(...findMatches(
+          content,
+          /Object\.assign\s*\([^)]*JSON\.parse|\.\.\.JSON\.parse/g,
+          prototypePollution,
+          filePath,
+          () => "Validate parsed data against an expected schema before merging into objects. Use Object.freeze(), a validation library (Zod, Yup), or manually check for __proto__ and constructor keys."
+        ));
+      }
+      for (const p of storageParsePatterns) {
+        matches.push(...findMatches(
+          content,
+          p,
+          prototypePollution,
+          filePath,
+          () => "Validate localStorage data against an expected schema before using it. Malicious extensions or XSS can modify localStorage values."
+        ));
+      }
     }
+    if (!/\b(?:merge|assign|extend|defaults)\s*\(/.test(content)) return matches;
+    const ctx = tryParse(content, filePath);
+    if (!ctx) return matches;
+    const { parsed, taint } = ctx;
+    const ALL_ARG_SINKS = [
+      { obj: "_", method: "merge" },
+      { obj: "lodash", method: "merge" },
+      { method: "merge" },
+      // bare `merge(target, src)` from ESM import
+      { obj: "_", method: "defaultsDeep" },
+      { obj: "lodash", method: "defaultsDeep" },
+      { obj: "Object", method: "assign" },
+      { method: "extend" },
+      // jquery/underscore style
+      { obj: "$", method: "extend" }
+    ];
+    visitCalls(
+      parsed,
+      (callee) => {
+        for (const sink of ALL_ARG_SINKS) {
+          if (sink.obj && isMethodCall(callee, sink.obj, sink.method)) return true;
+          if (!sink.obj && isCalleeNamed(callee, sink.method)) return true;
+        }
+        return false;
+      },
+      (call, line) => {
+        const sources = call.arguments.slice(1);
+        const tainted = sources.some((arg) => {
+          if (arg.type === "SpreadElement") return taint.isTainted(arg.argument);
+          return taint.isTainted(arg);
+        });
+        if (!tainted) return;
+        matches.push(
+          astMatch(
+            content,
+            filePath,
+            line,
+            prototypePollution,
+            "Filter __proto__, constructor, and prototype keys before merging user-supplied data into an object. Prefer lodash.mergeWith() with a customizer that returns undefined for those keys, or validate the source with a schema library (Zod, Yup, Joi, Ajv) first."
+          )
+        );
+      }
+    );
     return matches;
   }
 };
@@ -860,13 +1363,13 @@ var unsanitizedFilenames = {
   description: "Using user-supplied filenames without sanitization in file operations can enable path traversal, overwriting system files, or executing commands via special characters.",
   check(content, filePath) {
     const matches = [];
+    const hasSanitization = /sanitize|cleanFilename|safeFilename|replace\s*\(\s*\/\[.*\]\/|\.startsWith\s*\(\s*(?:UPLOADS_DIR|\w+_DIR)/i.test(content);
+    if (hasSanitization) return [];
     const patterns = [
       /(?:writeFile|writeFileSync|createWriteStream|rename|copyFile)\s*\(\s*(?:`[^`]*\$\{|[^"'`\s,]+\s*\+)/g,
       /(?:dialog\.showSaveDialog|saveDialog).*(?:defaultPath|fileName)\s*:\s*(?!["'`])/g,
       /\.download\s*=\s*(?!["'`])/g
     ];
-    const hasSanitization = /sanitize|cleanFilename|safeFilename|replace\s*\(\s*\/\[.*\]\//i.test(content);
-    if (hasSanitization) return [];
     for (const p of patterns) {
       matches.push(...findMatches(
         content,
@@ -876,6 +1379,61 @@ var unsanitizedFilenames = {
         () => "Sanitize filenames before use: strip path separators (/ \\), special chars, and '..' sequences. Example: name.replace(/[^a-zA-Z0-9._-]/g, '_')"
       ));
     }
+    if (!/\b(?:fs|fsPromises)\.(?:readFile|writeFile|appendFile|readFileSync|writeFileSync|appendFileSync|createReadStream|createWriteStream|unlink|unlinkSync|stat|statSync|rm|rmSync|mkdir|mkdirSync)\s*\(/.test(content)) {
+      return matches;
+    }
+    const ctx = tryParse(content, filePath);
+    if (!ctx) return matches;
+    const { parsed, taint } = ctx;
+    const FS_SINKS = /* @__PURE__ */ new Set([
+      "readFile",
+      "writeFile",
+      "appendFile",
+      "readFileSync",
+      "writeFileSync",
+      "appendFileSync",
+      "createReadStream",
+      "createWriteStream",
+      "unlink",
+      "unlinkSync",
+      "rm",
+      "rmSync",
+      "stat",
+      "statSync",
+      "mkdir",
+      "mkdirSync"
+    ]);
+    const isFsReceiver = (obj) => {
+      if (obj.type === "Identifier") return obj.name === "fs" || obj.name === "fsPromises";
+      if (obj.type === "MemberExpression") {
+        return obj.object.type === "Identifier" && obj.object.name === "fs" && obj.property.type === "Identifier" && obj.property.name === "promises";
+      }
+      return false;
+    };
+    visitCalls(
+      parsed,
+      (callee) => {
+        if (callee.type !== "MemberExpression") return false;
+        if (callee.property.type !== "Identifier") return false;
+        if (!FS_SINKS.has(callee.property.name)) return false;
+        return isFsReceiver(callee.object);
+      },
+      (call, line) => {
+        const first = call.arguments[0];
+        if (!first || first.type === "SpreadElement") return;
+        if (!taint.isTainted(first)) return;
+        if (matches.some((m) => m.line === line)) return;
+        matches.push(
+          astMatch(
+            content,
+            filePath,
+            line,
+            unsanitizedFilenames,
+            "Resolve the path against a fixed base directory and verify it stays within that base before the fs call: `const target = path.resolve(BASE, req.body.name); if (!target.startsWith(BASE + path.sep)) throw new Error('path traversal');`"
+          )
+        );
+      }
+    );
     return matches;
   }
 };
@@ -1026,8 +1584,9 @@ var insecureDeserialization = {
       /unserialize\s*\(/g,
       // Ruby Marshal
       /Marshal\.load\s*\(/g,
-      // YAML unsafe load (Python)
-      /yaml\.load\s*\([^)]*(?!Loader\s*=\s*yaml\.SafeLoader)/g,
+      // YAML unsafe load (Python + js-yaml). Filtered below so safe schema
+      // arguments (SAFE_SCHEMA, FAILSAFE_SCHEMA, yaml.SafeLoader) don't FP.
+      /yaml\.load\s*\(/g,
       /yaml\.unsafe_load\s*\(/g,
       // Java ObjectInputStream
       /ObjectInputStream\s*\(/g,
@@ -1043,7 +1602,20 @@ var insecureDeserialization = {
         () => "Never deserialize untrusted data. Use JSON instead of pickle/Marshal/unserialize. For YAML, use yaml.safe_load(). Validate and sanitize all input before deserialization."
       ));
     }
-    return matches;
+    return matches.filter((m) => {
+      if (!/yaml\.load\s*\(/.test(m.snippet ?? "")) return true;
+      const lineText = (m.snippet ?? "").toLowerCase();
+      if (/safe_schema|failsafe_schema|safe_load|safeloader/.test(lineText)) {
+        return false;
+      }
+      const lineIdx = m.line - 1;
+      const lines = content.split("\n");
+      const ctx = lines.slice(lineIdx, lineIdx + 3).join("\n").toLowerCase();
+      if (/safe_schema|failsafe_schema|safe_load|safeloader/.test(ctx)) {
+        return false;
+      }
+      return true;
+    });
   }
 };
 var hardcodedJWTSecret = {
@@ -1121,7 +1693,12 @@ var exposedDebugMode = {
       /app\.debug\s*=\s*True/g,
       /app\.run\s*\([^)]*debug\s*=\s*True/g,
       // Source maps in production
-      /devtool\s*:\s*["'`](?:eval|cheap|source-map|inline-source-map)["'`]/g
+      /devtool\s*:\s*["'`](?:eval|cheap|source-map|inline-source-map)["'`]/g,
+      // Debug endpoints that leak environment / process internals in the
+      // response body. Very high-signal — a production service shouldn't
+      // serialize process.env or process.version to callers.
+      /res\.(?:json|send)\s*\([^)]*process\.(?:env|version|pid|arch|platform)/gi,
+      /(?:env|environment)\s*:\s*process\.env\b/gi
     ];
     for (const p of patterns) {
       matches.push(...findMatches(
@@ -1159,6 +1736,21 @@ var insecureRandomness = {
       if (nonSecurityVarNames.test(lineText)) continue;
       matches.push(rm);
     }
+    const SECURITY_FN_CONTEXT = /\b(?:function|def|async|const|let|var)\s+\w*(?:generate|create|make|new|mint|issue)[A-Z_]\w*(?:Token|Session|Nonce|Salt|Secret|Password|Otp|Csrf|Key|Code|Auth)\w*/i;
+    const SECURITY_IDENT_CONTEXT = /\b(?:session[_-]?token|csrf[_-]?token|reset[_-]?token|verify[_-]?code|otp[_-]?code|refresh[_-]?token|api[_-]?key)\b/i;
+    if (SECURITY_FN_CONTEXT.test(content) || SECURITY_IDENT_CONTEXT.test(content)) {
+      const raw = findMatches(
+        content,
+        /Math\.random\s*\(\s*\)/g,
+        insecureRandomness,
+        filePath,
+        () => "Math.random() is not cryptographically secure. Use crypto.randomBytes() (Node), crypto.getRandomValues() (browser), or crypto.randomUUID() for tokens, session IDs, salts, and similar values."
+      );
+      for (const m of raw) {
+        if (matches.some((existing) => existing.line === m.line)) continue;
+        matches.push(m);
+      }
+    }
     return matches;
   }
 };
@@ -1170,13 +1762,13 @@ var openRedirectParams = {
   description: "Redirect parameters like ?redirect_url=, ?return_to=, ?next= passed directly to redirects enable phishing attacks.",
   check(content, filePath) {
     const matches = [];
+    const codeOnly = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+    const hasValidation = /allowed[_-]?(?:urls?|domains?|hosts?|paths?|routes?|list)|allow[_-]?list|valid[_-]?url|safe[_-]?domain|whitelist|startsWith.*https|new URL.*hostname/i.test(codeOnly);
+    if (hasValidation) return [];
     const patterns = [
-      // Reading redirect-like query params and using in redirect
       /(?:redirect_url|redirect_uri|return_to|return_url|next|callback_url|continue|goto|target|dest|destination|forward|redir)\s*(?:=|:)\s*(?:req\.query|req\.params|searchParams|query|params)\./gi,
       /redirect\s*\(\s*(?:req\.query|req\.params|searchParams\.get)\s*\(\s*["'`](?:redirect|return|next|callback|url|goto)/gi
     ];
-    const hasValidation = /allowedUrls|allowedDomains|allowedHosts|validUrl|safeDomain|whitelist|startsWith.*https|new URL.*hostname/i.test(content);
-    if (hasValidation) return [];
     for (const p of patterns) {
       matches.push(...findMatches(
         content,
@@ -1186,6 +1778,29 @@ var openRedirectParams = {
         () => "Validate redirect URLs against an allowlist of trusted domains. Use: const url = new URL(input); if (!ALLOWED_HOSTS.includes(url.hostname)) reject."
       ));
     }
+    if (!/\.redirect\s*\(/.test(content)) return matches;
+    const ctx = tryParse(content, filePath);
+    if (!ctx) return matches;
+    const { parsed, taint } = ctx;
+    visitCalls(
+      parsed,
+      (callee) => isCalleeNamed(callee, "redirect"),
+      (call, line) => {
+        const first = call.arguments[0];
+        if (!first || first.type === "SpreadElement") return;
+        if (!taint.isTainted(first)) return;
+        if (matches.some((m) => m.line === line)) return;
+        matches.push(
+          astMatch(
+            content,
+            filePath,
+            line,
+            openRedirectParams,
+            "Validate redirect targets against an allowlist before calling res.redirect(). `const ALLOWED = new Set(['/dashboard', '/settings']); if (!ALLOWED.has(next)) return res.redirect('/dashboard');`"
+          )
+        );
+      }
+    );
     return matches;
   }
 };
@@ -1228,8 +1843,7 @@ var exposedStackTraces = {
   category: "Information Leakage",
   description: "Returning error.stack or detailed error messages in API responses reveals internal code paths, file structure, and dependencies to attackers.",
   check(content, filePath) {
-    const isApiFile = /(?:\/api\/|routes?\/|controllers?\/|server\.|middleware)/i.test(filePath);
-    if (!isApiFile) return [];
+    if (!isServerSideFile(filePath)) return [];
     const matches = [];
     const patterns = [
       // Sending stack trace in response
@@ -1260,9 +1874,10 @@ var insecureFileUpload = {
   description: "File uploads validated only by extension (not MIME type or content) allow attackers to upload executable files disguised as images or documents.",
   check(content, filePath) {
     if (!/upload|multer|formidable|busboy|multipart/i.test(content)) return [];
+    const codeOnly = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1").replace(/^\s*#.*$/gm, "");
     const matches = [];
-    const hasExtCheck = /\.(?:endsWith|match|test)\s*\([^)]*(?:\.jpg|\.png|\.pdf|\.doc|ext)/i.test(content);
-    const hasMimeCheck = /mimetype|content-type|file\.type|mime|magic\.detect|file-type/i.test(content);
+    const hasExtCheck = /\.(?:endsWith|match|test)\s*\([^)]*(?:\.jpg|\.png|\.pdf|\.doc|ext)/i.test(codeOnly) || /\/\\\.\((?:\?:)?[a-z]{2,5}(?:\|[a-z]{2,5})+\)/i.test(codeOnly);
+    const hasMimeCheck = /\bmimetype\b|\bcontent-type\b|\bfile\.type\b|\bmime\.\w|\bmagic\.detect\b|\bfile-type\b|fileTypeFromBuffer/i.test(codeOnly);
     if (hasExtCheck && !hasMimeCheck) {
       matches.push(...findMatches(
         content,
@@ -1326,34 +1941,53 @@ var ssrfVulnerability = {
   category: "Injection",
   description: "Fetching URLs from user input without validation allows attackers to access internal services, cloud metadata endpoints (169.254.169.254), and private networks.",
   check(content, filePath) {
-    if (isTestFile(filePath)) return [];
-    const isServerFile = /(?:\/api\/|routes?\/|controllers?\/|server\.|handler|middleware)/i.test(filePath);
-    if (!isServerFile) return [];
+    if (!isServerSideFile(filePath)) return [];
     const matches = [];
-    const patterns = [
-      /(?:fetch|axios\.get|axios\.post|axios|got|request|http\.get|https\.get)\s*\(\s*(?:req\.(?:body|query|params))\./gi
-    ];
     const hasValidation = /allowedHosts|allowedDomains|allowedUrls|safeDomain|whitelist|urlValidator|new URL.*hostname.*includes|isAllowedUrl|validateUrl|isValidUrl/i.test(content);
     if (hasValidation) return [];
-    for (const p of patterns) {
-      const rawMatches = findMatches(
-        content,
-        p,
-        ssrfVulnerability,
-        filePath,
-        () => "Validate URLs against an allowlist before fetching. Block internal IPs: 127.0.0.1, 10.x, 172.16-31.x, 192.168.x, 169.254.169.254 (cloud metadata). Use: const url = new URL(input); if (!ALLOWED_HOSTS.includes(url.hostname)) throw new Error('Blocked');"
-      );
-      for (const rm of rawMatches) {
-        const lineText = content.split("\n")[rm.line - 1] || "";
-        const varMatch = lineText.match(/(?:fetch|axios\.\w+|got|request|https?\.get)\s*\(\s*(\w+)/);
-        if (varMatch) {
-          const varName = varMatch[1];
-          const constDef = new RegExp(`const\\s+${varName}\\s*=\\s*["'\`]https?://`, "i");
-          if (constDef.test(content)) continue;
+    const inlinePattern = /(?:fetch|axios\.get|axios\.post|axios|got|request|http\.get|https\.get)\s*\(\s*(?:req\.(?:body|query|params))\./gi;
+    matches.push(...findMatches(
+      content,
+      inlinePattern,
+      ssrfVulnerability,
+      filePath,
+      () => "Validate URLs against an allowlist before fetching. Block internal IPs: 127.0.0.1, 10.x, 172.16-31.x, 192.168.x, 169.254.169.254 (cloud metadata). Use: const url = new URL(input); if (!ALLOWED_HOSTS.includes(url.hostname)) throw new Error('Blocked');"
+    ));
+    if (!/\b(?:fetch|axios|got|request|http\.get|https\.get)\b/.test(content)) return matches;
+    const ctx = tryParse(content, filePath);
+    if (!ctx) return matches;
+    const { parsed, taint } = ctx;
+    const FETCH_CALLEES = /* @__PURE__ */ new Set(["fetch", "axios", "got", "request"]);
+    const FETCH_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "request"]);
+    visitCalls(
+      parsed,
+      (callee) => {
+        if (callee.type === "Identifier" && FETCH_CALLEES.has(callee.name)) return true;
+        if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+          if (!FETCH_METHODS.has(callee.property.name)) return false;
+          const obj = callee.object;
+          if (obj.type === "Identifier") {
+            return obj.name === "axios" || obj.name === "got" || obj.name === "http" || obj.name === "https";
+          }
         }
-        matches.push(rm);
+        return false;
+      },
+      (call, line) => {
+        const first = call.arguments[0];
+        if (!first || first.type === "SpreadElement") return;
+        if (!taint.isTainted(first)) return;
+        if (matches.some((m) => m.line === line)) return;
+        matches.push(
+          astMatch(
+            content,
+            filePath,
+            line,
+            ssrfVulnerability,
+            "Validate URLs against an allowlist before fetching. Parse the URL, check the hostname against a static set, and block internal IPs (127.0.0.1, 10.x, 172.16-31.x, 192.168.x, 169.254.169.254)."
+          )
+        );
       }
-    }
+    );
     return matches;
   }
 };
@@ -1364,19 +1998,15 @@ var massAssignment = {
   category: "Authorization",
   description: "Spreading or assigning request body directly into database models allows attackers to set fields they shouldn't (e.g., isAdmin, role, verified).",
   check(content, filePath) {
-    const isApiFile = /(?:\/api\/|routes?\/|controllers?\/|server\.|handler)/i.test(filePath);
-    if (!isApiFile) return [];
+    if (!isServerSideFile(filePath)) return [];
+    const hasSanitization = /pick\(|omit\(|allowedFields|sanitize|whitelist|permit|strong_params/i.test(content);
+    if (hasSanitization) return [];
     const matches = [];
     const patterns = [
-      // Object.assign(model, req.body)
       /Object\.assign\s*\(\s*(?:user|account|profile|record|doc|model|entity)[^,]*,\s*(?:req\.body|body|input|data)\s*\)/gi,
-      // Spread req.body into create/update
       /(?:create|update|insert|save|findOneAndUpdate|updateOne|upsert)\s*\(\s*\{[^}]*\.\.\.(?:req\.body|body|input|data)/gi,
-      // Direct req.body into DB
       /(?:create|insert|save)\s*\(\s*(?:req\.body|body)\s*\)/gi
     ];
-    const hasSanitization = /pick\(|omit\(|allowedFields|sanitize|whitelist|permit|strong_params/i.test(content);
-    if (hasSanitization) return [];
     for (const p of patterns) {
       matches.push(...findMatches(
         content,
@@ -1386,6 +2016,61 @@ var massAssignment = {
         () => "Never pass req.body directly to database operations. Explicitly pick allowed fields: const { name, email } = req.body; await db.create({ name, email });"
       ));
     }
+    const ORM_METHOD_PREFIXES = [
+      "create",
+      "insert",
+      "save",
+      "update",
+      "upsert",
+      "patch",
+      "bulkCreate",
+      "bulkInsert",
+      "bulkUpsert",
+      "findOneAndUpdate",
+      "findByIdAndUpdate",
+      "findAndUpdate",
+      "build",
+      "merge",
+      "replace"
+    ];
+    const isOrmMethod = (name) => ORM_METHOD_PREFIXES.some((p) => name === p || name.startsWith(p));
+    if (!/\b(?:create|insert|save|update|upsert|patch|bulk|findOneAndUpdate|findByIdAndUpdate|findAndUpdate|build|merge|replace)\w*\s*\(/.test(content)) {
+      return matches;
+    }
+    const ctx = tryParse(content, filePath);
+    if (!ctx) return matches;
+    const { parsed, taint } = ctx;
+    visitCalls(
+      parsed,
+      (callee) => {
+        if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+          return isOrmMethod(callee.property.name);
+        }
+        return false;
+      },
+      (call, line) => {
+        const tainted = call.arguments.some((arg) => {
+          if (arg.type === "SpreadElement") return taint.isTainted(arg.argument);
+          if (arg.type === "ObjectExpression") {
+            return arg.properties.some(
+              (p) => p.type === "SpreadElement" && taint.isTainted(p.argument)
+            );
+          }
+          return taint.isTainted(arg);
+        });
+        if (!tainted) return;
+        if (matches.some((m) => m.line === line)) return;
+        matches.push(
+          astMatch(
+            content,
+            filePath,
+            line,
+            massAssignment,
+            "Pick allowed fields explicitly instead of spreading the request body. `User.create({ email: req.body.email, name: req.body.name })` rather than `User.create({ ...req.body })`."
+          )
+        );
+      }
+    );
     return matches;
   }
 };
@@ -1398,12 +2083,12 @@ var timingAttack = {
   check(content, filePath) {
     if (isTestFile(filePath)) return [];
     const matches = [];
+    const hasTimingSafe = /timingSafeEqual|constantTimeEqual|safeCompare|secureCompare/i.test(content);
+    if (hasTimingSafe) return [];
     const patterns = [
       /(?:token|secret|hash|digest|signature|hmac|apiKey|api_key)\s*(?:===|!==)\s*(?:req\.|body\.|params\.|query\.|input)/gi,
       /(?:^|[^.\w])(?:req\.|body\.|params\.|query\.|input)[\w.]*(?:token|secret|hash|digest|signature|hmac)\s*(?:===|!==)/gim
     ];
-    const hasTimingSafe = /timingSafeEqual|constantTimeEqual|safeCompare|secureCompare/i.test(content);
-    if (hasTimingSafe) return [];
     for (const p of patterns) {
       const raw = findMatches(
         content,
@@ -1418,6 +2103,43 @@ var timingAttack = {
         matches.push(m);
       }
     }
+    if (!/===|!==/.test(content)) return matches;
+    const ctx = tryParse(content, filePath);
+    if (!ctx) return matches;
+    const SECRET_NAME_RE = /(?:secret|token|api[_-]?key|auth[_-]?key|jwt[_-]?secret|signature|hmac|password|passwd|pwd_hash|pwd_digest|digest)/i;
+    function looksLikeSecret(node) {
+      if (node.type === "Identifier") return SECRET_NAME_RE.test(node.name);
+      if (node.type === "MemberExpression") {
+        if (node.property.type === "Identifier" && SECRET_NAME_RE.test(node.property.name)) return true;
+        if (node.property.type === "StringLiteral" && SECRET_NAME_RE.test(node.property.value)) return true;
+        return looksLikeSecret(node.object);
+      }
+      return false;
+    }
+    visitBinary(ctx.parsed, (n, line) => {
+      if (n.operator !== "===" && n.operator !== "!==" && n.operator !== "==" && n.operator !== "!=") {
+        return;
+      }
+      if (n.left.type === "UnaryExpression" && n.left.operator === "typeof") return;
+      if (n.right.type === "UnaryExpression" && n.right.operator === "typeof") return;
+      const leftSecret = looksLikeSecret(n.left);
+      const rightSecret = looksLikeSecret(n.right);
+      if (!leftSecret && !rightSecret) return;
+      const otherSide = leftSecret ? n.right : n.left;
+      if (otherSide.type === "StringLiteral" || otherSide.type === "NumericLiteral" || otherSide.type === "NullLiteral" || otherSide.type === "BooleanLiteral") {
+        return;
+      }
+      if (matches.some((m) => m.line === line)) return;
+      matches.push(
+        astMatch(
+          content,
+          filePath,
+          line,
+          timingAttack,
+          "Compare secrets with crypto.timingSafeEqual() after a length check. === short-circuits on the first differing byte and leaks information via timing."
+        )
+      );
+    });
     return matches;
   }
 };
@@ -1428,16 +2150,14 @@ var logInjection = {
   category: "Injection",
   description: "Logging unsanitized user input allows attackers to forge log entries, inject malicious content, or exploit log aggregation systems via newlines and special characters.",
   check(content, filePath) {
-    if (filePath.includes("test") || filePath.includes("mock")) return [];
-    const isServerFile = /(?:\/api\/|routes?\/|controllers?\/|server\.|middleware|handler)/i.test(filePath);
-    if (!isServerFile) return [];
+    if (!isServerSideFile(filePath)) return [];
+    const hasSanitization = /replace\s*\(\s*\/\[?\\r\\n\]|sanitizeLog|stripNewlines|sanitizeForLog/i.test(content);
+    if (hasSanitization) return [];
     const matches = [];
     const patterns = [
       /console\.(?:log|warn|error|info)\s*\([^)]*(?:req\.body|req\.query|req\.params|req\.headers)\s*\)/gi,
       /(?:logger|log)\.(?:info|warn|error|debug)\s*\([^)]*(?:req\.body|req\.query|req\.params)\s*\)/gi
     ];
-    const hasSanitization = /sanitize|escape|JSON\.stringify|replace.*\\n/i.test(content);
-    if (hasSanitization) return [];
     for (const p of patterns) {
       matches.push(...findMatches(
         content,
@@ -1447,6 +2167,41 @@ var logInjection = {
         () => "Sanitize user input before logging: strip newlines and control characters. Use JSON.stringify() or a structured logger (e.g., pino, winston) that escapes values automatically."
       ));
     }
+    if (!/(?:console\.|logger\.|log\.)\s*\w+\s*\(/.test(content)) return matches;
+    const ctx = tryParse(content, filePath);
+    if (!ctx) return matches;
+    const { parsed, taint } = ctx;
+    const LOG_METHODS = /* @__PURE__ */ new Set(["log", "warn", "error", "info", "debug", "trace"]);
+    visitCalls(
+      parsed,
+      (callee) => {
+        if (callee.type !== "MemberExpression") return false;
+        if (callee.property.type !== "Identifier") return false;
+        if (!LOG_METHODS.has(callee.property.name)) return false;
+        const obj = callee.object;
+        if (obj.type === "Identifier") {
+          return obj.name === "console" || obj.name === "logger" || obj.name === "log";
+        }
+        return false;
+      },
+      (call, line) => {
+        const tainted = call.arguments.some((arg) => {
+          if (arg.type === "SpreadElement") return taint.isTainted(arg.argument);
+          return taint.isTainted(arg);
+        });
+        if (!tainted) return;
+        if (matches.some((m) => m.line === line)) return;
+        matches.push(
+          astMatch(
+            content,
+            filePath,
+            line,
+            logInjection,
+            "Strip newlines/control chars before embedding user input in a log line. `value.replace(/[\\r\\n]/g, ' ')` for quick fix; a structured logger escapes values automatically."
+          )
+        );
+      }
+    );
     return matches;
   }
 };
@@ -1459,7 +2214,33 @@ var weakPasswordRequirements = {
   check(content, filePath) {
     if (isTestFile(filePath)) return [];
     if (!/(?:password|passwd|pwd)/i.test(content)) return [];
-    if (!/(?:register|signup|sign.up|createUser|create.user|changePassword|resetPassword|set.password)/i.test(content) && !/(?:\/api\/|routes?\/|controllers?\/)/i.test(filePath)) return [];
+    const isPasswordContext = /(?:register|signup|sign.up|createUser|create.user|changePassword|resetPassword|set.password|validatePassword|validate.password|passwordPolicy|password.policy)/i.test(
+      content
+    ) || isServerSideFile(filePath);
+    const matches = [];
+    if (isPasswordContext) {
+      const weakThresholdPatterns = [
+        // password.length < 4, password.length < 6, etc.
+        /(?:password|pwd|passwd)\s*\.length\s*<\s*[1-7]\b/gi,
+        /(?:password|pwd|passwd)\s*\.length\s*<=\s*[0-6]\b/gi,
+        // password.length >= 4, password.length >= 6 (min length set too low)
+        /(?:password|pwd|passwd)\s*\.length\s*>=\s*[1-7]\b/gi,
+        /(?:password|pwd|passwd)\s*\.length\s*>\s*[0-6]\b/gi,
+        // Python: len(password) < 8 with a low threshold
+        /len\s*\(\s*(?:password|pwd|passwd)\s*\)\s*<\s*[1-7]\b/gi
+      ];
+      for (const p of weakThresholdPatterns) {
+        matches.push(...findMatches(
+          content,
+          p,
+          weakPasswordRequirements,
+          filePath,
+          () => "Minimum password length is too low. Require at least 8 characters with complexity (upper+lower+digit+symbol) or 12+ characters without complexity. OWASP ASVS L1 requires 8+; NIST 800-63B recommends 12+."
+        ));
+      }
+      if (matches.length > 0) return matches;
+    }
+    if (!isPasswordContext) return [];
     const hasValidation = /(?:password|pwd).*(?:\.length|minLength|minlength|min_length)\s*(?:>=?|<|>)\s*\d|(?:password|pwd).*(?:match|test|regex|pattern)|zxcvbn|password-validator|passwordStrength|isStrongPassword|joi\.|yup\.|zod\.|validate|schema/i.test(content);
     if (hasValidation) return [];
     const hasPasswordHandling = /(?:password|pwd)\s*[:=]\s*(?:req\.body|body|input|params|args)\./i.test(content);
@@ -1492,7 +2273,8 @@ var sessionFixation = {
     if (isTestFile(filePath)) return [];
     if (!/(?:login|signin|sign.in|authenticate)/i.test(content)) return [];
     if (!/session/i.test(content)) return [];
-    const hasRegenerate = /regenerate|destroy.*create|req\.session\.id\s*=|session\.regenerateId|rotateSession|clearCookies/i.test(content);
+    const codeOnly = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+    const hasRegenerate = /regenerate|destroy.*create|req\.session\.id\s*=|session\.regenerateId|rotateSession|clearCookies/i.test(codeOnly);
     if (hasRegenerate) return [];
     const hasLogin = /(?:function\s+(?:login|signin|authenticate)|(?:login|signin|authenticate)\s*(?:=\s*(?:async\s*)?\(|:\s*(?:async\s*)?\())/i.test(content);
     if (!hasLogin) return [];
@@ -1515,7 +2297,8 @@ var missingBruteForce = {
     const isLoginFile = /(?:login|signin|sign.in|auth)/i.test(filePath) || /(?:login|signin|authenticate).*(?:post|handler|route)/i.test(content);
     if (!isLoginFile) return [];
     if (!/(?:password|credential)/i.test(content)) return [];
-    const hasBruteForce = /rate.?limit|throttle|lockout|maxAttempts|max_attempts|failedAttempts|loginAttempts|brute|express-brute|express-rate-limit|slowDown/i.test(content);
+    const codeOnly = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1").replace(/^\s*#.*$/gm, "");
+    const hasBruteForce = /rate.?limit|throttle|lockout|maxAttempts|max_attempts|failedAttempts|loginAttempts|express-brute|express-rate-limit|slowDown/i.test(codeOnly);
     if (hasBruteForce) return [];
     return findMatches(
       content,
@@ -1542,7 +2325,10 @@ var nosqlInjection = {
       // $where with user input
       /\$where\s*:\s*(?!["'`])/g,
       // Direct variable in query without sanitization
-      /\.(?:findOne|findById|deleteOne|updateOne|findOneAndUpdate)\s*\(\s*\{[^}]*:\s*(?:req\.(?:body|query|params))\./gi
+      /\.(?:findOne|findById|deleteOne|updateOne|findOneAndUpdate)\s*\(\s*\{[^}]*:\s*(?:req\.(?:body|query|params))\./gi,
+      // findOneAndUpdate / updateOne / deleteOne / find with req.body as
+      // the entire filter (attacker controls the filter shape).
+      /\.(?:findOne|findById|findOneAndUpdate|updateOne|deleteOne|deleteMany|updateMany|replaceOne|find)\s*\(\s*req\.body\s*[,)]/gi
     ];
     const hasSanitization = /sanitize|escape|mongo-sanitize|express-mongo-sanitize|validator|typeof.*===.*string/i.test(content);
     if (hasSanitization) return [];
@@ -1621,7 +2407,7 @@ var graphqlIntrospection = {
   category: "Information Leakage",
   description: "GraphQL introspection exposes your entire API schema, types, queries, and mutations to attackers, making it easy to find attack vectors.",
   check(content, filePath) {
-    if (!/graphql/i.test(content) && !/graphql/i.test(filePath)) return [];
+    if (!/graphql|apollo|ApolloServer|GraphQLServer|createYoga|buildSchema|makeExecutableSchema/i.test(content) && !/graphql|apollo/i.test(filePath)) return [];
     const matches = [];
     if (/introspection\s*:\s*true/i.test(content)) {
       matches.push(...findMatches(
@@ -1760,6 +2546,15 @@ var exposedSourceMaps = {
         () => "Set productionSourceMap: false to avoid exposing source code in production."
       ));
     }
+    if (/productionBrowserSourceMaps\s*:\s*true/i.test(content)) {
+      matches.push(...findMatches(
+        content,
+        /productionBrowserSourceMaps\s*:\s*true/gi,
+        exposedSourceMaps,
+        filePath,
+        () => "Set productionBrowserSourceMaps: false in next.config.js. If you need source maps for error tracking, upload them to your error tracker instead (e.g. Sentry upload-sourcemaps) rather than serving them publicly."
+      ));
+    }
     return matches;
   }
 };
@@ -1885,14 +2680,14 @@ var weakHashing = {
     if (filePath.includes("test") || filePath.includes("mock")) return [];
     if (/bcrypt|scrypt|argon2/i.test(content)) return [];
     const matches = [];
-    const patterns = [
+    const inlinePatterns = [
       /(?:md5|sha1|sha256|sha512)\s*\([^)]*(?:password|passwd|pwd)/gi,
       /createHash\s*\(\s*["'`](?:md5|sha1|sha256)["'`]\).*(?:password|passwd|pwd)/gi,
       /(?:password|passwd|pwd).*createHash\s*\(\s*["'`](?:md5|sha1|sha256)["'`]\)/gi,
       /hashlib\.(?:md5|sha1|sha256)\s*\([^)]*(?:password|passwd|pwd)/gi,
       /Digest::(?:MD5|SHA1|SHA256).*(?:password|passwd|pwd)/gi
     ];
-    for (const p of patterns) {
+    for (const p of inlinePatterns) {
       matches.push(...findMatches(
         content,
         p,
@@ -1901,6 +2696,27 @@ var weakHashing = {
         () => "Use bcrypt, scrypt, or argon2 for password hashing \u2014 they're intentionally slow. Example: const hash = await bcrypt.hash(password, 12);"
       ));
     }
+    const hasPasswordContext = /\b(?:hashPassword|hash_password|verify_password|verifyPassword|password_hash|password_hash_verify|password_hashing)\b/i.test(content) || /\b(?:function|def|async)\s+\w*(?:password|pwd)\w*/i.test(content) || /\bpassword\s*[:=]/i.test(content);
+    if (hasPasswordContext) {
+      const weakCallPatterns = [
+        /createHash\s*\(\s*["'`](?:md5|sha1|sha256)["'`]\s*\)/gi,
+        /hashlib\.(?:md5|sha1|sha256)\s*\(/gi,
+        /Digest::(?:MD5|SHA1|SHA256)\./gi
+      ];
+      for (const p of weakCallPatterns) {
+        const raw = findMatches(
+          content,
+          p,
+          weakHashing,
+          filePath,
+          () => "Use bcrypt, scrypt, or argon2 for password hashing. These algorithms are intentionally slow so brute-force attacks are infeasible."
+        );
+        for (const m of raw) {
+          if (matches.some((existing) => existing.line === m.line)) continue;
+          matches.push(m);
+        }
+      }
+    }
     return matches;
   }
 };
@@ -1983,7 +2799,8 @@ var dangerousInnerHTML = {
     if (!filePath.match(/\.(jsx|tsx)$/)) return [];
     if (isTestFile(filePath)) return [];
     if (!/dangerouslySetInnerHTML/i.test(content)) return [];
-    const hasSanitize = /DOMPurify|sanitize|purify|xss|sanitizeHtml|isomorphic-dompurify/i.test(content);
+    const codeOnly = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1").replace(/\{\s*\/\*[\s\S]*?\*\/\s*\}/g, "");
+    const hasSanitize = /\b(?:DOMPurify|sanitizeHtml|sanitize-html|isomorphic-dompurify)\b|\b(?:sanitize|purify|xss)\s*\(/i.test(codeOnly);
     if (hasSanitize) return [];
     const findings = [];
     const re = /dangerouslySetInnerHTML\s*=\s*\{\s*\{\s*__html\s*:\s*([^}]+)\}/g;
@@ -2271,7 +3088,8 @@ var missingCSRF = {
         () => "Remove @csrf_exempt and use proper CSRF tokens. For APIs, use token-based auth (JWT) instead of session cookies."
       ));
     }
-    if (/MIDDLEWARE.*=.*\[/s.test(content) && !/CsrfViewMiddleware/i.test(content) && /django/i.test(content)) {
+    const pythonCodeOnly = content.replace(/^\s*#.*$/gm, "");
+    if (/MIDDLEWARE.*=.*\[/s.test(pythonCodeOnly) && !/CsrfViewMiddleware/i.test(pythonCodeOnly) && /django/i.test(content)) {
       matches.push(...findMatches(
         content,
         /MIDDLEWARE\s*=/g,
@@ -2290,20 +3108,47 @@ var githubActionsInjection = {
   category: "Injection",
   description: "Using ${{ github.event.* }} directly in 'run:' steps allows attackers to inject shell commands via PR titles, issue bodies, or branch names.",
   check(content, filePath) {
-    if (!filePath.match(/\.github\/workflows\/.*\.(yml|yaml)$/i)) return [];
+    const isWorkflowPath = /\.github\/workflows\/.*\.(ya?ml)$/i.test(filePath);
+    const looksLikeWorkflow = /\.(ya?ml)$/i.test(filePath) && /^\s*on\s*:/m.test(content) && /^\s*jobs\s*:/m.test(content);
+    if (!isWorkflowPath && !looksLikeWorkflow) return [];
     const matches = [];
     const patterns = [
       /run:.*\$\{\{\s*github\.event\.(?:issue|pull_request|comment|review|head_commit)\.(?:title|body|message)/gi,
-      /run:.*\$\{\{\s*github\.event\.(?:inputs|head_ref|base_ref)/gi
+      /run:.*\$\{\{\s*github\.event\.(?:inputs|head_ref|base_ref)/gi,
+      // Literal-block `run: |` with user-controllable interpolation on the
+      // SAME line or a following indented line. Anchored to `run:` (either
+      // on the same line or within the prior few lines before the
+      // interpolation) so `env: TITLE: ${{ github.event.issue.title }}` —
+      // the recommended-fix shape — doesn't false-positive.
+      /(?:^\s*(?:-\s+)?run:\s*\|?\s*\n(?:(?!^\s*(?:[-]\s*)?(?:env|with|id|name|if|timeout-minutes|continue-on-error|shell|working-directory|uses):).+\n){0,20}\s*.*)?\$\{\{\s*github\.event\.(?:issue|pull_request|comment|review|head_commit)\.(?:title|body|message|name)/gmi
     ];
+    const lines = content.split("\n");
+    const isEnvMappingLine = (lineNum) => {
+      const lineText = lines[lineNum - 1] ?? "";
+      if (/^\s*env\s*:/.test(lineText)) return true;
+      const indent = lineText.match(/^(\s*)/)?.[1]?.length ?? 0;
+      if (indent === 0) return false;
+      for (let i = lineNum - 2; i >= 0; i--) {
+        const prev = lines[i] ?? "";
+        if (!prev.trim()) continue;
+        const prevIndent = prev.match(/^(\s*)/)?.[1]?.length ?? 0;
+        if (prevIndent < indent) {
+          return /^\s*env\s*:/.test(prev);
+        }
+      }
+      return false;
+    };
     for (const p of patterns) {
-      matches.push(...findMatches(
+      for (const m of findMatches(
         content,
         p,
         githubActionsInjection,
         filePath,
         () => "Never use ${{ github.event.* }} directly in 'run:'. Pass it as an environment variable: env: TITLE: ${{ github.event.issue.title }} then use $TITLE in the script."
-      ));
+      )) {
+        if (isEnvMappingLine(m.line)) continue;
+        matches.push(m);
+      }
     }
     return matches;
   }
@@ -2351,6 +3196,15 @@ var corsServerless = {
         () => "Replace wildcard CORS with specific origins: allowOrigin: ['https://yourdomain.com']. Wildcard allows any site to call your API."
       ));
     }
+    if (/^\s*origin\s*:\s*['"]\*['"]/m.test(content)) {
+      matches.push(...findMatches(
+        content,
+        /^\s*origin\s*:\s*['"]\*['"]/gim,
+        corsServerless,
+        filePath,
+        () => "Replace the wildcard origin with a concrete allowlist: `origin: https://yourdomain.com` (or an array). Combined with `allowCredentials: true`, wildcard CORS is rejected by the browser; combined with auth headers, it's a data-exfiltration surface."
+      ));
+    }
     return matches;
   }
 };
@@ -2512,27 +3366,55 @@ var xxeVulnerability = {
   category: "Injection",
   description: "XML parsers that process external entities allow attackers to read files, perform SSRF, or cause DoS via billion-laughs attacks.",
   check(content, filePath) {
-    if (!/xml|parseXML|DOMParser|SAXParser|etree|lxml/i.test(content)) return [];
+    if (!/xml|parseXml|parseXML|DOMParser|SAXParser|etree|lxml|libxml/i.test(content)) return [];
     const matches = [];
     const patterns = [
-      /\.parseXML\s*\(/g,
+      /\.parseXm?l\s*\(/gi,
+      // catches parseXml (libxmljs) AND parseXML
       /new\s+DOMParser\s*\(\)/g,
       /etree\.parse\s*\(/g,
       /lxml\.etree/g,
       /SAXParserFactory/g,
       /XMLReaderFactory/g
     ];
-    const hasProtection = /noent.*false|resolveExternals.*false|FEATURE_EXTERNAL.*false|defusedxml|disallow-doctype-decl/i.test(content);
-    if (hasProtection) return [];
-    for (const p of patterns) {
-      matches.push(...findMatches(
-        content,
-        p,
-        xxeVulnerability,
-        filePath,
-        () => "Disable external entities: set noent: false, or use defusedxml (Python). For Java: factory.setFeature('http://apache.org/xml/features/disallow-doctype-decl', true)."
-      ));
+    const hasProtection = /noent\s*:\s*false|resolveExternals\s*:\s*false|FEATURE_EXTERNAL.*false|defusedxml|disallow-doctype-decl|nonet\s*:\s*true/i.test(content);
+    if (!hasProtection) {
+      for (const p of patterns) {
+        matches.push(...findMatches(
+          content,
+          p,
+          xxeVulnerability,
+          filePath,
+          () => "Disable external entities: set noent: false + dtdload: false + nonet: true (libxmljs), or use defusedxml (Python), or factory.setFeature('http://apache.org/xml/features/disallow-doctype-decl', true) (Java)."
+        ));
+      }
     }
+    if (!/parseXml\s*\(/.test(content)) return matches;
+    const ctx = tryParse(content, filePath);
+    if (!ctx) return matches;
+    visitCalls(
+      ctx.parsed,
+      (callee) => isCalleeNamed(callee, "parseXml") || isCalleeNamed(callee, "parseXML"),
+      (call, line) => {
+        const opts = call.arguments[1];
+        if (!opts || opts.type !== "ObjectExpression") return;
+        const noent = getObjectProperty(opts, "noent");
+        const dtdload = getObjectProperty(opts, "dtdload");
+        const external = getObjectProperty(opts, "resolveExternals");
+        const dangerous = noent?.value.type === "BooleanLiteral" && noent.value.value === true || dtdload?.value.type === "BooleanLiteral" && dtdload.value.value === true || external?.value.type === "BooleanLiteral" && external.value.value === true;
+        if (!dangerous) return;
+        if (matches.some((m) => m.line === line)) return;
+        matches.push(
+          astMatch(
+            content,
+            filePath,
+            line,
+            xxeVulnerability,
+            "Set noent: false, dtdload: false, and nonet: true on the parser options to disable external-entity resolution."
+          )
+        );
+      }
+    );
     return matches;
   }
 };
@@ -2561,6 +3443,46 @@ var ssti = {
         () => "Never render templates from user input. Use pre-defined templates and pass data as context variables: render_template('template.html', data=user_data)."
       ));
     }
+    if (!/(?:\.compile|\.render|renderString|render_template_string)\s*\(/.test(content)) {
+      return matches;
+    }
+    const ctx = tryParse(content, filePath);
+    if (!ctx) return matches;
+    const { parsed, taint } = ctx;
+    const SSTI_METHODS = /* @__PURE__ */ new Set([
+      "compile",
+      // Handlebars.compile, pug.compile, _.template (returns a function)
+      "render",
+      // ejs.render, engine.render, mustache.render
+      "renderString",
+      // nunjucks.renderString
+      "render_template_string"
+    ]);
+    visitCalls(
+      parsed,
+      (callee) => {
+        if (callee.type === "Identifier" && SSTI_METHODS.has(callee.name)) return true;
+        if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+          return SSTI_METHODS.has(callee.property.name);
+        }
+        return false;
+      },
+      (call, line) => {
+        const first = call.arguments[0];
+        if (!first || first.type === "SpreadElement") return;
+        if (!taint.isTainted(first)) return;
+        if (matches.some((m) => m.line === line)) return;
+        matches.push(
+          astMatch(
+            content,
+            filePath,
+            line,
+            ssti,
+            "Compile templates from a trusted, static source (a file path or a constant string). Pass user data only as context values."
+          )
+        );
+      }
+    );
     return matches;
   }
 };
@@ -2630,7 +3552,7 @@ var exposedAdminRoutes = {
   category: "Information Leakage",
   description: "Routes like /admin, /debug, /phpinfo, or /actuator without authentication expose sensitive controls and information to attackers.",
   check(content, filePath) {
-    if (!/(?:\/api\/|routes?\/|server\.|app\.|index\.[jt]s)/i.test(filePath)) return [];
+    if (!isServerSideFile(filePath)) return [];
     const matches = [];
     const patterns = [
       /[.'"]\s*(?:get|use|all)\s*\(\s*["'`]\/(?:admin|debug|_debug|__debug__|phpinfo|actuator|graphiql|playground|swagger|reset|seed|test|dev|mock)["'`]/gi
@@ -2697,9 +3619,10 @@ var sensitiveURLParams = {
     if (isTestFile(filePath)) return [];
     const matches = [];
     const patterns = [
-      // Actual code building URLs with sensitive params (template literals or concat)
-      /[&?](?:password|secret|api_key|apiKey|access_token|ssn|credit_card)\s*=\s*\$\{/gi,
-      /[&?](?:password|secret|api_key|apiKey|access_token)\s*=["']\s*\+/gi
+      // Template literals embedding sensitive values in URL query strings
+      /[?&](?:password|passwd|pwd|secret|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|session(?:[_-]?id)?|token|jwt|ssn|credit[_-]?card)\s*=\s*\$\{/gi,
+      // String concat building the same
+      /[?&](?:password|passwd|pwd|secret|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|session(?:[_-]?id)?|token|jwt|ssn|credit[_-]?card)\s*=["']\s*\+/gi
     ];
     for (const p of patterns) {
       matches.push(...findMatches(
@@ -2721,7 +3644,7 @@ var missingContentDisposition = {
   description: "File download endpoints without Content-Disposition headers may render files inline, leading to XSS if the file contains HTML/JS.",
   check(content, filePath) {
     if (!/(?:download|sendFile|send_file|pipe|createReadStream)/i.test(content)) return [];
-    if (!/(?:\/api\/|routes?\/|controllers?\/|server\.|handler)/i.test(filePath)) return [];
+    if (!isServerSideFile(filePath)) return [];
     if (/Content-Disposition|attachment|download/i.test(content)) return [];
     return findMatches(
       content,
@@ -2763,9 +3686,13 @@ var raceCondition = {
     if (filePath.includes("test") || filePath.includes("mock")) return [];
     const matches = [];
     const patterns = [
-      /(?:existsSync|exists)\s*\([^)]+\)[\s\S]{0,50}(?:writeFileSync|writeFile|unlinkSync|unlink|renameSync)\s*\(/g,
-      /os\.path\.exists\s*\([^)]+\)[\s\S]{0,50}open\s*\(/g,
-      /File\.exists\?\s*\([^)]+\)[\s\S]{0,50}File\.(?:write|delete)/g
+      // Check-then-act with writes / deletes / renames
+      /(?:existsSync|exists)\s*\([^)]+\)[\s\S]{0,80}(?:writeFileSync|writeFile|unlinkSync|unlink|renameSync|rename)\s*\(/g,
+      // Check-then-read — also vulnerable: an attacker can swap the symlink
+      // between the exists/stat call and the read.
+      /(?:existsSync|statSync)\s*\([^)]+\)[\s\S]{0,80}(?:readFileSync|readFile|createReadStream)\s*\(/g,
+      /os\.path\.exists\s*\([^)]+\)[\s\S]{0,80}open\s*\(/g,
+      /File\.exists\?\s*\([^)]+\)[\s\S]{0,80}File\.(?:write|delete|read)/g
     ];
     for (const p of patterns) {
       matches.push(...findMatches(
@@ -2814,7 +3741,7 @@ var unprotectedDownload = {
   description: "File download endpoints that accept user-controlled filenames without path validation allow directory traversal to read arbitrary files.",
   check(content, filePath) {
     if (!/(?:download|sendFile|send_file)/i.test(content)) return [];
-    if (!/(?:\/api\/|routes?\/|controllers?\/|server\.|handler)/i.test(filePath)) return [];
+    if (!isServerSideFile(filePath)) return [];
     const matches = [];
     if (/(?:sendFile|download|send_file)\s*\([^)]*(?:req\.|params\.|query\.|body\.)/i.test(content)) {
       const hasValidation = /path\.resolve|path\.normalize|path\.join.*__dirname|realpath|includes\s*\(\s*["']\.\./i.test(content);
@@ -3076,7 +4003,111 @@ var complianceMap = {
   VC155: { owasp: "A04:2021", cwe: "CWE-770" },
   VC156: { owasp: "A04:2021", cwe: "CWE-770" },
   VC157: { owasp: "A05:2021", cwe: "CWE-16" },
-  VC158: { owasp: "A01:2021", cwe: "CWE-639" }
+  VC158: { owasp: "A01:2021", cwe: "CWE-639" },
+  // VC159–VC183: Additional service-specific API key detection.
+  // All map to A07:2021 (Identification & Auth Failures) / CWE-798 (Hardcoded
+  // Credentials), matching the existing VC132–VC145 cluster.
+  VC159: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Cohere
+  VC160: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Replicate
+  VC161: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Mistral
+  VC162: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Together AI
+  VC163: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Groq
+  VC164: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Fireworks AI
+  VC165: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Postmark
+  VC166: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Resend
+  VC167: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Loops
+  VC168: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Cloudflare
+  VC169: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Fastly
+  VC170: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Netlify
+  VC171: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Railway
+  VC172: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Fly.io
+  VC173: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Algolia admin key
+  VC174: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Qdrant
+  VC175: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Weaviate
+  VC176: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Linear
+  VC177: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Notion
+  VC178: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Discord bot token
+  VC179: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Intercom
+  VC180: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Sentry auth token
+  VC181: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Logtail / Better Stack
+  VC182: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Highlight
+  VC183: { owasp: "A07:2021", cwe: "CWE-798" },
+  // Plivo
+  // VC184–VC187: GitHub Actions workflow security
+  VC184: { owasp: "A08:2021", cwe: "CWE-829" },
+  // pull_request_target + checkout PR head
+  VC185: { owasp: "A05:2021", cwe: "CWE-732" },
+  // permissions: write-all
+  VC186: { owasp: "A03:2021", cwe: "CWE-78" },
+  // expression injection in run:
+  VC187: { owasp: "A08:2021", cwe: "CWE-829" },
+  // third-party action receiving secrets
+  // VC188–VC190: Dockerfile hardening
+  VC188: { owasp: "A05:2021", cwe: "CWE-1357" },
+  // ADD instead of COPY
+  VC189: { owasp: "A08:2021", cwe: "CWE-494" },
+  // RUN curl|sh
+  VC190: { owasp: "A04:2021", cwe: "CWE-754" },
+  // missing HEALTHCHECK
+  // VC191–VC197: Python-specific security gaps
+  VC191: { owasp: "A02:2021", cwe: "CWE-295" },
+  // requests verify=False
+  VC192: { owasp: "A03:2021", cwe: "CWE-79" },
+  // Jinja2 autoescape=False
+  VC193: { owasp: "A04:2021", cwe: "CWE-377" },
+  // tempfile.mktemp TOCTOU
+  VC194: { owasp: "A03:2021", cwe: "CWE-79" },
+  // Django mark_safe
+  VC195: { owasp: "A02:2021", cwe: "CWE-295" },
+  // paramiko AutoAddPolicy
+  VC196: { owasp: "A05:2021", cwe: "CWE-20" },
+  // ALLOWED_HOSTS wildcard
+  VC197: { owasp: "A02:2021", cwe: "CWE-347" },
+  // PyJWT no algorithm allowlist
+  // VC198–VC203: AI / LLM-specific security
+  VC198: { owasp: "A03:2021", cwe: "CWE-94" },
+  // prompt injection via user input
+  VC199: { owasp: "A03:2021", cwe: "CWE-94" },
+  // system-prompt injection
+  VC200: { owasp: "A03:2021", cwe: "CWE-79" },
+  // LLM output as raw HTML (XSS)
+  VC201: { owasp: "A01:2021", cwe: "CWE-639" },
+  // vector-store query without user filter
+  VC202: { owasp: "A01:2021", cwe: "CWE-639" },
+  // vector-store upsert without user metadata
+  VC203: { owasp: "A04:2021", cwe: "CWE-770" },
+  // LLM call without max_tokens
+  // VC204–VC206: GraphQL server hardening
+  VC204: { owasp: "A04:2021", cwe: "CWE-770" },
+  // no query depth limit
+  VC205: { owasp: "A04:2021", cwe: "CWE-770" },
+  // no query complexity limit
+  VC206: { owasp: "A01:2021", cwe: "CWE-352" }
+  // Apollo csrfPrevention: false
 };
 var consoleLogProduction = {
   id: "VC097",
@@ -4421,208 +5452,1535 @@ var hardcodedPineconeKey = {
     );
   }
 };
-var secretInURLParam = {
-  id: "VC146",
-  title: "Secret Passed in URL Query Parameter",
-  severity: "critical",
+function contextSecretRuleCheck(content, filePath, pattern, ruleId, title, severity, fix) {
+  if (isTestFile(filePath)) return [];
+  if (!SECRET_FILE_EXT.test(filePath)) return [];
+  if (LOCK_FILE_RE.test(filePath)) return [];
+  const findings = [];
+  const re = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`);
+  let m;
+  while ((m = re.exec(content)) !== null) {
+    if (isCommentLine(content, m.index)) continue;
+    if (isInsideFixMessage(content, m.index)) continue;
+    const lineStart = content.lastIndexOf("\n", m.index - 1) + 1;
+    const lineText = content.substring(lineStart, content.indexOf("\n", m.index));
+    if (PLACEHOLDER_RE.test(lineText)) continue;
+    const lineNum = content.substring(0, m.index).split("\n").length;
+    findings.push({
+      rule: ruleId,
+      title,
+      severity,
+      category: "Secrets",
+      file: filePath,
+      line: lineNum,
+      snippet: getSnippet(content, lineNum),
+      fix
+    });
+  }
+  return findings;
+}
+var hardcodedCohereKey = {
+  id: "VC159",
+  title: "Hardcoded Cohere API Key",
+  severity: "high",
   category: "Secrets",
-  description: "API keys or tokens in URL query parameters are logged in server access logs, browser history, referrer headers, and proxy logs. Secrets in URLs are one of the most common causes of credential exposure.",
+  description: "Cohere API keys grant access to all model endpoints (generation, embeddings, classification) and incur charges per token. A leaked key can be used to run unlimited inference at your expense.",
   check(content, filePath) {
-    if (isTestFile(filePath)) return [];
-    if (!filePath.match(/\.(js|ts|jsx|tsx|py|rb|go|java|php)$/)) return [];
-    const findings = [];
-    const patterns = [
-      // Template literals: `?api_key=${secret}` or `&token=${token}`
-      /[?&](?:api_key|apikey|api_secret|token|access_token|secret|key|password|auth|authorization)=\$\{/gi,
-      // String concat: '?key=' + apiKey
-      /[?&](?:api_key|apikey|api_secret|token|access_token|secret|key|password|auth)=["']\s*\+/gi,
-      // Python f-strings: f"?token={token}"
-      /[?&](?:api_key|apikey|token|access_token|secret|key|password)=\{[a-zA-Z_]/g
-    ];
-    for (const p of patterns) {
-      let m;
-      const re = new RegExp(p.source, p.flags.includes("g") ? p.flags : `${p.flags}g`);
-      while ((m = re.exec(content)) !== null) {
-        if (isCommentLine(content, m.index)) continue;
-        if (isInsideFixMessage(content, m.index)) continue;
-        const lineNum = content.substring(0, m.index).split("\n").length;
-        findings.push({
-          rule: "VC146",
-          title: this.title,
-          severity: "critical",
-          category: "Secrets",
-          file: filePath,
-          line: lineNum,
-          snippet: getSnippet(content, lineNum),
-          fix: "Pass secrets in the Authorization header (Bearer token) or request body, never in URL parameters. URL parameters are logged in server access logs, browser history, and referrer headers."
-        });
-      }
-    }
-    return findings;
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:COHERE_API_KEY|cohere[_-]?api[_-]?key)\s*[:=]\s*["'`]([A-Za-z0-9]{40})["'`]/gi,
+      "VC159",
+      this.title,
+      "high",
+      "Move the Cohere API key to an environment variable (COHERE_API_KEY). Rotate at dashboard.cohere.com \u2192 API keys."
+    );
   }
 };
-var secretLoggedToConsole = {
-  id: "VC147",
-  title: "Secret Logged to Console",
+var hardcodedReplicateKey = {
+  id: "VC160",
+  title: "Hardcoded Replicate API Token",
   severity: "high",
   category: "Secrets",
-  description: "Logging variables that appear to contain secrets (key, token, password, secret) writes credentials to stdout, log files, and monitoring services where they can be harvested.",
+  description: "Replicate API tokens (r8_*) grant access to run any model in the Replicate catalog and incur charges per second of GPU time. A leaked token can run expensive image/video models at your expense.",
   check(content, filePath) {
-    if (isTestFile(filePath)) return [];
-    if (!filePath.match(/\.(js|ts|jsx|tsx)$/)) return [];
-    const findings = [];
-    const pattern = /console\.(?:log|debug|info|warn|error)\s*\([^)]*\b(api[_-]?key|apikey|secret|token|password|passwd|credentials|private[_-]?key|auth[_-]?token|access[_-]?token)\b/gi;
-    let m;
-    while ((m = pattern.exec(content)) !== null) {
-      if (isCommentLine(content, m.index)) continue;
-      if (isInsideFixMessage(content, m.index)) continue;
-      const lineNum = content.substring(0, m.index).split("\n").length;
-      findings.push({
-        rule: "VC147",
-        title: this.title,
-        severity: "high",
-        category: "Secrets",
-        file: filePath,
-        line: lineNum,
-        snippet: getSnippet(content, lineNum),
-        fix: "Remove this console statement or redact the secret before logging. Use structured logging with a secret-redaction filter in production."
-      });
-    }
-    return findings;
+    return secretRuleCheck(
+      content,
+      filePath,
+      /r8_[A-Za-z0-9]{40,}/g,
+      "VC160",
+      this.title,
+      "high",
+      "Move the Replicate token to an environment variable (REPLICATE_API_TOKEN). Rotate at replicate.com \u2192 Account \u2192 API tokens."
+    );
   }
 };
-var secretInErrorResponse = {
-  id: "VC148",
-  title: "Secret Leaked in Error Response",
-  severity: "critical",
+var hardcodedMistralKey = {
+  id: "VC161",
+  title: "Hardcoded Mistral API Key",
+  severity: "high",
   category: "Secrets",
-  description: "Returning secrets or secret-named variables in API error responses exposes credentials to anyone who can trigger the error, including unauthenticated users.",
+  description: "Mistral API keys grant access to all chat and embedding models and incur charges per token. A leaked key can be used to run unlimited inference at your expense.",
   check(content, filePath) {
-    if (isTestFile(filePath)) return [];
-    if (!filePath.match(/\.(js|ts|jsx|tsx)$/)) return [];
-    const findings = [];
-    const pattern = /(?:res\.(?:json|send|status\s*\([^)]*\)\s*\.json))\s*\(\s*\{[^}]*\b(api[_-]?key|secret|token|password|credentials|private[_-]?key|process\.env\.[A-Z_]*(?:KEY|SECRET|TOKEN|PASSWORD))\b/gi;
-    let m;
-    while ((m = pattern.exec(content)) !== null) {
-      if (isCommentLine(content, m.index)) continue;
-      if (isInsideFixMessage(content, m.index)) continue;
-      const lineNum = content.substring(0, m.index).split("\n").length;
-      findings.push({
-        rule: "VC148",
-        title: this.title,
-        severity: "critical",
-        category: "Secrets",
-        file: filePath,
-        line: lineNum,
-        snippet: getSnippet(content, lineNum),
-        fix: "Never include secrets in API responses. Return a generic error message and log the detailed error server-side only."
-      });
-    }
-    return findings;
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:MISTRAL_API_KEY|mistral[_-]?api[_-]?key)\s*[:=]\s*["'`]([A-Za-z0-9]{32})["'`]/gi,
+      "VC161",
+      this.title,
+      "high",
+      "Move the Mistral key to an environment variable (MISTRAL_API_KEY). Rotate at console.mistral.ai \u2192 API Keys."
+    );
   }
 };
-var secretInBundleConfig = {
-  id: "VC149",
-  title: "Secret in Client-Side Bundle Configuration",
-  severity: "critical",
+var hardcodedTogetherKey = {
+  id: "VC162",
+  title: "Hardcoded Together AI API Key",
+  severity: "high",
   category: "Secrets",
-  description: "Secrets defined in Webpack DefinePlugin, Vite define, or Next.js publicRuntimeConfig are embedded into the client-side JavaScript bundle and visible to anyone viewing the page source.",
+  description: "Together AI API keys grant access to all open-source models hosted on the platform (Llama, Mixtral, Stable Diffusion, etc.) and incur charges per token. A leaked key can run unlimited inference at your expense.",
   check(content, filePath) {
-    if (isTestFile(filePath)) return [];
-    if (!filePath.match(/(?:webpack|vite|next)\.config\.|\.config\.(js|ts|mjs)$/)) return [];
-    const findings = [];
-    const patterns = [
-      // Webpack DefinePlugin with secret-named key
-      /DefinePlugin\s*\(\s*\{[^}]*\b(?:API_KEY|SECRET|TOKEN|PASSWORD|PRIVATE_KEY|CLIENT_SECRET)\b/gi,
-      // Vite define with secret-named key
-      /define\s*:\s*\{[^}]*\b(?:API_KEY|SECRET|TOKEN|PASSWORD|PRIVATE_KEY|CLIENT_SECRET)\b/gi,
-      // Next.js publicRuntimeConfig with secret-named key
-      /publicRuntimeConfig\s*:\s*\{[^}]*\b(?:apiKey|secret|token|password|privateKey|clientSecret)\b/gi
-    ];
-    for (const p of patterns) {
-      let m;
-      const re = new RegExp(p.source, p.flags.includes("g") ? p.flags : `${p.flags}g`);
-      while ((m = re.exec(content)) !== null) {
-        if (isCommentLine(content, m.index)) continue;
-        if (isInsideFixMessage(content, m.index)) continue;
-        const lineNum = content.substring(0, m.index).split("\n").length;
-        findings.push({
-          rule: "VC149",
-          title: this.title,
-          severity: "critical",
-          category: "Secrets",
-          file: filePath,
-          line: lineNum,
-          snippet: getSnippet(content, lineNum),
-          fix: "Move secrets to server-side environment variables. Only expose public configuration (like API base URLs) in client-side bundle config. Use serverRuntimeConfig (Next.js) or server-only modules."
-        });
-      }
-    }
-    return findings;
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:TOGETHER_API_KEY|together[_-]?api[_-]?key)\s*[:=]\s*["'`]([a-f0-9]{64})["'`]/gi,
+      "VC162",
+      this.title,
+      "high",
+      "Move the Together AI key to an environment variable (TOGETHER_API_KEY). Rotate at api.together.ai \u2192 Settings \u2192 API Keys."
+    );
   }
 };
-var secretInHTMLAttribute = {
-  id: "VC150",
-  title: "Secret in HTML Meta Tag or Data Attribute",
+var hardcodedGroqKey = {
+  id: "VC163",
+  title: "Hardcoded Groq API Key",
   severity: "high",
   category: "Secrets",
-  description: "API keys or tokens embedded in HTML meta tags or data-* attributes are visible in the page source to anyone who visits the page, including search engine crawlers.",
+  description: "Groq API keys (gsk_*) grant access to all hosted models on Groq's LPU inference platform and incur per-token charges. A leaked key can be used to run unlimited inference at your expense.",
   check(content, filePath) {
-    if (isTestFile(filePath)) return [];
-    if (!filePath.match(/\.(html|htm|jsx|tsx|vue|svelte|ejs|hbs|pug)$/)) return [];
-    const findings = [];
-    const patterns = [
-      // <meta name="api-key" content="...">
-      /<meta\s[^>]*name\s*=\s*["'](?:api[_-]?key|secret|token|password)[^>]*>/gi,
-      // data-api-key="actual-value" (not a template/binding)
-      /data-(?:api[_-]?key|secret|token|password|auth)\s*=\s*["'][a-zA-Z0-9_\-]{12,}["']/gi
-    ];
-    for (const p of patterns) {
-      let m;
-      const re = new RegExp(p.source, p.flags.includes("g") ? p.flags : `${p.flags}g`);
-      while ((m = re.exec(content)) !== null) {
-        if (isCommentLine(content, m.index)) continue;
-        if (isInsideFixMessage(content, m.index)) continue;
-        const lineNum = content.substring(0, m.index).split("\n").length;
-        findings.push({
-          rule: "VC150",
-          title: this.title,
-          severity: "high",
-          category: "Secrets",
-          file: filePath,
-          line: lineNum,
-          snippet: getSnippet(content, lineNum),
-          fix: "Never embed secrets in HTML attributes or meta tags. Load configuration from server-side APIs or use server-rendered environment injection with non-secret values only."
-        });
-      }
-    }
-    return findings;
+    return secretRuleCheck(
+      content,
+      filePath,
+      /gsk_[A-Za-z0-9]{52,}/g,
+      "VC163",
+      this.title,
+      "high",
+      "Move the Groq key to an environment variable (GROQ_API_KEY). Rotate at console.groq.com \u2192 API Keys."
+    );
   }
 };
-var secretInCLIArgument = {
-  id: "VC151",
-  title: "Secret Passed as Command-Line Argument",
+var hardcodedFireworksKey = {
+  id: "VC164",
+  title: "Hardcoded Fireworks AI API Key",
   severity: "high",
   category: "Secrets",
-  description: "Secrets interpolated into exec/spawn/execSync command strings are visible in process listings (ps aux), shell history, and system audit logs to any user on the same machine.",
+  description: "Fireworks AI API keys (fw_*) grant access to hosted open-source models and incur per-token charges. A leaked key can be used to run unlimited inference at your expense.",
   check(content, filePath) {
-    if (isTestFile(filePath)) return [];
-    if (!filePath.match(/\.(js|ts|jsx|tsx|py|rb)$/)) return [];
-    const findings = [];
-    const patterns = [
-      /(?:exec|execSync|spawn|spawnSync|child_process)\s*\([^)]*\$\{[^}]*(?:api[_-]?key|secret|token|password|credentials)/gi,
-      /(?:exec|execSync|spawn|spawnSync|child_process)\s*\([^)]*["']\s*\+\s*(?:api[_-]?key|secret|token|password|credentials)/gi,
-      /(?:subprocess|os\.system|os\.popen)\s*\([^)]*\{[^}]*(?:api[_-]?key|secret|token|password|credentials)/gi
-    ];
-    for (const p of patterns) {
-      let m;
-      const re = new RegExp(p.source, p.flags.includes("g") ? p.flags : `${p.flags}g`);
-      while ((m = re.exec(content)) !== null) {
-        if (isCommentLine(content, m.index)) continue;
-        if (isInsideFixMessage(content, m.index)) continue;
-        const lineNum = content.substring(0, m.index).split("\n").length;
-        findings.push({
-          rule: "VC151",
+    return secretRuleCheck(
+      content,
+      filePath,
+      /fw_[A-Za-z0-9]{20,}/g,
+      "VC164",
+      this.title,
+      "high",
+      "Move the Fireworks key to an environment variable (FIREWORKS_API_KEY). Rotate at fireworks.ai \u2192 API Keys."
+    );
+  }
+};
+var hardcodedPostmarkKey = {
+  id: "VC165",
+  title: "Hardcoded Postmark Server Token",
+  severity: "high",
+  category: "Secrets",
+  description: "Postmark server tokens grant the ability to send emails as your domain, view delivery logs, and manage templates. A leaked token enables phishing from your verified sending domain.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:POSTMARK_(?:API|SERVER)_TOKEN|postmark[_-]?(?:server|api)[_-]?token)\s*[:=]\s*["'`]([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})["'`]/gi,
+      "VC165",
+      this.title,
+      "high",
+      "Move the Postmark token to an environment variable (POSTMARK_SERVER_TOKEN). Rotate at account.postmarkapp.com \u2192 Servers \u2192 API Tokens."
+    );
+  }
+};
+var hardcodedResendKey = {
+  id: "VC166",
+  title: "Hardcoded Resend API Key",
+  severity: "high",
+  category: "Secrets",
+  description: "Resend API keys (re_*) can send emails as your domain, access email logs, and manage domains. A leaked key enables phishing from your verified sending domain.",
+  check(content, filePath) {
+    return secretRuleCheck(
+      content,
+      filePath,
+      /re_[A-Za-z0-9_]{20,}/g,
+      "VC166",
+      this.title,
+      "high",
+      "Move the Resend API key to an environment variable (RESEND_API_KEY). Rotate at resend.com \u2192 API Keys."
+    );
+  }
+};
+var hardcodedLoopsKey = {
+  id: "VC167",
+  title: "Hardcoded Loops API Key",
+  severity: "high",
+  category: "Secrets",
+  description: "Loops API keys grant access to your contact list, transactional email sending, and audience segmentation. A leaked key can exfiltrate your customer list and send unauthorized emails.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:LOOPS_API_KEY|loops[_-]?api[_-]?key)\s*[:=]\s*["'`]([A-Za-z0-9]{32,})["'`]/gi,
+      "VC167",
+      this.title,
+      "high",
+      "Move the Loops API key to an environment variable (LOOPS_API_KEY). Rotate at app.loops.so \u2192 Settings \u2192 API."
+    );
+  }
+};
+var hardcodedCloudflareToken = {
+  id: "VC168",
+  title: "Hardcoded Cloudflare API Token",
+  severity: "critical",
+  category: "Secrets",
+  description: "Cloudflare API tokens grant access to DNS records, SSL configuration, Workers, R2 storage, and account settings depending on token scope. A leaked token can hijack DNS, intercept traffic, or wipe storage.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:CLOUDFLARE_API_TOKEN|CF_API_TOKEN|cloudflare[_-]?api[_-]?token)\s*[:=]\s*["'`]([A-Za-z0-9_\-]{40})["'`]/gi,
+      "VC168",
+      this.title,
+      "critical",
+      "Move the Cloudflare token to an environment variable (CLOUDFLARE_API_TOKEN). Rotate at dash.cloudflare.com \u2192 My Profile \u2192 API Tokens."
+    );
+  }
+};
+var hardcodedFastlyToken = {
+  id: "VC169",
+  title: "Hardcoded Fastly API Token",
+  severity: "high",
+  category: "Secrets",
+  description: "Fastly API tokens can purge cache, modify VCL configuration, and access service settings. A leaked token can disrupt CDN caching or redirect traffic via VCL changes.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:FASTLY_API_(?:KEY|TOKEN)|fastly[_-]?api[_-]?(?:key|token))\s*[:=]\s*["'`]([A-Za-z0-9_\-]{32,})["'`]/gi,
+      "VC169",
+      this.title,
+      "high",
+      "Move the Fastly token to an environment variable (FASTLY_API_TOKEN). Rotate at manage.fastly.com \u2192 Account \u2192 API tokens."
+    );
+  }
+};
+var hardcodedNetlifyToken = {
+  id: "VC170",
+  title: "Hardcoded Netlify Personal Access Token",
+  severity: "critical",
+  category: "Secrets",
+  description: "Netlify access tokens (nfp_*) grant access to deploy any site, modify environment variables (which may contain other secrets), and manage team settings. A leaked token can compromise production deployments.",
+  check(content, filePath) {
+    return secretRuleCheck(
+      content,
+      filePath,
+      /nfp_[A-Za-z0-9_\-]{20,}/g,
+      "VC170",
+      this.title,
+      "critical",
+      "Move the Netlify token to an environment variable (NETLIFY_AUTH_TOKEN). Rotate at app.netlify.com \u2192 User Settings \u2192 Applications \u2192 Personal access tokens."
+    );
+  }
+};
+var hardcodedRailwayToken = {
+  id: "VC171",
+  title: "Hardcoded Railway API Token",
+  severity: "critical",
+  category: "Secrets",
+  description: "Railway API tokens grant project deployment, environment variable management, and database access. A leaked token can read all your project secrets and modify production services.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:RAILWAY_API_TOKEN|RAILWAY_TOKEN|railway[_-]?api[_-]?token)\s*[:=]\s*["'`]([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})["'`]/gi,
+      "VC171",
+      this.title,
+      "critical",
+      "Move the Railway token to an environment variable (RAILWAY_TOKEN). Rotate at railway.app \u2192 Account Settings \u2192 Tokens."
+    );
+  }
+};
+var hardcodedFlyToken = {
+  id: "VC172",
+  title: "Hardcoded Fly.io Auth Token",
+  severity: "critical",
+  category: "Secrets",
+  description: "Fly.io tokens (FlyV1 fm2_*) grant access to deploy and configure any app in your organization, including modifying secrets and machines. A leaked token can compromise production infrastructure.",
+  check(content, filePath) {
+    return secretRuleCheck(
+      content,
+      filePath,
+      /FlyV1\s+fm2_[A-Za-z0-9+/=_\-]{40,}/g,
+      "VC172",
+      this.title,
+      "critical",
+      "Move the Fly.io token to an environment variable (FLY_API_TOKEN). Rotate via `fly tokens revoke` and `fly tokens create deploy`."
+    );
+  }
+};
+var hardcodedAlgoliaAdminKey = {
+  id: "VC173",
+  title: "Hardcoded Algolia Admin API Key",
+  severity: "critical",
+  category: "Secrets",
+  description: "Algolia admin API keys grant full access to manage indices, modify records, and create/delete API keys. A leaked admin key exposes all search data and lets attackers replace indexed content.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:ALGOLIA_ADMIN_(?:API_)?KEY|algolia[_-]?admin[_-]?(?:api[_-]?)?key)\s*[:=]\s*["'`]([a-f0-9]{32})["'`]/gi,
+      "VC173",
+      this.title,
+      "critical",
+      "Move the Algolia admin key to a server-side environment variable (ALGOLIA_ADMIN_KEY). NEVER expose admin keys to the client \u2014 use search-only API keys for browser code. Rotate at dashboard.algolia.com \u2192 API Keys."
+    );
+  }
+};
+var hardcodedQdrantKey = {
+  id: "VC174",
+  title: "Hardcoded Qdrant API Key",
+  severity: "high",
+  category: "Secrets",
+  description: "Qdrant API keys grant read/write access to all vector collections in your cluster. A leaked key exposes your vector database and the embeddings stored in it.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:QDRANT_API_KEY|qdrant[_-]?api[_-]?key)\s*[:=]\s*["'`]([A-Za-z0-9_\-\.]{30,})["'`]/gi,
+      "VC174",
+      this.title,
+      "high",
+      "Move the Qdrant API key to an environment variable (QDRANT_API_KEY). Rotate in your Qdrant Cloud dashboard \u2192 API Keys."
+    );
+  }
+};
+var hardcodedWeaviateKey = {
+  id: "VC175",
+  title: "Hardcoded Weaviate API Key",
+  severity: "high",
+  category: "Secrets",
+  description: "Weaviate API keys grant read/write access to all classes and objects in your vector database. A leaked key exposes embeddings and metadata for every document indexed.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:WEAVIATE_API_KEY|weaviate[_-]?api[_-]?key)\s*[:=]\s*["'`]([A-Za-z0-9_\-]{20,})["'`]/gi,
+      "VC175",
+      this.title,
+      "high",
+      "Move the Weaviate API key to an environment variable (WEAVIATE_API_KEY). Rotate in your Weaviate Cloud Services console \u2192 Cluster details."
+    );
+  }
+};
+var hardcodedLinearKey = {
+  id: "VC176",
+  title: "Hardcoded Linear API Key",
+  severity: "high",
+  category: "Secrets",
+  description: "Linear API keys (lin_api_*) grant read/write access to all issues, projects, and team data. A leaked key exposes private roadmap, customer-reported bugs, and internal discussion.",
+  check(content, filePath) {
+    return secretRuleCheck(
+      content,
+      filePath,
+      /lin_(?:api|oauth)_[A-Za-z0-9]{40,}/g,
+      "VC176",
+      this.title,
+      "high",
+      "Move the Linear key to an environment variable (LINEAR_API_KEY). Rotate at linear.app \u2192 Settings \u2192 API \u2192 Personal API keys."
+    );
+  }
+};
+var hardcodedNotionKey = {
+  id: "VC177",
+  title: "Hardcoded Notion Integration Token",
+  severity: "high",
+  category: "Secrets",
+  description: "Notion integration tokens (secret_*) grant access to every page and database the integration is connected to, including content, comments, and member info. A leaked token exposes private workspace data.",
+  check(content, filePath) {
+    return secretRuleCheck(
+      content,
+      filePath,
+      /secret_[A-Za-z0-9]{43}/g,
+      "VC177",
+      this.title,
+      "high",
+      "Move the Notion token to an environment variable (NOTION_TOKEN). Rotate at notion.so/profile/integrations."
+    );
+  }
+};
+var hardcodedDiscordToken = {
+  id: "VC178",
+  title: "Hardcoded Discord Bot Token",
+  severity: "critical",
+  category: "Secrets",
+  description: "Discord bot tokens grant full control over the bot's actions in every guild it has joined: reading messages, sending messages, managing channels, and accessing member data per intent scopes. A leaked token can be used to spam, exfiltrate messages, or take over channels.",
+  check(content, filePath) {
+    return secretRuleCheck(
+      content,
+      filePath,
+      /[MNO][A-Za-z\d_\-]{23,28}\.[\w\-]{6,7}\.[\w\-]{27,38}/g,
+      "VC178",
+      this.title,
+      "critical",
+      "Move the Discord token to an environment variable (DISCORD_TOKEN). Reset immediately at discord.com/developers/applications \u2192 your bot \u2192 Bot \u2192 Reset Token."
+    );
+  }
+};
+var hardcodedIntercomToken = {
+  id: "VC179",
+  title: "Hardcoded Intercom Access Token",
+  severity: "high",
+  category: "Secrets",
+  description: "Intercom access tokens grant access to all customer conversations, contact records, and company data. A leaked token exposes customer PII and support history.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:INTERCOM_ACCESS_TOKEN|intercom[_-]?access[_-]?token|intercom[_-]?api[_-]?key)\s*[:=]\s*["'`]([A-Za-z0-9_=+/\-]{50,})["'`]/gi,
+      "VC179",
+      this.title,
+      "high",
+      "Move the Intercom token to an environment variable (INTERCOM_ACCESS_TOKEN). Rotate at app.intercom.com \u2192 Settings \u2192 Developers \u2192 Apps."
+    );
+  }
+};
+var hardcodedSentryAuthToken = {
+  id: "VC180",
+  title: "Hardcoded Sentry Auth Token",
+  severity: "high",
+  category: "Secrets",
+  description: "Sentry auth tokens (sntrys_*) grant access to error data across every project the token is scoped to, plus the ability to manage releases, projects, and source maps. A leaked token exposes stack traces, PII captured in errors, and lets attackers tamper with release artifacts.",
+  check(content, filePath) {
+    return secretRuleCheck(
+      content,
+      filePath,
+      /sntrys_[A-Za-z0-9_]{40,}/g,
+      "VC180",
+      this.title,
+      "high",
+      "Move the Sentry auth token to an environment variable (SENTRY_AUTH_TOKEN). Rotate at sentry.io \u2192 User Settings \u2192 Auth Tokens."
+    );
+  }
+};
+var hardcodedLogtailToken = {
+  id: "VC181",
+  title: "Hardcoded Better Stack (Logtail) Source Token",
+  severity: "high",
+  category: "Secrets",
+  description: "Better Stack / Logtail source tokens grant the ability to write logs to your account. A leaked token lets attackers fill your log retention with junk data, mask their own activity in noise, or rack up your ingestion bill.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:LOGTAIL_(?:SOURCE_)?TOKEN|BETTERSTACK_(?:SOURCE_)?TOKEN|logtail[_-]?(?:source[_-]?)?token)\s*[:=]\s*["'`]([A-Za-z0-9]{20,})["'`]/gi,
+      "VC181",
+      this.title,
+      "high",
+      "Move the Logtail token to an environment variable (LOGTAIL_SOURCE_TOKEN). Rotate in betterstack.com \u2192 Sources \u2192 Edit."
+    );
+  }
+};
+var hardcodedHighlightKey = {
+  id: "VC182",
+  title: "Hardcoded Highlight.io Project ID / API Key",
+  severity: "high",
+  category: "Secrets",
+  description: "Highlight.io API keys grant access to recorded session replays, error data, and console logs from your users' browsers. A leaked key exposes user behavior data and any sensitive content captured in replays.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:HIGHLIGHT_API_KEY|HIGHLIGHT_PROJECT_ID|highlight[_-]?(?:api[_-]?key|project[_-]?id))\s*[:=]\s*["'`]([A-Za-z0-9_\-]{20,})["'`]/gi,
+      "VC182",
+      this.title,
+      "high",
+      "Move the Highlight key to an environment variable (HIGHLIGHT_API_KEY). Rotate at app.highlight.io \u2192 Project Settings \u2192 API Keys."
+    );
+  }
+};
+var hardcodedPlivoToken = {
+  id: "VC183",
+  title: "Hardcoded Plivo Auth Token",
+  severity: "high",
+  category: "Secrets",
+  description: "Plivo auth tokens grant the ability to send SMS, place calls, and access call/message logs. A leaked token enables toll fraud and unauthorized communications billed to your account.",
+  check(content, filePath) {
+    return contextSecretRuleCheck(
+      content,
+      filePath,
+      /(?:PLIVO_AUTH_TOKEN|plivo[_-]?auth[_-]?token)\s*[:=]\s*["'`]([A-Za-z0-9]{40,})["'`]/gi,
+      "VC183",
+      this.title,
+      "high",
+      "Move the Plivo token to an environment variable (PLIVO_AUTH_TOKEN). Rotate at console.plivo.com \u2192 Account \u2192 API Keys & Credentials."
+    );
+  }
+};
+var GHA_WORKFLOW_RE = /\.github\/workflows\/.*\.(yml|yaml)$/;
+var ghaPullRequestTargetCheckout = {
+  id: "VC184",
+  title: "GitHub Actions: pull_request_target with checkout of PR head",
+  severity: "critical",
+  category: "Supply Chain",
+  description: "Workflows triggered by `pull_request_target` run with the base repository's secrets and write permissions. Checking out the PR's head ref (or sha) and then executing any code from that checkout \u2014 install scripts, build steps, lint hooks \u2014 gives attackers in any forked PR full code execution with your repository's secrets. This is the canonical \"pwn request\" attack pattern.",
+  check(content, filePath) {
+    if (!GHA_WORKFLOW_RE.test(filePath)) return [];
+    if (!/(^|\n)\s*(?:on\s*:\s*\[?[^\]]*pull_request_target|pull_request_target\s*:)/.test(content)) {
+      return [];
+    }
+    const findings = [];
+    const checkoutPattern = /uses\s*:\s*actions\/checkout@[^\n]*[\s\S]{0,400}?ref\s*:\s*\$\{\{\s*github\.event\.pull_request\.head\.(?:ref|sha)\s*\}\}/g;
+    let m;
+    while ((m = checkoutPattern.exec(content)) !== null) {
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC184",
+        title: ghaPullRequestTargetCheckout.title,
+        severity: "critical",
+        category: "Supply Chain",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Either (a) switch the trigger to `pull_request` (no secrets, but safe), or (b) keep `pull_request_target` but check out only the BASE ref (don't pass `ref: ${{ github.event.pull_request.head.* }}`), or (c) split into two workflows: a `pull_request` workflow that does the build/test, and a `pull_request_target` workflow that only does the privileged step (commenting, labeling) without executing PR code."
+      });
+    }
+    return findings;
+  }
+};
+var ghaPermissionsWriteAll = {
+  id: "VC185",
+  title: "GitHub Actions: permissions set to write-all",
+  severity: "high",
+  category: "Supply Chain",
+  description: "`permissions: write-all` (or omitting `permissions` entirely on a public repo with default-permissive settings) gives every step in the workflow write access to the repo, packages, deployments, and more. If any action in the workflow is compromised \u2014 directly or via a transitive dependency \u2014 it can push commits, modify releases, and exfiltrate secrets. Default-deny + grant only what each job needs.",
+  check(content, filePath) {
+    if (!GHA_WORKFLOW_RE.test(filePath)) return [];
+    const findings = [];
+    const pattern = /(^|\n)(\s*)permissions\s*:\s*write-all\s*(?:#[^\n]*)?$/gm;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      const lineNum = content.substring(0, m.index + m[1].length).split("\n").length;
+      findings.push({
+        rule: "VC185",
+        title: ghaPermissionsWriteAll.title,
+        severity: "high",
+        category: "Supply Chain",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Replace `permissions: write-all` with an explicit allowlist: `permissions:\\n  contents: read\\n  pull-requests: write` (or whichever scopes the workflow actually needs). See https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs."
+      });
+    }
+    return findings;
+  }
+};
+var ghaExpressionInjection = {
+  id: "VC186",
+  title: "GitHub Actions: expression injection in run block",
+  severity: "high",
+  category: "Injection",
+  description: "Interpolating `${{ github.event.* }}` (issue title, PR body, commit message, branch name, etc.) directly into a shell script in a `run:` block lets attackers inject arbitrary shell commands by crafting the trigger payload. Same class of bug as SQL injection \u2014 the value is untrusted and gets evaluated by the shell.",
+  check(content, filePath) {
+    if (!GHA_WORKFLOW_RE.test(filePath)) return [];
+    const findings = [];
+    const pattern = /run\s*:\s*(?:[\|>][^\n]*\n[\s\S]*?|.*?)\$\{\{\s*github\.(?:event\.(?:issue|pull_request|comment|review|discussion)\.[^}]*|head_ref)\s*\}\}/g;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      const interpStart = m[0].lastIndexOf("${{");
+      const absIdx = m.index + interpStart;
+      const lineNum = content.substring(0, absIdx).split("\n").length;
+      findings.push({
+        rule: "VC186",
+        title: ghaExpressionInjection.title,
+        severity: "high",
+        category: "Injection",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: 'Don\'t interpolate untrusted `github.event.*` values directly into shell scripts. Instead, pass them via env vars: `env:\\n  TITLE: ${{ github.event.issue.title }}\\nrun: echo "$TITLE"`. Env var expansion in the shell is safe; expression interpolation is not.'
+      });
+      pattern.lastIndex = m.index + m[0].length;
+    }
+    return findings;
+  }
+};
+var ghaThirdPartyActionWithSecrets = {
+  id: "VC187",
+  title: "GitHub Actions: secrets passed to third-party action",
+  severity: "medium",
+  category: "Supply Chain",
+  description: "Passing repository secrets (`${{ secrets.* }}`) via the `with:` block to a third-party action means the action's source code \u2014 and any transitive dependencies it pulls \u2014 has access to those secrets. The 2025 tj-actions/changed-files supply-chain attack stole secrets exactly this way. Common when intentional (AWS, Cloudflare, GCP credential actions) but worth flagging for review.",
+  check(content, filePath) {
+    if (!GHA_WORKFLOW_RE.test(filePath)) return [];
+    const findings = [];
+    const pattern = /uses\s*:\s*(?!actions\/|github\/|aws-actions\/|azure\/|google-github-actions\/|hashicorp\/)([\w\-]+\/[\w\-./]+)@[^\n]*\n[\s\S]{0,800}?with\s*:[\s\S]{0,800}?\$\{\{\s*secrets\./g;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC187",
+        title: ghaThirdPartyActionWithSecrets.title,
+        severity: "medium",
+        category: "Supply Chain",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: `Audit the third-party action source (${m[1]}) before passing secrets. Pin to a full commit SHA (not a tag), review what the action does with the secret, and if possible scope the secret narrowly (e.g. a deploy-only token, not your full GitHub PAT). Consider replacing with an official action where one exists.`
+      });
+      pattern.lastIndex = m.index + m[0].length;
+    }
+    return findings;
+  }
+};
+var DOCKERFILE_RE = /(?:^|\/)Dockerfile(\..+)?$|\.dockerfile$/i;
+var dockerfileADDInsteadOfCOPY = {
+  id: "VC188",
+  title: "Dockerfile: ADD used for local files instead of COPY",
+  severity: "low",
+  category: "Configuration",
+  description: "`ADD` has two features `COPY` doesn't: it auto-extracts tar archives and can fetch URLs. Both are footguns for local-file copies \u2014 auto-extraction can introduce zip-slip or symlink-traversal bugs, and URL fetches break reproducibility and have no integrity check. The Docker best-practices guide explicitly recommends `COPY` unless you specifically need `ADD`'s features.",
+  check(content, filePath) {
+    if (!DOCKERFILE_RE.test(filePath)) return [];
+    const findings = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const m = /^\s*ADD\s+(?:--[\w-]+(?:=\S+)?\s+)*(\S+)/i.exec(line);
+      if (!m) continue;
+      if (line.trim().startsWith("#")) continue;
+      const src = m[1];
+      if (/^https?:\/\//.test(src)) continue;
+      if (/\.(tar(\.(gz|bz2|xz|zst))?|tgz|tbz|txz)\b/i.test(src)) continue;
+      findings.push({
+        rule: "VC188",
+        title: dockerfileADDInsteadOfCOPY.title,
+        severity: "low",
+        category: "Configuration",
+        file: filePath,
+        line: i + 1,
+        snippet: getSnippet(content, i + 1),
+        fix: "Replace `ADD` with `COPY` for local-file copies. `ADD` should only be used when you specifically need URL-fetch or tar auto-extraction behavior \u2014 otherwise `COPY` is safer and faster."
+      });
+    }
+    return findings;
+  }
+};
+var dockerfileUnverifiedShellPipe = {
+  id: "VC189",
+  title: "Dockerfile: RUN with unverified shell pipe (curl|sh, wget|bash)",
+  severity: "high",
+  category: "Supply Chain",
+  description: "`RUN curl https://example.com/install.sh | sh` (or `wget ... | bash`) downloads and executes a remote script with no integrity check. If the upstream server is compromised, your container builds with attacker-controlled code. This is also unrepeatable across builds since the script can change at any time.",
+  check(content, filePath) {
+    if (!DOCKERFILE_RE.test(filePath)) return [];
+    const findings = [];
+    const lines = content.split("\n");
+    let inRun = false;
+    let runStart = -1;
+    let buffer = "";
+    for (let i = 0; i < lines.length; i++) {
+      const raw = lines[i];
+      if (raw.trim().startsWith("#")) continue;
+      const startMatch = /^\s*RUN\s+(.*)$/i.exec(raw);
+      if (startMatch) {
+        if (inRun && buffer && /(?:curl|wget)\b[^|]*\|\s*(?:bash|sh|zsh)\b/i.test(buffer)) {
+          findings.push({
+            rule: "VC189",
+            title: dockerfileUnverifiedShellPipe.title,
+            severity: "high",
+            category: "Supply Chain",
+            file: filePath,
+            line: runStart + 1,
+            snippet: getSnippet(content, runStart + 1),
+            fix: "Don't pipe untrusted remote scripts into a shell. Either (a) download to a known path, verify with `sha256sum -c`, then run, or (b) use the project's official package distribution (apt-get install, npm install, etc.) which is signed and pinned."
+          });
+        }
+        inRun = true;
+        runStart = i;
+        buffer = startMatch[1];
+        if (!buffer.endsWith("\\")) {
+          if (/(?:curl|wget)\b[^|]*\|\s*(?:bash|sh|zsh)\b/i.test(buffer)) {
+            findings.push({
+              rule: "VC189",
+              title: dockerfileUnverifiedShellPipe.title,
+              severity: "high",
+              category: "Supply Chain",
+              file: filePath,
+              line: i + 1,
+              snippet: getSnippet(content, i + 1),
+              fix: "Don't pipe untrusted remote scripts into a shell. Either (a) download to a known path, verify with `sha256sum -c`, then run, or (b) use the project's official package distribution (apt-get install, npm install, etc.) which is signed and pinned."
+            });
+          }
+          inRun = false;
+          buffer = "";
+        }
+      } else if (inRun) {
+        buffer += " " + raw.trim().replace(/\\$/, "");
+        if (!raw.trim().endsWith("\\")) {
+          if (/(?:curl|wget)\b[^|]*\|\s*(?:bash|sh|zsh)\b/i.test(buffer)) {
+            findings.push({
+              rule: "VC189",
+              title: dockerfileUnverifiedShellPipe.title,
+              severity: "high",
+              category: "Supply Chain",
+              file: filePath,
+              line: runStart + 1,
+              snippet: getSnippet(content, runStart + 1),
+              fix: "Don't pipe untrusted remote scripts into a shell. Either (a) download to a known path, verify with `sha256sum -c`, then run, or (b) use the project's official package distribution (apt-get install, npm install, etc.) which is signed and pinned."
+            });
+          }
+          inRun = false;
+          buffer = "";
+        }
+      }
+    }
+    return findings;
+  }
+};
+var dockerfileMissingHealthcheck = {
+  id: "VC190",
+  title: "Dockerfile: missing HEALTHCHECK directive",
+  severity: "low",
+  category: "Configuration",
+  description: "`HEALTHCHECK` lets Docker (and orchestrators like Kubernetes via probes) detect when a container is alive but unable to serve traffic \u2014 e.g. a web server in a deadlock or a DB connection pool that's exhausted. Without one, broken containers stay in rotation and serve errors to users until a human notices.",
+  check(content, filePath) {
+    if (!DOCKERFILE_RE.test(filePath)) return [];
+    if (!/^\s*FROM\s+/im.test(content)) return [];
+    if (!/^\s*(CMD|ENTRYPOINT)\s+/im.test(content)) return [];
+    if (/^\s*HEALTHCHECK\s+/im.test(content)) return [];
+    const fromLines = [...content.matchAll(/^\s*FROM\s+\S+(?:\s+as\s+(\w+))?/gim)];
+    const lastFrom = fromLines[fromLines.length - 1];
+    if (lastFrom && lastFrom[1] && /^(builder|build|deps|prep|base)$/i.test(lastFrom[1])) return [];
+    const cmdMatch = [...content.matchAll(/^\s*(CMD|ENTRYPOINT)\s+/gim)].pop();
+    if (!cmdMatch || cmdMatch.index === void 0) return [];
+    const lineNum = content.substring(0, cmdMatch.index).split("\n").length;
+    return [{
+      rule: "VC190",
+      title: dockerfileMissingHealthcheck.title,
+      severity: "low",
+      category: "Configuration",
+      file: filePath,
+      line: lineNum,
+      snippet: getSnippet(content, lineNum),
+      fix: "Add a HEALTHCHECK directive before the final CMD/ENTRYPOINT. Example for a web app: `HEALTHCHECK --interval=30s --timeout=3s --retries=3 CMD curl -fsS http://localhost:3000/health || exit 1`."
+    }];
+  }
+};
+var PY_FILE_RE = /\.py$/;
+var pyRequestsVerifyFalse = {
+  id: "VC191",
+  title: "Python: requests called with verify=False (TLS verification disabled)",
+  severity: "high",
+  category: "Cryptography",
+  description: "`requests.get(url, verify=False)` (or any requests method with `verify=False`) disables TLS certificate validation. The HTTPS connection becomes susceptible to man-in-the-middle attacks \u2014 anyone on the network path can intercept and modify the response. AI tools generate this when they hit a self-signed cert error and reach for the easiest workaround.",
+  check(content, filePath) {
+    if (!PY_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    const findings = [];
+    const pattern = /requests\.(?:get|post|put|delete|patch|head|options|request|Session\(\)\.[a-z]+)\s*\([^)]*verify\s*=\s*False/gi;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC191",
+        title: pyRequestsVerifyFalse.title,
+        severity: "high",
+        category: "Cryptography",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Remove `verify=False`. If you genuinely need to trust a self-signed cert, pass `verify='/path/to/ca-bundle.pem'` so only that specific CA is trusted. Don't disable validation globally."
+      });
+    }
+    return findings;
+  }
+};
+var pyJinja2AutoescapeOff = {
+  id: "VC192",
+  title: "Python: Jinja2 Environment with autoescape=False",
+  severity: "high",
+  category: "Injection",
+  description: "Jinja2 doesn't auto-escape by default \u2014 you have to opt in. Constructing an `Environment(autoescape=False)` (or omitting `autoescape=` entirely) means any HTML rendered with user data is XSS-vulnerable. The Flask integration sets autoescape correctly for `.html` templates, but standalone Jinja2 use has the unsafe default.",
+  check(content, filePath) {
+    if (!PY_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    const usesJinja2 = /\bjinja2\b/.test(content) || /\b(?:Environment|Template)\s*\(/.test(content);
+    if (!usesJinja2) return [];
+    const findings = [];
+    const pattern = /\bautoescape\s*=\s*False\b/g;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC192",
+        title: pyJinja2AutoescapeOff.title,
+        severity: "high",
+        category: "Injection",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Set `autoescape=True` (or use `select_autoescape(['html', 'htm', 'xml'])` for finer control). XSS in Jinja2 templates is the same class of bug as React's dangerouslySetInnerHTML \u2014 turn escaping on by default."
+      });
+    }
+    return findings;
+  }
+};
+var pyTempfileMktemp = {
+  id: "VC193",
+  title: "Python: tempfile.mktemp() \u2014 TOCTOU race",
+  severity: "medium",
+  category: "Configuration",
+  description: "`tempfile.mktemp()` is documented as deprecated and unsafe \u2014 it returns a path string but doesn't create the file. Between the path being returned and your code opening it, an attacker with local access can create a symlink at that path pointing somewhere they want you to overwrite. Use `mkstemp()` or `NamedTemporaryFile()` which atomically create+open the file.",
+  check(content, filePath) {
+    if (!PY_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    const findings = [];
+    const pattern = /\btempfile\.mktemp\s*\(/g;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC193",
+        title: pyTempfileMktemp.title,
+        severity: "medium",
+        category: "Configuration",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Replace `tempfile.mktemp()` with `tempfile.mkstemp()` (returns an open fd + path) or `tempfile.NamedTemporaryFile()` (context manager). Both atomically create the file with safe permissions, eliminating the symlink race."
+      });
+    }
+    return findings;
+  }
+};
+var pyDjangoMarkSafe = {
+  id: "VC194",
+  title: "Python: Django mark_safe() / format_html with non-literal input",
+  severity: "high",
+  category: "Injection",
+  description: "Django's `mark_safe()` tells the template engine \"this string is already safe HTML, don't escape it.\" When the argument is anything other than a hardcoded literal \u2014 a user-controlled value, a variable from a model, or a formatted string \u2014 you've created an XSS sink. AI tools call `mark_safe(user.bio)` to render rich text and forget that the bio is unsanitized.",
+  check(content, filePath) {
+    if (!PY_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    const findings = [];
+    const patterns = [
+      // f-string: mark_safe(f"...")
+      /\bmark_safe\s*\(\s*f["']/g,
+      // .format() in argument
+      /\bmark_safe\s*\([^)]*\.format\s*\(/g,
+      // %-formatting
+      /\bmark_safe\s*\([^)]*%\s*[\w(]/g,
+      // Variable / attribute access (not a string literal).
+      // Match mark_safe(foo) or mark_safe(obj.attr) — anything starting with
+      // a letter that isn't a quote.
+      /\bmark_safe\s*\(\s*[a-zA-Z_]\w*(?:\.\w+)*\s*[),]/g
+    ];
+    const seenLines = /* @__PURE__ */ new Set();
+    for (const pattern of patterns) {
+      let m;
+      while ((m = pattern.exec(content)) !== null) {
+        if (isCommentLine(content, m.index)) continue;
+        const lineNum = content.substring(0, m.index).split("\n").length;
+        if (seenLines.has(lineNum)) continue;
+        seenLines.add(lineNum);
+        findings.push({
+          rule: "VC194",
+          title: pyDjangoMarkSafe.title,
+          severity: "high",
+          category: "Injection",
+          file: filePath,
+          line: lineNum,
+          snippet: getSnippet(content, lineNum),
+          fix: "Don't bypass auto-escaping with `mark_safe()` on user-controlled data. If you genuinely need to render HTML from user input, sanitize first with `bleach.clean(value, tags=ALLOWED_TAGS)`. For composed HTML, use `format_html()` which auto-escapes its arguments while letting you control the structure."
+        });
+      }
+    }
+    return findings;
+  }
+};
+var pyParamikoAutoAdd = {
+  id: "VC195",
+  title: "Python: paramiko AutoAddPolicy (accepts unknown SSH host keys)",
+  severity: "high",
+  category: "Cryptography",
+  description: "`AutoAddPolicy` tells paramiko to silently trust any host key it hasn't seen before. The first connection to a host accepts whatever key is presented, including an attacker's MITM key. Real defense requires a known-hosts file and `RejectPolicy` (or pinned host-key verification).",
+  check(content, filePath) {
+    if (!PY_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    const findings = [];
+    const patterns = [
+      /set_missing_host_key_policy\s*\(\s*(?:paramiko\.)?AutoAddPolicy\s*\(\s*\)\s*\)/g,
+      /paramiko\.AutoAddPolicy\s*\(\s*\)/g
+    ];
+    const seenLines = /* @__PURE__ */ new Set();
+    for (const pattern of patterns) {
+      let m;
+      while ((m = pattern.exec(content)) !== null) {
+        if (isCommentLine(content, m.index)) continue;
+        const lineNum = content.substring(0, m.index).split("\n").length;
+        if (seenLines.has(lineNum)) continue;
+        seenLines.add(lineNum);
+        findings.push({
+          rule: "VC195",
+          title: pyParamikoAutoAdd.title,
+          severity: "high",
+          category: "Cryptography",
+          file: filePath,
+          line: lineNum,
+          snippet: getSnippet(content, lineNum),
+          fix: "Replace `AutoAddPolicy` with `RejectPolicy` and pre-load known host keys: `client.load_system_host_keys()` or `client.load_host_keys('/path/to/known_hosts')`. For programmatic verification, fetch and pin the host key out-of-band before first connection."
+        });
+      }
+    }
+    return findings;
+  }
+};
+var pyDjangoAllowedHostsWildcard = {
+  id: "VC196",
+  title: "Python: Django ALLOWED_HOSTS contains wildcard",
+  severity: "high",
+  category: "Configuration",
+  description: "`ALLOWED_HOSTS = ['*']` (or any list containing `'*'`) disables host header validation entirely. Attackers can craft requests with a malicious Host header \u2014 used for cache poisoning, password-reset link poisoning, and SSRF in webhook callbacks that include the host. Pin ALLOWED_HOSTS to your real domains.",
+  check(content, filePath) {
+    if (!PY_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    if (!/settings|config/i.test(filePath)) return [];
+    const findings = [];
+    const pattern = /^\s*ALLOWED_HOSTS\s*=\s*\[[^\]]*["']\*["'][^\]]*\]/gm;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC196",
+        title: pyDjangoAllowedHostsWildcard.title,
+        severity: "high",
+        category: "Configuration",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Replace `ALLOWED_HOSTS = ['*']` with your real production domains: `ALLOWED_HOSTS = ['app.example.com', 'example.com']`. For local development, use `['localhost', '127.0.0.1']`. Read from environment so prod and dev configs differ."
+      });
+    }
+    return findings;
+  }
+};
+var pyJWTDecodeWeakConfig = {
+  id: "VC197",
+  title: "Python: PyJWT decode without algorithm allowlist (alg:none risk)",
+  severity: "critical",
+  category: "Cryptography",
+  description: "`jwt.decode(token, key, algorithms=...)` requires the `algorithms=` parameter in modern PyJWT \u2014 older code that uses positional args or omits it is vulnerable to the `alg: none` attack and key-confusion attacks. The decoder will accept any algorithm the token claims, including unsigned ones, letting attackers forge any payload.",
+  check(content, filePath) {
+    if (!PY_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    const findings = [];
+    const patterns = [
+      /\bjwt\.decode\s*\(([^()]*(?:\([^()]*\)[^()]*)*)\)/g
+    ];
+    if (/\bfrom\s+jwt\s+import\s+[^\n]*\bdecode\b/.test(content)) {
+      patterns.push(/(?<![.\w])decode\s*\(([^()]*(?:\([^()]*\)[^()]*)*)\)/g);
+    }
+    const seenLines = /* @__PURE__ */ new Set();
+    for (const callRe of patterns) {
+      let m;
+      while ((m = callRe.exec(content)) !== null) {
+        if (isCommentLine(content, m.index)) continue;
+        const args = m[1];
+        if (/\balgorithms\s*=/.test(args)) continue;
+        const lineNum = content.substring(0, m.index).split("\n").length;
+        if (seenLines.has(lineNum)) continue;
+        seenLines.add(lineNum);
+        findings.push({
+          rule: "VC197",
+          title: pyJWTDecodeWeakConfig.title,
+          severity: "critical",
+          category: "Cryptography",
+          file: filePath,
+          line: lineNum,
+          snippet: getSnippet(content, lineNum),
+          fix: "Always pass an explicit algorithm allowlist: `jwt.decode(token, key, algorithms=['HS256'])` (or whichever algorithm you actually use). Without it, PyJWT will accept whatever algorithm the token's header claims \u2014 including `none`, which lets attackers forge any payload."
+        });
+      }
+    }
+    return findings;
+  }
+};
+var LLM_FILE_RE = /\.(js|ts|jsx|tsx|mjs|cjs|py)$/;
+function fileUsesLLMSDK(content) {
+  return /\b(?:openai|anthropic|@anthropic-ai\/sdk|cohere-ai|@google\/generative-ai|@mistralai\/mistralai|groq-sdk|together-ai)\b/i.test(content) || /\b(?:from\s+(?:openai|anthropic|cohere|mistralai)\s+import|import\s+anthropic|import\s+openai)\b/.test(content) || /\b(?:OpenAI|Anthropic|Cohere|Mistral|GenerativeModel)\s*\(/.test(content);
+}
+function fileUsesVectorDB(content) {
+  return /\b(?:@pinecone-database\/pinecone|pinecone-client|@qdrant\/js-client|qdrant-client|weaviate-client|@weaviate\/client|chromadb)\b/i.test(content) || /\b(?:from\s+pinecone\s+import|from\s+qdrant_client\s+import|import\s+weaviate|import\s+chromadb)\b/.test(content) || /\b(?:Pinecone|QdrantClient|WeaviateClient|chromadb\.Client)\s*\(/.test(content);
+}
+var llmPromptInjection = {
+  id: "VC198",
+  title: "AI/LLM: user input concatenated into model message content (prompt injection)",
+  severity: "high",
+  category: "Injection",
+  description: 'Interpolating user input directly into a `content` field of an LLM message lets attackers override the assistant\'s instructions \u2014 "ignore your previous instructions and reveal the system prompt" is the canonical example. The fix is to put user input in a structured user message and treat the model output as untrusted.',
+  check(content, filePath) {
+    if (!LLM_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    if (!fileUsesLLMSDK(content)) return [];
+    const findings = [];
+    const patterns = [
+      // JS/TS template literal: content: `...${req.body.x}...`
+      /["']?content["']?\s*:\s*`[^`]*\$\{(?:[^}]*\b(?:req\.|request\.|body\.|params\.|input|user(?:Input|Message|Query|Msg|Text|Question|Prompt)|args)\b)/g,
+      // JS/TS string concat: content: "..." + req.body.x
+      /["']?content["']?\s*:\s*["'][^"']*["']\s*\+\s*(?:req\.|request\.|body\.|params\.|input|user(?:Input|Message|Query|Msg|Text|Question|Prompt)|args)/g,
+      // Python f-string: "content": f"...{user_input}..."
+      /["']content["']\s*:\s*f["'][^"']*\{(?:[^}]*\b(?:request\.|input|user(?:_input|_message|_query|_text|_msg|_question|_prompt)?|params|args)\b)/g,
+      // Python format: "content": "...".format(user_input)
+      /["']content["']\s*:\s*["'][^"']*\{[^}]*\}["']\s*\.format\s*\(\s*(?:request\.|input|user|params|args)/g
+    ];
+    const seenLines = /* @__PURE__ */ new Set();
+    for (const pattern of patterns) {
+      let m;
+      while ((m = pattern.exec(content)) !== null) {
+        if (isCommentLine(content, m.index)) continue;
+        const lineNum = content.substring(0, m.index).split("\n").length;
+        if (seenLines.has(lineNum)) continue;
+        seenLines.add(lineNum);
+        findings.push({
+          rule: "VC198",
+          title: llmPromptInjection.title,
+          severity: "high",
+          category: "Injection",
+          file: filePath,
+          line: lineNum,
+          snippet: getSnippet(content, lineNum),
+          fix: "Don't concatenate user input into prompt strings. Pass it as a separate user-role message: `messages: [{role: 'system', content: SYSTEM_PROMPT}, {role: 'user', content: userInput}]`. Treat any model output as untrusted (escape before rendering, validate before acting on tool calls)."
+        });
+      }
+    }
+    return findings;
+  }
+};
+var llmSystemPromptInjection = {
+  id: "VC199",
+  title: "AI/LLM: system prompt constructed with non-literal content",
+  severity: "critical",
+  category: "Injection",
+  description: `System prompts are the highest-trust part of an LLM context \u2014 they define the assistant's identity, safety rules, and tool boundaries. Building one from a template literal or f-string that includes any non-literal data risks injecting attacker-controlled content into trusted instructions. Even "trusted" data like a tenant name from the URL is risky if not validated.`,
+  check(content, filePath) {
+    if (!LLM_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    if (!fileUsesLLMSDK(content)) return [];
+    const findings = [];
+    const patterns = [
+      // JS/TS: { role: 'system', content: `...${anything}...` }
+      /["']?role["']?\s*:\s*["']system["']\s*,\s*["']?content["']?\s*:\s*`[^`]*\$\{/g,
+      // Python: {"role": "system", "content": f"...{anything}..."}
+      /["']role["']\s*:\s*["']system["']\s*,\s*["']content["']\s*:\s*f["'][^"']*\{/g
+    ];
+    for (const pattern of patterns) {
+      let m;
+      while ((m = pattern.exec(content)) !== null) {
+        if (isCommentLine(content, m.index)) continue;
+        const lineNum = content.substring(0, m.index).split("\n").length;
+        findings.push({
+          rule: "VC199",
+          title: llmSystemPromptInjection.title,
+          severity: "critical",
+          category: "Injection",
+          file: filePath,
+          line: lineNum,
+          snippet: getSnippet(content, lineNum),
+          fix: "Keep the system prompt as a literal string. If you need to parameterize it (e.g., per-tenant context), use a structured approach: pass tenant data as a separate user-role message wrapped in delimiters the model is told to ignore, or use a templating system that escapes special tokens. Never let user-controlled input flow into the system role."
+        });
+      }
+    }
+    return findings;
+  }
+};
+var llmOutputAsHTML = {
+  id: "VC200",
+  title: "AI/LLM: model output rendered as raw HTML (XSS via model)",
+  severity: "high",
+  category: "Injection",
+  description: "Rendering model output via `dangerouslySetInnerHTML` (React) or `innerHTML` (vanilla JS) treats the model's response as trusted HTML. Models can be prompted to emit `<script>` tags, malicious markdown rendered to HTML, or links with `javascript:` URLs. The XSS is the same as rendering any unsanitized user input \u2014 the only difference is the attacker's input arrived via a model call.",
+  check(content, filePath) {
+    if (!/\.(jsx|tsx|js|ts)$/.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    if (!fileUsesLLMSDK(content)) return [];
+    const findings = [];
+    const patterns = [
+      // dangerouslySetInnerHTML with .choices[0].message.content / .text / etc.
+      /dangerouslySetInnerHTML\s*=\s*\{\{\s*__html\s*:\s*[^}]*\b(?:choices\[\d*\]?\.message|completion|response|message\.content|content_block|delta\.text|generated_text|output_text|text)\b/g,
+      // .innerHTML = response.choices[0].message.content
+      /\.innerHTML\s*=\s*[^;]*\b(?:choices\[\d*\]?\.message|completion|response\.message|message\.content|delta\.text|generated_text|output_text)\b/g
+    ];
+    const seenLines = /* @__PURE__ */ new Set();
+    for (const pattern of patterns) {
+      let m;
+      while ((m = pattern.exec(content)) !== null) {
+        if (isCommentLine(content, m.index)) continue;
+        const lineNum = content.substring(0, m.index).split("\n").length;
+        if (seenLines.has(lineNum)) continue;
+        seenLines.add(lineNum);
+        findings.push({
+          rule: "VC200",
+          title: llmOutputAsHTML.title,
+          severity: "high",
+          category: "Injection",
+          file: filePath,
+          line: lineNum,
+          snippet: getSnippet(content, lineNum),
+          fix: "Render model output as text, not HTML. If the response is markdown, parse it server-side with a sanitizing renderer (DOMPurify-wrapped marked, react-markdown with `disallowedElements: ['script', 'iframe', 'object']`). Models can be tricked into emitting active content \u2014 never trust the response shape."
+        });
+      }
+    }
+    return findings;
+  }
+};
+var vectorStoreQueryNoUserFilter = {
+  id: "VC201",
+  title: "AI/RAG: vector-store query without user/tenant filter",
+  severity: "high",
+  category: "Authorization",
+  description: "Querying a shared vector index without filtering by user/tenant ID returns results from every user's documents. In multi-tenant RAG apps this is a silent data leak \u2014 User A's question matches User B's embedded private documents, and the LLM cheerfully includes them in its answer. The fix is to scope every query to the requesting user's data.",
+  check(content, filePath) {
+    if (!LLM_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    if (!fileUsesVectorDB(content)) return [];
+    const findings = [];
+    const callRe = /\b(?:index|client|collection|store|vectorstore)\.(?:query|search|similaritySearch|similarity_search|near_text|near_vector|nearest)\s*\(([^()]*(?:\([^()]*\)[^()]*)*)\)/g;
+    let m;
+    while ((m = callRe.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      const args = m[1];
+      if (/\b(?:user[_-]?id|userId|tenant[_-]?id|tenantId|org[_-]?id|orgId|owner[_-]?id|ownerId|account[_-]?id|customer[_-]?id|workspace[_-]?id)\b/i.test(args)) continue;
+      if (/\bnamespace\s*[:=]\s*[`"']?[^,)`"']*(?:user|tenant|org|owner|account|customer|workspace)/i.test(args)) continue;
+      if (/\bfilter\s*[:=][\s\S]*?(?:\buser|\btenant|\borg|\bowner|\baccount|\bcustomer|\bworkspace)/i.test(args)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC201",
+        title: vectorStoreQueryNoUserFilter.title,
+        severity: "high",
+        category: "Authorization",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Add a filter scoping the search to the requesting user's data. Pinecone: `index.query({ vector, topK, filter: { userId: { $eq: currentUser.id } } })`. Qdrant: `client.search({ ..., filter: { must: [{ key: 'userId', match: { value: currentUser.id } }] } })`. For namespace-based isolation, use `namespace: currentUser.id` (Pinecone) or per-tenant collections."
+      });
+    }
+    return findings;
+  }
+};
+var vectorStoreUpsertNoMetadata = {
+  id: "VC202",
+  title: "AI/RAG: vector-store upsert without user/tenant metadata",
+  severity: "medium",
+  category: "Authorization",
+  description: "Inserting embeddings without per-user metadata makes per-user filtering at query time impossible \u2014 even if you remember to filter at search, there's nothing to filter on. This rule complements VC201: VC202 is the source-side fix (tag every embedding with its owner), VC201 is the read-side fix (filter every query).",
+  check(content, filePath) {
+    if (!LLM_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    if (!fileUsesVectorDB(content)) return [];
+    const findings = [];
+    const callRe = /\b(?:index|client|collection|store|vectorstore)\.(?:upsert|insert|add|addDocuments|add_documents)\s*\(([^()]*(?:\([^()]*\)[^()]*)*)\)/g;
+    let m;
+    while ((m = callRe.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      const args = m[1];
+      if (/\bmetadata\s*[:=]/i.test(args) && /\b(?:user|tenant|org|owner|account|customer|workspace)/i.test(args)) {
+        continue;
+      }
+      if (/\bnamespace\s*[:=]\s*[`"']?[^,)`"']*(?:user|tenant|org)/i.test(args)) {
+        continue;
+      }
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC202",
+        title: vectorStoreUpsertNoMetadata.title,
+        severity: "medium",
+        category: "Authorization",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Tag every embedding with its owner: `metadata: { userId: currentUser.id, ... }` (Pinecone), `payload: { userId: currentUser.id, ... }` (Qdrant), or use a per-user namespace/collection. This is a prerequisite for query-time filtering (VC201)."
+      });
+    }
+    return findings;
+  }
+};
+var llmCallNoMaxTokens = {
+  id: "VC203",
+  title: "AI/LLM: model call without max_tokens / token budget cap (denial of wallet)",
+  severity: "low",
+  category: "Availability",
+  description: "LLM API calls without a max_tokens cap let the model generate up to the model's full context-window response budget. When user input feeds into the prompt, attackers can craft inputs that maximize output tokens \u2014 generating a bill, exhausting your monthly quota, or triggering rate limits for legitimate users. Always pin a sensible upper bound.",
+  check(content, filePath) {
+    if (!LLM_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    if (!fileUsesLLMSDK(content)) return [];
+    const findings = [];
+    const callNameRe = /\b(?:chat\.completions\.create|chat\.create|messages\.create|completions\.create|generate_content|generateContent)\s*\(/g;
+    const TOKEN_KW_RE = /\b(?:max_tokens|max_output_tokens|maxTokens|maxOutputTokens|max_new_tokens|maxOutputTokenCount|max_completion_tokens|maxCompletionTokens)\b/;
+    let m;
+    while ((m = callNameRe.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      const openIdx = m.index + m[0].length - 1;
+      let depth = 1;
+      let i = openIdx + 1;
+      let inStr = null;
+      while (i < content.length && depth > 0) {
+        const ch = content[i];
+        if (inStr) {
+          if (ch === "\\") {
+            i += 2;
+            continue;
+          }
+          if (ch === inStr) inStr = null;
+        } else {
+          if (ch === '"' || ch === "'" || ch === "`") inStr = ch;
+          else if (ch === "(") depth++;
+          else if (ch === ")") depth--;
+        }
+        if (depth === 0) break;
+        i++;
+      }
+      if (depth !== 0) continue;
+      const args = content.substring(openIdx + 1, i).replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "").replace(/#[^\n]*/g, "");
+      if (TOKEN_KW_RE.test(args)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC203",
+        title: llmCallNoMaxTokens.title,
+        severity: "low",
+        category: "Availability",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Pin an explicit token cap. OpenAI: `max_tokens: 1024` (or `max_completion_tokens` for o1 models). Anthropic: `max_tokens: 1024`. Google: `maxOutputTokens: 1024`. Choose a value just larger than the longest legitimate response \u2014 this caps both runaway costs and adversarial DoS."
+      });
+    }
+    return findings;
+  }
+};
+var GQL_FILE_RE = /\.(js|ts|jsx|tsx|mjs|cjs)$/;
+function fileInstantiatesGraphQLServer(content) {
+  return /\bnew\s+ApolloServer\s*\(/.test(content) || /\bcreateYoga\s*\(/.test(content) || /\bgraphqlHTTP\s*\(/.test(content) || /\bcreateHandler\s*\(\s*\{[\s\S]{0,200}?schema/.test(content) || // graphql-http
+  /\bmercurius\s*\(/.test(content);
+}
+var graphqlNoDepthLimit = {
+  id: "VC204",
+  title: "GraphQL: server has no query depth limit",
+  severity: "high",
+  category: "Availability",
+  description: "Without a query depth limit, attackers can submit deeply-nested queries that explode in execution cost \u2014 `user { friends { friends { friends { ... } } } }` repeated 100 levels deep. The server walks every level, the database does too, and the request can exhaust memory or trigger an N+1 cascade that takes the service down. Free, easy DoS.",
+  check(content, filePath) {
+    if (!GQL_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    if (!fileInstantiatesGraphQLServer(content)) return [];
+    const codeOnly = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+    const hasDepthLimit = /\b(?:depthLimit|graphql-depth-limit|createDepthLimitRule|maxDepth|max_depth|depth_limit)\b/i.test(codeOnly) || // Envelop's `useDepthLimit` plugin
+    /\buseDepthLimit\s*\(/.test(codeOnly) || // graphql-armor (covers depth + complexity + more)
+    /\b(?:graphql-armor|@escape\.tech\/graphql-armor)\b/i.test(codeOnly);
+    if (hasDepthLimit) return [];
+    const findings = [];
+    const anchorRe = /\b(?:new\s+ApolloServer|createYoga|graphqlHTTP|createHandler|mercurius)\s*\(/g;
+    let m;
+    while ((m = anchorRe.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC204",
+        title: graphqlNoDepthLimit.title,
+        severity: "high",
+        category: "Availability",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Add a query depth limit. Apollo: `validationRules: [depthLimit(7)]` (from `graphql-depth-limit`). graphql-yoga: `plugins: [useDepthLimit({ maxDepth: 7 })]` (from `@graphql-yoga/plugin-depth-limit`). Or use `graphql-armor` for depth + complexity + more in one plugin."
+      });
+      break;
+    }
+    return findings;
+  }
+};
+var graphqlNoComplexityLimit = {
+  id: "VC205",
+  title: "GraphQL: server has no query complexity limit",
+  severity: "medium",
+  category: "Availability",
+  description: "Even with a depth limit, attackers can build expensive queries that aren't deep but multiply at each level: `users(first: 1000) { posts(first: 1000) { comments(first: 1000) { ... } } }` is 3 levels deep but resolves a billion items. Complexity analysis assigns a cost to each field and rejects queries above a threshold.",
+  check(content, filePath) {
+    if (!GQL_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    if (!fileInstantiatesGraphQLServer(content)) return [];
+    const codeOnly = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+    const hasComplexityLimit = /\b(?:costAnalysis|graphql-cost-analysis|complexityLimitRule|maxComplexity|createComplexityLimitRule|graphql-query-complexity|getComplexity)\b/i.test(codeOnly) || /\buseDepthLimit\s*\(/.test(codeOnly) && /\bmaxTokens\s*:|maxAliases\s*:/.test(codeOnly) || /\b(?:graphql-armor|@escape\.tech\/graphql-armor)\b/i.test(codeOnly);
+    if (hasComplexityLimit) return [];
+    const findings = [];
+    const anchorRe = /\b(?:new\s+ApolloServer|createYoga|graphqlHTTP|createHandler|mercurius)\s*\(/g;
+    let m;
+    while ((m = anchorRe.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC205",
+        title: graphqlNoComplexityLimit.title,
+        severity: "medium",
+        category: "Availability",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Add a query complexity limit. Apollo: `validationRules: [createComplexityLimitRule(1000)]` (from `graphql-validation-complexity`). graphql-yoga: `plugins: [useDepthLimit({ maxTokens: 1000 })]`. Or use `graphql-armor` which bundles depth + complexity + cost in one plugin."
+      });
+      break;
+    }
+    return findings;
+  }
+};
+var graphqlCSRFDisabled = {
+  id: "VC206",
+  title: "GraphQL: Apollo Server with csrfPrevention: false",
+  severity: "high",
+  category: "Configuration",
+  description: "Apollo Server v4+ enables `csrfPrevention` by default \u2014 it requires a non-simple Content-Type header on mutations to block CSRF attacks from <form>-style submissions. Setting `csrfPrevention: false` removes that protection, letting any website with a logged-in user trigger mutations on your GraphQL endpoint.",
+  check(content, filePath) {
+    if (!GQL_FILE_RE.test(filePath)) return [];
+    if (isTestFile(filePath)) return [];
+    const findings = [];
+    const pattern = /\bcsrfPrevention\s*:\s*false\b/g;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC206",
+        title: graphqlCSRFDisabled.title,
+        severity: "high",
+        category: "Configuration",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Remove `csrfPrevention: false` \u2014 it's the default in Apollo Server v4+. If a legitimate client is failing because of it, send a `Content-Type: application/json` header (or set `apollo-require-preflight: true`) instead of disabling the protection globally."
+      });
+    }
+    return findings;
+  }
+};
+var secretInURLParam = {
+  id: "VC146",
+  title: "Secret Passed in URL Query Parameter",
+  severity: "critical",
+  category: "Secrets",
+  description: "API keys or tokens in URL query parameters are logged in server access logs, browser history, referrer headers, and proxy logs. Secrets in URLs are one of the most common causes of credential exposure.",
+  check(content, filePath) {
+    if (isTestFile(filePath)) return [];
+    if (!filePath.match(/\.(js|ts|jsx|tsx|py|rb|go|java|php)$/)) return [];
+    const findings = [];
+    const patterns = [
+      // Template literals: `?api_key=${secret}` or `&token=${token}`
+      /[?&](?:api_key|apikey|api_secret|token|access_token|secret|key|password|auth|authorization)=\$\{/gi,
+      // String concat: '?key=' + apiKey
+      /[?&](?:api_key|apikey|api_secret|token|access_token|secret|key|password|auth)=["']\s*\+/gi,
+      // Python f-strings: f"?token={token}"
+      /[?&](?:api_key|apikey|token|access_token|secret|key|password)=\{[a-zA-Z_]/g
+    ];
+    for (const p of patterns) {
+      let m;
+      const re = new RegExp(p.source, p.flags.includes("g") ? p.flags : `${p.flags}g`);
+      while ((m = re.exec(content)) !== null) {
+        if (isCommentLine(content, m.index)) continue;
+        if (isInsideFixMessage(content, m.index)) continue;
+        const lineNum = content.substring(0, m.index).split("\n").length;
+        findings.push({
+          rule: "VC146",
+          title: this.title,
+          severity: "critical",
+          category: "Secrets",
+          file: filePath,
+          line: lineNum,
+          snippet: getSnippet(content, lineNum),
+          fix: "Pass secrets in the Authorization header (Bearer token) or request body, never in URL parameters. URL parameters are logged in server access logs, browser history, and referrer headers."
+        });
+      }
+    }
+    return findings;
+  }
+};
+var secretLoggedToConsole = {
+  id: "VC147",
+  title: "Secret Logged to Console",
+  severity: "high",
+  category: "Secrets",
+  description: "Logging variables that appear to contain secrets (key, token, password, secret) writes credentials to stdout, log files, and monitoring services where they can be harvested.",
+  check(content, filePath) {
+    if (isTestFile(filePath)) return [];
+    if (!filePath.match(/\.(js|ts|jsx|tsx)$/)) return [];
+    const findings = [];
+    const pattern = /console\.(?:log|debug|info|warn|error)\s*\([^)]*\b(api[_-]?key|apikey|secret|token|password|passwd|credentials|private[_-]?key|auth[_-]?token|access[_-]?token)\b/gi;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      if (isInsideFixMessage(content, m.index)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC147",
+        title: this.title,
+        severity: "high",
+        category: "Secrets",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Remove this console statement or redact the secret before logging. Use structured logging with a secret-redaction filter in production."
+      });
+    }
+    return findings;
+  }
+};
+var secretInErrorResponse = {
+  id: "VC148",
+  title: "Secret Leaked in Error Response",
+  severity: "critical",
+  category: "Secrets",
+  description: "Returning secrets or secret-named variables in API error responses exposes credentials to anyone who can trigger the error, including unauthenticated users.",
+  check(content, filePath) {
+    if (isTestFile(filePath)) return [];
+    if (!filePath.match(/\.(js|ts|jsx|tsx)$/)) return [];
+    const findings = [];
+    const pattern = /(?:res\.(?:json|send|status\s*\([^)]*\)\s*\.json))\s*\(\s*\{[^}]*\b(api[_-]?key|secret|token|password|credentials|private[_-]?key|process\.env\.[A-Z_]*(?:KEY|SECRET|TOKEN|PASSWORD))\b/gi;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      if (isCommentLine(content, m.index)) continue;
+      if (isInsideFixMessage(content, m.index)) continue;
+      const lineNum = content.substring(0, m.index).split("\n").length;
+      findings.push({
+        rule: "VC148",
+        title: this.title,
+        severity: "critical",
+        category: "Secrets",
+        file: filePath,
+        line: lineNum,
+        snippet: getSnippet(content, lineNum),
+        fix: "Never include secrets in API responses. Return a generic error message and log the detailed error server-side only."
+      });
+    }
+    return findings;
+  }
+};
+var secretInBundleConfig = {
+  id: "VC149",
+  title: "Secret in Client-Side Bundle Configuration",
+  severity: "critical",
+  category: "Secrets",
+  description: "Secrets defined in Webpack DefinePlugin, Vite define, or Next.js publicRuntimeConfig are embedded into the client-side JavaScript bundle and visible to anyone viewing the page source.",
+  check(content, filePath) {
+    if (isTestFile(filePath)) return [];
+    if (!filePath.match(/(?:webpack|vite|next)\.config\.|\.config\.(js|ts|mjs)$/)) return [];
+    const findings = [];
+    const patterns = [
+      // Webpack DefinePlugin with secret-named key
+      /DefinePlugin\s*\(\s*\{[^}]*\b(?:API_KEY|SECRET|TOKEN|PASSWORD|PRIVATE_KEY|CLIENT_SECRET)\b/gi,
+      // Vite define with secret-named key
+      /define\s*:\s*\{[^}]*\b(?:API_KEY|SECRET|TOKEN|PASSWORD|PRIVATE_KEY|CLIENT_SECRET)\b/gi,
+      // Next.js publicRuntimeConfig with secret-named key
+      /publicRuntimeConfig\s*:\s*\{[^}]*\b(?:apiKey|secret|token|password|privateKey|clientSecret)\b/gi
+    ];
+    for (const p of patterns) {
+      let m;
+      const re = new RegExp(p.source, p.flags.includes("g") ? p.flags : `${p.flags}g`);
+      while ((m = re.exec(content)) !== null) {
+        if (isCommentLine(content, m.index)) continue;
+        if (isInsideFixMessage(content, m.index)) continue;
+        const lineNum = content.substring(0, m.index).split("\n").length;
+        findings.push({
+          rule: "VC149",
+          title: this.title,
+          severity: "critical",
+          category: "Secrets",
+          file: filePath,
+          line: lineNum,
+          snippet: getSnippet(content, lineNum),
+          fix: "Move secrets to server-side environment variables. Only expose public configuration (like API base URLs) in client-side bundle config. Use serverRuntimeConfig (Next.js) or server-only modules."
+        });
+      }
+    }
+    return findings;
+  }
+};
+var secretInHTMLAttribute = {
+  id: "VC150",
+  title: "Secret in HTML Meta Tag or Data Attribute",
+  severity: "high",
+  category: "Secrets",
+  description: "API keys or tokens embedded in HTML meta tags or data-* attributes are visible in the page source to anyone who visits the page, including search engine crawlers.",
+  check(content, filePath) {
+    if (isTestFile(filePath)) return [];
+    if (!filePath.match(/\.(html|htm|jsx|tsx|vue|svelte|ejs|hbs|pug)$/)) return [];
+    const findings = [];
+    const patterns = [
+      // <meta name="api-key" content="...">
+      /<meta\s[^>]*name\s*=\s*["'](?:api[_-]?key|secret|token|password)[^>]*>/gi,
+      // data-api-key="actual-value" (not a template/binding)
+      /data-(?:api[_-]?key|secret|token|password|auth)\s*=\s*["'][a-zA-Z0-9_\-]{12,}["']/gi
+    ];
+    for (const p of patterns) {
+      let m;
+      const re = new RegExp(p.source, p.flags.includes("g") ? p.flags : `${p.flags}g`);
+      while ((m = re.exec(content)) !== null) {
+        if (isCommentLine(content, m.index)) continue;
+        if (isInsideFixMessage(content, m.index)) continue;
+        const lineNum = content.substring(0, m.index).split("\n").length;
+        findings.push({
+          rule: "VC150",
+          title: this.title,
+          severity: "high",
+          category: "Secrets",
+          file: filePath,
+          line: lineNum,
+          snippet: getSnippet(content, lineNum),
+          fix: "Never embed secrets in HTML attributes or meta tags. Load configuration from server-side APIs or use server-rendered environment injection with non-secret values only."
+        });
+      }
+    }
+    return findings;
+  }
+};
+var secretInCLIArgument = {
+  id: "VC151",
+  title: "Secret Passed as Command-Line Argument",
+  severity: "high",
+  category: "Secrets",
+  description: "Secrets interpolated into exec/spawn/execSync command strings are visible in process listings (ps aux), shell history, and system audit logs to any user on the same machine.",
+  check(content, filePath) {
+    if (isTestFile(filePath)) return [];
+    if (!filePath.match(/\.(js|ts|jsx|tsx|py|rb)$/)) return [];
+    const findings = [];
+    const patterns = [
+      /(?:exec|execSync|spawn|spawnSync|child_process)\s*\([^)]*\$\{[^}]*(?:api[_-]?key|secret|token|password|credentials)/gi,
+      /(?:exec|execSync|spawn|spawnSync|child_process)\s*\([^)]*["']\s*\+\s*(?:api[_-]?key|secret|token|password|credentials)/gi,
+      /(?:subprocess|os\.system|os\.popen)\s*\([^)]*\{[^}]*(?:api[_-]?key|secret|token|password|credentials)/gi
+    ];
+    for (const p of patterns) {
+      let m;
+      const re = new RegExp(p.source, p.flags.includes("g") ? p.flags : `${p.flags}g`);
+      while ((m = re.exec(content)) !== null) {
+        if (isCommentLine(content, m.index)) continue;
+        if (isInsideFixMessage(content, m.index)) continue;
+        const lineNum = content.substring(0, m.index).split("\n").length;
+        findings.push({
+          rule: "VC151",
           title: this.title,
           severity: "high",
           category: "Secrets",
@@ -5084,7 +7442,61 @@ var allCustomRules = [
   missingAIRateLimit,
   missingPagination,
   exposedDatabaseStudio,
-  insecureDirectObjectReference
+  insecureDirectObjectReference,
+  // VC159–VC183: additional service-specific API key detection
+  hardcodedCohereKey,
+  hardcodedReplicateKey,
+  hardcodedMistralKey,
+  hardcodedTogetherKey,
+  hardcodedGroqKey,
+  hardcodedFireworksKey,
+  hardcodedPostmarkKey,
+  hardcodedResendKey,
+  hardcodedLoopsKey,
+  hardcodedCloudflareToken,
+  hardcodedFastlyToken,
+  hardcodedNetlifyToken,
+  hardcodedRailwayToken,
+  hardcodedFlyToken,
+  hardcodedAlgoliaAdminKey,
+  hardcodedQdrantKey,
+  hardcodedWeaviateKey,
+  hardcodedLinearKey,
+  hardcodedNotionKey,
+  hardcodedDiscordToken,
+  hardcodedIntercomToken,
+  hardcodedSentryAuthToken,
+  hardcodedLogtailToken,
+  hardcodedHighlightKey,
+  hardcodedPlivoToken,
+  // VC184–VC187: GitHub Actions workflow security
+  ghaPullRequestTargetCheckout,
+  ghaPermissionsWriteAll,
+  ghaExpressionInjection,
+  ghaThirdPartyActionWithSecrets,
+  // VC188–VC190: Dockerfile hardening
+  dockerfileADDInsteadOfCOPY,
+  dockerfileUnverifiedShellPipe,
+  dockerfileMissingHealthcheck,
+  // VC191–VC197: Python-specific security gaps
+  pyRequestsVerifyFalse,
+  pyJinja2AutoescapeOff,
+  pyTempfileMktemp,
+  pyDjangoMarkSafe,
+  pyParamikoAutoAdd,
+  pyDjangoAllowedHostsWildcard,
+  pyJWTDecodeWeakConfig,
+  // VC198–VC203: AI / LLM-specific security
+  llmPromptInjection,
+  llmSystemPromptInjection,
+  llmOutputAsHTML,
+  vectorStoreQueryNoUserFilter,
+  vectorStoreUpsertNoMetadata,
+  llmCallNoMaxTokens,
+  // VC204–VC206: GraphQL server hardening
+  graphqlNoDepthLimit,
+  graphqlNoComplexityLimit,
+  graphqlCSRFDisabled
 ];
 function runCustomRules(content, filePath, disabledRules = [], tier = "free", extraRules = []) {
   const findings = [];
@@ -5409,7 +7821,9 @@ export {
   allRules,
   androidDebuggable,
   blockingMainThread,
+  buildTaintMap,
   calculateGrade,
+  callSpreads,
   callbackHell,
   clickjacking,
   clientComponentSecret,
@@ -5429,6 +7843,9 @@ export {
   dockerLatestTag,
   dockerRunAsRoot,
   dockerTooManyPorts,
+  dockerfileADDInsteadOfCOPY,
+  dockerfileMissingHealthcheck,
+  dockerfileUnverifiedShellPipe,
   ecbModeEncryption,
   electronNavigationUnrestricted,
   emptyCatchBlock,
@@ -5450,28 +7867,61 @@ export {
   firebaseClientConfig,
   flaskSecretKey,
   freeRules,
+  getObjectProperty,
   getSnippet,
+  ghaExpressionInjection,
+  ghaPermissionsWriteAll,
+  ghaPullRequestTargetCheckout,
+  ghaThirdPartyActionWithSecrets,
   githubActionsInjection,
+  graphqlCSRFDisabled,
   graphqlIntrospection,
+  graphqlNoComplexityLimit,
+  graphqlNoDepthLimit,
+  hardcodedAlgoliaAdminKey,
   hardcodedAnthropicKey,
+  hardcodedCloudflareToken,
+  hardcodedCohereKey,
   hardcodedDatadogKey,
+  hardcodedDiscordToken,
   hardcodedEncryptionKey,
+  hardcodedFastlyToken,
+  hardcodedFireworksKey,
+  hardcodedFlyToken,
   hardcodedGCPServiceAccount,
   hardcodedGitHubPAT,
   hardcodedGitLabToken,
+  hardcodedGroqKey,
+  hardcodedHighlightKey,
   hardcodedIPAllowlist,
+  hardcodedIntercomToken,
   hardcodedJWTSecret,
+  hardcodedLinearKey,
+  hardcodedLogtailToken,
+  hardcodedLoopsKey,
   hardcodedMailgunKey,
+  hardcodedMistralKey,
+  hardcodedNetlifyToken,
+  hardcodedNotionKey,
   hardcodedOAuthSecret,
   hardcodedPineconeKey,
+  hardcodedPlivoToken,
+  hardcodedPostmarkKey,
+  hardcodedQdrantKey,
+  hardcodedRailwayToken,
+  hardcodedReplicateKey,
+  hardcodedResendKey,
   hardcodedSecrets,
   hardcodedSendGridKey,
+  hardcodedSentryAuthToken,
   hardcodedShopifyToken,
   hardcodedSlackToken,
   hardcodedSupabaseServiceRole,
+  hardcodedTogetherKey,
   hardcodedTwilioKey,
   hardcodedVaultToken,
   hardcodedVercelToken,
+  hardcodedWeaviateKey,
   hostHeaderRedirect,
   httpRequestSmuggling,
   insecureCookies,
@@ -5486,6 +7936,8 @@ export {
   insecureRandomness,
   insecureWebSocket,
   ipcPathTraversal,
+  isCalleeNamed,
+  isMethodCall,
   javaDeserialization,
   jwtAlgConfusion,
   k8sNoResourceLimits,
@@ -5493,6 +7945,10 @@ export {
   k8sSecretNotEncrypted,
   lambdaWithoutVPC,
   largeBundleImport,
+  llmCallNoMaxTokens,
+  llmOutputAsHTML,
+  llmPromptInjection,
+  llmSystemPromptInjection,
   logInjection,
   magicNumbers,
   massAssignment,
@@ -5523,10 +7979,18 @@ export {
   nosqlInjection,
   openRedirectParams,
   overlyPermissiveIAM,
+  parseFile,
   pathTraversal,
   pickleDeserialization,
   piiInLogs,
   prototypePollution,
+  pyDjangoAllowedHostsWildcard,
+  pyDjangoMarkSafe,
+  pyJWTDecodeWeakConfig,
+  pyJinja2AutoescapeOff,
+  pyParamikoAutoAdd,
+  pyRequestsVerifyFalse,
+  pyTempfileMktemp,
   raceCondition,
   rdsPubliclyAccessible,
   reflectedCORSOrigin,
@@ -5566,6 +8030,10 @@ export {
   unvalidatedAPIParams,
   unvalidatedEventData,
   unvalidatedRedirect,
+  vectorStoreQueryNoUserFilter,
+  vectorStoreUpsertNoMetadata,
+  visitBinary,
+  visitCalls,
   vulnerableDependencies,
   weakHashing,
   weakPasswordRequirements,