circle-ir 3.194.0 → 3.197.0

package/dist/browser/circle-ir.js

@@ -11360,7 +11360,11 @@ var DEFAULT_SOURCES = [
   { method: "Json", type: "http_body", severity: "high", return_tainted: true, languages: ["rust"] },
   { method: "Query", type: "http_param", severity: "high", return_tainted: true, languages: ["rust"] },
   { method: "Path", type: "http_path", severity: "high", return_tainted: true, languages: ["rust"] },
-  { method: "Form", type: "http_param", severity: "high", return_tainted: true, languages: ["rust"] },
+  // `Form<T>` decodes the urlencoded request *body* (`Query<T>` above is the
+  // query-string extractor), so it is http_body — retyped from http_param
+  // when the RustPlugin's http_body duplicate was removed, so the two
+  // surfaces no longer disagree. Matches Gin's `Context.PostForm`.
+  { method: "Form", type: "http_body", severity: "high", return_tainted: true, languages: ["rust"] },
   // Rust std library
   { method: "var", class: "env", type: "env_input", severity: "medium", return_tainted: true },
   { method: "var_os", class: "env", type: "env_input", severity: "medium", return_tainted: true },
@@ -12638,7 +12642,11 @@ var DEFAULT_SINKS = [
   // Also match without receiver (destructured imports: const { exec } = require('child_process'))
   // `exec` is intentionally classless: catches Node.js child_process.exec AND
   // Java Runtime.exec (via `r.exec()` where heuristic can't resolve r → Runtime).
-  { method: "exec", type: "command_injection", cwe: "CWE-78", severity: "high", arg_positions: [0] },
+  // Excluded from Python: there, bare `exec(code)` is the code-execution
+  // builtin, registered below as code_injection / CWE-94. Before the exclusion
+  // a Python `exec(user_code)` matched both patterns and emitted two findings
+  // for one call — CWE-78 (wrong: no shell is involved) and CWE-94 (right).
+  { method: "exec", type: "command_injection", cwe: "CWE-78", severity: "high", arg_positions: [0], exclude_languages: ["python"] },
   // `execSync`/`spawn`/`spawnSync`/`execFile` are Node-specific — language-scope them.
   { method: "execSync", type: "command_injection", cwe: "CWE-78", severity: "high", arg_positions: [0], languages: ["javascript", "typescript"] },
   { method: "spawn", type: "command_injection", cwe: "CWE-78", severity: "high", arg_positions: [0], languages: ["javascript", "typescript"] },
@@ -12666,7 +12674,11 @@ var DEFAULT_SINKS = [
   // Note: classless { method: 'query' } removed — too many FPs (UriComponentsBuilder.query(), etc.)
   // SQL query calls are covered by class-specific patterns above (Connection, Pool, Client, JdbcTemplate)
   // Note: `raw` is shared with Python (Django ORM) — scoped to JS+TS to avoid leaking.
-  { method: "raw", type: "sql_injection", cwe: "CWE-89", severity: "high", arg_positions: [0], languages: ["javascript", "typescript"] },
+  // Severity `critical` (not `high`) preserves what the JS plugin's duplicate
+  // builtin emitted before the #4 follow-up consolidation removed it: the
+  // plugin copy carried `critical`, which won the `findSinks` dedup slot via
+  // the +0.1 critical-severity confidence boost.
+  { method: "raw", type: "sql_injection", cwe: "CWE-89", severity: "critical", arg_positions: [0], languages: ["javascript", "typescript"] },
   // sqlite3 (npm) — Database/Statement methods. The JS plugin resolves
   // `const db = new sqlite3.Database(...); db.all(sql)` to the resolution
   // target `Connection.all`, so class-scoped patterns matching `Connection`
@@ -13225,10 +13237,30 @@ var DEFAULT_SINKS = [
   { method: "Sprintf", class: "fmt", type: "format_string", cwe: "CWE-134", severity: "medium", arg_positions: [0], languages: ["go"] },
   { method: "Printf", class: "fmt", type: "format_string", cwe: "CWE-134", severity: "medium", arg_positions: [0], languages: ["go"] },
   { method: "Errorf", class: "fmt", type: "format_string", cwe: "CWE-134", severity: "medium", arg_positions: [0], languages: ["go"] },
+  // `fmt.Fprintf` is deliberately dual-classified: this CWE-134 entry and the
+  // Go plugin's xss (CWE-79) entry both cover arg[1], so a tainted format
+  // string emits two findings. Unlike the logger case above, neither is
+  // redundant — CWE-134 holds for any writer, while CWE-79 is the actionable
+  // finding when the writer is an http.ResponseWriter (`fmt.Fprintf(w, taint)`
+  // is the standard Go reflected-XSS shape). Collapsing it requires deciding
+  // by the *type of arg[0]*, which sink patterns cannot express today: the
+  // options are a Go-specific gate (mirroring isSafeGoJsonUnmarshalCall) that
+  // emits xss only for a resolved ResponseWriter, or dropping one CWE and
+  // accepting either lost XSS recall or a mis-classified stderr write.
+  // Left as-is pending the Go corpus run — see tasks.md.
   { method: "Fprintf", class: "fmt", type: "format_string", cwe: "CWE-134", severity: "medium", arg_positions: [1], languages: ["go"] },
   // cognium-dev #264 — Go stdlib `log` package format-string entry points.
   // log.Printf / Fatalf / Panicf take the format string at arg[0]; tainted
   // format string reaches the same fmt.Sprintf machinery internally.
+  //
+  // These deliberately coexist with the Go plugin's log_injection (CWE-117)
+  // entries for the same methods, so such a call emits both. The Logger
+  // decision note in the Java log_injection section above does NOT apply
+  // here: it reasons about SLF4J-style APIs where the format string is a
+  // literal with `{}` placeholders, whereas Go's `log.Printf(fmt, ...)` takes
+  // a real format string that an attacker can control. CWE-117 covers the
+  // forged log line, CWE-134 the format string itself. Locked by
+  // tests/analysis/passes/format-string-additions.test.ts.
   { method: "Printf", class: "log", type: "format_string", cwe: "CWE-134", severity: "medium", arg_positions: [0], languages: ["go"] },
   { method: "Fatalf", class: "log", type: "format_string", cwe: "CWE-134", severity: "medium", arg_positions: [0], languages: ["go"] },
   { method: "Panicf", class: "log", type: "format_string", cwe: "CWE-134", severity: "medium", arg_positions: [0], languages: ["go"] },
@@ -13242,6 +13274,14 @@ var DEFAULT_SINKS = [
   { method: "cookie", type: "crlf", cwe: "CWE-113", severity: "medium", arg_positions: [1], languages: ["javascript", "typescript"] },
   // Express: res.location(url) and res.redirect(url) — Location header.
   { method: "location", type: "crlf", cwe: "CWE-113", severity: "medium", arg_positions: [0], languages: ["javascript", "typescript"] },
+  // `redirect` is deliberately dual-classified: this crlf (CWE-113) entry
+  // coexists with the open_redirect (CWE-601) entry for js/ts, so a tainted
+  // redirect target emits two flows. That is intentional, not duplication —
+  // #189 Sprint 82 shipped a sink-type-aware flow dedup specifically so both
+  // survive ("res.redirect is both open_redirect AND crlf"), and #132 added a
+  // crlf recall test for the bare `res.redirect(req.query.url)` shape. Locked
+  // by issue-189-sprint82-open-redirect-cluster.test.ts and
+  // crlf-stage8-fp.test.ts — do not collapse without revisiting both tickets.
   { method: "redirect", type: "crlf", cwe: "CWE-113", severity: "medium", arg_positions: [0], languages: ["javascript", "typescript"] },
   // Go net/http: w.Header().Set(k, v) / Add(k, v) — first arg is the value
   // (Header is a map; the actual `value` is arg 1 of the call). We flag the
@@ -14162,18 +14202,28 @@ function analyzeTaint(calls, types, config = getDefaultConfig(), typeHierarchy,
   const sanitizers = findSanitizers(calls, types, config.sanitizers, sourceLines);
   return { sources, sinks, sanitizers };
 }
+function sinkPatternAppliesTo(pattern, language) {
+  if (language === void 0) return true;
+  if (pattern.languages && pattern.languages.length > 0 && !pattern.languages.includes(language)) {
+    return false;
+  }
+  if (pattern.exclude_languages && pattern.exclude_languages.includes(language)) {
+    return false;
+  }
+  return true;
+}
 function expandPromisifyAliases(patterns, sourceLines, language) {
   if (!sourceLines || sourceLines.length === 0) return patterns;
   if (language !== "javascript" && language !== "typescript") return patterns;
   const PROMISIFY_RE = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:util\s*\.\s*)?promisify\s*\(\s*([A-Za-z_$][\w$]*)\s*\)/;
   const innerToPattern = /* @__PURE__ */ new Map();
   for (const p of patterns) {
-    if (p.languages && !p.languages.includes(language)) continue;
+    if (!sinkPatternAppliesTo(p, language)) continue;
     if (p.class !== void 0) continue;
     if (!innerToPattern.has(p.method)) innerToPattern.set(p.method, p);
   }
   for (const p of patterns) {
-    if (p.languages && !p.languages.includes(language)) continue;
+    if (!sinkPatternAppliesTo(p, language)) continue;
     if (innerToPattern.has(p.method)) continue;
     innerToPattern.set(p.method, p);
   }
@@ -14207,7 +14257,7 @@ function expandIndirectEvalAliases(patterns, sourceLines, language) {
   const INDIRECT_EVAL_RE = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=\s*(eval|Function)\b(?!\s*\()/;
   const innerToPattern = /* @__PURE__ */ new Map();
   for (const p of patterns) {
-    if (p.languages && !p.languages.includes(language)) continue;
+    if (!sinkPatternAppliesTo(p, language)) continue;
     if (p.class !== void 0) continue;
     if (p.method !== "eval" && p.method !== "Function") continue;
     if (!innerToPattern.has(p.method)) innerToPattern.set(p.method, p);
@@ -14915,9 +14965,7 @@ function isSafeJinjaRenderCall(call, pattern, language, sourceLines) {
   return false;
 }
 function findSinks(calls, patterns, typeHierarchy, language, sourceLines, types) {
-  const patternsForLanguage = language === void 0 ? patterns : patterns.filter(
-    (p) => !p.languages || p.languages.length === 0 || p.languages.includes(language)
-  );
+  const patternsForLanguage = language === void 0 ? patterns : patterns.filter((p) => sinkPatternAppliesTo(p, language));
   const sinkMap = /* @__PURE__ */ new Map();
   for (const call of calls) {
     for (const pattern of patternsForLanguage) {
@@ -15262,10 +15310,8 @@ var SINK_FQN_EXCLUSIONS = {
   ]
 };
 function matchesSinkPattern(call, pattern, typeHierarchy, language) {
-  if (pattern.languages && pattern.languages.length > 0 && language !== void 0) {
-    if (!pattern.languages.includes(language)) {
-      return false;
-    }
+  if (!sinkPatternAppliesTo(pattern, language)) {
+    return false;
   }
   const callMethodName = call.method_name;
   const patternMethod = pattern.method;
@@ -22146,107 +22192,30 @@ var JavaPlugin = class extends BaseLanguagePlugin {
         severity: "high",
         confidence: 0.9,
         returnTainted: true
-      },
-      // Servlet API
-      {
-        method: "getParameter",
-        class: "HttpServletRequest",
-        type: "http_param",
-        severity: "high",
-        confidence: 0.95,
-        returnTainted: true
-      },
-      {
-        method: "getParameterValues",
-        class: "HttpServletRequest",
-        type: "http_param",
-        severity: "high",
-        confidence: 0.95,
-        returnTainted: true
-      },
-      {
-        method: "getHeader",
-        class: "HttpServletRequest",
-        type: "http_header",
-        severity: "high",
-        confidence: 0.9,
-        returnTainted: true
-      },
-      {
-        method: "getCookies",
-        class: "HttpServletRequest",
-        type: "http_cookie",
-        severity: "high",
-        confidence: 0.9,
-        returnTainted: true
-      },
-      {
-        method: "getInputStream",
-        class: "HttpServletRequest",
-        type: "http_body",
-        severity: "high",
-        confidence: 0.85,
-        returnTainted: true
-      },
-      {
-        method: "getReader",
-        class: "HttpServletRequest",
-        type: "http_body",
-        severity: "high",
-        confidence: 0.85,
-        returnTainted: true
       }
+      // NOTE: the Servlet API call sources (`HttpServletRequest.getParameter`,
+      // `getParameterValues`, `getHeader`, `getCookies`, `getInputStream`,
+      // `getReader`) are registered identically in DEFAULT_SOURCES. Because
+      // `findSources` pushes one TaintSource per matching pattern with no
+      // dedup, the duplicates emitted a second, byte-identical source at every
+      // call site. Removed in the #4 follow-up consolidation — DEFAULT_SOURCES
+      // is the canonical registry (ADR-004).
     ];
   }
   /**
    * Java-specific taint sink patterns.
-   * These supplement the YAML configuration.
+   *
+   * Only patterns that have NO counterpart in `DEFAULT_SINKS` belong here —
+   * `DEFAULT_SINKS` (`analysis/config-loader.ts`) is the canonical registry
+   * (ADR-004). Duplicated entries were dead weight: `TaintMatcherPass` merges
+   * plugin builtins *after* the config patterns, and `findSinks` dedupes by
+   * `location:line:cwe` keeping the higher-confidence match, so the config
+   * copy always won the slot. Removed in the #4 follow-up consolidation
+   * (`Statement.execute*`, `Runtime.exec`, `ProcessBuilder.start`,
+   * `PrintWriter.write/println`, `DirContext.search`, `XPath.evaluate`).
    */
   getBuiltinSinks() {
     return [
-      // SQL Injection
-      {
-        method: "executeQuery",
-        class: "Statement",
-        type: "sql_injection",
-        cwe: "CWE-89",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "executeUpdate",
-        class: "Statement",
-        type: "sql_injection",
-        cwe: "CWE-89",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "execute",
-        class: "Statement",
-        type: "sql_injection",
-        cwe: "CWE-89",
-        severity: "critical",
-        argPositions: [0]
-      },
-      // Command Injection
-      {
-        method: "exec",
-        class: "Runtime",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "start",
-        class: "ProcessBuilder",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: []
-        // Constructor args are dangerous
-      },
       // Path Traversal
       {
         method: "FileInputStream",
@@ -22262,41 +22231,6 @@ var JavaPlugin = class extends BaseLanguagePlugin {
         severity: "high",
         argPositions: [0]
       },
-      // XSS
-      {
-        method: "write",
-        class: "PrintWriter",
-        type: "xss",
-        cwe: "CWE-79",
-        severity: "high",
-        argPositions: [0]
-      },
-      {
-        method: "println",
-        class: "PrintWriter",
-        type: "xss",
-        cwe: "CWE-79",
-        severity: "high",
-        argPositions: [0]
-      },
-      // LDAP Injection
-      {
-        method: "search",
-        class: "DirContext",
-        type: "ldap_injection",
-        cwe: "CWE-90",
-        severity: "high",
-        argPositions: [0, 1]
-      },
-      // XPath Injection
-      {
-        method: "evaluate",
-        class: "XPath",
-        type: "xpath_injection",
-        cwe: "CWE-643",
-        severity: "high",
-        argPositions: [0]
-      },
       // Deserialization
       {
         method: "readObject",
@@ -22855,42 +22789,17 @@ var JavaScriptPlugin = class extends BaseLanguagePlugin {
   }
   /**
    * JavaScript/TypeScript taint sink patterns.
+   *
+   * Only patterns that have NO counterpart in `DEFAULT_SINKS` belong here —
+   * `DEFAULT_SINKS` (`analysis/config-loader.ts`) is the canonical registry
+   * (ADR-004). Duplicated entries were dead weight: `TaintMatcherPass` merges
+   * plugin builtins *after* the config patterns, and `findSinks` dedupes by
+   * `location:line:cwe` keeping the higher-confidence match, so the config
+   * copy always won the slot. Removed in the #4 follow-up consolidation.
    */
   getBuiltinSinks() {
     return [
-      // Command Injection
-      {
-        method: "exec",
-        class: "child_process",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "execSync",
-        class: "child_process",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "spawn",
-        class: "child_process",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0, 1]
-      },
       // Code Injection
-      {
-        method: "eval",
-        type: "code_injection",
-        cwe: "CWE-94",
-        severity: "critical",
-        argPositions: [0]
-      },
       {
         method: "Function",
         type: "code_injection",
@@ -22914,46 +22823,7 @@ var JavaScriptPlugin = class extends BaseLanguagePlugin {
         argPositions: [0]
         // When first arg is string
       },
-      // Path Traversal
-      {
-        method: "readFileSync",
-        class: "fs",
-        type: "path_traversal",
-        cwe: "CWE-22",
-        severity: "high",
-        argPositions: [0]
-      },
-      {
-        method: "writeFileSync",
-        class: "fs",
-        type: "path_traversal",
-        cwe: "CWE-22",
-        severity: "high",
-        argPositions: [0]
-      },
-      {
-        method: "createReadStream",
-        class: "fs",
-        type: "path_traversal",
-        cwe: "CWE-22",
-        severity: "high",
-        argPositions: [0]
-      },
       // XSS (DOM)
-      {
-        method: "innerHTML",
-        type: "xss",
-        cwe: "CWE-79",
-        severity: "high",
-        argPositions: [0]
-      },
-      {
-        method: "outerHTML",
-        type: "xss",
-        cwe: "CWE-79",
-        severity: "high",
-        argPositions: [0]
-      },
       {
         method: "document.write",
         type: "xss",
@@ -23005,13 +22875,6 @@ var JavaScriptPlugin = class extends BaseLanguagePlugin {
         severity: "critical",
         argPositions: [0]
       },
-      {
-        method: "raw",
-        type: "sql_injection",
-        cwe: "CWE-89",
-        severity: "critical",
-        argPositions: [0]
-      },
       // Prisma ORM - unsafe raw query methods ($executeRaw/$queryRaw with template literals are safe/parameterized)
       {
         method: "$executeRawUnsafe",
@@ -23027,30 +22890,6 @@ var JavaScriptPlugin = class extends BaseLanguagePlugin {
         severity: "critical",
         argPositions: [0]
       },
-      // SSRF
-      {
-        method: "fetch",
-        type: "ssrf",
-        cwe: "CWE-918",
-        severity: "high",
-        argPositions: [0]
-      },
-      {
-        method: "get",
-        class: "axios",
-        type: "ssrf",
-        cwe: "CWE-918",
-        severity: "high",
-        argPositions: [0]
-      },
-      {
-        method: "request",
-        class: "http",
-        type: "ssrf",
-        cwe: "CWE-918",
-        severity: "high",
-        argPositions: [0]
-      },
       // NoSQL Injection
       {
         method: "find",
@@ -23059,13 +22898,6 @@ var JavaScriptPlugin = class extends BaseLanguagePlugin {
         severity: "high",
         argPositions: [0]
       },
-      {
-        method: "findOne",
-        type: "nosql_injection",
-        cwe: "CWE-943",
-        severity: "high",
-        argPositions: [0]
-      },
       // Prototype Pollution (JS-specific)
       {
         method: "merge",
@@ -23159,14 +22991,9 @@ var JavaScriptPlugin = class extends BaseLanguagePlugin {
       // =========================================================
       // Next.js Sinks
       // =========================================================
-      {
-        // Server-side redirect
-        method: "redirect",
-        type: "open_redirect",
-        cwe: "CWE-601",
-        severity: "high",
-        argPositions: [0]
-      },
+      // NOTE: classless `redirect` (CWE-601) lives in DEFAULT_SINKS, scoped to
+      // javascript+typescript — the duplicate builtin here never won the dedup
+      // slot (equal confidence, config pattern iterates first).
       {
         // Router push with user-controlled URL
         method: "push",
@@ -23448,13 +23275,15 @@ var PythonPlugin = class extends BaseLanguagePlugin {
         returnTainted: true
       },
       // Standard library sources
-      {
-        method: "input",
-        type: "user_input",
-        severity: "high",
-        confidence: 0.95,
-        returnTainted: true
-      },
+      //
+      // `input()` and `os.getenv()` are registered in DEFAULT_SOURCES as
+      // `io_input` / `env_input`. The duplicates that used to sit here typed
+      // them `user_input` / `env_var` — strings outside the published
+      // `SourceType` union, which reach consumers only because the merge in
+      // TaintMatcherPass casts `TaintSourcePattern.type` (a bare `string`) to
+      // `SourceType`. Both entries fired, so one call emitted two sources with
+      // two different type strings. Removed in favour of the canonical
+      // registry (ADR-004).
       {
         method: "argv",
         class: "sys",
@@ -23470,153 +23299,37 @@ var PythonPlugin = class extends BaseLanguagePlugin {
         severity: "medium",
         confidence: 0.85,
         returnTainted: true
-      },
-      {
-        method: "getenv",
-        class: "os",
-        type: "env_var",
-        severity: "medium",
-        confidence: 0.85,
-        returnTainted: true
-      },
-      // File reading
-      {
-        method: "read",
-        type: "file_input",
-        severity: "medium",
-        confidence: 0.8,
-        returnTainted: true
-      },
-      {
-        method: "readline",
-        type: "file_input",
-        severity: "medium",
-        confidence: 0.8,
-        returnTainted: true
-      },
-      {
-        method: "readlines",
-        type: "file_input",
-        severity: "medium",
-        confidence: 0.8,
-        returnTainted: true
       }
+      // NOTE: the file-reading sources (`read`, `readline`, `readlines` as
+      // file_input) are registered identically in DEFAULT_SOURCES. Since
+      // `findSources` pushes one TaintSource per matching pattern with no
+      // dedup, these duplicates emitted a second, byte-identical source at
+      // every call site. Removed in the #4 follow-up consolidation —
+      // DEFAULT_SOURCES is the canonical registry (ADR-004).
     ];
   }
   /**
    * Python taint sink patterns.
+   *
+   * Only patterns that have NO counterpart in `DEFAULT_SINKS` belong here —
+   * `DEFAULT_SINKS` (`analysis/config-loader.ts`) is the canonical registry
+   * (ADR-004). Duplicated entries were dead weight: `TaintMatcherPass` merges
+   * plugin builtins *after* the config patterns, and `findSinks` dedupes by
+   * `location:line:cwe` keeping the higher-confidence match, so the config
+   * copy always won the slot. Removed in the #4 follow-up consolidation.
    */
   getBuiltinSinks() {
     return [
-      // Command Injection
+      // Path Traversal
       {
-        method: "system",
-        class: "os",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "popen",
-        class: "os",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "run",
-        class: "subprocess",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "call",
-        class: "subprocess",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "Popen",
-        class: "subprocess",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0]
-      },
-      // Code Injection
-      {
-        method: "eval",
-        type: "code_injection",
-        cwe: "CWE-94",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "exec",
-        type: "code_injection",
-        cwe: "CWE-94",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "compile",
-        type: "code_injection",
-        cwe: "CWE-94",
-        severity: "high",
-        argPositions: [0]
-      },
-      // SQL Injection
-      {
-        method: "execute",
-        type: "sql_injection",
-        cwe: "CWE-89",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "executemany",
-        type: "sql_injection",
-        cwe: "CWE-89",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "raw",
-        type: "sql_injection",
-        cwe: "CWE-89",
-        severity: "critical",
-        argPositions: [0]
-      },
-      // Path Traversal
-      {
-        method: "open",
-        type: "path_traversal",
-        cwe: "CWE-22",
-        severity: "high",
-        argPositions: [0]
-      },
-      {
-        method: "read",
-        class: "pathlib",
-        type: "path_traversal",
-        cwe: "CWE-22",
-        severity: "high",
-        argPositions: [0]
-      },
-      // XSS (template injection)
-      {
-        method: "Markup",
-        type: "xss",
-        cwe: "CWE-79",
-        severity: "high",
+        method: "read",
+        class: "pathlib",
+        type: "path_traversal",
+        cwe: "CWE-22",
+        severity: "high",
         argPositions: [0]
       },
+      // XSS (template injection)
       {
         method: "safe",
         type: "xss",
@@ -23625,22 +23338,6 @@ var PythonPlugin = class extends BaseLanguagePlugin {
         argPositions: [0]
       },
       // SSRF
-      {
-        method: "get",
-        class: "requests",
-        type: "ssrf",
-        cwe: "CWE-918",
-        severity: "high",
-        argPositions: [0]
-      },
-      {
-        method: "post",
-        class: "requests",
-        type: "ssrf",
-        cwe: "CWE-918",
-        severity: "high",
-        argPositions: [0]
-      },
       {
         method: "urlopen",
         class: "urllib",
@@ -23668,34 +23365,11 @@ var PythonPlugin = class extends BaseLanguagePlugin {
         argPositions: [1]
       },
       // Deserialization
-      {
-        method: "loads",
-        class: "pickle",
-        type: "deserialization",
-        cwe: "CWE-502",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "load",
-        class: "pickle",
-        type: "deserialization",
-        cwe: "CWE-502",
-        severity: "critical",
-        argPositions: [0]
-      },
       // NOTE: yaml.safe_load / yaml.SafeLoader are intentionally NOT sinks.
       // safe_load constructs only standard scalar/list/dict types and cannot
       // instantiate arbitrary Python objects, so it is not a CWE-502 sink
-      // (unlike yaml.load / yaml.unsafe_load / yaml.full_load below).
-      {
-        method: "load",
-        class: "yaml",
-        type: "deserialization",
-        cwe: "CWE-502",
-        severity: "critical",
-        argPositions: [0]
-      },
+      // (unlike yaml.load — registered in DEFAULT_SINKS — and
+      // yaml.unsafe_load / yaml.full_load below).
       {
         method: "unsafe_load",
         class: "yaml",
@@ -23854,34 +23528,17 @@ var RustPlugin = class extends BaseLanguagePlugin {
   getBuiltinSources() {
     return [
       // Actix-web request extractors
-      {
-        method: "Query",
-        type: "http_param",
-        severity: "high",
-        confidence: 0.95,
-        returnTainted: true
-      },
-      {
-        method: "Json",
-        type: "http_body",
-        severity: "high",
-        confidence: 0.95,
-        returnTainted: true
-      },
-      {
-        method: "Path",
-        type: "http_path",
-        severity: "high",
-        confidence: 0.95,
-        returnTainted: true
-      },
-      {
-        method: "Form",
-        type: "http_body",
-        severity: "high",
-        confidence: 0.95,
-        returnTainted: true
-      },
+      // NOTE: `Query` (http_param), `Json` (http_body) and `Path` (http_path)
+      // are registered identically in DEFAULT_SOURCES; the duplicates here
+      // emitted a second, byte-identical source at every call site
+      // (`findSources` has no dedup). Removed in the #4 follow-up
+      // consolidation — DEFAULT_SOURCES is the canonical registry (ADR-004).
+      // `Form` stays because the two surfaces disagree on its type
+      // `Form` is registered in DEFAULT_SOURCES, retyped there to `http_body`
+      // to match this entry (actix/axum `Form<T>` decodes the urlencoded
+      // request body, not the query string — `Query<T>` is the query one).
+      // The duplicate that used to sit here made every extractor emit two
+      // sources with different types.
       // Standard library sources
       {
         method: "args",
@@ -23931,20 +23588,22 @@ var RustPlugin = class extends BaseLanguagePlugin {
         severity: "medium",
         confidence: 0.8,
         returnTainted: true
-      },
-      // Network input
-      {
-        method: "read",
-        class: "TcpStream",
-        type: "network_input",
-        severity: "high",
-        confidence: 0.85,
-        returnTainted: true
       }
+      // NOTE: `TcpStream.read` (network_input) is registered identically in
+      // DEFAULT_SOURCES — duplicate removed in the #4 follow-up consolidation.
     ];
   }
   /**
    * Rust taint sink patterns.
+   *
+   * Only patterns that have NO counterpart in `DEFAULT_SINKS` belong here —
+   * `DEFAULT_SINKS` (`analysis/config-loader.ts`) is the canonical registry
+   * (ADR-004). Duplicated entries were dead weight: `TaintMatcherPass` merges
+   * plugin builtins *after* the config patterns, and `findSinks` dedupes by
+   * `location:line:cwe` keeping the higher-confidence match, so the config
+   * copy always won the slot. Removed in the #4 follow-up consolidation
+   * (`Command.arg/args`, classless `execute`, `File.open/create`,
+   * `serde_json.from_str/from_slice`, `reqwest.get/post`).
    */
   getBuiltinSinks() {
     return [
@@ -23957,30 +23616,7 @@ var RustPlugin = class extends BaseLanguagePlugin {
         severity: "critical",
         argPositions: [0]
       },
-      {
-        method: "arg",
-        class: "Command",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0]
-      },
-      {
-        method: "args",
-        class: "Command",
-        type: "command_injection",
-        cwe: "CWE-78",
-        severity: "critical",
-        argPositions: [0]
-      },
       // SQL Injection
-      {
-        method: "execute",
-        type: "sql_injection",
-        cwe: "CWE-89",
-        severity: "critical",
-        argPositions: [0]
-      },
       {
         method: "query",
         type: "sql_injection",
@@ -23996,22 +23632,6 @@ var RustPlugin = class extends BaseLanguagePlugin {
         argPositions: [0]
       },
       // Path Traversal
-      {
-        method: "open",
-        class: "File",
-        type: "path_traversal",
-        cwe: "CWE-22",
-        severity: "high",
-        argPositions: [0]
-      },
-      {
-        method: "create",
-        class: "File",
-        type: "path_traversal",
-        cwe: "CWE-22",
-        severity: "high",
-        argPositions: [0]
-      },
       {
         method: "read_to_string",
         class: "std::fs",
@@ -24051,40 +23671,6 @@ var RustPlugin = class extends BaseLanguagePlugin {
         severity: "critical",
         argPositions: [0]
       },
-      // Deserialization (with serde)
-      {
-        method: "from_str",
-        class: "serde_json",
-        type: "deserialization",
-        cwe: "CWE-502",
-        severity: "medium",
-        argPositions: [0]
-      },
-      {
-        method: "from_slice",
-        class: "serde_json",
-        type: "deserialization",
-        cwe: "CWE-502",
-        severity: "medium",
-        argPositions: [0]
-      },
-      // SSRF
-      {
-        method: "get",
-        class: "reqwest",
-        type: "ssrf",
-        cwe: "CWE-918",
-        severity: "high",
-        argPositions: [0]
-      },
-      {
-        method: "post",
-        class: "reqwest",
-        type: "ssrf",
-        cwe: "CWE-918",
-        severity: "high",
-        argPositions: [0]
-      },
       // Regex DoS
       {
         method: "new",
@@ -24199,14 +23785,13 @@ var BashPlugin = class extends BaseLanguagePlugin {
    */
   getBuiltinSources() {
     return [
-      // read built-in reads user input from stdin.
-      {
-        method: "read",
-        type: "io_input",
-        severity: "high",
-        confidence: 0.9,
-        returnTainted: true
-      },
+      // NOTE: no `read` entry here. The `read` builtin is covered precisely by
+      // `findBashTaintSources` (language-sources-pass, #213 slice 3), which
+      // emits `io_input` *with the bound variable name* for `read x`,
+      // `read -p "…" x`, `read -a arr`, bare `read` → `$REPLY`, etc. This
+      // pattern-based duplicate added a second, variable-less source on the
+      // same line, and typed it differently from the classless `read`
+      // (file_input) entry in DEFAULT_SOURCES that it collided with.
       // curl/wget output as taint sources for supply-chain attack patterns
       // (e.g., curl ... | sh, $(curl ...) piped to eval/bash).
       {
@@ -24232,14 +23817,11 @@ var BashPlugin = class extends BaseLanguagePlugin {
    */
   getBuiltinSinks() {
     return [
-      // Code / command injection via eval
-      {
-        method: "eval",
-        type: "code_injection",
-        cwe: "CWE-94",
-        severity: "critical",
-        argPositions: [0]
-      },
+      // NOTE: classless `eval` (CWE-94, critical) is registered unscoped in
+      // DEFAULT_SINKS and already covers Bash; the duplicate builtin that used
+      // to sit here never won the findSinks dedup slot (equal confidence, the
+      // config pattern iterates first). Removed in the #4 follow-up
+      // consolidation — DEFAULT_SINKS is the canonical registry (ADR-004).
       // Command injection: spawning a sub-shell with -c flag
       {
         method: "bash",
@@ -24681,30 +24263,15 @@ var GoPlugin = class extends BaseLanguagePlugin {
         returnTainted: true
       },
       // Gin framework
-      {
-        method: "Query",
-        class: "Context",
-        type: "http_param",
-        severity: "high",
-        confidence: 0.95,
-        returnTainted: true
-      },
-      {
-        method: "Param",
-        class: "Context",
-        type: "http_path",
-        severity: "high",
-        confidence: 0.95,
-        returnTainted: true
-      },
-      {
-        method: "PostForm",
-        class: "Context",
-        type: "http_param",
-        severity: "high",
-        confidence: 0.95,
-        returnTainted: true
-      },
+      // NOTE: `Context.Query` (http_param) and `Context.Param` (http_path) are
+      // registered identically in DEFAULT_SOURCES; the duplicates here emitted
+      // a second, byte-identical source at every call site (`findSources` has
+      // no dedup). Removed in the #4 follow-up consolidation — DEFAULT_SOURCES
+      // is the canonical registry (ADR-004). `PostForm` stays because the two
+      // `Context.PostForm` is registered in DEFAULT_SOURCES as `http_body`,
+      // which is the accurate type — Gin reads it from the POST body, not the
+      // query string. The duplicate that used to sit here typed it
+      // `http_param`, so one call emitted two sources with different types.
       {
         method: "GetRawData",
         class: "Context",
@@ -24750,6 +24317,10 @@ var GoPlugin = class extends BaseLanguagePlugin {
   }
   /**
    * Go taint sink patterns.
+   *
+   * Only patterns that have NO counterpart in `DEFAULT_SINKS` belong here —
+   * `DEFAULT_SINKS` (`analysis/config-loader.ts`) is the canonical registry
+   * (ADR-004). See the #4 follow-up consolidation note on the other plugins.
    */
   getBuiltinSinks() {
     return [
@@ -24926,14 +24497,9 @@ var GoPlugin = class extends BaseLanguagePlugin {
         severity: "medium",
         argPositions: [0]
       },
-      {
-        method: "Decode",
-        class: "Decoder",
-        type: "deserialization",
-        cwe: "CWE-502",
-        severity: "medium",
-        argPositions: [0]
-      },
+      // NOTE: `Decoder.Decode` (CWE-502) lives in DEFAULT_SINKS at severity
+      // `high`, which outranked this duplicate's `medium` in the findSinks
+      // dedup — removed in the #4 follow-up consolidation.
       // Log Injection — `log.Printf("event=%s", userInput)` allows
       // CRLF/log forging when the format string interpolates user data.
       // CWE-117. (cognium-dev #107)
@@ -26283,6 +25849,10 @@ var LanguageSourcesPass = class {
       additionalSanitizers.push(...findPythonRangeCheckGuardSanitizers(code));
       additionalSanitizers.push(...findPythonRegexAllowlistWrapperSanitizers(code));
       additionalSanitizers.push(...findPythonSetMembershipXssGuardSanitizers(code));
+      additionalSanitizers.push(...findPythonTraversalRejectGuardSanitizers(code));
+      additionalSanitizers.push(...findPythonStringLiteralGuardSanitizers(code));
+      additionalSanitizers.push(...findPythonDefaultSaxParserXxeSanitizers(code));
+      additionalSanitizers.push(...findPythonUrlAllowlistRedirectSanitizers(code));
       additionalSanitizers.push(...findPythonDefusedXmlSanitizers(code));
       additionalSanitizers.push(...findPythonJinjaAutoescapeSanitizers(code));
       const pyMisconfigFindings = findPythonPatternFindings(code, graph.ir.meta.file);
@@ -26897,13 +26467,138 @@ function findPythonAssignmentSources(sourceCode, language) {
   }
   return sources;
 }
+function evaluatePythonConstExpression(expr, consts) {
+  const COMPARISON = /(<=|>=|==|!=|<|>)/;
+  const parts2 = expr.split(COMPARISON);
+  if (parts2.length === 3) {
+    const left = evaluatePythonConstExpression(parts2[0], consts);
+    const right = evaluatePythonConstExpression(parts2[2], consts);
+    if (typeof left !== "number" || typeof right !== "number") return void 0;
+    switch (parts2[1]) {
+      case "<":
+        return left < right;
+      case ">":
+        return left > right;
+      case "<=":
+        return left <= right;
+      case ">=":
+        return left >= right;
+      case "==":
+        return left === right;
+      case "!=":
+        return left !== right;
+      default:
+        return void 0;
+    }
+  }
+  if (parts2.length !== 1) return void 0;
+  const matched = expr.match(/\d+|[A-Za-z_][A-Za-z0-9_]*|\/\/|[-+*/%()]|\S/g);
+  if (!matched) return void 0;
+  const tokens = matched;
+  let pos = 0;
+  const peek = () => tokens[pos];
+  const parseFactor = () => {
+    const tok = tokens[pos++];
+    if (tok === void 0) return void 0;
+    if (tok === "(") {
+      const inner = parseSum();
+      if (tokens[pos++] !== ")") return void 0;
+      return inner;
+    }
+    if (tok === "-") {
+      const operand = parseFactor();
+      return operand === void 0 ? void 0 : -operand;
+    }
+    if (/^\d+$/.test(tok)) return Number(tok);
+    if (/^[A-Za-z_]/.test(tok)) return consts.get(tok);
+    return void 0;
+  };
+  const parseTerm = () => {
+    let value = parseFactor();
+    if (value === void 0) return void 0;
+    while (peek() === "*" || peek() === "/" || peek() === "//" || peek() === "%") {
+      const op = tokens[pos++];
+      const rhs = parseFactor();
+      if (rhs === void 0) return void 0;
+      if ((op === "/" || op === "//" || op === "%") && rhs === 0) return void 0;
+      if (op === "*") value *= rhs;
+      else if (op === "/") value /= rhs;
+      else if (op === "//") value = Math.floor(value / rhs);
+      else value = (value % rhs + rhs) % rhs;
+    }
+    return value;
+  };
+  function parseSum() {
+    let value = parseTerm();
+    if (value === void 0) return void 0;
+    while (peek() === "+" || peek() === "-") {
+      const op = tokens[pos++];
+      const rhs = parseTerm();
+      if (rhs === void 0) return void 0;
+      value = op === "+" ? value + rhs : value - rhs;
+    }
+    return value;
+  }
+  const result = parseSum();
+  return pos === tokens.length ? result : void 0;
+}
+function normalizeListIndex(index, length) {
+  const resolved = index < 0 ? length + index : index;
+  return resolved >= 0 && resolved < length ? resolved : void 0;
+}
+function computeDeadPythonBranchLines(lines) {
+  const dead = /* @__PURE__ */ new Set();
+  const consts = /* @__PURE__ */ new Map();
+  const indentOf = (line) => line.length - line.trimStart().length;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    const assign = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=(?!=)\s*(.+)$/);
+    if (assign) {
+      const value = evaluatePythonConstExpression(assign[2].trim(), consts);
+      if (typeof value === "number") consts.set(assign[1], value);
+      else consts.delete(assign[1]);
+    }
+    const ifMatch = line.match(/^(\s*)if\s+(.+?)\s*:\s*$/);
+    if (!ifMatch) continue;
+    const indent = ifMatch[1].length;
+    const decided = evaluatePythonConstExpression(ifMatch[2].trim(), consts);
+    if (decided !== true && decided !== false) continue;
+    const thenStart = i2 + 1;
+    let cursor = thenStart;
+    while (cursor < lines.length && (lines[cursor].trim() === "" || indentOf(lines[cursor]) > indent)) {
+      cursor++;
+    }
+    const thenEnd = cursor - 1;
+    let elseStart = -1;
+    let elseEnd = -1;
+    if (cursor < lines.length && indentOf(lines[cursor]) === indent) {
+      if (/^\s*elif\b/.test(lines[cursor])) continue;
+      if (/^\s*else\s*:\s*$/.test(lines[cursor])) {
+        elseStart = cursor + 1;
+        let k = elseStart;
+        while (k < lines.length && (lines[k].trim() === "" || indentOf(lines[k]) > indent)) k++;
+        elseEnd = k - 1;
+      }
+    }
+    if (decided === true) {
+      for (let l = elseStart; l >= 0 && l <= elseEnd; l++) dead.add(l);
+    } else {
+      for (let l = thenStart; l <= thenEnd; l++) dead.add(l);
+    }
+  }
+  return dead;
+}
 function buildPythonTaintedVars(sourceCode) {
   const tainted = /* @__PURE__ */ new Map();
   const containerTainted = /* @__PURE__ */ new Map();
   const lines = sourceCode.split("\n");
+  const deadBranchLines = computeDeadPythonBranchLines(lines);
+  const listElems = /* @__PURE__ */ new Map();
+  const intConsts = /* @__PURE__ */ new Map();
   for (let i2 = 0; i2 < lines.length; i2++) {
     const line = lines[i2];
     if (line.trimStart().startsWith("#")) continue;
+    if (deadBranchLines.has(i2)) continue;
     const subscriptAssign = line.match(/^\s*([\p{L}\p{N}_]+)\[(['"])([^'"]+)\2\]\s*=\s*(.+)$/u);
     if (subscriptAssign) {
       const [, container, , key, rhs2] = subscriptAssign;
@@ -26920,10 +26615,48 @@ function buildPythonTaintedVars(sourceCode) {
     }
     const containerAppendMatch = line.match(/^\s*([\p{L}\p{N}_]+)\.(append|extend|insert|add|push|put|appendleft)\s*\(\s*(.+?)\s*\)\s*$/u);
     if (containerAppendMatch) {
-      const [, receiver, , argExpr] = containerAppendMatch;
+      const [, receiver, method, argExpr] = containerAppendMatch;
       const argIsTainted = [...tainted.keys()].some((v) => new RegExp(`(?<![\\p{L}\\p{N}_])${v}(?![\\p{L}\\p{N}_])`, "u").test(argExpr));
       const argIsDirectSource = PYTHON_TAINTED_PATTERNS2.some((p) => p.pattern.test(argExpr));
       if (argIsTainted || argIsDirectSource) tainted.set(receiver, tainted.get(receiver) ?? i2 + 1);
+      const elems = listElems.get(receiver);
+      if (elems) {
+        if (method === "append") {
+          elems.push(argIsTainted || argIsDirectSource);
+        } else if (method === "insert") {
+          const insertAt = argExpr.match(/^(-?\d+)\s*,\s*(.+)$/);
+          if (insertAt) {
+            const idx = normalizeListIndex(Number(insertAt[1]), elems.length);
+            const valueExpr = insertAt[2];
+            const valueTainted = [...tainted.keys()].some((v) => new RegExp(`(?<![\\p{L}\\p{N}_])${v}(?![\\p{L}\\p{N}_])`, "u").test(valueExpr)) || PYTHON_TAINTED_PATTERNS2.some((p) => p.pattern.test(valueExpr));
+            if (idx !== void 0) elems.splice(idx, 0, valueTainted);
+            else listElems.delete(receiver);
+          } else {
+            listElems.delete(receiver);
+          }
+        } else {
+          listElems.delete(receiver);
+        }
+      }
+      continue;
+    }
+    const popMatch = line.match(/^\s*(?:([\p{L}\p{N}_]+)\s*=\s*)?([\p{L}\p{N}_]+)\.pop\s*\(\s*(-?\d+)?\s*\)\s*$/u);
+    const delMatch = line.match(/^\s*del\s+([\p{L}\p{N}_]+)\s*\[\s*(-?\d+)\s*\]\s*$/u);
+    if (popMatch || delMatch) {
+      const receiver = popMatch ? popMatch[2] : delMatch[1];
+      const rawIndex = popMatch ? popMatch[3] !== void 0 ? Number(popMatch[3]) : -1 : Number(delMatch[2]);
+      const elems = listElems.get(receiver);
+      if (elems) {
+        const idx = normalizeListIndex(rawIndex, elems.length);
+        if (idx === void 0) listElems.delete(receiver);
+        else {
+          const [removed] = elems.splice(idx, 1);
+          if (popMatch && popMatch[1]) {
+            if (removed) tainted.set(popMatch[1], i2 + 1);
+            else tainted.delete(popMatch[1]);
+          }
+        }
+      }
       continue;
     }
     const augAssign = line.match(/^\s*([\p{L}\p{N}_]+)\s*\+=\s*(.+)$/u);
@@ -26943,7 +26676,48 @@ function buildPythonTaintedVars(sourceCode) {
     }
     const assignMatch = line.match(/^\s*([\p{L}\p{N}_]+)\s*=\s*(.+)$/u);
     if (!assignMatch) continue;
-    const [, lhs, rhs] = assignMatch;
+    const [, lhs, rhsRaw] = assignMatch;
+    const constValue = evaluatePythonConstExpression(rhsRaw.trim(), intConsts);
+    if (typeof constValue === "number") intConsts.set(lhs, constValue);
+    else intConsts.delete(lhs);
+    let rhs = rhsRaw;
+    const ternary = rhsRaw.match(/^(.+?)\s+if\s+(.+?)\s+else\s+(.+)$/);
+    if (ternary) {
+      const decided = evaluatePythonConstExpression(ternary[2].trim(), intConsts);
+      if (decided === true) rhs = ternary[1].trim();
+      else if (decided === false) rhs = ternary[3].trim();
+    }
+    const listLiteral = rhs.trim().match(/^\[\s*(.*?)\s*\]$/);
+    if (listLiteral) {
+      const inner = listLiteral[1];
+      if (inner === "") {
+        listElems.set(lhs, []);
+      } else if (!inner.includes("[") && !inner.includes("(")) {
+        listElems.set(
+          lhs,
+          inner.split(",").map((part) => {
+            const expr = part.trim();
+            return [...tainted.keys()].some((v) => new RegExp(`(?<![\\p{L}\\p{N}_])${v}(?![\\p{L}\\p{N}_])`, "u").test(expr)) || PYTHON_TAINTED_PATTERNS2.some((p) => p.pattern.test(expr));
+          })
+        );
+      } else {
+        listElems.delete(lhs);
+      }
+    } else {
+      listElems.delete(lhs);
+    }
+    const indexRead = rhs.trim().match(/^([\p{L}\p{N}_]+)\s*\[\s*(-?\d+)\s*\]$/u);
+    if (indexRead) {
+      const elems = listElems.get(indexRead[1]);
+      if (elems) {
+        const idx = normalizeListIndex(Number(indexRead[2]), elems.length);
+        if (idx !== void 0) {
+          if (elems[idx]) tainted.set(lhs, i2 + 1);
+          else tainted.delete(lhs);
+          continue;
+        }
+      }
+    }
     const isDirectSource = PYTHON_TAINTED_PATTERNS2.some((p) => p.pattern.test(rhs));
     let propagatedFrom;
     const dictAccessMatch = rhs.trim().match(/^([\p{L}\p{N}_]+)\[(['"])([^'"]+)\2\]$/u);
@@ -28067,6 +27841,185 @@ function findPythonSetMembershipXssGuardSanitizers(code) {
   }
   return sanitizers;
 }
+function findPythonTraversalRejectGuardSanitizers(code) {
+  const sanitizers = [];
+  const lines = code.split("\n");
+  const guardOpen = /^(\s*)if\s+(['"])(\.\.[/\\]?)\2\s+in\s+([A-Za-z_][A-Za-z0-9_]*)\s*:\s*$/;
+  const terminator = /\b(return|raise|abort\s*\(|sys\.exit\s*\()/;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const m = guardOpen.exec(lines[i2]);
+    if (!m) continue;
+    const guardIndent = m[1].length;
+    const guardedVar = m[4];
+    let bodyHasTerminator = false;
+    let blockEnd = -1;
+    const maxScan = Math.min(lines.length, i2 + 26);
+    for (let j = i2 + 1; j < maxScan; j++) {
+      const line = lines[j];
+      if (line.trim() === "") continue;
+      const indent = line.length - line.trimStart().length;
+      if (indent <= guardIndent) {
+        blockEnd = j - 1;
+        break;
+      }
+      if (terminator.test(line)) bodyHasTerminator = true;
+    }
+    if (blockEnd === -1) blockEnd = Math.min(lines.length - 1, i2 + 25);
+    if (!bodyHasTerminator) continue;
+    const guarded = /* @__PURE__ */ new Set([guardedVar]);
+    const assignRe = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=(?!=)\s*(.*)$/;
+    const mentionsGuarded = (text) => {
+      for (const name2 of guarded) {
+        if (new RegExp(`\\b${name2}\\b`).test(text)) return true;
+      }
+      return false;
+    };
+    for (let l = blockEnd + 2; l <= lines.length; l++) {
+      const lineText = lines[l - 1];
+      const assign = assignRe.exec(lineText);
+      if (assign) {
+        const target = assign[1];
+        const rhs = assign[2];
+        if (mentionsGuarded(rhs)) guarded.add(target);
+        else if (target !== guardedVar) guarded.delete(target);
+      }
+      if (!mentionsGuarded(lineText)) continue;
+      sanitizers.push({
+        type: "python_traversal_reject_guard",
+        method: "if",
+        line: l,
+        sanitizes: ["path_traversal"]
+      });
+    }
+  }
+  return sanitizers;
+}
+function findPythonStringLiteralGuardSanitizers(code) {
+  const sanitizers = [];
+  const lines = code.split("\n");
+  const terminator = /\b(return|raise|abort\s*\(|sys\.exit\s*\()/;
+  const Q = `(?:'(?:\\\\')'|"'"|'"'|"(?:\\\\")")`;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const guard = lines[i2].match(
+      new RegExp(
+        `^(\\s*)if\\s+not\\s+([A-Za-z_][A-Za-z0-9_]*)\\.startswith\\(\\s*${Q}\\s*\\)\\s+or\\s+not\\s+\\2\\.endswith\\(\\s*${Q}\\s*\\)\\s+or\\s+${Q}\\s+in\\s+\\2\\[1:-1\\]\\s*:\\s*$`
+      )
+    );
+    if (!guard) continue;
+    const guardIndent = guard[1].length;
+    const guardedVar = guard[2];
+    let bodyHasTerminator = false;
+    let blockEnd = -1;
+    const maxScan = Math.min(lines.length, i2 + 26);
+    for (let j = i2 + 1; j < maxScan; j++) {
+      const line = lines[j];
+      if (line.trim() === "") continue;
+      const indent = line.length - line.trimStart().length;
+      if (indent <= guardIndent) {
+        blockEnd = j - 1;
+        break;
+      }
+      if (terminator.test(line)) bodyHasTerminator = true;
+    }
+    if (blockEnd === -1) blockEnd = Math.min(lines.length - 1, i2 + 25);
+    if (!bodyHasTerminator) continue;
+    const varRe = new RegExp(`\\b${guardedVar}\\b`);
+    for (let l = blockEnd + 2; l <= lines.length; l++) {
+      if (!varRe.test(lines[l - 1])) continue;
+      sanitizers.push({
+        type: "python_string_literal_guard",
+        method: "if",
+        line: l,
+        sanitizes: ["code_injection"]
+      });
+    }
+  }
+  return sanitizers;
+}
+function findPythonDefaultSaxParserXxeSanitizers(code) {
+  const sanitizers = [];
+  const lines = code.split("\n");
+  const parserVars = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const made = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:xml\.)?sax\.make_parser\s*\(/);
+    if (made) parserVars.add(made[1]);
+  }
+  if (parserVars.size === 0) return sanitizers;
+  for (const line of lines) {
+    for (const parser of [...parserVars]) {
+      const enabled = new RegExp(
+        `\\b${parser}\\.setFeature\\s*\\([^,]*external_(?:ges|pes)[^,]*,\\s*True\\s*\\)`
+      );
+      const resolver = new RegExp(`\\b${parser}\\.setEntityResolver\\s*\\(`);
+      const rebound = new RegExp(`^\\s*${parser}\\s*=(?!=)`);
+      if (enabled.test(line) || resolver.test(line)) parserVars.delete(parser);
+      else if (rebound.test(line) && !/make_parser\s*\(/.test(line)) parserVars.delete(parser);
+    }
+  }
+  if (parserVars.size === 0) return sanitizers;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const line = lines[i2];
+    const parseCall = /\b(?:minidom\.)?parseString\s*\(|\b(?:minidom\.)?parse\s*\(|\bsax\.parse(?:String)?\s*\(/;
+    if (!parseCall.test(line)) continue;
+    const usesDefaultParser = [...parserVars].some((p) => new RegExp(`\\b${p}\\b`).test(line));
+    if (!usesDefaultParser) continue;
+    sanitizers.push({
+      type: "python_default_sax_parser",
+      method: "make_parser",
+      line: i2 + 1,
+      sanitizes: ["xxe"]
+    });
+  }
+  return sanitizers;
+}
+function findPythonUrlAllowlistRedirectSanitizers(code) {
+  const sanitizers = [];
+  const lines = code.split("\n");
+  const parsedFrom = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const m = line.match(
+      /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(?:urllib\.parse\.)?urlparse\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/
+    );
+    if (m) parsedFrom.set(m[1], m[2]);
+  }
+  if (parsedFrom.size === 0) return sanitizers;
+  const terminator = /\b(return|raise|abort\s*\(|sys\.exit\s*\()/;
+  for (let i2 = 0; i2 < lines.length; i2++) {
+    const guard = lines[i2].match(
+      /^(\s*)if\s+([A-Za-z_][A-Za-z0-9_]*)\.netloc\s+not\s+in\s+[[({]/
+    );
+    if (!guard) continue;
+    const guardIndent = guard[1].length;
+    const rawVar = parsedFrom.get(guard[2]);
+    if (!rawVar) continue;
+    let bodyHasTerminator = false;
+    let blockEnd = -1;
+    const maxScan = Math.min(lines.length, i2 + 26);
+    for (let j = i2 + 1; j < maxScan; j++) {
+      const line = lines[j];
+      if (line.trim() === "") continue;
+      const indent = line.length - line.trimStart().length;
+      if (indent <= guardIndent) {
+        blockEnd = j - 1;
+        break;
+      }
+      if (terminator.test(line)) bodyHasTerminator = true;
+    }
+    if (blockEnd === -1) blockEnd = Math.min(lines.length - 1, i2 + 25);
+    if (!bodyHasTerminator) continue;
+    const varRe = new RegExp(`\\b${rawVar}\\b`);
+    for (let l = blockEnd + 2; l <= lines.length; l++) {
+      if (!varRe.test(lines[l - 1])) continue;
+      sanitizers.push({
+        type: "python_url_allowlist_guard",
+        method: "if",
+        line: l,
+        sanitizes: ["open_redirect"]
+      });
+    }
+  }
+  return sanitizers;
+}
 function findPythonDefusedXmlSanitizers(code) {
   const sanitizers = [];
   const lines = code.split("\n");
@@ -32588,15 +32541,19 @@ var SinkFilterPass = class {
       filtered = filtered.filter((sink) => {
         if (sink.type !== "xpath_injection") return true;
         const sinkLineText = sourceLines[sink.line - 1] ?? "";
-        const taintedVarOnLine = [...pyTaintedVars.keys()].find(
-          (v) => new RegExp(`\\b${v}\\b`).test(sinkLineText)
+        const taintedValueVars = [...pyTaintedVars.keys()].filter(
+          (v) => new RegExp(`(?<![\\w.])${v}\\b(?!\\s*=(?!=))`).test(sinkLineText)
         );
+        const taintedVarOnLine = taintedValueVars[0];
         const oopVarOnLine = [...oopFieldVars].find(
           (v) => sinkLineText.includes(v)
         );
         if (oopVarOnLine) return true;
         if (!taintedVarOnLine) return false;
+        const neutralised = (v) => pySanitizedVars.has(v) || new RegExp(`\\.xpath\\s*\\([^)]*\\b\\w+\\s*=\\s*\\b${v}\\b`).test(sinkLineText) || isXPathQuoteEscapedOnLine(sinkLineText, v);
+        if (taintedValueVars.every(neutralised)) return false;
         if (pySanitizedVars.has(taintedVarOnLine)) return false;
+        if (isXPathQuoteEscapedOnLine(sinkLineText, taintedVarOnLine)) return false;
         if (new RegExp(`\\.xpath\\s*\\([^)]*\\b\\w+\\s*=\\s*\\b${taintedVarOnLine}\\b`).test(sinkLineText)) return false;
         return true;
       });
@@ -33572,6 +33529,27 @@ function filterSanitizedSinks(sinks, sanitizers, calls) {
     return true;
   });
 }
+function isXPathQuoteEscapedOnLine(lineText, varName) {
+  const STRING_LITERAL = `'(?:[^'\\\\]|\\\\.)*'|"(?:[^"\\\\]|\\\\.)*"`;
+  const replaceCall = new RegExp(
+    `^${varName}\\.replace\\s*\\(\\s*(${STRING_LITERAL})\\s*,\\s*(${STRING_LITERAL})\\s*\\)`
+  );
+  const decode = (literal) => literal.slice(1, -1).replace(/\\(.)/g, "$1");
+  const occurrence = new RegExp(`(?<![\\w.])${varName}\\b`, "g");
+  let match;
+  let seen = 0;
+  while ((match = occurrence.exec(lineText)) !== null) {
+    seen++;
+    const rest = lineText.slice(match.index);
+    const call = replaceCall.exec(rest);
+    if (!call) return false;
+    const searched = decode(call[1]);
+    const replacement = decode(call[2]);
+    if (searched !== "'" && searched !== '"') return false;
+    if (replacement.includes("'") || replacement.includes('"')) return false;
+  }
+  return seen > 0;
+}
 
 // src/analysis/passes/sink-semantics-pass.ts
 function buildRegistry(entries) {