gitnexus 1.6.10-rc.98 → 1.6.10-rc.99

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

@@ -1,6 +1,6 @@
 // gitnexus/src/core/ingestion/class-extractors/configs/jvm.ts
 import { SupportedLanguages } from '../../../../_shared/index.js';
-import { synthesizeJavaAnonymousClassName } from '../../utils/ast-helpers.js';
+import { synthesizeJavaTypeIdentity } from '../../utils/ast-helpers.js';
 // ---------------------------------------------------------------------------
 // Java
 // ---------------------------------------------------------------------------
@@ -29,10 +29,10 @@ export const javaClassConfig = {
         'record_declaration',
     ],
     extractName(node) {
-        if (node.type === 'object_creation_expression' || node.type === 'enum_constant') {
-            return synthesizeJavaAnonymousClassName(node);
-        }
-        return undefined;
+        return synthesizeJavaTypeIdentity(node)?.name;
+    },
+    extractType(node) {
+        return synthesizeJavaTypeIdentity(node)?.label;
     },
     // An anonymous body whose name CANNOT be synthesized must not become a
     // Class node at all. Without this skip, `extract()`'s
@@ -45,7 +45,7 @@ export const javaClassConfig = {
             definitionNode !== undefined &&
             (definitionNode.type === 'object_creation_expression' ||
                 definitionNode.type === 'enum_constant') &&
-            synthesizeJavaAnonymousClassName(definitionNode) === undefined);
+            synthesizeJavaTypeIdentity(definitionNode) === undefined);
     },
 };
 // ---------------------------------------------------------------------------

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

@@ -1,5 +1,5 @@
 import { materializeClassAnnotationFacts, recordClassAnnotationCapture, } from '../../frameworks/spring/bean-candidates.js';
