gitnexus 1.6.9 → 1.6.10-aptos.0

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -42,9 +42,11 @@ import { buildPopulatedMethodDispatch } from '../graph-bridge/method-dispatch.js
 import { propagateImportedReturnTypes } from '../passes/imported-return-types.js';
 import { emitReceiverBoundCalls } from '../passes/receiver-bound-calls.js';
 import { emitFreeCallFallback } from '../passes/free-call-fallback.js';
+import { emitPropertyDispatchCalls, MAX_PROPERTY_DISPATCH_FANOUT, } from '../passes/property-dispatch.js';
 import { emitReferencesViaLookup } from '../graph-bridge/references-to-edges.js';
 import { createCalleeIdAccumulator, } from '../graph-bridge/callee-id-sink.js';
 import { emitImportEdges } from '../graph-bridge/imports-to-edges.js';
+import { callableFlowSiteKey, collectDeferredIndirectSites, emitCallableValueFlow, } from '../passes/callable-value-flow.js';
 import { findEnclosingClassDef, resolveInheritanceBaseInScope } from '../scope/walkers.js';
 import { buildWorkspaceResolutionIndex } from '../workspace-index.js';
 import { logHeapProbe } from '../../utils/heap-probe.js';
@@ -198,6 +200,7 @@ function emitDetectedInterfaceImplementations(graph, parsedFiles, nodeLookup, pr
 }
 export function runScopeResolution(input, provider) {
     const { graph, files } = input;
+    const callableFlowOnly = provider.scopeResolutionEdgeMode === 'callable-flow-only';
     const onWarn = input.onWarn ?? (() => { });
     const resolutionOutcomes = [];
     const recordResolutionOutcome = (outcome) => {
@@ -272,6 +275,25 @@ export function runScopeResolution(input, provider) {
     }
     logHeapProbe('sr-extract-end', `lang=${provider.language} parsedFiles=${parsedFiles.length} preExtractedHits=${preExtractedHits} skipped=${filesSkipped}`);
     provider.populateWorkspaceOwners?.(parsedFiles, { fileContents: getFileContents() });
+    // A callable-flow-only provider has no reason to build the whole-graph
+    // lookup or finalize ordinary references when none of its files emitted a
+    // callable fact. This keeps the opt-in path proportional to source scanning
+    // for repositories that use the provider but no first-class callables.
+    if (callableFlowOnly &&
+        !parsedFiles.some((parsed) => (parsed.callableFlowSites?.length ?? 0) > 0)) {
+        return {
+            filesProcessed: parsedFiles.length,
+            filesSkipped,
+            importsEmitted: 0,
+            resolve: { sitesProcessed: 0, referencesEmitted: 0, unresolved: 0 },
+            referenceEdgesEmitted: 0,
+            referenceSkipped: 0,
+            propertyDispatchSkippedKeys: 0,
+            resolutionOutcomes,
+            functionSummaries: [],
+            callSummaries: [],
+        };
+    }
     // Reconcile scope-resolution's ownership view into the SemanticModel.
     // See `reconcile-ownership.ts` for the full rationale (Contract
     // Invariant I9). Debug-mode validator runs immediately after to
@@ -293,6 +315,7 @@ export function runScopeResolution(input, provider) {
             resolve: { sitesProcessed: 0, referencesEmitted: 0, unresolved: 0 },
             referenceEdgesEmitted: 0,
             referenceSkipped: 0,
+            propertyDispatchSkippedKeys: 0,
             resolutionOutcomes,
             functionSummaries: [],
             callSummaries: [],
@@ -308,32 +331,45 @@ export function runScopeResolution(input, provider) {
     const resolutionConfig = input.resolutionConfig;
     const finalized = finalizeScopeModel(parsedFiles, {
         hooks: {
-            resolveImportTarget: (targetRaw, fromFile) => provider.resolveImportTarget(targetRaw, fromFile, allFilePaths, resolutionConfig),
+            resolveImportTarget: (targetRaw, fromFile, _workspaceIndex, parsedImport) => provider.resolveImportTarget(targetRaw, fromFile, allFilePaths, resolutionConfig, {
+                parsedFiles,
+                parsedImport,
+            }),
             expandsWildcardTo: (targetModuleScope) => provider.expandsWildcardTo?.(targetModuleScope, parsedFiles) ?? [],
             mergeBindings: (existing, incoming, scopeId) => provider.mergeBindings(existing, incoming, scopeId),
         },
     });
     logHeapProbe('sr-post-finalize', `lang=${provider.language}`);
-    const preEmittedInheritanceSites = preEmitInheritanceEdges(graph, finalized, nodeLookup);
+    const preEmittedInheritanceSites = callableFlowOnly
+        ? new Set()
+        : preEmitInheritanceEdges(graph, finalized, nodeLookup);
     // Call-based heritage hook (e.g., Ruby include/extend/prepend) — emits
     // IMPLEMENTS edges that `preEmitInheritanceEdges` cannot produce because
     // the heritage declarations are syntactic method calls, not grammar-level
     // heritage clauses. Must run BEFORE `buildMro` so MRO construction sees
     // the freshly-emitted IMPLEMENTS edges.
-    provider.emitHeritageEdges?.(graph, parsedFiles, nodeLookup, finalized);
+    if (!callableFlowOnly) {
+        provider.emitHeritageEdges?.(graph, parsedFiles, nodeLookup, finalized);
+    }
     // Implicit IMPORTS-edge hook — for languages whose files have compiler-
     // implicit cross-file visibility (no syntactic import statement). The
     // finalized-ImportEdge pipeline (`emitImportEdges`) cannot produce these
     // because there is no `ImportEdge` to materialize. Idempotent.
-    provider.emitImplicitImportEdges?.(graph, parsedFiles, nodeLookup, resolutionConfig);
+    if (!callableFlowOnly) {
+        provider.emitImplicitImportEdges?.(graph, parsedFiles, nodeLookup, resolutionConfig);
+    }
     // Rebuild the node lookup after heritage-edge emission. Languages like
     // Ruby create Property graph nodes inside `emitHeritageEdges`; those
     // nodes must be visible to downstream passes (`emitReceiverBoundCalls`
     // resolves write-access targets via `resolveDefGraphId` which consults
     // `nodeLookup`). Without this rebuild, Property nodes added by the
     // heritage hook are invisible and ACCESSES edges silently fail to emit.
-    const postHeritageNodeLookup = provider.emitHeritageEdges !== undefined ? buildGraphNodeLookup(graph) : nodeLookup;
-    emitDetectedInterfaceImplementations(graph, parsedFiles, postHeritageNodeLookup, provider, finalized, readonlyModel);
+    const postHeritageNodeLookup = !callableFlowOnly && provider.emitHeritageEdges !== undefined
+        ? buildGraphNodeLookup(graph)
+        : nodeLookup;
+    if (!callableFlowOnly) {
+        emitDetectedInterfaceImplementations(graph, parsedFiles, postHeritageNodeLookup, provider, finalized, readonlyModel);
+    }
     const mroByClassDefId = provider.buildMro(graph, parsedFiles, postHeritageNodeLookup);
     const extendsOnlyMroByClassDefId = provider.buildExtendsOnlyMro?.(graph, parsedFiles, postHeritageNodeLookup);
     // Replace the empty MethodDispatchIndex that finalizeScopeModel
@@ -437,37 +473,106 @@ export function runScopeResolution(input, provider) {
     // ── Phase 4: emit graph edges (LOAD-BEARING ORDER — see I1) ────────────
     input.onProgress?.('linking symbols', files.length, files.length);
     const handledSites = new Set(preEmittedInheritanceSites);
-    // Resolved-callee-id capture accumulator (#2227 U2). Created ONLY under
-    // `--pdg` — `undefined` otherwise so the three emitters do zero work and emit
-    // byte-identical output (R4). Populated below at all three CALLS emit paths
-    // (each before its dedup, KTD6/R8); consumed by the CFG-emit join (U3) at
-    // `emitFileCfgs` below to produce `BasicBlock.calleeIds`.
-    const calleeIdAccumulator = input.pdg === true ? createCalleeIdAccumulator() : undefined;
-    const receiverExtras = emitReceiverBoundCalls(graph, indexes, emitParsedFiles, postHeritageNodeLookup, handledSites, provider, workspaceIndex, readonlyModel, {
-        recordResolutionOutcome,
-        calleeIdSink: calleeIdAccumulator,
-    });
-    const unresolvedReceiverExtras = provider.emitUnresolvedReceiverEdges !== undefined
+    const deferredIndirectSites = collectDeferredIndirectSites(emitParsedFiles, indexes);
+    const callableArgumentSites = new Set();
+    if (input.pdg !== true && deferredIndirectSites.size > 0) {
+        for (const parsed of emitParsedFiles) {
+            for (const site of parsed.callableFlowSites ?? []) {
+                if (site.kind === 'argument') {
+                    callableArgumentSites.add(callableFlowSiteKey(parsed.filePath, site.callSite));
+                }
+            }
+        }
+    }
+    // Resolved-callee-id accumulator (#2227 U2 + callable-value-flow). Created
+    // for PDG OR when indirect-call facts need direct targets for actual→formal
+    // propagation. Populated below at every CALLS emit path before dedup; the CFG
+    // join still consumes it only inside the `input.pdg` block.
+    const calleeIdAccumulator = input.pdg === true || deferredIndirectSites.size > 0
+        ? createCalleeIdAccumulator(input.pdg === true
+            ? undefined
+            : (filePath, line, col) => callableArgumentSites.has(`${filePath}:${line}:${col}`))
+        : undefined;
+    const receiverExtras = callableFlowOnly
+        ? 0
+        : emitReceiverBoundCalls(graph, indexes, emitParsedFiles, postHeritageNodeLookup, handledSites, provider, workspaceIndex, readonlyModel, {
+            recordResolutionOutcome,
+            calleeIdSink: calleeIdAccumulator,
+        });
+    const unresolvedReceiverExtras = !callableFlowOnly && provider.emitUnresolvedReceiverEdges !== undefined
         ? provider.emitUnresolvedReceiverEdges(graph, indexes, emitParsedFiles, postHeritageNodeLookup, handledSites, readonlyModel)
         : 0;
-    const freeCallExtras = emitFreeCallFallback(graph, indexes, emitParsedFiles, postHeritageNodeLookup, referenceIndex, handledSites, readonlyModel, workspaceIndex, {
-        allowGlobalFallback: provider.allowGlobalFreeCallFallback === true,
-        constructorCallTargetsClass: provider.constructorCallTargetsClass === true,
-        isFileLocalDef: provider.isFileLocalDef,
-        isCallableVisibleFromCaller: provider.isCallableVisibleFromCaller,
-        resolveAdlCandidates: provider.resolveAdlCandidates,
-        conversionRankFn: provider.conversionRankFn,
-        conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
-        constraintCompatibility: provider.constraintCompatibility,
-        recordResolutionOutcome,
-        calleeIdSink: calleeIdAccumulator,
-    });
-    const { emitted, skipped } = emitReferencesViaLookup(graph, indexes, referenceIndex, postHeritageNodeLookup, handledSites, calleeIdAccumulator);
-    const importsEmitted = emitImportEdges(graph, indexes.imports, indexes.scopeTree, provider.importEdgeReason);
+    const freeCallExtras = callableFlowOnly
+        ? 0
+        : emitFreeCallFallback(graph, indexes, emitParsedFiles, postHeritageNodeLookup, referenceIndex, handledSites, readonlyModel, workspaceIndex, {
+            allowGlobalFallback: provider.allowGlobalFreeCallFallback === true,
+            constructorCallTargetsClass: provider.constructorCallTargetsClass === true,
+            isFileLocalDef: provider.isFileLocalDef,
+            isBuiltInName: provider.languageProvider.isBuiltInName,
+            freeCallsRequireInstanceOwnership: provider.freeCallsRequireInstanceOwnership === true,
+            isCallableVisibleFromCaller: provider.isCallableVisibleFromCaller,
+            resolveAdlCandidates: provider.resolveAdlCandidates,
+            conversionRankFn: provider.conversionRankFn,
+            conversionOnlyArgTypePrefixes: provider.conversionOnlyArgTypePrefixes,
+            constraintCompatibility: provider.constraintCompatibility,
+            recordResolutionOutcome,
+            calleeIdSink: calleeIdAccumulator,
+            skipSites: deferredIndirectSites,
+        });
+    const referenceSkipSites = new Set(handledSites);
+    for (const key of deferredIndirectSites)
+        referenceSkipSites.add(key);
+    const { emitted, skipped } = callableFlowOnly
+        ? { emitted: 0, skipped: 0 }
+        : emitReferencesViaLookup(graph, indexes, referenceIndex, postHeritageNodeLookup, referenceSkipSites, calleeIdAccumulator);
+    // value-ref registrations (#2437): USES edges at the registration sites
+    // plus field-based dispatch — synthesized CALLS from member-call sites to
+    // functions registered under the same property key. This runs after the
+    // ordinary precise passes but before callable-value-flow: property-dispatched
+    // wrapper calls must populate the callee accumulator before actual→formal
+    // propagation. `graph.addRelationship` remains first-write-wins, so precise
+    // edges already emitted for a site retain ownership.
+    const propertyDispatch = callableFlowOnly
+        ? { usesEmitted: 0, callsEmitted: 0, skippedKeys: 0, skippedKeyNames: [] }
+        : emitPropertyDispatchCalls(graph, indexes, emitParsedFiles, postHeritageNodeLookup, calleeIdAccumulator);
+    if (propertyDispatch.skippedKeys > 0) {
+        // Never drop dispatch coverage silently: a hook table larger than the
+        // fan-out cap means member calls through those keys get no synthesized
+        // CALLS — the #2437 false-safe gap reappears for exactly those keys.
+        logger.warn({
+            lang: provider.language,
+            skippedKeys: propertyDispatch.skippedKeys,
+            skippedKeyNames: propertyDispatch.skippedKeyNames,
+            fanoutCap: MAX_PROPERTY_DISPATCH_FANOUT,
+        }, 'property-dispatch: keys over the fan-out cap were dropped (no CALLS synthesized for them)');
+    }
+    const callableValueFlow = calleeIdAccumulator === undefined
+        ? {
+            emitted: 0,
+            resolvedInvokes: 0,
+            ambiguousInvokes: 0,
+            unmatchedInvokes: 0,
+            iterations: 0,
+        }
+        : emitCallableValueFlow({
+            graph,
+            scopes: indexes,
+            parsedFiles: emitParsedFiles,
+            nodeLookup: postHeritageNodeLookup,
+            calleeIds: calleeIdAccumulator,
+            language: provider.language,
+            collapseByCallerTarget: provider.collapseMemberCallsByCallerTarget === true,
+            isCallableValueTarget: provider.isCallableValueTarget,
+            hasFileLocalCallableLinkage: provider.hasFileLocalCallableLinkage,
+            onWarn: (warning) => logger.warn(warning, 'callable-value-flow: candidate set exceeded the cap; no partial CALLS emitted'),
+        });
+    const importsEmitted = callableFlowOnly
+        ? 0
+        : emitImportEdges(graph, indexes.imports, indexes.scopeTree, provider.importEdgeReason);
     // Language-specific supplementary edges (e.g. Vue template-derived
     // BINDS_EVENT_HANDLER / EMITS_EVENT / CALLS / ACCESSES edges).
     // Runs last so the full graph — including import edges — is visible.
-    if (provider.emitPostResolutionEdges !== undefined) {
+    if (!callableFlowOnly && provider.emitPostResolutionEdges !== undefined) {
         provider.emitPostResolutionEdges(graph, emitParsedFiles, postHeritageNodeLookup, indexes, {
             fileContents: getFileContents(),
             resolutionConfig,
@@ -608,8 +713,8 @@ export function runScopeResolution(input, provider) {
                 (message) => logger.warn(message), 
                 // U3 (#2227): the resolved-callee-id map for this file (captured at the
                 // three CALLS emit paths in U2), joined by exact call-site position to
-                // emit `BasicBlock.calleeIds`. `undefined` when pdg is off (the
-                // accumulator is only created under `input.pdg === true`).
+                // emit `BasicBlock.calleeIds`. Callable-flow may also have allocated
+                // the accumulator in a normal run, but this join remains PDG-only.
                 calleeIdAccumulator?.get(pf.filePath));
                 cfgBlocks += emitted.blocks;
                 cfgEdges += emitted.edges;
@@ -817,8 +922,15 @@ export function runScopeResolution(input, provider) {
         filesSkipped,
         importsEmitted,
         resolve: resolveStats,
-        referenceEdgesEmitted: emitted + receiverExtras + unresolvedReceiverExtras + freeCallExtras,
+        referenceEdgesEmitted: emitted +
+            receiverExtras +
+            unresolvedReceiverExtras +
+            freeCallExtras +
+            callableValueFlow.emitted +
+            propertyDispatch.usesEmitted +
+            propertyDispatch.callsEmitted,
         referenceSkipped: skipped,
+        propertyDispatchSkippedKeys: propertyDispatch.skippedKeys,
         resolutionOutcomes,
         functionSummaries: harvestedSummaries,
         callSummaries: harvestedCallSummaries,

package/dist/core/ingestion/scope-resolution/resolution-outcome.d.ts

@@ -1,5 +1,5 @@
 import type { Range } from '../../../_shared/index.js';
-export type ResolutionSuppressionReason = 'adl-ordinary-lookup-blocked' | 'conversion-rank-tied' | 'inline-ns-ambiguous' | 'member-lookup-ambiguous' | 'selected-callable-deleted' | 'overload-ambiguous' | 'overload-ambiguous-normalization';
+export type ResolutionSuppressionReason = 'adl-ordinary-lookup-blocked' | 'conversion-rank-tied' | 'inline-ns-ambiguous' | 'member-lookup-ambiguous' | 'selected-callable-deleted' | 'overload-ambiguous' | 'overload-ambiguous-normalization' | 'free-call-instance-ownership';
 export type ResolutionOutcome = {
     readonly kind: 'resolved';
     readonly targetId: string;

package/dist/core/ingestion/scope-resolution/scope/walkers.js

@@ -577,20 +577,26 @@ function walkScopeChain(startScope, name, scopes, predicate) {
         const scope = scopes.scopeTree.getScope(currentId);
         if (scope === undefined)
             return undefined;
-        // Local first: a `const x` in this scope shadows any imported `x`.
-        const localBindings = scope.bindings.get(name);
-        if (localBindings !== undefined) {
-            for (const b of localBindings) {
+        // `Object` scopes (object/record literal bodies) are a hoist
+        // boundary only -- their members are reachable via property access,
+        // never bare identifiers, so they contribute nothing to lookup
+        // (#2545/#2551). Still traverse past to the parent.
+        if (scope.kind !== 'Object') {
+            // Local first: a `const x` in this scope shadows any imported `x`.
+            const localBindings = scope.bindings.get(name);
+            if (localBindings !== undefined) {
+                for (const b of localBindings) {
+                    if (predicate(b.def))
+                        return b.def;
+                }
+            }
+            // Then imported/augmented bindings — only consulted when no local match.
+            const importedBindings = lookupBindingsAt(currentId, name, scopes);
+            for (const b of importedBindings) {
                 if (predicate(b.def))
                     return b.def;
             }
         }
-        // Then imported/augmented bindings — only consulted when no local match.
-        const importedBindings = lookupBindingsAt(currentId, name, scopes);
-        for (const b of importedBindings) {
-            if (predicate(b.def))
-                return b.def;
-        }
         currentId = scope.parent;
     }
     return undefined;
@@ -626,28 +632,32 @@ export function findAllCallableBindingsInScope(startScope, callableName, scopes)
         const scope = scopes.scopeTree.getScope(currentId);
         if (scope === undefined)
             return [];
-        const out = [];
-        const seen = new Set();
-        const pushCallable = (def) => {
-            if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
-                return;
-            if (seen.has(def.nodeId))
-                return;
-            seen.add(def.nodeId);
-            out.push(def);
-        };
-        const localBindings = scope.bindings.get(callableName);
-        if (localBindings !== undefined) {
-            for (const b of localBindings) {
+        // `Object` scopes are a hoist boundary only -- see walkScopeChain's
+        // comment (#2545/#2551). Skip lookup here, still traverse to parent.
+        if (scope.kind !== 'Object') {
+            const out = [];
+            const seen = new Set();
+            const pushCallable = (def) => {
+                if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
+                    return;
+                if (seen.has(def.nodeId))
+                    return;
+                seen.add(def.nodeId);
+                out.push(def);
+            };
+            const localBindings = scope.bindings.get(callableName);
+            if (localBindings !== undefined) {
+                for (const b of localBindings) {
+                    pushCallable(b.def);
+                }
+            }
+            const importedBindings = lookupBindingsAt(currentId, callableName, scopes);
+            for (const b of importedBindings) {
                 pushCallable(b.def);
             }
+            if (out.length > 0)
+                return out;
         }
-        const importedBindings = lookupBindingsAt(currentId, callableName, scopes);
-        for (const b of importedBindings) {
-            pushCallable(b.def);
-        }
-        if (out.length > 0)
-            return out;
         currentId = scope.parent;
     }
     return [];
@@ -694,16 +704,22 @@ export function findCallableBindingsAndAdlBlocker(startScope, name, scopes) {
                 nonCallableFound = true;
             }
         };
-        const localBindings = scope.bindings.get(name);
-        if (localBindings !== undefined) {
-            for (const b of localBindings) {
+        // `Object` scopes are a hoist boundary only (#2545/#2551) -- never
+        // reached by C++'s ADL path in practice (no language reusing this
+        // function emits `@scope.object`), guarded for consistency with the
+        // other scope-chain walkers in this file.
+        if (scope.kind !== 'Object') {
+            const localBindings = scope.bindings.get(name);
+            if (localBindings !== undefined) {
+                for (const b of localBindings) {
+                    process(b.def);
+                }
+            }
+            const importedBindings = lookupBindingsAt(currentId, name, scopes);
+            for (const b of importedBindings) {
                 process(b.def);
             }
         }
-        const importedBindings = lookupBindingsAt(currentId, name, scopes);
-        for (const b of importedBindings) {
-            process(b.def);
-        }
         if (anyBinding) {
             // ISO C++: a block-scope function declaration (Function or Block scope)
             // that is NOT a using-declaration blocks ADL. If we found callables at
@@ -747,6 +763,16 @@ export function populateClassOwnedMembers(parsed) {
             return;
         if (q.includes('.'))
             return; // already qualified (dotted)
+        // A synthesized anonymous-class def (Java `$`-chain binary name,
+        // #2550/#2555 — `M3$2`, `EnumWrap$Mode$1`) already carries its
+        // COMPLETE name. Prefixing it (`M3.M3$2`) desyncs from the
+        // structure-phase node id (`M3$2.hook`), so same-named methods
+        // across sibling enum-constant bodies collapse onto the first
+        // body's node via the simple-name fallback (empirically caught in
+        // review). Class-like only: `$`-named MEMBERS (legal in JS/TS)
+        // still qualify normally against their class.
+        if (isClassLike(def.type) && q.includes('$'))
+            return;
         const classQ = classDef.qualifiedName;
         if (classQ === undefined || classQ.length === 0)
             return;
@@ -930,18 +956,21 @@ export function findExportedDefByName(name, inScope, scopes, index) {
         const scope = scopes.scopeTree.getScope(currentId);
         if (scope === undefined)
             break;
-        const local = scope.bindings.get(name);
-        if (local !== undefined) {
-            for (const b of local) {
+        // `Object` scopes are a hoist boundary only (#2545/#2551).
+        if (scope.kind !== 'Object') {
+            const local = scope.bindings.get(name);
+            if (local !== undefined) {
+                for (const b of local) {
+                    if (b.def.type === 'Function' || b.def.type === 'Method')
+                        return b.def;
+                }
+            }
+            const finalized = lookupBindingsAt(currentId, name, scopes);
+            for (const b of finalized) {
                 if (b.def.type === 'Function' || b.def.type === 'Method')
                     return b.def;
             }
         }
-        const finalized = lookupBindingsAt(currentId, name, scopes);
-        for (const b of finalized) {
-            if (b.def.type === 'Function' || b.def.type === 'Method')
-                return b.def;
-        }
         currentId = scope.parent;
     }
     // Workspace-wide fallback: the first locally-declared callable binding

package/dist/core/ingestion/taint/typescript-model.js

@@ -35,10 +35,14 @@ export const TS_JS_TAINT_MODEL = {
         },
     ],
     sinks: [
-        // Command execution — the command string is argument 0.
+        // Command execution — shell strings are arg 0; argv-form APIs also treat
+        // the argv array at arg 1 as command/option injection surface.
         { name: 'exec', kind: 'command-injection', args: [0], module: 'child_process' },
         { name: 'execSync', kind: 'command-injection', args: [0], module: 'child_process' },
-        { name: 'spawn', kind: 'command-injection', args: [0], module: 'child_process' },
+        { name: 'spawn', kind: 'command-injection', args: [0, 1], module: 'child_process' },
+        { name: 'spawnSync', kind: 'command-injection', args: [0, 1], module: 'child_process' },
+        { name: 'execFile', kind: 'command-injection', args: [0, 1], module: 'child_process' },
+        { name: 'execFileSync', kind: 'command-injection', args: [0, 1], module: 'child_process' },
         // Code evaluation. `eval` takes code at 0; `new Function(...)` treats
         // EVERY argument as source text (params + body), so `args` is omitted
         // (= all positions) rather than pinned to 0.
@@ -53,9 +57,37 @@ export const TS_JS_TAINT_MODEL = {
         // (mysql2/pg/knex handles go by many names; receiver-conventional).
         { name: 'query', kind: 'sql-injection', args: [0], anyReceiver: true },
         { name: 'execute', kind: 'sql-injection', args: [0], anyReceiver: true },
+        // Modern DB libraries expose shorter method names with high collision
+        // rates (`map.get`, `task.run`, ...), so keep these receiver-conventional.
+        {
+            name: 'run',
+            kind: 'sql-injection',
+            args: [0],
+            receivers: ['db', 'database', 'conn', 'client', 'pool', 'stmt', 'statement', 'prepared'],
+        },
+        {
+            name: 'all',
+            kind: 'sql-injection',
+            args: [0],
+            receivers: ['db', 'database', 'conn', 'client', 'pool', 'stmt', 'statement', 'prepared'],
+        },
+        {
+            name: 'get',
+            kind: 'sql-injection',
+            args: [0],
+            receivers: ['db', 'database', 'conn', 'client', 'pool', 'stmt', 'statement', 'prepared'],
+        },
+        {
+            name: 'values',
+            kind: 'sql-injection',
+            args: [0],
+            receivers: ['db', 'database', 'conn', 'client', 'pool'],
+        },
+        { name: 'raw', kind: 'sql-injection', args: [0], receivers: ['db', 'knex', 'sequelize'] },
         // Reflected XSS — Express response writes, conventional receiver `res`.
         { name: 'send', kind: 'xss', args: [0], receivers: ['res'] },
         { name: 'write', kind: 'xss', args: [0], receivers: ['res'] },
+        { name: 'render', kind: 'xss', args: [0, 1], receivers: ['res'] },
     ],
     sanitizers: [
         // URL-encoding: neutralizes markup injection AND path separators

package/dist/core/ingestion/tree-sitter-queries.d.ts

@@ -1,7 +1,7 @@
 export declare const TYPESCRIPT_QUERIES: string;
 export declare const JAVASCRIPT_QUERIES: string;
-export declare const PYTHON_QUERIES = "\n(class_definition\n  name: (identifier) @name) @definition.class\n\n(function_definition\n  name: (identifier) @name) @definition.function\n\n(import_statement\n  name: (dotted_name) @import.source) @import\n\n; import numpy as np  \u2192  aliased_import captures the module name so the\n; import path is resolved and named-binding extraction stores \"np\" \u2192 \"numpy\".\n(import_statement\n  name: (aliased_import\n    name: (dotted_name) @import.source)) @import\n\n(import_from_statement\n  module_name: (dotted_name) @import.source) @import\n\n(import_from_statement\n  module_name: (relative_import) @import.source) @import\n\n(call\n  function: (identifier) @call.name) @call\n\n(call\n  function: (attribute\n    attribute: (identifier) @call.name)) @call\n\n; Class attribute type annotations \u2014 PEP 526: address: Address or address: Address = Address()\n; Both bare annotations (address: Address) and annotated assignments (name: str = \"test\")\n; are parsed as (assignment left: ... type: ...) in tree-sitter-python.\n(expression_statement\n  (assignment\n    left: (identifier) @name\n    type: (type)) @definition.property)\n\n; Plain variable assignments without type annotation: x = 5, MAX_SIZE = 100\n; Overlap with @definition.property (typed) is handled by parse-worker dedup.\n(expression_statement\n  (assignment\n    left: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Python HTTP clients: requests.get('/path'), httpx.post('/path'), session.get('/path')\n(call\n  function: (attribute\n    attribute: (identifier) @http_client.method)\n  arguments: (argument_list\n    (string (string_content) @http_client.url))) @http_client\n\n; Python decorators: @app.route, @router.get, etc.\n(decorator\n  (call\n    function: (attribute\n      object: (identifier) @decorator.receiver\n      attribute: (identifier) @decorator.name)\n    arguments: (argument_list\n      (string (string_content) @decorator.arg)?))) @decorator\n";
-export declare const JAVA_QUERIES = "\n; Classes, Interfaces, Enums, Annotations\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(enum_declaration name: (identifier) @name) @definition.enum\n(annotation_type_declaration name: (identifier) @name) @definition.annotation\n\n; Methods & Constructors\n(method_declaration name: (identifier) @name) @definition.method\n(constructor_declaration name: (identifier) @name) @definition.constructor\n\n; Fields \u2014 typed field declarations inside class bodies\n(field_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.property\n\n; Imports - capture any import declaration child as source\n(import_declaration (_) @import.source) @import\n\n; Calls\n(method_invocation name: (identifier) @call.name) @call\n(method_invocation object: (_) name: (identifier) @call.name) @call\n(method_reference) @call\n\n; Constructor calls: new Foo()\n(object_creation_expression type: (type_identifier) @call.name) @call\n\n; Local variable declarations inside method bodies\n(local_variable_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_access\n    object: (_) @assignment.receiver\n    field: (identifier) @assignment.property)\n  right: (_)) @assignment\n";
+export declare const PYTHON_QUERIES = "\n(class_definition\n  name: (identifier) @name) @definition.class\n\n(function_definition\n  name: (identifier) @name) @definition.function\n\n(import_statement\n  name: (dotted_name) @import.source) @import\n\n; import numpy as np  \u2192  aliased_import captures the module name so the\n; import path is resolved and named-binding extraction stores \"np\" \u2192 \"numpy\".\n(import_statement\n  name: (aliased_import\n    name: (dotted_name) @import.source)) @import\n\n(import_from_statement\n  module_name: (dotted_name) @import.source) @import\n\n(import_from_statement\n  module_name: (relative_import) @import.source) @import\n\n(call\n  function: (identifier) @call.name) @call\n\n(call\n  function: (attribute\n    attribute: (identifier) @call.name)) @call\n\n; Class attribute type annotations \u2014 PEP 526: address: Address or address: Address = Address()\n; Both bare annotations (address: Address) and annotated assignments (name: str = \"test\")\n; are parsed as (assignment left: ... type: ...) in tree-sitter-python.\n(expression_statement\n  (assignment\n    left: (identifier) @name\n    type: (type)) @definition.property)\n\n; Plain variable assignments without type annotation: x = 5, MAX_SIZE = 100\n; Overlap with @definition.property (typed) is handled by parse-worker dedup.\n(expression_statement\n  (assignment\n    left: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Write access: obj.field += value (compound assignment)\n(augmented_assignment\n  left: (attribute\n    object: (_) @assignment.receiver\n    attribute: (identifier) @assignment.property)\n  right: (_)) @assignment\n\n; Python HTTP clients: requests.get('/path'), httpx.post('/path'), session.get('/path')\n(call\n  function: (attribute\n    attribute: (identifier) @http_client.method)\n  arguments: (argument_list\n    (string (string_content) @http_client.url))) @http_client\n\n; Python decorators: @app.route, @router.get, etc.\n; The first positional argument is captured three ways (#2391): a string literal\n; path via @decorator.arg (quote-free, the fast path); a bare constant name or a\n; plus-concatenation via @decorator.arg_expr (resolved cross-file by the constant\n; resolver). The anchored optional alternation pins to the FIRST arg and stays\n; optional, so no-arg decorators (@app.tool(), etc.) and non-path first args still\n; match.\n(decorator\n  (call\n    function: (attribute\n      object: (identifier) @decorator.receiver\n      attribute: (identifier) @decorator.name)\n    arguments: (argument_list\n      .\n      [\n        (string (string_content)? @decorator.arg) @decorator.arg_str\n        (identifier) @decorator.arg_expr\n        (binary_operator) @decorator.arg_expr\n      ]?))) @decorator\n";
+export declare const JAVA_QUERIES = "\n; Classes, Interfaces, Enums, Records, Annotations\n(class_declaration name: (identifier) @name) @definition.class\n(interface_declaration name: (identifier) @name) @definition.interface\n(enum_declaration name: (identifier) @name) @definition.enum\n(record_declaration name: (identifier) @name) @definition.record\n(annotation_type_declaration name: (identifier) @name) @definition.annotation\n\n; Anonymous class bodies: new Runnable() { ... } \u2014 no @name capture; the\n; class extractor synthesizes the javac-style Worker$N name (#2550)\n(object_creation_expression (class_body)) @definition.class\n\n; Enum constant bodies: enum E { A { ... } } \u2014 javac's other anonymous\n; shape, synthesized as E$N by the same naming authority (#2555)\n(enum_constant body: (class_body)) @definition.class\n\n; Methods & Constructors\n(method_declaration name: (identifier) @name) @definition.method\n(constructor_declaration name: (identifier) @name) @definition.constructor\n\n; Fields \u2014 typed field declarations inside class bodies\n(field_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.property\n\n; Imports - capture any import declaration child as source\n(import_declaration (_) @import.source) @import\n\n; Calls\n(method_invocation name: (identifier) @call.name) @call\n(method_invocation object: (_) name: (identifier) @call.name) @call\n(method_reference) @call\n\n; Constructor calls: new Foo()\n(object_creation_expression type: (type_identifier) @call.name) @call\n\n; Local variable declarations inside method bodies\n(local_variable_declaration\n  declarator: (variable_declarator\n    name: (identifier) @name)) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_access\n    object: (_) @assignment.receiver\n    field: (identifier) @assignment.property)\n  right: (_)) @assignment\n";
 export declare const C_QUERIES = "\n; Functions (direct declarator)\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n\n; Functions returning pointers (pointer_declarator wraps function_declarator)\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n\n; Functions returning double pointers (nested pointer_declarator)\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function\n\n; Structs, Unions, Enums, Typedefs\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(type_definition\n  type: (struct_specifier\n    body: (field_declaration_list))\n  declarator: (type_identifier) @name) @definition.struct\n(union_specifier name: (type_identifier) @name) @definition.union\n(enum_specifier name: (type_identifier) @name) @definition.enum\n(type_definition\n  type: (enum_specifier\n    body: (enumerator_list))\n  declarator: (type_identifier) @name) @definition.enum\n(enumerator name: (identifier) @name) @definition.const\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n\n; Variable declarations: int x = 5; or int x;\n(declaration\n  declarator: (init_declarator\n    declarator: (identifier) @name)) @definition.variable\n";
 export declare const GO_QUERIES = "\n; Functions & Methods\n(function_declaration name: (identifier) @name) @definition.function\n(method_declaration name: (field_identifier) @name) @definition.method\n(method_elem name: (field_identifier) @name) @definition.method\n\n; Types\n(type_declaration (type_spec name: (type_identifier) @name type: (struct_type))) @definition.struct\n(type_declaration (type_spec name: (type_identifier) @name type: (interface_type))) @definition.interface\n\n; Imports\n(import_declaration (import_spec path: (interpreted_string_literal) @import.source)) @import\n(import_declaration (import_spec_list (import_spec path: (interpreted_string_literal) @import.source))) @import\n\n; Struct fields \u2014 named field declarations inside struct types\n(field_declaration_list\n  (field_declaration\n    name: (field_identifier) @name) @definition.property)\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (selector_expression field: (field_identifier) @call.name)) @call\n\n; Const/var declarations\n(const_declaration (const_spec (identifier) @name)) @definition.const\n(var_declaration (var_spec (identifier) @name)) @definition.variable\n(var_declaration (var_spec_list (var_spec (identifier) @name))) @definition.variable\n\n; Short variable declaration: x := 5\n(short_var_declaration left: (expression_list (identifier) @name)) @definition.variable\n\n; Struct literal construction: User{Name: \"Alice\"}\n(composite_literal type: (type_identifier) @call.name) @call\n\n; Write access: obj.field = value\n(assignment_statement\n  left: (expression_list\n    (selector_expression\n      operand: (_) @assignment.receiver\n      field: (field_identifier) @assignment.property))\n  right: (_)) @assignment\n\n; Write access: obj.field++ / obj.field--\n(inc_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n(dec_statement\n  (selector_expression\n    operand: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)) @assignment\n";
 export declare const CPP_QUERIES = "\n; Classes, Structs, Namespaces\n(class_specifier name: (type_identifier) @name) @definition.class\n(class_specifier\n  name: (template_type\n    (type_identifier) @name\n    (template_argument_list) @template-arguments)) @definition.class\n; Out-of-line nested definition: class Outer::Inner { ... } / struct Outer::Inner { ... }.\n; Key the node by the full qualified_identifier text so the def materializes a\n; node that matches the HAS_METHOD owner id (also the full qualified text) and\n; stays distinct from a same-tail type in another scope (#1975, #1978).\n(class_specifier name: (qualified_identifier) @name) @definition.class\n(struct_specifier name: (qualified_identifier) @name) @definition.struct\n(struct_specifier name: (type_identifier) @name) @definition.struct\n(struct_specifier\n  name: (template_type\n    (type_identifier) @name\n    (template_argument_list) @template-arguments)) @definition.struct\n(namespace_definition name: (namespace_identifier) @name) @definition.namespace\n(enum_specifier name: (type_identifier) @name) @definition.enum\n\n; Typedefs and unions (common in C-style headers and mixed C/C++ code)\n(type_definition\n  type: (struct_specifier\n    body: (field_declaration_list))\n  declarator: (type_identifier) @name) @definition.struct\n(type_definition\n  type: (enum_specifier\n    body: (enumerator_list))\n  declarator: (type_identifier) @name) @definition.enum\n(enumerator name: (identifier) @name) @definition.const\n(type_definition declarator: (type_identifier) @name) @definition.typedef\n(union_specifier name: (type_identifier) @name) @definition.union\n\n; Macros\n(preproc_function_def name: (identifier) @name) @definition.macro\n(preproc_def name: (identifier) @name) @definition.macro\n\n; Functions & Methods (direct declarator)\n(function_definition declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(function_definition declarator: (function_declarator declarator: (operator_name) @name)) @definition.function\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))) @definition.method\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (operator_name) @name))) @definition.method\n\n; Functions/methods returning pointers (pointer_declarator wraps function_declarator)\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(function_definition declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method\n\n; Functions/methods returning double pointers (nested pointer_declarator)\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name)))) @definition.function\n(function_definition declarator: (pointer_declarator declarator: (pointer_declarator declarator: (function_declarator declarator: (qualified_identifier name: (identifier) @name))))) @definition.method\n\n; Functions/methods returning references (reference_declarator wraps function_declarator)\n(function_definition declarator: (reference_declarator (function_declarator declarator: (identifier) @name))) @definition.function\n(function_definition declarator: (reference_declarator (function_declarator declarator: (operator_name) @name))) @definition.function\n(function_definition declarator: (reference_declarator (function_declarator declarator: (qualified_identifier name: (identifier) @name)))) @definition.method\n(function_definition declarator: (reference_declarator (function_declarator declarator: (qualified_identifier name: (operator_name) @name)))) @definition.method\n\n; Destructors (destructor_name is distinct from identifier in tree-sitter-cpp)\n(function_definition declarator: (function_declarator declarator: (qualified_identifier name: (destructor_name) @name))) @definition.method\n\n; Function declarations / prototypes (common in headers)\n(declaration declarator: (function_declarator declarator: (identifier) @name)) @definition.function\n(declaration declarator: (function_declarator declarator: (operator_name) @name)) @definition.function\n(declaration declarator: (pointer_declarator declarator: (function_declarator declarator: (identifier) @name))) @definition.function\n(declaration declarator: (reference_declarator (function_declarator declarator: (operator_name) @name))) @definition.function\n\n; Class/struct data member fields (Address address; int count;)\n; Uses field_identifier to exclude method declarations (which use function_declarator)\n(field_declaration\n  declarator: (field_identifier) @name) @definition.property\n\n; Pointer member fields (Address* address;)\n(field_declaration\n  declarator: (pointer_declarator\n    declarator: (field_identifier) @name)) @definition.property\n\n; Reference member fields (Address& address;)\n(field_declaration\n  declarator: (reference_declarator\n    (field_identifier) @name)) @definition.property\n\n; Inline class method declarations (inside class body, no body: void save();)\n; tree-sitter-cpp uses field_identifier (not identifier) for names inside class bodies\n(field_declaration declarator: (function_declarator declarator: [(field_identifier) (identifier) (operator_name)] @name)) @definition.method\n\n; Inline class method declarations returning a pointer (User* lookup();)\n(field_declaration declarator: (pointer_declarator declarator: (function_declarator declarator: [(field_identifier) (identifier)] @name))) @definition.method\n\n; Inline class method declarations returning a reference (User& lookup();)\n(field_declaration declarator: (reference_declarator (function_declarator declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method\n\n; Inline class method definitions (inside class body, with body: void Foo() { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (function_declarator\n      declarator: [(field_identifier) (identifier) (operator_name) (destructor_name)] @name)) @definition.method)\n\n; Inline class methods returning a pointer type (User* lookup(int id) { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (pointer_declarator\n      declarator: (function_declarator\n        declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method)\n\n; Inline class methods returning a reference type (User& lookup(int id) { ... })\n(field_declaration_list\n  (function_definition\n    declarator: (reference_declarator\n      (function_declarator\n        declarator: [(field_identifier) (identifier) (operator_name)] @name))) @definition.method)\n\n; Templates\n(template_declaration (class_specifier name: (type_identifier) @name)) @definition.template\n(template_declaration\n  (class_specifier\n    name: (template_type\n      (type_identifier) @name\n      (template_argument_list) @template-arguments))) @definition.template\n(template_declaration (function_definition declarator: (function_declarator declarator: (identifier) @name))) @definition.template\n\n; Includes\n(preproc_include path: (_) @import.source) @import\n\n; Calls\n(call_expression function: (identifier) @call.name) @call\n(call_expression function: (field_expression field: (field_identifier) @call.name)) @call\n(call_expression function: (qualified_identifier name: (identifier) @call.name)) @call\n(call_expression function: (template_function name: (identifier) @call.name)) @call\n(binary_expression operator: \"+\" @call.name) @call\n(binary_expression operator: \"<<\" @call.name) @call\n\n; Constructor calls: new User()\n(new_expression type: (type_identifier) @call.name) @call\n\n; Variable declarations: int x = 5; or auto x = 5;\n(declaration\n  declarator: (init_declarator\n    declarator: (identifier) @name)) @definition.variable\n\n; Structured bindings: auto [a, b] = makePair();  (one @name per bound identifier)\n(declaration\n  declarator: (init_declarator\n    declarator: (structured_binding_declarator\n      (identifier) @name))) @definition.variable\n\n; Structured bindings, reference form: auto& [x, y] = tup;\n(declaration\n  declarator: (init_declarator\n    declarator: (reference_declarator\n      (structured_binding_declarator\n        (identifier) @name)))) @definition.variable\n\n; Write access: obj.field = value\n(assignment_expression\n  left: (field_expression\n    argument: (_) @assignment.receiver\n    field: (field_identifier) @assignment.property)\n  right: (_)) @assignment\n\n";

package/dist/core/ingestion/tree-sitter-queries.js

@@ -717,22 +717,42 @@ export const PYTHON_QUERIES = `
     (string (string_content) @http_client.url))) @http_client
 
 ; Python decorators: @app.route, @router.get, etc.
+; The first positional argument is captured three ways (#2391): a string literal
+; path via @decorator.arg (quote-free, the fast path); a bare constant name or a
+; plus-concatenation via @decorator.arg_expr (resolved cross-file by the constant
+; resolver). The anchored optional alternation pins to the FIRST arg and stays
+; optional, so no-arg decorators (@app.tool(), etc.) and non-path first args still
+; match.
 (decorator
   (call
     function: (attribute
       object: (identifier) @decorator.receiver
       attribute: (identifier) @decorator.name)
     arguments: (argument_list
-      (string (string_content) @decorator.arg)?))) @decorator
+      .
+      [
+        (string (string_content)? @decorator.arg) @decorator.arg_str
+        (identifier) @decorator.arg_expr
+        (binary_operator) @decorator.arg_expr
+      ]?))) @decorator
 `;
 // Java queries - works with tree-sitter-java
 export const JAVA_QUERIES = `
-; Classes, Interfaces, Enums, Annotations
+; Classes, Interfaces, Enums, Records, Annotations
 (class_declaration name: (identifier) @name) @definition.class
 (interface_declaration name: (identifier) @name) @definition.interface
 (enum_declaration name: (identifier) @name) @definition.enum
+(record_declaration name: (identifier) @name) @definition.record
 (annotation_type_declaration name: (identifier) @name) @definition.annotation
 
+; Anonymous class bodies: new Runnable() { ... } — no @name capture; the
+; class extractor synthesizes the javac-style Worker$N name (#2550)
+(object_creation_expression (class_body)) @definition.class
+
+; Enum constant bodies: enum E { A { ... } } — javac's other anonymous
+; shape, synthesized as E$N by the same naming authority (#2555)
+(enum_constant body: (class_body)) @definition.class
+
 ; Methods & Constructors
 (method_declaration name: (identifier) @name) @definition.method
 (constructor_declaration name: (identifier) @name) @definition.constructor
@@ -1755,4 +1775,5 @@ export const LANGUAGE_QUERIES = {
     [SupportedLanguages.Dart]: DART_QUERIES,
     [SupportedLanguages.Vue]: TYPESCRIPT_QUERIES, // Vue <script> blocks are parsed as TypeScript
     [SupportedLanguages.Cobol]: '', // Standalone regex processor — no tree-sitter queries
+    [SupportedLanguages.Move]: '', // Compiler-first via move-flow — no tree-sitter queries
 };