gitnexus 1.6.10-rc.46 → 1.6.10-rc.48

package/README.md

@@ -471,6 +471,8 @@ Configure the behavior with these environment variables:
 | `GITNEXUS_FTS_CJK_SEGMENTATION`              | `none`, `bigram`               | `none`              | `bigram` inserts overlapping character-bigram boundaries into Chinese/Japanese Han-ideograph spans in `content`/`description` before FTS indexing, so LadybugDB's space-only tokenizer can see sub-phrase word boundaries. Scoped to CJK Unified Ideographs only — Japanese Hiragana/Katakana and Korean Hangul are not currently segmented. Unlike `GITNEXUS_FTS_STEMMER`, this rewrites stored text — enabling it on an already-indexed repo requires a full `gitnexus analyze --force`; neither `--repair-fts` nor a plain incremental `analyze` applies it to previously-indexed files. Set the same value wherever `analyze` and search-serving processes (CLI query, MCP server, web server) run. |
 | `GITNEXUS_COMMUNITY_ENGINE`                  | `graphology`, `icebug`, `auto` | `graphology`        | Community-detection engine used during analyze. `graphology` uses the bundled default path. `icebug` and `auto` currently behave identically: both try the experimental Icebug CSR path and fall back to Graphology if the optional native module is unavailable or incompatible.                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `GITNEXUS_WAL_CHECKPOINT_THRESHOLD`          | integer `>= -1`                | `67108864` (64 MiB) | LadybugDB WAL auto-checkpoint threshold during analyze (bytes). Auto-checkpoint remains enabled; `-1` keeps Ladybug's stock ~16 MiB. Larger thresholds reduce checkpoint frequency but increase the WAL size at rotation time — choose a smaller value on disk-constrained environments.                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `GITNEXUS_LBUG_BUFFER_POOL_SIZE`             | integer `>= 0` (bytes)         | min(2 GiB, 80% RAM) | LadybugDB buffer-pool ceiling for every GitNexus database (analyze, MCP server, serve, group bridges). Bounded so a long-lived `gitnexus mcp` process or a large incremental `analyze` cannot grow toward LadybugDB's native 80%-of-RAM default and OOM the host (#2557). `0` restores that native unbounded default; invalid values warn and fall back to the default.                                                                                                                                                                                                                                                                                                                                  |
+| `GITNEXUS_LBUG_MAX_DB_SIZE`                  | positive integer (bytes)       | `17179869184` (16 GiB) | Upper bound for a single LadybugDB database file. This is an mmap/disk-address-space ceiling, not a memory limit — it does not constrain the buffer pool (use `GITNEXUS_LBUG_BUFFER_POOL_SIZE` for that). Raise it when indexing genuinely huge monorepos; invalid values silently fall back to the default.                                                                                                                                                                                                                                                                                                                                                                                             |
 
 ```bash
 # Offline/airgapped: never reach the network for extensions

package/dist/_shared/scope-resolution/types.d.ts

@@ -27,8 +27,20 @@ import type { SymbolDefinition } from './symbol-definition.js';
 export type ScopeId = string;
 /** Stable symbol-definition identifier (graph nodeId). */
 export type DefId = string;
-/** Kinds of lexical scope a `Scope` node can represent. */
-export type ScopeKind = 'Module' | 'Namespace' | 'Class' | 'Function' | 'Block' | 'Expression';
+/**
+ * Kinds of lexical scope a `Scope` node can represent.
+ *
+ * `Object` is a hoist boundary ONLY: an object/record literal body
+ * (TS/JS `{...}`, Kotlin anonymous `object {...}`). Members are
+ * reachable via property access, never as bare identifiers, so
+ * scope-chain walkers (`scope/walkers.ts`) must skip an `Object`
+ * scope's own bindings while still traversing past it to the parent
+ * (#2545/#2551) -- unlike `Block`, where a nested closure legitimately
+ * DOES see a sibling `let`/`const` from an enclosing `if`/`for`/`while`,
+ * a nested closure inside an object literal must NOT see a sibling
+ * property's name as a free identifier.
+ */
+export type ScopeKind = 'Module' | 'Namespace' | 'Class' | 'Function' | 'Block' | 'Expression' | 'Object';
 /** Source-text range. 1-based `startLine`/`endLine`; 0-based `startCol`/`endCol`. */
 export interface Range {
     readonly startLine: number;

package/dist/_shared/scope-resolution/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"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"}

package/dist/core/ingestion/class-extractors/configs/jvm.js

@@ -1,5 +1,6 @@
 // gitnexus/src/core/ingestion/class-extractors/configs/jvm.ts
 import { SupportedLanguages } from '../../../../_shared/index.js';
+import { synthesizeJavaAnonymousClassName } from '../../utils/ast-helpers.js';
 // ---------------------------------------------------------------------------
 // Java
 // ---------------------------------------------------------------------------
@@ -10,6 +11,12 @@ export const javaClassConfig = {
         'interface_declaration',
         'enum_declaration',
         'record_declaration',
+        // Anonymous class bodies (`new Runnable() { ... }`) — the matching
+        // JAVA_QUERIES pattern only captures `object_creation_expression`
+        // WITH a `class_body`, and `extractName` below returns undefined for
+        // any other shape, so plain `new Foo()` constructor calls never
+        // produce a Class node (#2550).
+        'object_creation_expression',
     ],
     fileScopeNodeTypes: ['package_declaration'],
     ancestorScopeNodeTypes: [
@@ -18,6 +25,23 @@ export const javaClassConfig = {
         'enum_declaration',
         'record_declaration',
     ],
+    extractName(node) {
+        if (node.type === 'object_creation_expression') {
+            return synthesizeJavaAnonymousClassName(node);
+        }
+        return undefined;
+    },
+    // An anonymous body whose name CANNOT be synthesized (no supported host
+    // type declaration) must not become a Class node at all. Without this
+    // skip, `extract()`'s `extractTypeNameFromNode` fallback names the node
+    // after the CONSTRUCTED type — emitting a phantom `Class:...:Runnable`
+    // for `new Runnable() { ... }` (empirically caught in review).
+    shouldSkipClassCapture({ definitionNode }) {
+        return (definitionNode !== null &&
+            definitionNode !== undefined &&
+            definitionNode.type === 'object_creation_expression' &&
+            synthesizeJavaAnonymousClassName(definitionNode) === undefined);
+    },
 };
 // ---------------------------------------------------------------------------
 // Kotlin

package/dist/core/ingestion/languages/java/captures.js

@@ -13,7 +13,7 @@
  *
  * Pure given the input source text. No I/O, no globals consulted.
  */
-import { nodeIfType, nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { nodeIfType, nodeToCapture, synthesizeJavaAnonymousClassName, syntheticCapture, } from '../../utils/ast-helpers.js';
 import { splitImportDeclaration } from './import-decomposer.js';
 import { computeJavaArityMetadata } from './arity-metadata.js';
 import { synthesizeJavaReceiverBinding } from './receiver-binding.js';
@@ -184,9 +184,79 @@ export function emitJavaScopeCaptures(sourceText, _filePath, cachedTree) {
         ...resolveVarTypeBindings(out),
         ...synthesizeJavaInheritanceReferences(tree.rootNode),
         ...synthesizeJavaExplicitConstructorReferences(tree.rootNode),
+        ...synthesizeJavaAnonymousClassDeclarations(tree.rootNode),
         ...synthesizeCallableFlowCaptures(tree.rootNode, JAVA_CALLABLE_CAPTURE_OPTIONS),
     ];
 }
+/**
+ * Synthesize `@declaration.class` matches for anonymous class bodies
+ * (`new Runnable() { ... }`), named by the same javac-style authority
+ * (`synthesizeJavaAnonymousClassName` → `Worker$N`) the structure phase
+ * uses — the two layers agree by construction (#2550).
+ *
+ * The anchor is the `class_body` node: it shares its range with the
+ * `(object_creation_expression (class_body) @scope.class)` scope rule in
+ * query.ts, so the def is owned by that Class scope's `ownedDefs`
+ * (making `populateClassOwnedMembers` stamp `ownerId` on the anonymous
+ * class's methods) and the name auto-hoists to the enclosing scope —
+ * exactly the binding shape a named class declaration produces.
+ */
+function synthesizeJavaAnonymousClassDeclarations(rootNode) {
+    const out = [];
+    for (const oce of rootNode.descendantsOfType('object_creation_expression')) {
+        const name = synthesizeJavaAnonymousClassName(oce);
+        if (name === undefined)
+            continue;
+        const body = oce.namedChildren.find((c) => c.type === 'class_body');
+        if (body === undefined)
+            continue;
+        out.push({
+            '@declaration.class': nodeToCapture('@declaration.class', body),
+            '@declaration.name': syntheticCapture('@declaration.name', body, name),
+        });
+        // Inheritance: the anonymous class extends/implements its constructed
+        // type. Anchor the `@reference.inherits` on the `class_body` — its
+        // range equals the anonymous Class scope, so the reference site's
+        // enclosing class resolves to the SYNTHESIZED `Worker$N` def (anchoring
+        // on the constructed-type node would sit OUTSIDE the anonymous scope
+        // and mis-attribute the edge to the lexically enclosing class). The
+        // synthetic `@reference.name` carries the base's simple name; a JDK
+        // type with no repo def simply resolves to nothing (no edge). Without
+        // this edge `mroFor(Worker$N)` is empty and the #2550 instance-
+        // ownership gate suppressed TRUE bare calls to inherited methods
+        // inside the anonymous body (empirically caught in review).
+        const constructedType = oce.childForFieldName?.('type');
+        const baseSimpleName = constructedType !== null && constructedType !== undefined
+            ? javaBaseSimpleNameOf(constructedType)
+            : undefined;
+        if (baseSimpleName !== undefined) {
+            out.push({
+                '@reference.inherits': nodeToCapture('@reference.inherits', body),
+                '@reference.name': syntheticCapture('@reference.name', body, baseSimpleName),
+            });
+        }
+        // Receiver typeBinding: `Runnable handler = new Runnable() { ... }`
+        // binds `handler` to the ANONYMOUS class (`Worker$1`), not the declared
+        // interface — the instance is what `handler.run()` dispatches into, and
+        // the declared type is frequently a JDK interface with no repo def.
+        // Appended after the raw matches, so it overwrites the declared-type
+        // binding the `@type-binding.annotation` query rule produced for the
+        // same variable (pass-4 applies bindings in match order; last wins).
+        const declarator = oce.parent;
+        if (declarator !== null && declarator.type === 'variable_declarator') {
+            const varName = declarator.childForFieldName?.('name');
+            const declNode = declarator.parent ?? declarator;
+            if (varName !== null && varName !== undefined) {
+                out.push({
+                    '@type-binding.annotation': nodeToCapture('@type-binding.annotation', declNode),
+                    '@type-binding.name': nodeToCapture('@type-binding.name', varName),
+                    '@type-binding.type': syntheticCapture('@type-binding.type', oce, name),
+                });
+            }
+        }
+    }
+    return out;
+}
 /**
  * Synthesize `@reference.call.constructor` captures for explicit constructor
  * invocations — `super(...)` and `this(...)` (F38 #1928). tree-sitter-java
@@ -377,6 +447,13 @@ function emitJavaInheritanceBase(out, base) {
     });
 }
 /** Resolve a Java base-type node to its bare simple-name identifier node. */
+/** Simple name of a constructed/base type node, reusing the same node
+ *  shapes `javaBaseLookupNameNode` handles (`Runnable`, `a.b.Base`,
+ *  `Box<T>`). Returns undefined when the node is none of those. */
+function javaBaseSimpleNameOf(typeNode) {
+    const nameNode = javaBaseLookupNameNode(typeNode);
+    return nameNode === null ? undefined : nameNode.text;
+}
 function javaBaseLookupNameNode(node) {
     switch (node.type) {
         case 'type_identifier':

package/dist/core/ingestion/languages/java/query.js

@@ -37,6 +37,14 @@ const JAVA_SCOPE_QUERY = `
 (record_declaration) @scope.class
 (annotation_type_declaration) @scope.class
 
+;; Anonymous class body: \`new Runnable() { public void run() {} }\`.
+;; Without its own scope, a method's auto-hoist (scope-extractor.ts) has
+;; nowhere to stop and leaks the name past the anonymous class into the
+;; enclosing scope -- the same failure mode fixed for TS/JS object
+;; literals (#2545).
+(object_creation_expression
+  (class_body) @scope.class)
+
 (method_declaration) @scope.function
 (constructor_declaration) @scope.function
 

package/dist/core/ingestion/languages/java/scope-resolver.js

@@ -31,6 +31,12 @@ const javaScopeResolver = {
     collapseMemberCallsByCallerTarget: true,
     hoistTypeBindingsToModule: true,
     stripReceiverCastExpressions: true,
+    // #2550: every Java method belongs to a class instance — a free call may
+    // resolve to a Method only when the caller's enclosing class chain
+    // (self + MRO) contains the method's owner. Closes the finalize-bucket
+    // leak (unqualified `run()` matching an unrelated same-file anonymous
+    // class's method). C# is the intended next adopter.
+    freeCallsRequireInstanceOwnership: true,
     populateNamespaceSiblings: populateJavaPackageSiblings,
     populateRangeBindings: populateJavaCrossFileReturnTypes,
 };

package/dist/core/ingestion/languages/javascript/query.js

@@ -66,6 +66,13 @@ const JAVASCRIPT_SCOPE_QUERY = `
 (arrow_function) @scope.function
 (method_definition) @scope.function
 
+;; Object literals get their own scope boundary -- see the matching
+;; comment in typescript/query.ts (#2545/#2551). Prevents a
+;; method_definition/property-arrow's auto-hoist from leaking its name
+;; past the literal into the enclosing scope, and (unlike Block) keeps
+;; sibling properties from seeing each other as bare identifiers.
+(object) @scope.object
+
 ;; Declarations — classes
 (class_declaration
   name: (identifier) @declaration.name) @declaration.class

package/dist/core/ingestion/languages/kotlin/query.js

@@ -15,6 +15,12 @@ const KOTLIN_SCOPE_QUERY = `
 (class_declaration) @scope.class
 (object_declaration) @scope.class
 (companion_object) @scope.class
+;; Anonymous object expression: \`val h = object { fun fetch() {} }\`
+;; (distinct from the named \`object_declaration\`/\`companion_object\` above).
+;; Without its own scope, a method's auto-hoist (scope-extractor.ts) has
+;; nowhere to stop and leaks the name past the literal into the enclosing
+;; scope -- the same failure mode fixed for TS/JS object literals (#2545).
+(object_literal) @scope.class
 (function_declaration) @scope.function
 
 ;; Secondary-constructor body scope (issue #1919 review CF1). A

package/dist/core/ingestion/languages/typescript/query.js

@@ -96,6 +96,23 @@ const TYPESCRIPT_SCOPE_QUERY = `
 (arrow_function) @scope.function
 (function_expression) @scope.function
 
+;; Object literals (the { ... } value expression, NOT object_type or
+;; object_pattern) get their own scope boundary. Without it, a
+;; method_definition/property-arrow's auto-hoist (scope-extractor.ts)
+;; has nowhere to stop and leaks the name past the literal into whatever
+;; lexically encloses it -- e.g. 'export default { async fetch(req) {} }'
+;; would bind fetch at Module scope, letting an unrelated same-file
+;; fetch(...) call (the platform global) incorrectly resolve to it
+;; (#2545). Object (not Block or Class): object-literal members are
+;; reachable only via property access, never as bare identifiers -- not
+;; even by a SIBLING property's function body, unlike a real Block
+;; (if/for/while, where a nested closure legitimately sees a sibling
+;; let/const) or a Class (implicit-this sibling dispatch). Scope-chain
+;; walkers (scope-resolution/scope/walkers.ts) skip an Object scope's
+;; own bindings entirely while still treating it as a hoist boundary
+;; (#2551).
+(object) @scope.object
+
 ;; Type aliases that contain an object_type are structurally class-like —
 ;; they define a shape with named members. Emit @scope.class so the
 ;; field-extractor's type-alias-with-object-type handling (in

package/dist/core/ingestion/scope-extractor.js

@@ -308,6 +308,8 @@ function resolveKindForScopeMatch(match, anchor, provider) {
             return 'Block';
         case 'expression':
             return 'Expression';
+        case 'object':
+            return 'Object';
         default:
             return null;
     }

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -626,6 +626,23 @@ export interface ScopeResolver {
      * but is too loose as a default for strict module systems.
      */
     readonly allowGlobalFreeCallFallback?: boolean;
+    /**
+     * In this language every `Method` belongs to a class instance, so a
+     * FREE (receiver-less) call may resolve to a `Method` only when the
+     * caller's enclosing class chain — the class itself plus its MRO —
+     * contains the method's owner (#2550). Suppresses the finalize-bucket
+     * leak where an unqualified call matched any same-file method by bare
+     * name (`materializeBindings` flattens every declaration onto module
+     * scope). Java opts in; C# is the intended next adopter.
+     *
+     * NOT implemented via `LanguageProvider.builtInNames`: that mechanism
+     * has unrelated consumers (`parse-worker`'s call-site extraction gate
+     * suppresses member calls too; `type-env`'s return-type lookup) which
+     * assume a flagged name is never a real repository declaration —
+     * false for common method names like `run`/`get`/`compare` (verified
+     * regression).
+     */
+    readonly freeCallsRequireInstanceOwnership?: boolean;
     /**
      * When true, a constructor-form call `Type(...)` links to the Class def
      * itself rather than its explicit Constructor def. Default

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.d.ts

@@ -57,6 +57,15 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
      *  fail at the call site. Three-valued; `'unknown'` keeps the
      *  candidate (monotonicity). */
     readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];
+    /** Platform/language built-in names (e.g. `fetch`, `setTimeout`) that
+     *  are never real repository declarations. Gates the finalize-bucket
+     *  guard below (#2545) -- see `hasGenuineLexicalBinding`. */
+    readonly isBuiltInName?: (name: string) => boolean;
+    /** Instance-ownership gate (#2550): a free call may resolve to a
+     *  `Method` only when the caller's enclosing class chain (self + MRO)
+     *  contains the method's owner. See
+     *  `ScopeResolver.freeCallsRequireInstanceOwnership`. */
+    readonly freeCallsRequireInstanceOwnership?: boolean;
     readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
     /** Call sites owned by a later precise pass (for example callable-value-flow). */
     readonly skipSites?: ReadonlySet<string>;

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -17,7 +17,7 @@
  * generalization plan.
  */
 import { resolveCallerGraphId, resolveDefGraphId } from '../graph-bridge/ids.js';
-import { findAllCallableBindingsInScope, findCallableBindingInScope, findCallableBindingsAndAdlBlocker, resolveInheritanceBaseInScope, } from '../scope/walkers.js';
+import { findAllCallableBindingsInScope, findCallableBindingInScope, findCallableBindingsAndAdlBlocker, findEnclosingClassDef, resolveInheritanceBaseInScope, } from '../scope/walkers.js';
 import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from './overload-narrowing.js';
 export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _referenceIndex, handledSites, model, workspaceIndex, options = {}) {
     let emitted = 0;
@@ -109,6 +109,72 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                     // available AND the binding scope contains multiple overloads,
                     // refine with narrowOverloadCandidates (#1578).
                     fnDef = findCallableBindingInScope(site.inScope, site.name, scopes);
+                    if (fnDef !== undefined &&
+                        options.isBuiltInName?.(site.name) === true &&
+                        fnDef.filePath === parsed.filePath &&
+                        !hasGenuineLexicalBinding(site.inScope, site.name, scopes)) {
+                        // A platform/language built-in (e.g. `fetch`, `setTimeout`)
+                        // with no binding reachable via the TRUE lexical scope chain
+                        // (Scope.bindings only) -- the match came solely from
+                        // finalize's per-file "local + imports + wildcards" bucket,
+                        // which flattens every declaration in the file onto the
+                        // module scope regardless of true nesting depth
+                        // (gitnexus-shared's `materializeBindings`). That flattening
+                        // is correct for its purpose (cross-file import targets) but
+                        // over-matches same-file built-in-shadowing declarations that
+                        // were never really module-scope-visible -- e.g. a Cloudflare
+                        // Worker's `export default { fetch(req) {} }` handler (#2545).
+                        // Leave the call unresolved rather than emit a false edge.
+                        //
+                        // `fnDef.filePath === parsed.filePath` is the load-bearing
+                        // guard against a real regression: `materializeBindings`'s
+                        // flat bucket is per-file, so the leak this guard targets is
+                        // ALWAYS same-file. A cross-file match at this point can only
+                        // come from a genuine import/namespace/workspace-FQN channel
+                        // (the separate, gated `pickUniqueGlobalCallable` global
+                        // fallback runs later and isn't what populated `fnDef` here)
+                        // -- e.g. `import { fetch } from './fetch-polyfill'` must
+                        // keep resolving. Without this check, that import silently
+                        // stopped resolving (verified via a scratch probe fixture).
+                        fnDef = undefined;
+                    }
+                    // Instance-ownership gate (#2550). Placement matters: after the
+                    // scope-chain lookup, BEFORE overload narrowing -- a suppressed
+                    // candidate must not participate in overload selection. The
+                    // legitimate same-class bare call already resolved earlier via
+                    // `pickImplicitThisOverload`; an inherited bare call passes the
+                    // MRO arm here; what remains is the finalize-bucket leak (an
+                    // unrelated same-file method matched by bare name).
+                    //
+                    // Same-file only (mirrors the #2545 guard's load-bearing
+                    // condition): the `materializeBindings` bucket is per-file, so
+                    // the leak is ALWAYS same-file. A cross-file Method match here
+                    // came through a genuine import channel -- e.g. the arity-
+                    // narrowing parity fixtures resolve a bare `writeAudit(u)` to
+                    // an imported class's method, which must keep working
+                    // (suppressing it broke `java.test.ts`'s arity-filtering suite,
+                    // verified empirically).
+                    if (fnDef !== undefined &&
+                        options.freeCallsRequireInstanceOwnership === true &&
+                        fnDef.type === 'Method' &&
+                        fnDef.ownerId !== undefined &&
+                        fnDef.filePath === parsed.filePath) {
+                        const enclosing = findEnclosingClassDef(site.inScope, scopes);
+                        const ownerReachable = enclosing !== undefined &&
+                            (enclosing.nodeId === fnDef.ownerId ||
+                                scopes.methodDispatch.mroFor(enclosing.nodeId).includes(fnDef.ownerId));
+                        if (!ownerReachable) {
+                            recordSuppressedOutcome(options.recordResolutionOutcome, {
+                                phase: 'free-call-fallback',
+                                filePath: parsed.filePath,
+                                name: site.name,
+                                range: site.atRange,
+                                reason: 'free-call-instance-ownership',
+                                candidates: [fnDef],
+                            });
+                            fnDef = undefined;
+                        }
+                    }
                     if (fnDef !== undefined && options.conversionRankFn !== undefined) {
                         const allCallables = findAllCallableBindingsInScope(site.inScope, site.name, scopes);
                         if (allCallables.length > 1) {
@@ -709,3 +775,31 @@ export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, ho
         return undefined;
     return candidates[0];
 }
+/**
+ * True when `name` is bound somewhere along the TRUE lexical scope
+ * chain from `startScope` -- i.e. via `Scope.bindings` (the raw,
+ * nesting-aware per-scope map built during extraction), NOT via
+ * finalize's `indexes.bindings` module-scope bucket (which flattens
+ * every declaration in the file onto the module scope regardless of
+ * true nesting -- see `hasGenuineLexicalBinding`'s caller for why that
+ * distinction matters, #2545).
+ */
+function hasGenuineLexicalBinding(startScope, name, scopes) {
+    let currentId = startScope;
+    const visited = new Set();
+    while (currentId !== null) {
+        if (visited.has(currentId))
+            return false;
+        visited.add(currentId);
+        const scope = scopes.scopeTree.getScope(currentId);
+        if (scope === undefined)
+            return false;
+        // `Object` scopes (object/record literal bodies) are a hoist
+        // boundary only -- never a genuine lexical binding, not even to
+        // their own nested children (#2551, mirrors scope/walkers.ts).
+        if (scope.kind !== 'Object' && scope.bindings.get(name) !== undefined)
+            return true;
+        currentId = scope.parent;
+    }
+    return false;
+}

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

@@ -508,6 +508,8 @@ export function runScopeResolution(input, provider) {
             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,

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
@@ -930,18 +946,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/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; 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, 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 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; 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; 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

@@ -744,6 +744,10 @@ export const JAVA_QUERIES = `
 (enum_declaration name: (identifier) @name) @definition.enum
 (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
+
 ; Methods & Constructors
 (method_declaration name: (identifier) @name) @definition.method
 (constructor_declaration name: (identifier) @name) @definition.constructor

package/dist/core/ingestion/type-extractors/jvm.js

@@ -1,10 +1,20 @@
-import { findChild } from '../utils/ast-helpers.js';
+import { findChild, synthesizeJavaAnonymousClassName, } from '../utils/ast-helpers.js';
 import { extractSimpleTypeName, extractVarName, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString, } from './shared.js';
 // ── Java ──────────────────────────────────────────────────────────────────
 const JAVA_DECLARATION_NODE_TYPES = new Set([
     'local_variable_declaration',
     'field_declaration',
 ]);
+/** `Runnable handler = new Runnable() { ... }` — the variable's effective
+ *  type is the ANONYMOUS class (`Worker$1`), not the declared interface;
+ *  that is the instance `handler.run()` dispatches into (#2550). Returns
+ *  undefined for declarators without an anonymous-body initializer. */
+const anonymousInitializerTypeName = (declarator) => {
+    const valueNode = declarator.childForFieldName('value');
+    if (!valueNode || valueNode.type !== 'object_creation_expression')
+        return undefined;
+    return synthesizeJavaAnonymousClassName(valueNode);
+};
 /** Java: Type x = ...; Type x; */
 const extractJavaDeclaration = (node, env) => {
     const typeNode = node.childForFieldName('type');
@@ -22,7 +32,7 @@ const extractJavaDeclaration = (node, env) => {
         if (nameNode) {
             const varName = extractVarName(nameNode);
             if (varName)
-                env.set(varName, typeName);
+                env.set(varName, anonymousInitializerTypeName(child) ?? typeName);
         }
     }
 };
@@ -42,6 +52,11 @@ const extractJavaInitializer = (node, env, _classNames) => {
             continue;
         if (valueNode.type !== 'object_creation_expression')
             continue;
+        const anonName = anonymousInitializerTypeName(child);
+        if (anonName) {
+            env.set(varName, anonName);
+            continue;
+        }
         const ctorType = valueNode.childForFieldName('type');
         if (!ctorType)
             continue;

package/dist/core/ingestion/utils/ast-helpers.d.ts

@@ -102,6 +102,7 @@ export interface EnclosingClassInfo {
      */
     qualifiedClassId?: string;
 }
+export declare const synthesizeJavaAnonymousClassName: (node: SyntaxNode) => string | undefined;
 export declare const findEnclosingClassInfo: (node: SyntaxNode, filePath: string, resolveEnclosingOwner?: (node: SyntaxNode) => SyntaxNode | null, 
 /**
  * Optional (#1978): returns the enclosing type's fully-qualified name

package/dist/core/ingestion/utils/ast-helpers.js

@@ -270,7 +270,14 @@ export function getLabelFromCaptures(captureMap, provider) {
         return null;
     const hasDefaultExportHocNameSeed = captureMap['definition.function'] !== undefined &&
         (captureMap['hoc'] !== undefined || captureMap['callee'] !== undefined);
-    if (!captureMap['name'] && !captureMap['definition.constructor'] && !hasDefaultExportHocNameSeed)
+    // Nameless `definition.class` passes through: a class extractor may
+    // synthesize the name (Java anonymous class bodies → `Worker$N`, #2550).
+    // Downstream stays safe — parse-worker skips any nameless definition the
+    // extractor could not name (its `!nameNode && !extractedClassSymbol` gate).
+    if (!captureMap['name'] &&
+        !captureMap['definition.constructor'] &&
+        !captureMap['definition.class'] &&
+        !hasDefaultExportHocNameSeed)
         return null;
     if (captureMap['definition.function']) {
         if (provider.labelOverride) {
@@ -353,6 +360,82 @@ export function getLabelFromCaptures(captureMap, provider) {
  *    `MAX_ENCLOSING_WALK_ITERATIONS` defense-in-depth guard below prevents
  *    pathological hooks from creating an infinite loop. */
 const MAX_ENCLOSING_WALK_ITERATIONS = 4096;
+/**
+ * Synthesize a javac-style name for a Java anonymous class body:
+ * `new Runnable() { ... }` inside top-level class `Worker` becomes
+ * `Worker$1` (`$N` = 1-based source order of anonymous bodies within the
+ * top-level class). Returns undefined when the node is not an
+ * `object_creation_expression` carrying a `class_body` child — which also
+ * keeps this a no-op for C#, whose `object_creation_expression` uses
+ * `initializer_expression`, never `class_body` (#2550).
+ *
+ * The SAME name must be produced by every layer that keys the anonymous
+ * class (structure-phase node id, enclosing-owner walk, scope-side
+ * declaration synthesis, receiver typeBinding) — they agree by all calling
+ * this one helper.
+ */
+/** Type-declaration node types that can host (and name) a Java anonymous
+ *  class body — javac numbers `$N` per top-level type of any of these
+ *  kinds. Enum constant bodies (`A { ... }`) are a different node shape
+ *  and remain unmodeled. */
+const JAVA_ANON_HOST_TYPES = new Set([
+    'class_declaration',
+    'enum_declaration',
+    'interface_declaration',
+    'record_declaration',
+]);
+/** Per-parse-tree memo of anonymous-body numbering: tree → (startIndex →
+ *  synthesized name). Keyed by the tree OBJECT via WeakMap so entries die
+ *  with the parse; without it every call re-scans the host subtree
+ *  (`descendantsOfType`), and the helper is called from four independent
+ *  layers per anonymous body — quadratic on anon-heavy files (old-style
+ *  listener-per-widget Java). */
+const javaAnonNameMemo = new WeakMap();
+export const synthesizeJavaAnonymousClassName = (node) => {
+    if (node.type !== 'object_creation_expression')
+        return undefined;
+    const hasClassBody = node.namedChildren?.some((c) => c.type === 'class_body');
+    if (hasClassBody !== true)
+        return undefined;
+    const tree = node.tree;
+    if (tree !== undefined) {
+        const cached = javaAnonNameMemo.get(tree)?.get(node.startIndex);
+        if (cached !== undefined)
+            return cached;
+    }
+    // Topmost enclosing host type declaration — javac numbers per top-level type.
+    let topHost = null;
+    let cursor = node.parent;
+    let iterations = 0;
+    while (cursor) {
+        if (++iterations > MAX_ENCLOSING_WALK_ITERATIONS)
+            return undefined;
+        if (JAVA_ANON_HOST_TYPES.has(cursor.type))
+            topHost = cursor;
+        cursor = cursor.parent;
+    }
+    if (topHost === null)
+        return undefined;
+    const topName = topHost.childForFieldName?.('name')?.text;
+    if (topName === undefined || topName.length === 0)
+        return undefined;
+    const anonBodies = (topHost.descendantsOfType?.('object_creation_expression') ?? []).filter((c) => c.namedChildren?.some((n) => n.type === 'class_body'));
+    if (tree !== undefined) {
+        let byStart = javaAnonNameMemo.get(tree);
+        if (byStart === undefined) {
+            byStart = new Map();
+            javaAnonNameMemo.set(tree, byStart);
+        }
+        for (let i = 0; i < anonBodies.length; i++) {
+            byStart.set(anonBodies[i].startIndex, `${topName}$${i + 1}`);
+        }
+        return byStart.get(node.startIndex);
+    }
+    const index = anonBodies.findIndex((c) => c.startIndex === node.startIndex);
+    if (index === -1)
+        return undefined;
+    return `${topName}$${index + 1}`;
+};
 export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner, 
 /**
  * Optional (#1978): returns the enclosing type's fully-qualified name
@@ -411,6 +494,21 @@ getQualifiedOwnerName) => {
                 }
             }
         }
+        // Java: an anonymous class body (`new Runnable() { ... }`) owns its
+        // members — attribute to the synthesized `Worker$N` class, not the
+        // lexically enclosing named class (#2550). `synthesizeJavaAnonymousClassName`
+        // returns undefined for `object_creation_expression` without a
+        // `class_body` (plain `new Foo()`, and every C# shape), so the walk
+        // continues unchanged for those.
+        if (current.type === 'object_creation_expression') {
+            const anonName = synthesizeJavaAnonymousClassName(current);
+            if (anonName !== undefined) {
+                return {
+                    classId: generateId('Class', `${filePath}:${anonName}`),
+                    className: anonName,
+                };
+            }
+        }
         if (CLASS_CONTAINER_TYPES.has(current.type)) {
             // Delegate language-specific container remapping to the provider hook.
             if (resolveEnclosingOwner) {

package/dist/core/lbug/lbug-config.d.ts

@@ -39,8 +39,15 @@ export declare function resolveNativeSafeStorageDir(storagePath: string, subdir:
  *    `true` (0.16.0). Existing call sites that relied on the positional
  *    default must now pass `false` explicitly to preserve behaviour.
  *
- * Putting both in one shared module guarantees every `new lbug.Database(...)`
- * call site agrees on the same ceiling and behaviour.
+ * 3. `bufferManagerSize` (not a 0.16.0 change, same pin-explicitly
+ *    principle): `0` means "native default", and the native default buffer
+ *    pool is 80% of physical RAM. A long-lived `gitnexus mcp` process or a
+ *    large incremental analyze can balloon to that ceiling and OOM-kill the
+ *    host session (#2557), so GitNexus pins an explicit bounded pool — see
+ *    `resolveBufferManagerSize`.
+ *
+ * Putting these in one shared module guarantees every `new lbug.Database(...)`
+ * call site agrees on the same ceilings and behaviour.
  */
 /**
  * Upper bound for any single GitNexus LadybugDB file (graph index, group

package/dist/core/lbug/lbug-config.js

@@ -227,8 +227,15 @@ export function resolveNativeSafeStorageDir(storagePath, subdir) {
  *    `true` (0.16.0). Existing call sites that relied on the positional
  *    default must now pass `false` explicitly to preserve behaviour.
  *
- * Putting both in one shared module guarantees every `new lbug.Database(...)`
- * call site agrees on the same ceiling and behaviour.
+ * 3. `bufferManagerSize` (not a 0.16.0 change, same pin-explicitly
+ *    principle): `0` means "native default", and the native default buffer
+ *    pool is 80% of physical RAM. A long-lived `gitnexus mcp` process or a
+ *    large incremental analyze can balloon to that ceiling and OOM-kill the
+ *    host session (#2557), so GitNexus pins an explicit bounded pool — see
+ *    `resolveBufferManagerSize`.
+ *
+ * Putting these in one shared module guarantees every `new lbug.Database(...)`
+ * call site agrees on the same ceilings and behaviour.
  */
 /**
  * Upper bound for any single GitNexus LadybugDB file (graph index, group
@@ -286,6 +293,53 @@ const resolveCheckpointThreshold = () => {
     }
     return DEFAULT_WAL_CHECKPOINT_THRESHOLD;
 };
+/**
+ * Default ceiling for the LadybugDB buffer pool in bytes (#2557).
+ *
+ * The pool is a page cache with eviction, so the ceiling trades throughput
+ * on very large working sets for a machine that stays alive: 2 GiB is
+ * ~40× the GitNexus self-index, while the native 80%-of-RAM default let a
+ * `detect_changes` call grow a 105 MiB on-disk index to 19.5 GiB RSS and
+ * OOM-kill the reporter's session. The `min` with 80% of `os.totalmem()`
+ * keeps sub-2.5-GiB machines at the native-equivalent bound (no regression
+ * there); the 64 MiB floor keeps tiny containers above any plausible
+ * native minimum pool size.
+ */
+const DEFAULT_BUFFER_POOL_CAP = 2 * 1024 * 1024 * 1024;
+const BUFFER_POOL_FLOOR = 64 * 1024 * 1024;
+const parseBufferPoolSize = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    const normalized = raw.trim();
+    if (normalized.length === 0)
+        return undefined;
+    const parsed = Number(normalized);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return undefined;
+    return Math.floor(parsed);
+};
+const defaultBufferPoolSize = () => Math.min(DEFAULT_BUFFER_POOL_CAP, Math.max(BUFFER_POOL_FLOOR, Math.floor(os.totalmem() * 0.8)));
+/**
+ * Resolve the `bufferManagerSize` passed to every `new lbug.Database(...)`.
+ * `GITNEXUS_LBUG_BUFFER_POOL_SIZE` (bytes) overrides the default; `0` is a
+ * deliberate escape hatch that restores LadybugDB's native unbounded
+ * 80%-of-RAM default. Resolved at call time (not module load) so tests can
+ * stub the env var and `os.totalmem`.
+ */
+const resolveBufferManagerSize = () => {
+    const raw = process.env.GITNEXUS_LBUG_BUFFER_POOL_SIZE;
+    if (raw === undefined)
+        return defaultBufferPoolSize();
+    const parsed = parseBufferPoolSize(raw);
+    if (parsed !== undefined)
+        return parsed;
+    // Non-empty but unparseable input: warn the operator and fall back —
+    // mirrors the GITNEXUS_WAL_CHECKPOINT_THRESHOLD env path above.
+    if (raw.trim().length > 0) {
+        logger.warn({ rawValue: raw, fallback: defaultBufferPoolSize() }, `Ignoring invalid GITNEXUS_LBUG_BUFFER_POOL_SIZE=${raw}; expected integer >= 0 (bytes; 0 restores the native 80%-of-RAM default); falling back to min(2 GiB, 80% of RAM).`);
+    }
+    return defaultBufferPoolSize();
+};
 /** Matches WAL corruption errors from the LadybugDB engine. */
 const WAL_CORRUPTION_RE = /corrupt(ed)?\s+wal|invalid\s+wal\s+record|wal.*corrupt|checksum.*wal/i;
 export const WAL_RECOVERY_SUGGESTION = 'WAL corruption detected. Run `gitnexus analyze --force` to rebuild the index.';
@@ -496,7 +550,7 @@ export const classifyDeleteAllError = (err) => {
 };
 export function createLbugDatabase(lbugModule, databasePath, options = {}) {
     // .d.ts declares fewer args than the native constructor accepts.
-    return new lbugModule.Database(databasePath, 0, // bufferManagerSize
+    return new lbugModule.Database(databasePath, resolveBufferManagerSize(), // bufferManagerSize (#2557: default min(2 GiB, 80% RAM); GITNEXUS_LBUG_BUFFER_POOL_SIZE overrides; 0 restores the native 80%-of-RAM default)
     false, // enableCompression (pinned for v0.16.0)
     options.readOnly ?? false, LBUG_MAX_DB_SIZE, true, // autoCheckpoint (always on)
     resolveCheckpointThreshold(), // checkpointThreshold (default 64 MiB; override with GITNEXUS_WAL_CHECKPOINT_THRESHOLD; -1 keeps Ladybug stock ~16 MiB)

package/dist/storage/parse-cache.js

@@ -52,7 +52,7 @@ import { fileURLToPath } from 'url';
 // the main thread (the #1983 OOM). Because the two stores share this version,
 // any future change to the `ParsedFile` serialization shape MUST bump
 // SCHEMA_BUMP so both invalidate in lockstep.
-const SCHEMA_BUMP = 17; // Callable-value-flow operands now retain expression kind/qualified identity and formal signature metadata. (16 = direct callee identity; 15 = always-on callableFlowSites; 14 = #2437 value refs.)
+const SCHEMA_BUMP = 18; // Java anonymous class bodies emit synthesized Worker$N Class nodes and re-keyed methods (#2550). (17 = callable-value-flow operand identity; 16 = direct callee identity; 15 = always-on callableFlowSites.)
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/dist/storage/repo-manager.d.ts

@@ -335,8 +335,14 @@ export interface RepoMeta {
  * only covers changed files (`computeEffectiveWriteSet`), so a top-up against a
  * pre-v7 index would silently omit the new edges for every unchanged file pair;
  * force a full re-analyze instead (same contract as v2–v6).
- */
-export declare const INCREMENTAL_SCHEMA_VERSION = 7;
+ * v8: Java anonymous class bodies became first-class Class nodes (#2550):
+ * `new Runnable() { run(){} }` now emits `Class:...:Worker$1` and its methods
+ * re-keyed from `Worker.run` to `Worker$1.run`. Node identities move on
+ * unchanged files — a top-up against a pre-v8 index would strand the old
+ * `Worker.run`-keyed Method nodes alongside the new ones (the v5 Route
+ * precedent); force a full re-analyze instead.
+ */
+export declare const INCREMENTAL_SCHEMA_VERSION = 8;
 export interface IndexedRepo {
     repoPath: string;
     storagePath: string;

package/dist/storage/repo-manager.js

@@ -112,8 +112,14 @@ export const cloneDirBelongsToEntry = (cloneDir, entryPath) => registryPathEqual
  * only covers changed files (`computeEffectiveWriteSet`), so a top-up against a
  * pre-v7 index would silently omit the new edges for every unchanged file pair;
  * force a full re-analyze instead (same contract as v2–v6).
+ * v8: Java anonymous class bodies became first-class Class nodes (#2550):
+ * `new Runnable() { run(){} }` now emits `Class:...:Worker$1` and its methods
+ * re-keyed from `Worker.run` to `Worker$1.run`. Node identities move on
+ * unchanged files — a top-up against a pre-v8 index would strand the old
+ * `Worker.run`-keyed Method nodes alongside the new ones (the v5 Route
+ * precedent); force a full re-analyze instead.
  */
-export const INCREMENTAL_SCHEMA_VERSION = 7;
+export const INCREMENTAL_SCHEMA_VERSION = 8;
 const GITNEXUS_DIR = '.gitnexus';
 const GITNEXUS_EXCLUDE_ENTRY = `${GITNEXUS_DIR}/`;
 export const INDEX_METADATA_FILE = 'gitnexus.json';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-rc.46",
+  "version": "1.6.10-rc.48",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",