-import { nodeIfType, nodeToCapture, synthesizeJavaAnonymousClassName, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { javaLocalTypeDeclarationContainer, nodeIfType, nodeToCapture, synthesizeJavaTypeIdentity, syntheticCapture, } from '../../utils/ast-helpers.js';
 import { splitImportDeclaration } from './import-decomposer.js';
 import { computeJavaArityMetadata } from './arity-metadata.js';
 import { synthesizeJavaReceiverBinding } from './receiver-binding.js';
@@ -15,7 +15,11 @@ import { captureJavaSpringDiClassFact } from './spring-di.js';
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.constructor'];
 /** tree-sitter-java node types that the method extractor accepts. */
-const FUNCTION_NODE_TYPES = ['method_declaration', 'constructor_declaration'];
+const FUNCTION_NODE_TYPES = [
+    'method_declaration',
+    'constructor_declaration',
+    'compact_constructor_declaration',
+];
 const JAVA_CALLABLE_CAPTURE_OPTIONS = {
     functionNodeTypes: new Set([...FUNCTION_NODE_TYPES, 'lambda_expression']),
     callNodeTypes: new Set(['method_invocation']),
@@ -34,6 +38,26 @@ const JAVA_CALLABLE_CAPTURE_OPTIONS = {
     callableProtocolMethods: new Set(['run', 'apply', 'accept', 'call']),
     normalizeQualifiedName: (raw) => raw.replaceAll('::', '.'),
 };
+/** Visibility of a local type begins at its declaration and ends with its
+ * immediately enclosing block (JLS 6.3). A Java-only synthetic Block scope
+ * models that range without changing shared resolver selection semantics. */
+function javaLocalTypeVisibilityScope(node) {
+    const container = javaLocalTypeDeclarationContainer(node);
+    if (container === null)
+        return undefined;
+    return {
+        '@scope.block': {
+            name: '@scope.block',
+            range: {
+                startLine: node.startPosition.row + 1,
+                startCol: node.startPosition.column,
+                endLine: container.endPosition.row + 1,
+                endCol: container.endPosition.column,
+            },
+            text: node.text,
+        },
+    };
+}
 /** Suppress read.member emissions when the field_access is already
  *  covered by a method_invocation (object of a call) or an
  *  assignment_expression (write target). */
@@ -96,6 +120,22 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
             recordClassAnnotationCapture(classAnnotations, filePath, annotatedClass, annotationName.text);
             continue;
         }
+        const typeDeclaration = [
+            nodeMap['@declaration.class'],
+            nodeMap['@declaration.enum'],
+            nodeMap['@declaration.record'],
+            nodeMap['@declaration.interface'],
+        ].find((node) => node !== undefined);
+        const localTypeIdentity = typeDeclaration === undefined ? undefined : synthesizeJavaTypeIdentity(typeDeclaration);
+        if (localTypeIdentity?.bindingName !== undefined &&
+            grouped['@declaration.name'] !== undefined &&
+            typeDeclaration !== undefined) {
+            grouped['@declaration.binding-name'] = grouped['@declaration.name'];
+            grouped['@declaration.name'] = syntheticCapture('@declaration.name', typeDeclaration, localTypeIdentity.name);
+            const visibilityScope = javaLocalTypeVisibilityScope(typeDeclaration);
+            if (visibilityScope !== undefined)
+                out.push(visibilityScope);
+        }
         // Decompose each `import_declaration`. `@import.statement` is captured
         // directly on the `import_declaration` node.
         if (grouped['@import.statement'] !== undefined) {
@@ -218,8 +258,8 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
 }
 /**
  * Synthesize `@declaration.class` matches for anonymous class bodies
- * (`new Runnable() { ... }`), named by the same javac-style authority
- * (`synthesizeJavaAnonymousClassName` → `Worker$N`) the structure phase
+ * (`new Runnable() { ... }`), named by the same javac-compatible authority
+ * (`synthesizeJavaTypeIdentity` → `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
@@ -232,15 +272,15 @@ export function emitJavaScopeCaptures(sourceText, filePath, cachedTree) {
 function synthesizeJavaAnonymousClassDeclarations(rootNode) {
     const out = [];
     for (const oce of rootNode.descendantsOfType('object_creation_expression')) {
-        const name = synthesizeJavaAnonymousClassName(oce);
-        if (name === undefined)
+        const identity = synthesizeJavaTypeIdentity(oce);
+        if (identity === 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),
+            '@declaration.name': syntheticCapture('@declaration.name', body, identity.name),
         });
         // Inheritance: the anonymous class extends/implements its constructed
         // type. Anchor the `@reference.inherits` on the `class_body` — its
@@ -278,7 +318,7 @@ function synthesizeJavaAnonymousClassDeclarations(rootNode) {
                 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),
+                    '@type-binding.type': syntheticCapture('@type-binding.type', oce, identity.name),
                 });
             }
         }
@@ -293,11 +333,11 @@ function synthesizeJavaAnonymousClassDeclarations(rootNode) {
         const hostEnum = javaEnclosingEnumNameOf(constant);
         const bodyNode = constant.childForFieldName?.('body');
         const isBodied = bodyNode !== null && bodyNode !== undefined && bodyNode.type === 'class_body';
-        const bodiedName = synthesizeJavaAnonymousClassName(constant);
-        if (bodiedName !== undefined && isBodied) {
+        const bodiedIdentity = synthesizeJavaTypeIdentity(constant);
+        if (bodiedIdentity !== undefined && isBodied) {
             out.push({
                 '@declaration.class': nodeToCapture('@declaration.class', bodyNode),
-                '@declaration.name': syntheticCapture('@declaration.name', bodyNode, bodiedName),
+                '@declaration.name': syntheticCapture('@declaration.name', bodyNode, bodiedIdentity.name),
             });
             if (hostEnum !== undefined) {
                 out.push({
@@ -324,7 +364,7 @@ function synthesizeJavaAnonymousClassDeclarations(rootNode) {
         // the `object_creation_expression` branch, which skips on synthesis
         // failure. `hostEnum` is used only for genuinely body-less constants.
         const constantNameNode = constant.childForFieldName?.('name');
-        const constantType = isBodied ? bodiedName : hostEnum;
+        const constantType = isBodied ? bodiedIdentity?.name : hostEnum;
         if (constantNameNode !== null && constantNameNode !== undefined && constantType !== undefined) {
             out.push({
                 '@type-binding.annotation': nodeToCapture('@type-binding.annotation', constant),

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

@@ -53,6 +53,7 @@ const JAVA_SCOPE_QUERY = `
 
 (method_declaration) @scope.function
 (constructor_declaration) @scope.function
+(compact_constructor_declaration) @scope.function
 
 ;; Declarations — types
 (class_declaration

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

@@ -522,7 +522,8 @@ function parseJsonStringArrayCapture(cap) {
     }
 }
 function deriveDeclarationName(match, def) {
-    const nameCap = match['@declaration.name'] ??
+    const nameCap = match['@declaration.binding-name'] ??
+        match['@declaration.name'] ??
         match[Object.keys(match).find((k) => k.startsWith('@declaration.') && k.endsWith('.name')) ?? ''];
     if (nameCap !== undefined)
         return nameCap.text;

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

@@ -1,4 +1,4 @@
-import { findChild, synthesizeJavaAnonymousClassName, } from '../utils/ast-helpers.js';
+import { findChild, synthesizeJavaTypeIdentity } from '../utils/ast-helpers.js';
 import { extractSimpleTypeName, extractVarName, extractGenericTypeArgs, resolveIterableElementType, methodToTypeArgPosition, extractElementTypeFromString, } from './shared.js';
 // ── Java ──────────────────────────────────────────────────────────────────
 const JAVA_DECLARATION_NODE_TYPES = new Set([
@@ -13,7 +13,7 @@ const anonymousInitializerTypeName = (declarator) => {
     const valueNode = declarator.childForFieldName('value');
     if (!valueNode || valueNode.type !== 'object_creation_expression')
         return undefined;
-    return synthesizeJavaAnonymousClassName(valueNode);
+    return synthesizeJavaTypeIdentity(valueNode)?.name;
 };
 /** Java: Type x = ...; Type x; */
 const extractJavaDeclaration = (node, env) => {

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

@@ -102,7 +102,31 @@ export interface EnclosingClassInfo {
      */
     qualifiedClassId?: string;
 }
-export declare const synthesizeJavaAnonymousClassName: (node: SyntaxNode) => string | undefined;
+/**
+ * GitNexus's source-type-relative Java identity for local and anonymous
+ * types. It follows javac's `$N` allocation but intentionally omits the
+ * package prefix because graph ids already include the source file path.
+ */
+export interface JavaSynthesizedTypeIdentity {
+    readonly name: string;
+    readonly label: 'Class' | 'Enum' | 'Record' | 'Interface';
+    readonly bindingName?: string;
+}
+/** A legal local type declaration is a class, enum, record, or interface
+ * directly occupying a block-statement position. Annotation interfaces are
+ * deliberately excluded: javac rejects local annotation declarations. */
+export declare const javaLocalTypeDeclarationContainer: (node: SyntaxNode) => SyntaxNode | null;
+/**
+ * Authoritative Java local/anonymous type identity.
+ *
+ * JLS 13.1 defines the shape and immediate-host prefix. OpenJDK javac's
+ * Check.localClassName allocates N independently for each
+ * (enclosing binary name, local simple name) pair; anonymous types use the
+ * empty simple name and therefore have their own sequence. Package names are
+ * omitted from this project identity because graph ids already include the
+ * file path.
+ */
+export declare const synthesizeJavaTypeIdentity: (node: SyntaxNode) => JavaSynthesizedTypeIdentity | 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

@@ -360,31 +360,29 @@ 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. Naming follows JLS 13.1: the binary name is the
- *  IMMEDIATELY enclosing type's binary name + `$N`, so the synthesized
- *  name is the `$`-joined chain of enclosing host names
- *  (`EnumWrap$Mode$1`), numbered per immediate host in source order. */
-const JAVA_ANON_HOST_TYPES = new Set([
-    'class_declaration',
-    'enum_declaration',
-    'interface_declaration',
-    'record_declaration',
+/** Named Java declarations that can host, or themselves be, local types. */
+const JAVA_NAMED_TYPE_NODE_LABELS = new Map([
+    ['class_declaration', 'Class'],
+    ['enum_declaration', 'Enum'],
+    ['interface_declaration', 'Interface'],
+    ['record_declaration', 'Record'],
+]);
+const JAVA_ANON_HOST_TYPES = new Set(JAVA_NAMED_TYPE_NODE_LABELS.keys());
+const JAVA_LOCAL_TYPE_CONTAINERS = new Set([
+    'block',
+    'constructor_body',
+    'switch_block_statement_group',
 ]);
+/** A legal local type declaration is a class, enum, record, or interface
+ * directly occupying a block-statement position. Annotation interfaces are
+ * deliberately excluded: javac rejects local annotation declarations. */
+export const javaLocalTypeDeclarationContainer = (node) => {
+    if (!JAVA_NAMED_TYPE_NODE_LABELS.has(node.type))
+        return null;
+    const parent = node.parent;
+    return parent !== null && JAVA_LOCAL_TYPE_CONTAINERS.has(parent.type) ? parent : null;
+};
+const isJavaLocalTypeNode = (node) => javaLocalTypeDeclarationContainer(node) !== null;
 /** The two Java anonymous-class-body shapes (#2550/#2555): an
  *  `object_creation_expression` with a `class_body` child
  *  (`new Runnable() { ... }`), and an `enum_constant` with a `body:`
@@ -392,10 +390,7 @@ const JAVA_ANON_HOST_TYPES = new Set([
 const isJavaAnonymousBodyNode = (node) => (node.type === 'object_creation_expression' &&
     node.namedChildren?.some((c) => c.type === 'class_body') === true) ||
     (node.type === 'enum_constant' && node.childForFieldName?.('body')?.type === 'class_body');
-/** Nearest ancestor of `node` that is an enclosing TYPE per JLS 13.1 —
- *  a named host declaration OR another anonymous body (both shapes).
- *  Anonymous ancestors chain through: an anon inside an anon is
- *  `Host$1$1`, and an anon inside an enum constant body is `E$1$1`. */
+/** Nearest ancestor of `node` that is an enclosing type per JLS 13.1. */
 const nearestJavaEnclosingType = (node) => {
     let cursor = node.parent;
     let iterations = 0;
@@ -408,84 +403,134 @@ const nearestJavaEnclosingType = (node) => {
     }
     return null;
 };
-/** 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 (!isJavaAnonymousBodyNode(node))
-        return undefined;
+/** Parse-tree-bounded memo. Sequence ordinals are built once per tree, avoiding
+ * a host-candidate scan for every extraction/ownership consumer. */
+const javaTypeIdentityMemo = new WeakMap();
+const javaHostKey = (node) => `${node.type}:${node.startIndex}`;
+const javaIdentityCandidatesBelow = (root) => {
+    const seen = new Set();
+    const candidates = [];
+    for (const type of [
+        'object_creation_expression',
+        'enum_constant',
+        ...JAVA_NAMED_TYPE_NODE_LABELS.keys(),
+    ]) {
+        for (const candidate of root.descendantsOfType?.(type) ?? []) {
+            if (!isJavaAnonymousBodyNode(candidate) && !isJavaLocalTypeNode(candidate))
+                continue;
+            const key = javaHostKey(candidate);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            candidates.push(candidate);
+        }
+    }
+    return candidates.sort((left, right) => left.startIndex - right.startIndex);
+};
+const buildJavaTypeIdentityState = (root) => {
+    const ordinalByStart = new Map();
+    const sequenceCounts = new Map();
+    for (const candidate of javaIdentityCandidatesBelow(root)) {
+        const host = nearestJavaEnclosingType(candidate);
+        if (host === null)
+            continue;
+        const isAnonymous = isJavaAnonymousBodyNode(candidate);
+        const bindingName = isAnonymous ? '' : candidate.childForFieldName?.('name')?.text;
+        // Anonymous types deliberately use the empty sequence key; malformed named
+        // declarations must not enter that sequence.
+        if (!isAnonymous && !bindingName)
+            continue;
+        const sequenceKey = `${javaHostKey(host)}:${bindingName}`;
+        const ordinal = (sequenceCounts.get(sequenceKey) ?? 0) + 1;
+        sequenceCounts.set(sequenceKey, ordinal);
+        ordinalByStart.set(candidate.startIndex, ordinal);
+    }
+    return { byStart: new Map(), ordinalByStart };
+};
+const javaTypeIdentityStateFor = (node) => {
     const tree = node.tree;
-    if (tree !== undefined) {
-        const cached = javaAnonNameMemo.get(tree)?.get(node.startIndex);
-        if (cached !== undefined)
-            return cached;
+    if (tree === undefined) {
+        const host = nearestJavaEnclosingType(node);
+        return buildJavaTypeIdentityState(host ?? node);
+    }
+    let state = javaTypeIdentityMemo.get(tree);
+    if (state === undefined) {
+        state = buildJavaTypeIdentityState(tree.rootNode ?? node);
+        javaTypeIdentityMemo.set(tree, state);
+    }
+    return state;
+};
+/** Source-type-relative binary name of a Java enclosing type, including
+ * synthesized local/anonymous hosts and named member-type chains. */
+const javaBinaryNameOfType = (node) => {
+    if (isJavaAnonymousBodyNode(node) || isJavaLocalTypeNode(node)) {
+        return synthesizeJavaTypeIdentity(node)?.name;
     }
-    // JLS 13.1: the binary name is the IMMEDIATELY ENCLOSING TYPE's binary
-    // name + `$N`. The enclosing type may itself be anonymous — then its
-    // own synthesized name is the prefix (recursion, memo-bounded):
-    // `NestHost$1$1` for an anon inside an anon, `E$1$1` for an anon
-    // inside an enum constant body. For a named enclosing type the prefix
-    // is the `$`-joined chain of named hosts (`EnumWrap$Mode`).
+    if (!JAVA_ANON_HOST_TYPES.has(node.type))
+        return undefined;
+    const simpleName = node.childForFieldName?.('name')?.text;
+    if (simpleName === undefined || simpleName.length === 0)
+        return undefined;
     const enclosing = nearestJavaEnclosingType(node);
     if (enclosing === null)
+        return simpleName;
+    const enclosingName = javaBinaryNameOfType(enclosing);
+    return enclosingName === undefined ? undefined : `${enclosingName}$${simpleName}`;
+};
+/**
+ * Authoritative Java local/anonymous type identity.
+ *
+ * JLS 13.1 defines the shape and immediate-host prefix. OpenJDK javac's
+ * Check.localClassName allocates N independently for each
+ * (enclosing binary name, local simple name) pair; anonymous types use the
+ * empty simple name and therefore have their own sequence. Package names are
+ * omitted from this project identity because graph ids already include the
+ * file path.
+ */
+export const synthesizeJavaTypeIdentity = (node) => {
+    const localLabel = JAVA_NAMED_TYPE_NODE_LABELS.get(node.type);
+    const isLocal = localLabel !== undefined && isJavaLocalTypeNode(node);
+    const isAnonymous = isJavaAnonymousBodyNode(node);
+    const enclosing = nearestJavaEnclosingType(node);
+    const memberSimpleName = !isLocal && !isAnonymous && localLabel !== undefined
+        ? node.childForFieldName?.('name')?.text
+        : undefined;
+    const synthesizedHostIdentity = memberSimpleName !== undefined && enclosing !== null
+        ? synthesizeJavaTypeIdentity(enclosing)
+        : undefined;
+    if (!isLocal && !isAnonymous && synthesizedHostIdentity === undefined)
         return undefined;
-    let prefix;
-    if (isJavaAnonymousBodyNode(enclosing)) {
-        const enclosingName = synthesizeJavaAnonymousClassName(enclosing);
-        if (enclosingName === undefined)
-            return undefined;
-        prefix = enclosingName;
-    }
-    else {
-        const hostNames = [];
-        let cursor = enclosing;
-        let iterations = 0;
-        while (cursor) {
-            if (++iterations > MAX_ENCLOSING_WALK_ITERATIONS)
-                return undefined;
-            if (JAVA_ANON_HOST_TYPES.has(cursor.type)) {
-                const hostName = cursor.childForFieldName?.('name')?.text;
-                if (hostName === undefined || hostName.length === 0)
-                    return undefined;
-                hostNames.unshift(hostName);
-            }
-            cursor = cursor.parent;
-        }
-        prefix = hostNames.join('$');
-    }
-    // All anonymous bodies (both shapes) whose immediately enclosing TYPE
-    // is THIS one, in source order. `descendantsOfType` over the subtree
-    // also finds bodies belonging to nested enclosing types — filter them
-    // out by re-deriving each candidate's own enclosing type.
-    const candidates = [
-        ...(enclosing.descendantsOfType?.('object_creation_expression') ?? []),
-        ...(enclosing.descendantsOfType?.('enum_constant') ?? []),
-    ]
-        .filter(isJavaAnonymousBodyNode)
-        .filter((c) => {
-        const host = nearestJavaEnclosingType(c);
-        return (host !== null && host.startIndex === enclosing.startIndex && host.type === enclosing.type);
-    })
-        .sort((a, b) => a.startIndex - b.startIndex);
-    if (tree !== undefined) {
-        let byStart = javaAnonNameMemo.get(tree);
-        if (byStart === undefined) {
-            byStart = new Map();
-            javaAnonNameMemo.set(tree, byStart);
-        }
-        for (let i = 0; i < candidates.length; i++) {
-            byStart.set(candidates[i].startIndex, `${prefix}$${i + 1}`);
-        }
-        return byStart.get(node.startIndex);
+    if (enclosing === null)
+        return undefined;
+    const state = javaTypeIdentityStateFor(node);
+    const cached = state.byStart.get(node.startIndex);
+    if (cached !== undefined)
+        return cached;
+    const prefix = javaBinaryNameOfType(enclosing);
+    if (prefix === undefined)
+        return undefined;
+    if (memberSimpleName !== undefined) {
+        const identity = {
+            name: `${prefix}$${memberSimpleName}`,
+            label: localLabel,
+            bindingName: memberSimpleName,
+        };
+        state.byStart.set(node.startIndex, identity);
+        return identity;
     }
-    const index = candidates.findIndex((c) => c.startIndex === node.startIndex);
-    if (index === -1)
+    const bindingName = isLocal ? node.childForFieldName?.('name')?.text : undefined;
+    if (isLocal && !bindingName)
         return undefined;
-    return `${prefix}$${index + 1}`;
+    const ordinal = state.ordinalByStart.get(node.startIndex);
+    if (ordinal === undefined)
+        return undefined;
+    const identity = {
+        name: `${prefix}$${ordinal}${bindingName ?? ''}`,
+        label: isAnonymous ? 'Class' : localLabel,
+        ...(bindingName === undefined ? {} : { bindingName }),
+    };
+    state.byStart.set(node.startIndex, identity);
+    return identity;
 };
 export const findEnclosingClassInfo = (node, filePath, resolveEnclosingOwner, 
 /**
@@ -553,12 +598,12 @@ getQualifiedOwnerName) => {
         // enum constant, and every C# `object_creation_expression`), so the
         // walk continues unchanged for those — including on to
         // `enum_declaration`, which sits in CLASS_CONTAINER_TYPES below.
-        if (current.type === 'object_creation_expression' || current.type === 'enum_constant') {
-            const anonName = synthesizeJavaAnonymousClassName(current);
-            if (anonName !== undefined) {
+        if (isJavaAnonymousBodyNode(current) || JAVA_ANON_HOST_TYPES.has(current.type)) {
+            const identity = synthesizeJavaTypeIdentity(current);
+            if (identity !== undefined) {
                 return {
-                    classId: generateId('Class', `${filePath}:${anonName}`),
-                    className: anonName,
+                    classId: generateId(identity.label, `${filePath}:${identity.name}`),
+                    className: identity.name,
                 };
             }
         }

package/dist/storage/parse-cache.js

@@ -56,6 +56,9 @@ import { fileURLToPath } from 'url';
 // method injection sites plus bean-name and @Primary provider metadata.
 // v20: Java/Kotlin capture side-channels persist package and class-annotation
 // facts for shared Spring Bean resolution.
+// v21: Java local class/enum/record/interface captures use javac-compatible,
+// source-type-relative JLS 13.1 identities and declaration-to-block scopes
+// (#2562).
 // v19: Java enum constant bodies emit E$N Class nodes; anonymous naming uses
 // JLS 13.1 immediate-host chains (#2555).
 // v18: Worker$N anonymous bodies. v17: callable-value-flow operand identity.

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

@@ -431,8 +431,14 @@ export interface RepoMeta {
  * spurious edges and these new resolved edges are cross-file, so a pre-v12
  * top-up would leave unchanged Rust files stale either way; force a full
  * re-analyze instead.
- */
-export declare const INCREMENTAL_SCHEMA_VERSION = 12;
+ * v13: Java local classes, enums, records, and interfaces use
+ * source-type-relative JLS 13.1 identities (`Outer$1Local`). Number allocation
+ * matches javac: one sequence per (enclosing type, local simple name), with a
+ * separate sequence for anonymous types. Existing type/member ids, lexical
+ * bindings, and ownership edges must not be mixed with newly named unchanged
+ * Java files; force a full re-analyze.
+ */
+export declare const INCREMENTAL_SCHEMA_VERSION = 13;
 export interface IndexedRepo {
     repoPath: string;
     storagePath: string;

package/dist/storage/repo-manager.js

@@ -152,8 +152,14 @@ export const cloneDirBelongsToEntry = (cloneDir, entryPath) => registryPathEqual
  * spurious edges and these new resolved edges are cross-file, so a pre-v12
  * top-up would leave unchanged Rust files stale either way; force a full
  * re-analyze instead.
+ * v13: Java local classes, enums, records, and interfaces use
+ * source-type-relative JLS 13.1 identities (`Outer$1Local`). Number allocation
+ * matches javac: one sequence per (enclosing type, local simple name), with a
+ * separate sequence for anonymous types. Existing type/member ids, lexical
+ * bindings, and ownership edges must not be mixed with newly named unchanged
+ * Java files; force a full re-analyze.
  */
-export const INCREMENTAL_SCHEMA_VERSION = 12;
+export const INCREMENTAL_SCHEMA_VERSION = 13;
 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.98",
+  "version": "1.6.10-rc.99",
   "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",