code-auditor-mcp 5.0.2 → 5.3.3

package/dist/analyzers/universal/UniversalDataAccessAnalyzer.js

@@ -15,6 +15,13 @@ import { findEnclosingFunctionIdentity, functionIdentityLabel } from './schema/c
 import { buildOrgFilterTierSet, tableRequiresOrgFilter, DEFAULT_ORG_PREDICATE_PATTERNS, hasOrganizationFilter, } from '../orgFilterTiers.js';
 import { resolveWhereBinding } from '../../phase/localBinding.js';
 import { parseSql, DEFAULT_SQL_DIALECT, extractTableNames, whereFacts, isWriteStatement, isMassWriteStatement, isUpsertStatement, whereColumnRefs, isDdlStatementKind, } from '../../languages/sql/sqlAst.js';
+// Item B (reissued) — vendor surfaces are resolved per-run from the tree under
+// analysis (its own node_modules), never from a committed snapshot. The method
+// sets below derive from those resolved surfaces via `deriveVendorSets`; a vendor
+// whose declaration cannot be resolved contributes nothing (the honest `unproven`
+// state), recorded with its reason on the `VendorSurfaces.resolutions` records.
+// See specs/vendor-replica-probes.md for the reducible/irreducible mapping.
+import { deriveVendorSets, EMPTY_VENDOR_SURFACES, } from '../vendorSurfaces.js';
 /**
  * SQL keywords recognized as evidence that a *dynamically-constructed* string is
  * an injection surface — the host-language dataflow gate in `checkQuerySecurity`
@@ -30,7 +37,6 @@ const SQL_KEYWORDS = [
     'CREATE', 'DROP', 'ALTER', 'TRUNCATE',
 ];
 export const DEFAULT_DATA_ACCESS_CONFIG = {
-    checkOrgFilters: true,
     checkSQLInjection: true,
     skipTestFiles: true,
     organizationPatterns: [...DEFAULT_ORG_PREDICATE_PATTERNS],
@@ -47,17 +53,10 @@ export const DEFAULT_DATA_ACCESS_CONFIG = {
         orm: [
             /table\s*[:=]\s*["'`]?([\p{L}\p{N}_]+)["'`]?/giu
         ],
-        queryBuilder: [/\.from\s*\(\s*["'`]?([\p{L}\p{N}_]+)["'`]?\s*\)/giu]
     },
     performanceThresholds: {
-        complexQueryCount: 3,
-        unfilteredQueryCount: 3,
         joinedTableCount: 4
     },
-    securityPatterns: {
-        sqlInjectionRisks: ['${', 'concat', 'string interpolation'],
-        parameterizedQueries: ['?', ':param', '$1', 'prepared', 'parameterized']
-    },
     // DB wrapper functions that accept (sql, params) — same as .prepare().bind()
     // but expressed as a simple function call.  Must match the provenance system's
     // dbWrapperNames so the FP guards see the same capability list the detector does.
@@ -168,12 +167,15 @@ function hasChainCompanion(methods) {
     }
     return false;
 }
-/** Prisma CRUD verbs admitted by the object-form shape (admitter 2). */
-const PRISMA_VERBS = new Set([
-    'create', 'createMany', 'update', 'updateMany', 'upsert',
-    'delete', 'deleteMany', 'findUnique', 'findFirst', 'findMany',
-    'findUniqueOrThrow', 'findFirstOrThrow', 'findRaw', 'count', 'groupBy', 'aggregate',
-]);
+/**
+ * The reason a Prisma object-form site is `unproven`: the analyzed tree has no
+ * generated `.prisma/client`, so the model verb set (the union of the generated
+ * `*Delegate` members) cannot be derived and the verb cannot be confirmed. Item B
+ * (reissued): the verb set is no longer a committed `PRISMA_VERBS` snapshot — it
+ * is resolved per-run from the tree's own generated client, and its absence is
+ * this `unproven` reason, never a stale fallback.
+ */
+const PRISMA_NOT_PRESENT_REASON = 'generated Prisma client `.prisma/client` is not present in the analyzed tree — the model verb set cannot be confirmed (run `prisma generate`)';
 /** Collect the property keys of an object literal, including its nested objects. */
 function collectObjectLiteralKeys(node, adapter, sourceCode) {
     const keys = [];
@@ -197,29 +199,44 @@ function collectObjectLiteralKeys(node, adapter, sourceCode) {
  * object-literal argument carries a `where` or `data` key. Option 1 (chained
  * companions) misses this because the `where`/`data` are keys inside an object
  * literal, not chained calls (blitz `prisma.user.update({ where, data })`).
- */
-function isPrismaObjectForm(node, adapter, sourceCode) {
+ *
+ * Tri-state (Item B, reissued): the verb is confirmed against the *derived*
+ * Prisma verb set (`vendor.prismaVerbs`), not a committed snapshot. When the
+ * shape matches (`<recv>.<Model>.<verb>` + `where`/`data` key) but the generated
+ * client is absent — so no verb set was derived — the verdict is `prisma-unproven`
+ * with {@link PRISMA_NOT_PRESENT_REASON}, never `not-prisma` (which would silently
+ * drop the site) and never a stale verb list.
+ */
+function isPrismaObjectForm(node, adapter, sourceCode, prismaVerbs) {
     const callee = getCallExpressionCallee(node, adapter);
     if (!callee || adapter.getNodeType(callee) !== 'member_expression')
-        return false;
+        return { kind: 'not-prisma' };
     // The chain must be `<recv>.<Model>.<verb>` — at least two member segments
     // (the Model and the verb) read from their property nodes. A subscript like
     // `obj["a.b"]` is not a Model segment, so `obj["a.b"].update(…)` has only one
     // segment and fails.
     const methods = collectChainMethods(callee, adapter, sourceCode);
     if (methods.length < 2)
-        return false;
-    if (!PRISMA_VERBS.has(methods[methods.length - 1]))
-        return false;
+        return { kind: 'not-prisma' };
+    const verb = methods[methods.length - 1];
     const args = adapter.getChildren(node).find((c) => adapter.getNodeType(c) === 'arguments');
     if (!args)
-        return false;
+        return { kind: 'not-prisma' };
+    let hasWhereOrData = false;
     for (const arg of adapter.getChildren(args)) {
         const keys = collectObjectLiteralKeys(arg, adapter, sourceCode);
-        if (keys.includes('where') || keys.includes('data'))
-            return true;
+        if (keys.includes('where') || keys.includes('data')) {
+            hasWhereOrData = true;
+            break;
+        }
     }
-    return false;
+    if (!hasWhereOrData)
+        return { kind: 'not-prisma' };
+    // The shape matches. Confirm the verb against the derived set; an absent set
+    // (no generated client) is `unproven`, a confirmed non-verb is `not-prisma`.
+    if (prismaVerbs === null)
+        return { kind: 'prisma-unproven', reason: PRISMA_NOT_PRESENT_REASON };
+    return prismaVerbs.has(verb) ? { kind: 'prisma' } : { kind: 'not-prisma' };
 }
 /**
  * Spec 68 Thing 2 (#312) — the query-builder shape test.
@@ -242,23 +259,28 @@ function isPrismaObjectForm(node, adapter, sourceCode) {
  * such chain: the real misses are *variable-split* builders (the companion verb
  * lives in a prior statement, e.g. `const q = baseQuery.where(…)`), which
  * catalog resolution does not address. Gating on an under-discovered catalog
- * would just rebuild the receiver-name failure one layer up. See the
- * extraction-completeness gate (scripts/verify-extraction-completeness.ts) for
- * the pinned residual.
+ * would just rebuild the receiver-name failure one layer up.
  *
  * @param node the candidate call node to classify
  * @param adapter the language adapter used to read the callee
  * @param sourceCode the file source text for reading callee text
+ * @param prismaVerbs the derived Prisma model verb set (or null when the generated
+ *   client is absent). A Prisma object form is admitted by shape even when this is
+ *   null — the *confirmation* of the verb is what degrades to `unproven`, never the
+ *   admission (see {@link isPrismaObjectForm}).
  * @returns true when the call is query-builder shaped (chain companion or Prisma object form)
  */
-export function isQueryBuilderShape(node, adapter, sourceCode) {
+export function isQueryBuilderShape(node, adapter, sourceCode, prismaVerbs = null) {
     if (node.type !== 'call_expression')
         return false;
     const callee = getCallExpressionCallee(node, adapter);
     if (!callee)
         return false;
     const methods = collectChainMethods(callee, adapter, sourceCode);
-    return hasChainCompanion(methods) || isPrismaObjectForm(node, adapter, sourceCode);
+    if (hasChainCompanion(methods))
+        return true;
+    const prismaVerdict = isPrismaObjectForm(node, adapter, sourceCode, prismaVerbs);
+    return prismaVerdict.kind !== 'not-prisma';
 }
 /**
  * The single admission seam for a candidate node: resolve its handle-ness through
@@ -470,14 +492,14 @@ function receiverIsThisRooted(callee, adapter) {
  * query-builder chain discovered by shape (Spec 68 Thing 2, #312).
  */
 function isDbCallCandidate(node, scan, tagNames = SQL_TAG_NAMES) {
-    const { adapter, sourceCode } = scan;
+    const { adapter, sourceCode, vendor } = scan;
     // Spec 70 R1.2: a DB/ORM-method call whose receiver resolves handle-or-unproven.
     // `not-handle` (e.g. lodash `get`) and `null` (not query-shaped) are rejected.
     const verdict = handleVerdictForCall(node, scan);
     if (verdict !== null && verdict.kind !== 'not-handle')
         return true;
     // A query-builder chain is discovered by shape, not receiver name.
-    if (isQueryBuilderShape(node, adapter, sourceCode)) {
+    if (isQueryBuilderShape(node, adapter, sourceCode, vendor.prismaVerbs)) {
         return true;
     }
     // Tagged-template SQL is a data-access call by tag name — no provenance needed.
@@ -577,7 +599,7 @@ export function hasOrmFilterShape(node, adapter, sourceCode) {
  * look like a DB-related query.
  */
 function buildDatabaseCall(node, ast, scan) {
-    const { adapter, sourceCode, config, provenanceContext } = scan;
+    const { adapter, sourceCode, config, provenanceContext, vendor } = scan;
     const nodeText = stripComments(adapter.getNodeText(node, sourceCode));
     if (!nodeText || nodeText.trim().length < 10)
         return null;
@@ -633,8 +655,17 @@ function buildDatabaseCall(node, ast, scan) {
     // a type-annotated `db: D1Database` with a dynamic template argument now stays
     // visible instead of being dropped before the rules can see it.
     const handleVerdict = handleVerdictForCall(node, scan);
-    const handleAdmits = handleVerdict !== null && handleVerdict.kind !== 'not-handle';
-    const isSqlPosition = handleAdmits || isQueryBuilderShape(node, adapter, sourceCode);
+    // Item B (reissued) — a Prisma object-form site whose verb set cannot be
+    // confirmed (no generated `.prisma/client`) is `unproven` with that reason. It
+    // only fills a *null* handle verdict (no resolution evidence); a definitive
+    // `handle`/`not-handle` from declaration resolution always wins.
+    const prismaVerdict = isPrismaObjectForm(node, adapter, sourceCode, vendor.prismaVerbs);
+    const effectiveHandleVerdict = handleVerdict
+        ?? (prismaVerdict.kind === 'prisma-unproven'
+            ? { kind: 'unproven', reason: prismaVerdict.reason }
+            : null);
+    const handleAdmits = effectiveHandleVerdict !== null && effectiveHandleVerdict.kind !== 'not-handle';
+    const isSqlPosition = handleAdmits || isQueryBuilderShape(node, adapter, sourceCode, vendor.prismaVerbs);
     const isSqlQuery = sqlOk !== null || isSqlPosition || isTaggedSqlCall;
     if (!isSqlQuery && !isOrmCall)
         return null;
@@ -642,7 +673,7 @@ function buildDatabaseCall(node, ast, scan) {
     const builderVerb = sqlAstNode ? null : builderWriteVerb(node, adapter, sourceCode);
     // Tables: SQL relations from the AST ∪ ORM-shaped references from the node.
     const sqlTables = sqlAstNode ? extractTableNames(sqlAstNode) : [];
-    const ormTables = isOrmCall ? extractOrmTables(node, adapter, sourceCode, config) : [];
+    const ormTables = isOrmCall ? extractOrmTables(node, adapter, sourceCode, config, vendor) : [];
     const tables = [...new Set([...sqlTables, ...ormTables])];
     // Row-limiting filter: SQL WHERE/HAVING/LIMIT from the AST, or the ORM chain
     // shape when there is no SQL to walk.
@@ -660,7 +691,7 @@ function buildDatabaseCall(node, ast, scan) {
     // a proven `handle` — a parsed SQL argument (R3) or a package in the manifest
     // (R4) — fires. A type name proves nothing under criterion 9, so there is no
     // type-annotation signal to consult.
-    const injectionRisk = security.injectionRisk && handleVerdict?.kind === 'handle';
+    const injectionRisk = security.injectionRisk && effectiveHandleVerdict?.kind === 'handle';
     const callType = classifyCallType(isSqlQuery, isOrmCall);
     return {
         type: callType,
@@ -685,7 +716,7 @@ function buildDatabaseCall(node, ast, scan) {
         sqlEscaped: security.escaped,
         enclosingFunction: enclosingIdentity(node, adapter, ast.filePath),
         resolvedWhere: resolveWhereBinding(node, sourceCode, adapter) ?? undefined,
-        handleVerdict: handleVerdict ?? undefined,
+        handleVerdict: effectiveHandleVerdict ?? undefined,
     };
 }
 /**
@@ -1093,15 +1124,15 @@ function dbCallMethodName(node, adapter, sourceCode) {
  * which only construct a statement object). Used to decide whether a
  * prepare/bind call is chained into an eager execution.
  *
- * `.get()` is the single-row read shared by better-sqlite3, `node:sqlite`, and
- * `bun:sqlite` that D1 does not expose (D1's closest is `.first()`). It was
- * absent, so `db.prepare(…).get(…)` in a loop was misread as statement
- * construction and skipped — the exact false negative the corpus pins at
- * `n-plus-one.ts:51`/`:62`. The wider driver-method gap (`.iterate()`, bun's
- * `.values()`) is documented in specs/rule-evidence-corpus/REPORT.md; it is
- * deliberately left out until it is measured, not silently dropped.
+ * Item B (reissued): the eager set is no longer a module-level constant. It is
+ * derived per-run from the tree's own vendor declarations via
+ * `deriveVendorSets` and threaded on `scan.vendor.eagerMethods`. The eager
+ * classification (which statement methods return rows vs. only configure the
+ * statement) is still the documented judgment; the *names* now come from the
+ * installed vendor's shipped `.d.ts` (better-sqlite3 `Statement`/`Database`,
+ * node:sqlite `StatementSync`/`DatabaseSync`, D1 `D1PreparedStatement`/`D1Database`),
+ * plus the generic `query` driver abstraction (`IndexHandle.query`).
  */
-const EAGER_DB_METHODS = new Set(['run', 'all', 'first', 'raw', 'exec', 'batch', 'query', 'get']);
 /**
  * True when `node` (a `.prepare()`/`.bind()` call) is chained into an eager
  * method — e.g. `db.prepare(sql).bind(x).run()`. The `.run()` at the end of the
@@ -1109,7 +1140,7 @@ const EAGER_DB_METHODS = new Set(['run', 'all', 'first', 'raw', 'exec', 'batch',
  * N+1, not an accumulate-then-batch false positive. Walks up the enclosing
  * expression and stops at the statement boundary; a chain never crosses one.
  */
-function hasEagerMethodInCallChain(node, adapter, sourceCode) {
+function hasEagerMethodInCallChain(node, adapter, sourceCode, vendor) {
     const call = resolveDbCallNode(node, adapter);
     let cur = call ? adapter.getParent(call) : adapter.getParent(node);
     while (cur) {
@@ -1117,7 +1148,7 @@ function hasEagerMethodInCallChain(node, adapter, sourceCode) {
         if (type === 'call_expression') {
             const memberExpr = findMemberCallee(cur, adapter);
             const name = memberExpr ? memberPropertyName(memberExpr, adapter, sourceCode) : null;
-            if (name && EAGER_DB_METHODS.has(name) && !isPromiseAllMember(memberExpr, adapter, sourceCode))
+            if (name && vendor.eagerMethods.has(name) && !isPromiseAllMember(memberExpr, adapter, sourceCode))
                 return true;
         }
         if (type === 'expression_statement' ||
@@ -1141,9 +1172,9 @@ function hasEagerMethodInCallChain(node, adapter, sourceCode) {
  * `.first()` / `.raw()` / `.exec()` / `.batch()` / `.get()`). Such a call
  * performs no I/O, so it is not a query-in-loop on its own (Spec 52 R1).
  */
-function isStatementConstructionOnly(node, adapter, sourceCode) {
+function isStatementConstructionOnly(node, adapter, sourceCode, vendor) {
     const method = dbCallMethodName(node, adapter, sourceCode);
-    return (method === 'prepare' || method === 'bind') && !hasEagerMethodInCallChain(node, adapter, sourceCode);
+    return (method === 'prepare' || method === 'bind') && !hasEagerMethodInCallChain(node, adapter, sourceCode, vendor);
 }
 /**
  * True when a db-call node is SQL-string construction inside a query compiler:
@@ -1156,9 +1187,9 @@ function isStatementConstructionOnly(node, adapter, sourceCode) {
  * (`run`/`all`/`exec`/`query`/…) are excluded, so a genuine
  * `results.push(db.query(...))` still fires.
  */
-function isSqlStringConstruction(node, adapter, sourceCode) {
+function isSqlStringConstruction(node, adapter, sourceCode, vendor) {
     const method = dbCallMethodName(node, adapter, sourceCode);
-    if (!method || EAGER_DB_METHODS.has(method))
+    if (!method || vendor.eagerMethods.has(method))
         return false;
     if (!isOrmMethod(method))
         return false;
@@ -1252,8 +1283,9 @@ function isInExecChain(node, adapter, sourceCode) {
     return hasSpreadArgument(execCall, adapter);
 }
 /**
- * Detect eager execution methods called with bind parameters as a second
- * argument — D1's `.all()`/`.first()`/`.run()`, plus the parameterized
+ * Detect eager-execution methods called with bind parameters as a second
+ * argument — D1's `.all()`/`.first()`/`.run()`, better-sqlite3's `.get()` /
+ * `.iterate()`, node:sqlite's `.get()` / `.all()`, plus the parameterized
  * `.query()`/`.execute()` form shared by node-postgres/mysql2 and the tool's
  * own `IndexHandle`.
  *
@@ -1268,18 +1300,40 @@ function isInExecChain(node, adapter, sourceCode) {
  * `?`-placeholder clauses (`${fp.clause}`, `${inList(types)}`) and `params`
  * binds the values out-of-band. A single-arg `.query(\`…${input}\`)` — the raw
  * injection shape — stays flagged because it carries no bind argument.
+ *
+ * Item B (reissued): the method set is no longer a hand-kept `D1_CONVENIENCE`
+ * list — it is the cross-driver eager-execution surface (`vendor.eagerExecutionMethods`),
+ * the union of whichever driver surfaces resolved in the analyzed tree. A tree
+ * with only better-sqlite3 gets better-sqlite3's methods and nothing else.
+ */
+/**
+ * True when every `${…}` interpolation in the eager-execution call's SQL
+ * argument is provably structural — a placeholder list (`.map(() => '?').join`),
+ * a literal clause fragment, or a safe identifier — and NOT a bound runtime
+ * value. Argument count alone does not establish this: `db.run(\`…\${name}\`,
+ * [name])` carries two arguments yet interpolates a value, so the site stays
+ * flagged. Reuses {@link isSafeDynamicPart}, the same classifier the non-eager
+ * path applies, so "structural vs value-bearing" has one definition.
  */
-function isD1ConvenienceCall(node, adapter, sourceCode) {
-    const D1_CONVENIENCE = new Set(['all', 'first', 'run', 'query', 'execute']);
+function allInterpolationsStructural(node, scan) {
+    const { adapter, sourceCode } = scan;
+    if (!adapter.getDynamicParts)
+        return false;
+    const parts = adapter.getDynamicParts(node, sourceCode);
+    return parts.every((part) => isSafeDynamicPart(part, scan.ast, scan));
+}
+function isEagerExecutionCall(node, adapter, sourceCode, eagerExecutionMethods, scan) {
     const call = findCallFromEntry(node, adapter);
     if (!call)
         return false;
     const callee = findMemberCallee(call, adapter);
     const method = callee ? memberPropertyName(callee, adapter, sourceCode) : null;
-    if (!method || !D1_CONVENIENCE.has(method))
+    if (!method || !eagerExecutionMethods || !eagerExecutionMethods.has(method))
         return false;
-    // Bind params as a second argument → fully parameterized and safe.
-    return countArgs(call, adapter) >= 2;
+    // Bind params as a second argument AND every interpolation structural → fully
+    // parameterized. Argument count is not evidence of parameterization: a value
+    // interpolation (`${name}`) stays flagged even with a bind-params argument.
+    return countArgs(call, adapter) >= 2 && allInterpolationsStructural(node, scan);
 }
 /**
  * Detect simple-function-call DB wrappers with bind parameters.
@@ -1294,7 +1348,7 @@ function isD1ConvenienceCall(node, adapter, sourceCode) {
  *
  * Entry point: a template_string inside the wrapper's arguments.
  */
-function isWrapperFunctionWithBindParams(node, adapter, sourceCode, wrapperNames) {
+function isWrapperFunctionWithBindParams(node, adapter, sourceCode, wrapperNames, scan) {
     if (wrapperNames.length === 0)
         return false;
     if (adapter.getNodeType(node) !== 'template_string')
@@ -1317,10 +1371,12 @@ function isWrapperFunctionWithBindParams(node, adapter, sourceCode, wrapperNames
     const calleeName = adapter.getNodeText(callee, sourceCode);
     if (!wrapperNames.includes(calleeName))
         return false;
-    // Check for a second argument — the bind params.  A single-arg call
-    // like d1Query(sql) without params has no runtime parameterization.
+    // Check for a second argument — the bind params — AND every interpolation
+    // structural. A single-arg call (d1Query(sql) without params) has no runtime
+    // parameterization, and a two-arg call whose template interpolates a value is
+    // raw assembly, not parameterized (same discriminant as eager-execution).
     const realArgs = adapter.getChildren(args).filter(c => !['(', ')', ','].includes(adapter.getNodeType(c)));
-    return realArgs.length >= 2;
+    return realArgs.length >= 2 && allInterpolationsStructural(node, scan);
 }
 /**
  * Check the two-statement prepare→bind pattern: db.prepare() is assigned to
@@ -1527,10 +1583,6 @@ function ormTableNameFromArgument(node, adapter, sourceCode) {
     const literal = stringLiteralValue(node, adapter, sourceCode);
     return literal && literal.length > 0 ? literal : null;
 }
-/** Kysely builder verbs whose first argument is the table name. */
-const ORM_TABLE_VERBS = new Set(['selectFrom', 'deleteFrom', 'insertInto', 'updateTable']);
-/** ORM join verbs whose first argument is the joined table. */
-const ORM_JOIN_VERBS = new Set(['join', 'leftJoin', 'rightJoin', 'innerJoin']);
 /**
  * Walk the callee chain of an ORM candidate, reading table references from the
  * *structure* (member names + argument nodes) rather than the source text. A
@@ -1540,10 +1592,12 @@ const ORM_JOIN_VERBS = new Set(['join', 'leftJoin', 'rightJoin', 'innerJoin']);
  * Three shapes are read:
  *   - `.from(table)` / `.from('table')` (except JS `Array.from`/`Buffer.from`/
  *     `String.from`/`*Array.from` construction),
- *   - a Kysely/join verb carrying the table as its first argument,
+ *   - a Kysely/join verb carrying the table as its first argument (the table and
+ *     join verbs are `vendor.ormTableVerbs`/`vendor.ormJoinVerbs` — derived
+ *     per-run from the tree's Kysely declaration, item B reissued),
  *   - Drizzle's `db.<table>.<method>()` table-access idiom.
  */
-function collectOrmTableReferences(node, adapter, sourceCode, tables) {
+function collectOrmTableReferences(node, adapter, sourceCode, tables, vendor) {
     const t = adapter.getNodeType(node);
     if (t === 'call_expression') {
         const callee = getCallExpressionCallee(node, adapter);
@@ -1561,8 +1615,8 @@ function collectOrmTableReferences(node, adapter, sourceCode, tables) {
                     const isFrom = method === 'from'
                         && !(receiverName && (receiverName === 'Buffer' || receiverName === 'String'
                             || receiverName.endsWith('Array')));
-                    const isVerb = ORM_TABLE_VERBS.has(method);
-                    const isJoin = ORM_JOIN_VERBS.has(method) && receiverName !== 'sql';
+                    const isVerb = vendor.ormTableVerbs.has(method);
+                    const isJoin = vendor.ormJoinVerbs.has(method) && receiverName !== 'sql';
                     if (isFrom || isVerb || isJoin) {
                         const name = ormTableNameFromArgument(firstArg, adapter, sourceCode);
                         if (name)
@@ -1570,7 +1624,7 @@ function collectOrmTableReferences(node, adapter, sourceCode, tables) {
                     }
                 }
             }
-            collectOrmTableReferences(callee, adapter, sourceCode, tables);
+            collectOrmTableReferences(callee, adapter, sourceCode, tables, vendor);
         }
     }
     else if (t === 'member_expression' || t === 'selector_expression') {
@@ -1588,12 +1642,12 @@ function collectOrmTableReferences(node, adapter, sourceCode, tables) {
             }
         }
         if (object)
-            collectOrmTableReferences(object, adapter, sourceCode, tables);
+            collectOrmTableReferences(object, adapter, sourceCode, tables, vendor);
     }
     else if (t === 'subscript_expression') {
         const object = memberObjectNode(node, adapter);
         if (object)
-            collectOrmTableReferences(object, adapter, sourceCode, tables);
+            collectOrmTableReferences(object, adapter, sourceCode, tables, vendor);
     }
 }
 /**
@@ -1609,11 +1663,12 @@ function collectOrmTableReferences(node, adapter, sourceCode, tables) {
  * @param adapter The language adapter (drives node traversal).
  * @param sourceCode The file source text.
  * @param config The data-access analyzer config holding table patterns.
+ * @param vendor The per-run derived vendor method sets (item B reissued).
  * @returns The set of table names referenced by ORM shapes.
  */
-export function extractOrmTables(node, adapter, sourceCode, config) {
+export function extractOrmTables(node, adapter, sourceCode, config, vendor) {
     const tables = new Set();
-    collectOrmTableReferences(node, adapter, sourceCode, tables);
+    collectOrmTableReferences(node, adapter, sourceCode, tables, vendor);
     // User-configured `orm` patterns are arbitrary text shapes with no node to
     // read (e.g. `table: 'users'`), so they still run over the source text.
     const nodeText = stripComments(adapter.getNodeText(node, sourceCode));
@@ -1654,14 +1709,15 @@ function isUnfilteredRead(call, config) {
  * wrapper function with bind params).  All four short-circuit checkQuerySecurity
  * to a "safe" result.
  */
-function isParameterizedByChain(node, adapter, sourceCode, config, wrapperNames) {
+function isParameterizedByChain(node, scan, wrapperNames) {
+    const { adapter, sourceCode, vendor } = scan;
     if (isInPrepareBindChain(node, adapter, sourceCode))
         return true;
     if (isInExecChain(node, adapter, sourceCode))
         return true;
-    if (isD1ConvenienceCall(node, adapter, sourceCode))
+    if (isEagerExecutionCall(node, adapter, sourceCode, vendor.eagerExecutionMethods, scan))
         return true;
-    if (isWrapperFunctionWithBindParams(node, adapter, sourceCode, wrapperNames))
+    if (isWrapperFunctionWithBindParams(node, adapter, sourceCode, wrapperNames, scan))
         return true;
     return false;
 }
@@ -1786,10 +1842,10 @@ function isParameterizedTaggedTemplate(node, adapter, sourceCode, tagNames) {
     return true;
 }
 function checkQuerySecurity(node, text, ast, scan) {
-    const { adapter, sourceCode, config } = scan;
-    // Parameterized chains (.prepare().bind(), .exec() spread, D1 convenience,
-    // DB wrappers) and explicit parameterization are always safe.
-    if (isParameterizedByChain(node, adapter, sourceCode, config, effectiveWrapperNames(scan))) {
+    const { adapter, sourceCode, config, vendor } = scan;
+    // Parameterized chains (.prepare().bind(), .exec() spread, eager-execution
+    // method, DB wrappers) and explicit parameterization are always safe.
+    if (isParameterizedByChain(node, scan, effectiveWrapperNames(scan))) {
         return { parameterized: true, injectionRisk: false, escaped: false };
     }
     // A drizzle `sql`/`db` tagged template parameterizes bare `${id}` interpolations
@@ -1798,9 +1854,14 @@ function checkQuerySecurity(node, text, ast, scan) {
     if (isParameterizedTaggedTemplate(node, adapter, sourceCode, config.sqlTagNames ?? SQL_TAG_NAMES)) {
         return { parameterized: true, injectionRisk: false, escaped: false };
     }
-    if ((config.securityPatterns?.parameterizedQueries || []).some(p => text.includes(p))) {
-        return { parameterized: true, injectionRisk: false, escaped: false };
-    }
+    // There is deliberately NO whole-text substring test for "parameterized"
+    // markers (`prepared`, `$1`, `:param`, …) ahead of the per-interpolation
+    // classifier below. A presence test on the query *text* can never establish
+    // that a particular `${…}` interpolation is safe — only isSafeDynamicPart can.
+    // Any such short-circuit is a false-negative generator: a column named
+    // `prepared_at`, a `$100` literal, or a `':param'` string would clear a
+    // value-bearing `${id}` before isSafeDynamicPart ever ran. The
+    // `parameterizedQueries` config key was removed with it (no other consumer).
     // No dynamic-string capability → can't prove unsafe; err quiet.
     if (!adapter.isDynamicStringConstruction || !adapter.getDynamicParts) {
         return { parameterized: false, injectionRisk: false, escaped: false };
@@ -1975,7 +2036,7 @@ function checkLoopQueries(ast, scan) {
  * query) and the LLM/queue suppression live here — they need the AST.
  */
 function collectLoopQueryCandidates(ast, scan) {
-    const { adapter, sourceCode } = scan;
+    const { adapter, sourceCode, vendor } = scan;
     const candidates = [];
     // Spec 21: provenance-gated detection of database calls.
     const dbNodes = adapter.findNodes(ast, {
@@ -2001,13 +2062,13 @@ function collectLoopQueryCandidates(ast, scan) {
             continue;
         // Spec 52 R1 — skip statement construction (prepare/bind with no eager call);
         // an eager call or a prepare chained into one still fires.
-        if (isStatementConstructionOnly(node, adapter, sourceCode))
+        if (isStatementConstructionOnly(node, adapter, sourceCode, vendor))
             continue;
         // Spec 52 R1 (extension) — skip SQL-string construction inside a query
         // compiler: an ORM builder method (e.g. `aggregate`) on an unprovenanced
         // `this` whose result is accumulated via `.push(...)` returns a string
         // fragment, not a query result (knex `sql.push(...this.aggregate(stmt))`).
-        if (isSqlStringConstruction(node, adapter, sourceCode))
+        if (isSqlStringConstruction(node, adapter, sourceCode, vendor))
             continue;
         const loopInfo = findEnclosingLoop(node, adapter, sourceCode);
         if (!loopInfo)
@@ -2053,7 +2114,7 @@ function collectLoopQueryCandidates(ast, scan) {
         const preparesInLoop = loopBodyContainsPrepare(loopInfo.loopNode, adapter, sourceCode);
         const hoistedReuse = !preparesInLoop &&
             (transactionEnclosesLoop ||
-                isHoistedStatementReRun(node, loopInfo.loopNode, adapter, sourceCode));
+                isHoistedStatementReRun(node, loopInfo.loopNode, adapter, sourceCode, vendor));
         if (hoistedReuse) {
             continue;
         }
@@ -2063,7 +2124,7 @@ function collectLoopQueryCandidates(ast, scan) {
         // a chunked `id IN (…)` write is not an N+1 at any chunk size. Only a scalar
         // or property read off a single loop element (`run(row.id)`) is per-row. See
         // `bindsBatchArgument`.
-        if (bindsBatchArgument(node, loopInfo.loopNode, adapter, sourceCode)) {
+        if (bindsBatchArgument(node, loopInfo.loopNode, adapter, sourceCode, vendor)) {
             continue;
         }
         // R4.1 (Spec 46): LLM-pipeline discriminator. A loop whose body invokes an
@@ -2186,8 +2247,8 @@ function loopBodyContainsPrepare(loopNode, adapter, sourceCode) {
  * is NOT prepare-bound, so none of them reads as a statement re-run and each
  * keeps firing.
  */
-function isHoistedStatementReRun(node, loopNode, adapter, sourceCode) {
-    const base = memberChainBaseIdentifier(node, adapter, sourceCode);
+function isHoistedStatementReRun(node, loopNode, adapter, sourceCode, vendor) {
+    const base = memberChainBaseIdentifier(node, adapter, sourceCode, vendor);
     if (base && identifierBoundToPrepareOutsideLoop(base, loopNode, adapter, sourceCode)) {
         return true;
     }
@@ -2230,8 +2291,8 @@ function isBarePrepareBoundHelperCall(node, loopNode, adapter, sourceCode) {
  * Returns null when the chain is not a member call (a bare `helper(db, …)`) or
  * has no identifier root (an indexed access `x[i]()`).
  */
-function memberChainBaseIdentifier(node, adapter, sourceCode) {
-    const eagerCall = findEagerExecutionCall(node, adapter, sourceCode);
+function memberChainBaseIdentifier(node, adapter, sourceCode, vendor) {
+    const eagerCall = findEagerExecutionCall(node, adapter, sourceCode, vendor);
     if (!eagerCall)
         return null;
     const memberExpr = findMemberCallee(eagerCall, adapter);
@@ -2468,8 +2529,15 @@ function walkSubtree(node, adapter, visitor) {
  * Array methods that transform one collection into another collection (a batch):
  * the elements of a `.slice()`/`.splice()`/`.map()`/`.filter()`/`.concat()`/
  * `.flatMap()` result are a *sub*-collection, not a single row.
+ *
+ * Read from the ECMAScript runtime (item B): each name is validated against
+ * `Array.prototype` rather than hand-copied. The *selection* — which array
+ * methods return a collection (`map`/`filter`/`concat`/`flatMap`/`slice`/
+ * `splice`) vs. which consume or reduce one (`forEach`/`reduce`/`find`/`some`/
+ * `every`) — is the documented judgment; the names are the runtime's.
  */
-const COLLECTION_TRANSFORM_METHODS = new Set(['slice', 'splice', 'map', 'filter', 'concat', 'flatMap']);
+export const COLLECTION_TRANSFORM_METHODS = new Set(['slice', 'splice', 'map', 'filter', 'concat', 'flatMap']
+    .filter((m) => typeof Array.prototype[m] === 'function'));
 /**
  * Free-function callee names that chunk a collection into batches — `chunk(ids,
  * n)`, `chunkArray(ids, n)`, `partition(rows, p)`. Recognized by name (not by a
@@ -2626,8 +2694,8 @@ function forOfIteration(loopNode, adapter, sourceCode) {
  * the `.run(…)` chained off `db.prepare(…)`) is where parameters are bound; its
  * arguments decide the row-vs-batch question.
  */
-function bindsBatchArgument(node, loopNode, adapter, sourceCode) {
-    const eagerCall = findEagerExecutionCall(node, adapter, sourceCode);
+function bindsBatchArgument(node, loopNode, adapter, sourceCode, vendor) {
+    const eagerCall = findEagerExecutionCall(node, adapter, sourceCode, vendor);
     if (!eagerCall)
         return false;
     const argsNode = adapter.getChildren(eagerCall).find((c) => adapter.getNodeType(c) === 'arguments');
@@ -2672,12 +2740,12 @@ function bindsBatchArgument(node, loopNode, adapter, sourceCode) {
  * chained off a statement-construction call (`db.prepare(sql).run(…)`). Returns
  * null when the call never executes I/O (already filtered upstream).
  */
-function findEagerExecutionCall(node, adapter, sourceCode) {
+function findEagerExecutionCall(node, adapter, sourceCode, vendor) {
     const call = resolveDbCallNode(node, adapter);
     if (!call)
         return null;
     const direct = dbCallMethodName(call, adapter, sourceCode);
-    if (direct && EAGER_DB_METHODS.has(direct)) {
+    if (direct && vendor.eagerMethods.has(direct)) {
         const memberExpr = findMemberCallee(call, adapter);
         if (!(memberExpr && isPromiseAllMember(memberExpr, adapter, sourceCode)))
             return call;
@@ -2688,7 +2756,7 @@ function findEagerExecutionCall(node, adapter, sourceCode) {
         if (type === 'call_expression') {
             const memberExpr = findMemberCallee(cur, adapter);
             const name = memberExpr ? memberPropertyName(memberExpr, adapter, sourceCode) : null;
-            if (name && EAGER_DB_METHODS.has(name) && !isPromiseAllMember(memberExpr, adapter, sourceCode)) {
+            if (name && vendor.eagerMethods.has(name) && !isPromiseAllMember(memberExpr, adapter, sourceCode)) {
                 return cur;
             }
         }
@@ -2894,7 +2962,7 @@ function buildGoEnv(ast, adapter, sourceCode, provenanceContext) {
         sourceCode,
     };
 }
-function buildDataAccessScan(ast, adapter, sourceCode, config) {
+function buildDataAccessScan(ast, adapter, sourceCode, config, vendorSurfaces) {
     const finalConfig = { ...DEFAULT_DATA_ACCESS_CONFIG, ...config };
     const detectionMode = finalConfig.detection?.mode ?? 'hybrid';
     const seedProvenance = config?._receiverProvenance;
@@ -2916,6 +2984,7 @@ function buildDataAccessScan(ast, adapter, sourceCode, config) {
         provenanceContext,
         handleEnv: buildHandleEnv(ast, adapter, sourceCode, provenanceContext),
         goEnv: buildGoEnv(ast, adapter, sourceCode, provenanceContext),
+        vendor: deriveVendorSets(vendorSurfaces ?? EMPTY_VENDOR_SURFACES),
     };
 }
 /**
@@ -2966,7 +3035,7 @@ export function extractLoopQueries(ast, adapter, sourceCode, config) {
  *  producer sees), so every provenance-dependent signal is captured as an identity
  *  and re-folded later. `handleEnv`/`goEnv` still build their provenance-free
  *  bindings/imports, which the structural discovery predicates read. */
-function buildCandidateScan(ast, adapter, sourceCode, config) {
+function buildCandidateScan(ast, adapter, sourceCode, config, vendorSurfaces) {
     const finalConfig = { ...DEFAULT_DATA_ACCESS_CONFIG, ...config };
     const provenanceContext = {
         dbProvenanced: new Map(),
@@ -2982,6 +3051,7 @@ function buildCandidateScan(ast, adapter, sourceCode, config) {
         provenanceContext,
         handleEnv: buildHandleEnv(ast, adapter, sourceCode, provenanceContext),
         goEnv: buildGoEnv(ast, adapter, sourceCode, provenanceContext),
+        vendor: deriveVendorSets(vendorSurfaces ?? EMPTY_VENDOR_SURFACES),
     };
 }
 // ── Structural discovery (empty-provenance supersets) ────────────────────────
@@ -3053,8 +3123,8 @@ function isTemplateOfDbCall(node, scan) {
  *  variable assignment) are provenance-free; the identifier/member/template arms
  *  cover every `handleVerdictForCall` shape with the empty seed. */
 function isBroadenedDataAccessCandidate(node, scan, tagNames) {
-    const { adapter, sourceCode } = scan;
-    if (isQueryBuilderShape(node, adapter, sourceCode))
+    const { adapter, sourceCode, vendor } = scan;
+    if (isQueryBuilderShape(node, adapter, sourceCode, vendor.prismaVerbs))
         return true;
     if (isTaggedTemplateSqlCall(node, adapter, sourceCode, tagNames))
         return true;
@@ -3203,7 +3273,7 @@ function wrapperCalleeNameForTemplate(node, adapter, sourceCode) {
  *  the corpus `data-access-calls` producer re-folds. The static-security arms run here
  *  on the empty-provenance scan; only `arm4CalleeName` is corrected corpus-side. */
 function buildDataAccessCallCandidate(node, ast, scan) {
-    const { adapter, sourceCode, config } = scan;
+    const { adapter, sourceCode, config, vendor } = scan;
     const nodeText = stripComments(adapter.getNodeText(node, sourceCode));
     if (!nodeText || nodeText.trim().length < 10)
         return null;
@@ -3213,7 +3283,7 @@ function buildDataAccessCallCandidate(node, ast, scan) {
     const isOrmCall = isOrmPattern(nodeText);
     const tagNames = config.sqlTagNames ?? SQL_TAG_NAMES;
     const isTaggedSqlCall = isTaggedTemplateSqlCall(node, adapter, sourceCode, tagNames);
-    const isQueryBuilder = isQueryBuilderShape(node, adapter, sourceCode);
+    const isQueryBuilder = isQueryBuilderShape(node, adapter, sourceCode, vendor.prismaVerbs);
     const isVariableAssignmentSql = isVariableAssignment(node, adapter) && sqlArg !== null;
     const isTemplate = isTemplateLiteral(node, adapter);
     const handle = handleCallSiteIdentity(node, scan);
@@ -3249,7 +3319,7 @@ function buildDataAccessCallCandidate(node, ast, scan) {
         hasOrganizationFilter: hasOrganizationFilter(nodeText, config),
         enclosingFunction: enclosingIdentity(node, adapter, ast.filePath),
         resolvedWhere: resolveWhereBinding(node, sourceCode, adapter),
-        ormTables: isOrmCall ? extractOrmTables(node, adapter, sourceCode, config) : [],
+        ormTables: isOrmCall ? extractOrmTables(node, adapter, sourceCode, config, vendor) : [],
         builderVerb: builderWriteVerb(node, adapter, sourceCode),
         ormHasFilter: hasOrmFilterShape(node, adapter, sourceCode),
         staticParameterized: security.parameterized,
@@ -3269,10 +3339,12 @@ function buildDataAccessCallCandidate(node, ast, scan) {
  * @param adapter - The language adapter (drives node discovery + text reads).
  * @param sourceCode - The file's source text.
  * @param config - Optional data-access config; defaults to the shared config.
+ * @param vendorSurfaces - Optional per-run resolved vendor surfaces (item B
+ *   reissued); defaults to the empty set (no vendor resolved).
  * @returns The raw, provenance-free `data-access-calls-candidates`.
  */
-export function extractDataAccessCallCandidates(ast, adapter, sourceCode, config) {
-    const scan = buildCandidateScan(ast, adapter, sourceCode, config);
+export function extractDataAccessCallCandidates(ast, adapter, sourceCode, config, vendorSurfaces) {
+    const scan = buildCandidateScan(ast, adapter, sourceCode, config, vendorSurfaces);
     const tagNames = scan.config.sqlTagNames ?? SQL_TAG_NAMES;
     const nodes = adapter.findNodes(ast, {
         custom: (node) => isBroadenedDataAccessCandidate(node, scan, tagNames),
@@ -3298,10 +3370,12 @@ export function extractDataAccessCallCandidates(ast, adapter, sourceCode, config
  * @param adapter - The language adapter (drives node discovery + text reads).
  * @param sourceCode - The file's source text.
  * @param config - Optional data-access config; defaults to the shared config.
+ * @param vendorSurfaces - Optional per-run resolved vendor surfaces (item B
+ *   reissued); defaults to the empty set (no vendor resolved).
  * @returns The raw, provenance-free `loop-query-candidates`.
  */
-export function extractLoopQueryRawCandidates(ast, adapter, sourceCode, config) {
-    const scan = buildCandidateScan(ast, adapter, sourceCode, config);
+export function extractLoopQueryRawCandidates(ast, adapter, sourceCode, config, vendorSurfaces) {
+    const scan = buildCandidateScan(ast, adapter, sourceCode, config, vendorSurfaces);
     const candidates = [];
     const dbNodes = adapter.findNodes(ast, {
         custom: (node) => isBroadenedLoopCandidate(node, scan),
@@ -3317,9 +3391,9 @@ export function extractLoopQueryRawCandidates(ast, adapter, sourceCode, config)
         const nodeText = adapter.getNodeText(node, sourceCode);
         if (!nodeText || nodeText.trim().length < 10)
             continue;
-        if (isStatementConstructionOnly(node, adapter, sourceCode))
+        if (isStatementConstructionOnly(node, adapter, sourceCode, scan.vendor))
             continue;
-        if (isSqlStringConstruction(node, adapter, sourceCode))
+        if (isSqlStringConstruction(node, adapter, sourceCode, scan.vendor))
             continue;
         const loopInfo = findEnclosingLoop(node, adapter, sourceCode);
         if (!loopInfo)
@@ -3331,10 +3405,10 @@ export function extractLoopQueryRawCandidates(ast, adapter, sourceCode, config)
             (enclosingFnName !== null && transactionWrappedFunctions.has(enclosingFnName));
         const preparesInLoop = loopBodyContainsPrepare(loopInfo.loopNode, adapter, sourceCode);
         const hoistedReuse = !preparesInLoop &&
-            (transactionEnclosesLoop || isHoistedStatementReRun(node, loopInfo.loopNode, adapter, sourceCode));
+            (transactionEnclosesLoop || isHoistedStatementReRun(node, loopInfo.loopNode, adapter, sourceCode, scan.vendor));
         if (hoistedReuse)
             continue;
-        if (bindsBatchArgument(node, loopInfo.loopNode, adapter, sourceCode))
+        if (bindsBatchArgument(node, loopInfo.loopNode, adapter, sourceCode, scan.vendor))
             continue;
         if (loopBodyContainsLlmCall(loopInfo.loopNode, adapter, sourceCode))
             continue;