gitnexus 1.6.6-rc.99 → 1.6.6

package/dist/core/ingestion/cobol-processor.js

@@ -18,6 +18,7 @@ import { SupportedLanguages } from '../../_shared/index.js';
 import { preprocessCobolSource, extractCobolSymbolsWithRegex, } from './cobol/cobol-preprocessor.js';
 import { expandCopies } from './cobol/cobol-copy-expander.js';
 import { processJclFiles } from './cobol/jcl-processor.js';
+import { logger } from '../logger.js';
 // ---------------------------------------------------------------------------
 // File detection
 // ---------------------------------------------------------------------------
@@ -68,6 +69,7 @@ export const processCobol = (graph, files, allPathSet) => {
         sets: 0,
         inspects: 0,
         initializes: 0,
+        arithmeticOps: 0,
     };
     // ── 1. Separate programs, copybooks, and JCL ───────────────────────
     const programs = [];
@@ -125,7 +127,14 @@ export const processCobol = (graph, files, allPathSet) => {
     // Track module names for cross-program CALL resolution
     const moduleNodeIds = new Map(); // uppercase program name -> node id
     // ── 3. Process each COBOL program ──────────────────────────────────
+    const raw = parseInt(process.env.GITNEXUS_MAX_COBOL_FILE_SIZE_BYTES ?? '', 10);
+    const MAX_COBOL_FILE_SIZE = Number.isFinite(raw) && raw > 0 ? raw : 5 * 1024 * 1024;
     for (const file of programs) {
+        // File-size guard: skip excessively large files to prevent OOM
+        if (file.content.length > MAX_COBOL_FILE_SIZE) {
+            logger.warn(`[cobol-processor] Skipping oversized file (${(file.content.length / 1024 / 1024).toFixed(1)}MB > ${(MAX_COBOL_FILE_SIZE / 1024 / 1024).toFixed(0)}MB): ${file.path}`);
+            continue;
+        }
         const fileNodeId = generateId('File', file.path);
         // Skip if file node doesn't exist (structure-processor creates it)
         if (!graph.getNode(fileNodeId))
@@ -156,6 +165,7 @@ export const processCobol = (graph, files, allPathSet) => {
         result.sets += extracted.sets.length;
         result.inspects += extracted.inspects.length;
         result.initializes += extracted.initializes.length;
+        result.arithmeticOps += extracted.arithmeticOps.length;
     }
     // ── 4. Second pass: resolve cross-program CALL targets ─────────────
     // During mapToGraph, early programs create unresolved CALL edges
@@ -1066,7 +1076,9 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
     }
     // ── MOVE data flow -> ACCESSES edges (read/write) ──────────────
     for (const move of extracted.moves) {
-        const fromPropId = dataItemMap.get(move.from.toUpperCase());
+        // Strip any subscript from the source name for data item lookup
+        const fromBase = stripMoveSubscript(move.from);
+        const fromPropId = dataItemMap.get(fromBase.toUpperCase());
         const callerId = scopedCallerLookup(move.caller, move.line);
         // One read edge per MOVE (regardless of number of targets)
         if (fromPropId) {
@@ -1081,7 +1093,8 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
         }
         // One write edge per target
         for (const target of move.targets) {
-            const toPropId = dataItemMap.get(target.toUpperCase());
+            const toBase = stripMoveSubscript(target);
+            const toPropId = dataItemMap.get(toBase.toUpperCase());
             if (toPropId) {
                 graph.addRelationship({
                     id: generateId('ACCESSES', `${callerId}->write->${target}:L${move.line}`),
@@ -1094,6 +1107,38 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
             }
         }
     }
+    // ── Arithmetic operations -> ACCESSES edges ──────────────────
+    for (const arith of extracted.arithmeticOps) {
+        const callerId = scopedCallerLookup(arith.caller, arith.line);
+        // Write edge to target variable
+        const targetBase = stripMoveSubscript(arith.target);
+        const targetPropId = dataItemMap.get(targetBase.toUpperCase());
+        if (targetPropId) {
+            graph.addRelationship({
+                id: generateId('ACCESSES', `${callerId}->arith-write->${arith.target}:L${arith.line}`),
+                type: 'ACCESSES',
+                sourceId: callerId,
+                targetId: targetPropId,
+                confidence: 0.9,
+                reason: 'cobol-arithmetic-write',
+            });
+        }
+        // Read edge for each source operand
+        for (const src of arith.sources) {
+            const srcBase = stripMoveSubscript(src);
+            const srcPropId = dataItemMap.get(srcBase.toUpperCase());
+            if (srcPropId) {
+                graph.addRelationship({
+                    id: generateId('ACCESSES', `${callerId}->arith-read->${src}:L${arith.line}`),
+                    type: 'ACCESSES',
+                    sourceId: callerId,
+                    targetId: srcPropId,
+                    confidence: 0.9,
+                    reason: 'cobol-arithmetic-read',
+                });
+            }
+        }
+    }
     // ── File declarations -> Record nodes ──────────────────────────
     for (const fd of extracted.fileDeclarations) {
         const fdId = generateId('Record', `${filePath}:${fd.selectName}`);
@@ -1219,6 +1264,10 @@ function mapToGraph(graph, extracted, file, copyResolutions, moduleNodeIds) {
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
+/** Strip parenthesized subscript/reference-modification suffixes */
+function stripMoveSubscript(name) {
+    return name.replace(/\([^)]*\)/g, '').trim();
+}
 /** Find the enclosing program name for a given line number (innermost wins). */
 function findOwningProgramName(lineNum, programs) {
     let best;

package/dist/core/ingestion/emit-references.js

@@ -202,9 +202,14 @@ function buildRelationship(ref, callerId, targetDef, sourceLabel) {
 }
 /**
  * Map a `Reference.kind` to an existing `RelationshipType`. Read/write
- * both fold into `ACCESSES`; `type-reference` + `import-use` both fold
- * into `USES`. This keeps the graph schema additive — no new
+ * both fold into `ACCESSES`; `type-reference`, `import-use`, and `macro`
+ * all fold into `USES`. This keeps the graph schema additive — no new
  * RelationshipType values are introduced by this module.
+ *
+ * `macro` folds into `USES` (not `CALLS`) deliberately: a macro
+ * invocation targets a `Macro` node, not a callable function, so keeping
+ * it out of the `CALLS` keyspace preserves the invariant that `CALLS`
+ * edges denote function/method dispatch.
  */
 function mapKindToType(kind) {
     switch (kind) {
@@ -217,6 +222,7 @@ function mapKindToType(kind) {
             return 'INHERITS';
         case 'type-reference':
         case 'import-use':
+        case 'macro':
             return 'USES';
     }
 }

package/dist/core/ingestion/export-detection.d.ts

@@ -4,7 +4,8 @@
  * Determines whether a symbol (function, class, etc.) is exported/public
  * in its language. This is a pure function — safe for use in worker threads.
  *
- * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
+ * Used by the language providers during worker parsing (parse-worker.ts) — the
+ * sole parse path. (Sequential parsing was removed.)
  */
 import { type SyntaxNode } from './utils/ast-helpers.js';
 /** Handler type: given a node and symbol name, return true if the symbol is exported/public. */

package/dist/core/ingestion/export-detection.js

@@ -4,7 +4,8 @@
  * Determines whether a symbol (function, class, etc.) is exported/public
  * in its language. This is a pure function — safe for use in worker threads.
  *
- * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
+ * Used by the language providers during worker parsing (parse-worker.ts) — the
+ * sole parse path. (Sequential parsing was removed.)
  */
 import { findSiblingChild } from './utils/ast-helpers.js';
 // ============================================================================
@@ -62,11 +63,6 @@ const CSHARP_DECL_TYPES = new Set([
     'struct_declaration',
     'enum_declaration',
     'record_declaration',
-    // tree-sitter-c-sharp absorbs 'record struct' and 'record class' into
-    // record_declaration — these two node types are listed defensively but
-    // never emitted by the grammar in practice (verified against ^0.23.1).
-    'record_struct_declaration',
-    'record_class_declaration',
     'delegate_declaration',
     'property_declaration',
     'field_declaration',

package/dist/core/ingestion/field-extractors/configs/dart.d.ts

@@ -1,8 +1,2 @@
 import type { FieldExtractionConfig } from '../generic.js';
-/**
- * Dart field extraction config.
- *
- * Dart class fields appear as declaration nodes inside class_body.
- * Visibility is convention-based: underscore prefix = private.
- */
 export declare const dartConfig: FieldExtractionConfig;

package/dist/core/ingestion/field-extractors/configs/dart.js

@@ -5,74 +5,92 @@ import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 /**
  * Dart field extraction config.
  *
- * Dart class fields appear as declaration nodes inside class_body.
+ * Dart class fields appear as `declaration` nodes inside `class_body`.
+ * Two shapes carry the field name(s):
+ *   - instance / plain fields → `initialized_identifier_list`
+ *     (`int z = 0;`, `int a = 1, b = 2;`)
+ *   - `static const` / `static final` / `const` fields → `static_final_declaration_list`
+ *     (`static const a = 1;`, `static final String b = 'x', c = 'y';`)
+ * Both shapes may declare SEVERAL fields in one declaration, so name extraction
+ * is multi-name (`extractNames`). The structure query (`DART_QUERIES`) emits one
+ * `@definition.property` per name for both shapes; this config enriches each.
+ *
  * Visibility is convention-based: underscore prefix = private.
  */
+/** All field names declared by a `declaration` node, across both Dart shapes. */
+function extractDartFieldNames(node) {
+    const names = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (!child)
+            continue;
+        // instance / plain fields: initialized_identifier_list > initialized_identifier > identifier
+        if (child.type === 'initialized_identifier_list') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const init = child.namedChild(j);
+                if (init?.type === 'initialized_identifier') {
+                    const ident = init.firstNamedChild;
+                    if (ident?.type === 'identifier')
+                        names.push(ident.text);
+                }
+            }
+        }
+        // static const / final fields: static_final_declaration_list > static_final_declaration > identifier
+        if (child.type === 'static_final_declaration_list') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const decl = child.namedChild(j);
+                if (decl?.type === 'static_final_declaration') {
+                    const ident = decl.firstNamedChild;
+                    if (ident?.type === 'identifier')
+                        names.push(ident.text);
+                }
+            }
+        }
+    }
+    return names;
+}
 export const dartConfig = {
     language: SupportedLanguages.Dart,
     typeDeclarationNodes: ['class_definition'],
     fieldNodeTypes: ['declaration'],
     bodyNodeTypes: ['class_body'],
     defaultVisibility: 'public',
+    // One AST `declaration` node may declare several fields (`int a, b;`,
+    // `static final String b = 'x', c = 'y';`), so use the multi-name path.
     extractName(node) {
-        // declaration > initialized_identifier_list > initialized_identifier > identifier
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'initialized_identifier_list') {
-                for (let j = 0; j < child.namedChildCount; j++) {
-                    const init = child.namedChild(j);
-                    if (init?.type === 'initialized_identifier') {
-                        const ident = init.firstNamedChild;
-                        if (ident?.type === 'identifier')
-                            return ident.text;
-                    }
-                }
-            }
-            if (child?.type === 'initialized_identifier') {
-                const ident = child.firstNamedChild;
-                if (ident?.type === 'identifier')
-                    return ident.text;
-            }
-        }
-        // fallback: look for direct identifier
-        const name = node.childForFieldName('name');
-        return name?.text;
+        return extractDartFieldNames(node)[0];
+    },
+    extractNames(node) {
+        return extractDartFieldNames(node);
     },
     extractType(node) {
-        // declaration > type_identifier (first named child usually)
+        // declaration > type_identifier (the type annotation, present for both the
+        // instance-field shape and `static final String b = …`). `static const a = 1;`
+        // has no annotation → undefined (untyped).
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
-            if (child &&
-                (child.type === 'type_identifier' ||
-                    child.type === 'generic_type' ||
-                    child.type === 'function_type')) {
+            if (child && (child.type === 'type_identifier' || child.type === 'function_type')) {
                 return extractSimpleTypeName(child) ?? child.text?.trim();
             }
         }
         return undefined;
     },
+    // Per-name: Dart convention is underscore-prefixed = private. A single
+    // declaration can mix visibilities (`static const _p = 1, q = 2;`), so the
+    // decision is keyed on the individual field name.
+    extractVisibilityForName(_node, name) {
+        return name.startsWith('_') ? 'private' : 'public';
+    },
     extractVisibility(node) {
-        // Dart uses _ prefix for private
-        // Walk to find the identifier name
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'initialized_identifier_list') {
-                for (let j = 0; j < child.namedChildCount; j++) {
-                    const init = child.namedChild(j);
-                    if (init?.type === 'initialized_identifier') {
-                        const ident = init.firstNamedChild;
-                        if (ident?.text?.startsWith('_'))
-                            return 'private';
-                    }
-                }
-            }
-        }
-        return 'public';
+        const first = extractDartFieldNames(node)[0];
+        return first?.startsWith('_') ? 'private' : 'public';
     },
     isStatic(node) {
         return hasKeyword(node, 'static');
     },
     isReadonly(node) {
+        // `final` / `const` (both `final_builtin`/`const_builtin` nodes whose text
+        // is `final`/`const`) are read-only.
         return hasKeyword(node, 'final') || hasKeyword(node, 'const');
     },
 };

package/dist/core/ingestion/field-extractors/configs/go.d.ts

@@ -1,11 +1,2 @@
 import type { FieldExtractionConfig } from '../generic.js';
-/**
- * Go field extraction config.
- *
- * Go struct fields live inside type_declaration > type_spec > struct_type >
- * field_declaration_list > field_declaration.
- *
- * Visibility in Go is based on the first character: uppercase = exported (public),
- * lowercase = unexported (package).
- */
 export declare const goConfig: FieldExtractionConfig;

package/dist/core/ingestion/field-extractors/configs/go.js

@@ -10,13 +10,48 @@ import { extractSimpleTypeName } from '../../type-extractors/shared.js';
  * Visibility in Go is based on the first character: uppercase = exported (public),
  * lowercase = unexported (package).
  */
+function goVisibilityForName(name) {
+    const first = name.charAt(0);
+    return first === first.toUpperCase() && first !== first.toLowerCase() ? 'public' : 'package';
+}
+function extractGoFieldNames(node) {
+    const names = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === 'field_identifier')
+            names.push(child.text);
+    }
+    return names;
+}
 export const goConfig = {
     language: SupportedLanguages.Go,
-    typeDeclarationNodes: ['type_declaration'],
+    typeDeclarationNodes: ['type_declaration', 'struct_type'],
     fieldNodeTypes: ['field_declaration'],
     bodyNodeTypes: ['field_declaration_list'],
     defaultVisibility: 'package',
+    extractOwnerName(node) {
+        if (node.type === 'struct_type') {
+            return node.parent?.type === 'type_spec'
+                ? node.parent.childForFieldName('name')?.text
+                : undefined;
+        }
+        const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
+        return typeSpec?.childForFieldName('name')?.text;
+    },
+    findBodyNodes(node) {
+        if (node.type === 'struct_type') {
+            const body = node.namedChildren.find((child) => child.type === 'field_declaration_list');
+            return body ? [body] : [];
+        }
+        const typeSpec = node.namedChildren.find((child) => child.type === 'type_spec');
+        const typeNode = typeSpec?.childForFieldName('type');
+        const body = typeNode?.namedChildren.find((child) => child.type === 'field_declaration_list');
+        return body ? [body] : [];
+    },
     extractName(node) {
+        const firstName = extractGoFieldNames(node)[0];
+        if (firstName)
+            return firstName;
         // field_declaration > name:(field_identifier)
         const name = node.childForFieldName('name');
         if (name)
@@ -29,6 +64,7 @@ export const goConfig = {
         }
         return undefined;
     },
+    extractNames: extractGoFieldNames,
     extractType(node) {
         // field_declaration > type:(type_identifier | pointer_type | ...)
         const typeNode = node.childForFieldName('type');
@@ -51,6 +87,9 @@ export const goConfig = {
         }
         return 'package';
     },
+    extractVisibilityForName(_node, name) {
+        return goVisibilityForName(name);
+    },
     isStatic(_node) {
         return false; // Go has no static fields
     },

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

@@ -60,12 +60,49 @@ export const javaConfig = {
 // Kotlin
 // ---------------------------------------------------------------------------
 const KOTLIN_VIS = new Set(['public', 'private', 'protected', 'internal']);
+/** A property_declaration is a companion-object member when its nearest
+ *  class-body ancestor is the body of a companion_object (F52, issue #1919).
+ *  Companion members are addressed statically through the enclosing class
+ *  (`C.TAG`), so they are marked static. */
+function isInsideKotlinCompanion(node) {
+    for (let cur = node.parent; cur !== null; cur = cur.parent) {
+        if (cur.type === 'class_body')
+            return cur.parent?.type === 'companion_object';
+        if (cur.type === 'companion_object')
+            return true;
+    }
+    return false;
+}
 export const kotlinConfig = {
     language: SupportedLanguages.Kotlin,
-    typeDeclarationNodes: ['class_declaration', 'object_declaration'],
+    // F52: include companion_object so a companion property's innermost
+    // class-container owner (findEnclosingClassNode returns the companion_object)
+    // is recognized as a type declaration and its nested class_body is walked.
+    // The structure query already creates the Property node and owns it on the
+    // ENCLOSING class for anonymous companions / on the named companion Class —
+    // this entry only drives field-metadata enrichment, so it does NOT change
+    // ownership or emit a second node (no double-count).
+    typeDeclarationNodes: ['class_declaration', 'object_declaration', 'companion_object'],
     fieldNodeTypes: ['property_declaration'],
     bodyNodeTypes: ['class_body'],
     defaultVisibility: 'public',
+    // F52: an anonymous `companion object { ... }` has no name child, so the
+    // generic factory's `childForFieldName('name')` owner lookup is empty and
+    // `extract()` would bail before walking the body. Supply a stable owner
+    // name (the named companion's identifier, else "Companion") so the body IS
+    // walked; the resulting FieldInfo map is keyed by field NAME only, so the
+    // owner name does not affect which Property node gets enriched.
+    extractOwnerName(node) {
+        const typeIdentifierText = node.namedChildren.find((c) => c.type === 'type_identifier')?.text;
+        if (node.type === 'companion_object') {
+            // Anonymous companions have no type_identifier — fall back to "Companion".
+            return typeIdentifierText ?? 'Companion';
+        }
+        const name = node.childForFieldName('name');
+        if (name)
+            return name.text;
+        return typeIdentifierText;
+    },
     extractName(node) {
         // property_declaration > variable_declaration > simple_identifier
         for (let i = 0; i < node.namedChildCount; i++) {
@@ -107,9 +144,11 @@ export const kotlinConfig = {
     extractVisibility(node) {
         return findVisibility(node, KOTLIN_VIS, 'public', 'modifiers');
     },
-    isStatic(_node) {
-        // Kotlin doesn't have static; companion object members are handled separately
-        return false;
+    isStatic(node) {
+        // Kotlin has no `static`, but companion-object members are accessed
+        // statically through the enclosing class (`C.TAG`) — mark them static
+        // so the field metadata reflects that (F52).
+        return isInsideKotlinCompanion(node);
     },
     isReadonly(node) {
         // 'val' = readonly, 'var' = mutable

package/dist/core/ingestion/field-extractors/configs/php.js

@@ -46,8 +46,7 @@ export const phpConfig = {
                 child.type === 'named_type' ||
                 child.type === 'optional_type' ||
                 child.type === 'primitive_type' ||
-                child.type === 'intersection_type' ||
-                child.type === 'nullable_type') {
+                child.type === 'intersection_type') {
                 return extractSimpleTypeName(child) ?? child.text?.trim();
             }
         }

package/dist/core/ingestion/field-extractors/configs/swift.d.ts

@@ -2,7 +2,18 @@ import type { FieldExtractionConfig } from '../generic.js';
 /**
  * Swift field extraction config.
  *
- * Handles property_declaration inside class_body / protocol_body.
+ * Handles property_declaration inside class_body / protocol_body and
+ * protocol_property_declaration inside protocol_body (F75 — protocol property
+ * requirements like "var title: String { get }").
+ *
  * tree-sitter-swift uses property_declaration for stored/computed properties.
+ * A protocol property requirement parses to its own node type,
+ * protocol_property_declaration, whose name lives in a "name:" pattern field
+ * (pattern > value_binding_pattern + simple_identifier(bound_identifier)), its
+ * type in a sibling type_annotation, and its "{ get }" / "{ get set }" in a
+ * protocol_property_requirements child. Note: Swift reuses the "name:" field
+ * across many positions (func name, every parameter label, parameter/return
+ * type), so the name is synthesized from the simple_identifier inside the
+ * pattern rather than read blindly off "name:".
  */
 export declare const swiftConfig: FieldExtractionConfig;

package/dist/core/ingestion/field-extractors/configs/swift.js

@@ -1,6 +1,6 @@
 // gitnexus/src/core/ingestion/field-extractors/configs/swift.ts
 import { SupportedLanguages } from '../../../../_shared/index.js';
-import { hasKeyword, findVisibility } from './helpers.js';
+import { hasKeyword, hasModifier, findVisibility } from './helpers.js';
 import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 const SWIFT_VIS = new Set([
     'public',
@@ -12,17 +12,32 @@ const SWIFT_VIS = new Set([
 /**
  * Swift field extraction config.
  *
- * Handles property_declaration inside class_body / protocol_body.
+ * Handles property_declaration inside class_body / protocol_body and
+ * protocol_property_declaration inside protocol_body (F75 — protocol property
+ * requirements like "var title: String { get }").
+ *
  * tree-sitter-swift uses property_declaration for stored/computed properties.
+ * A protocol property requirement parses to its own node type,
+ * protocol_property_declaration, whose name lives in a "name:" pattern field
+ * (pattern > value_binding_pattern + simple_identifier(bound_identifier)), its
+ * type in a sibling type_annotation, and its "{ get }" / "{ get set }" in a
+ * protocol_property_requirements child. Note: Swift reuses the "name:" field
+ * across many positions (func name, every parameter label, parameter/return
+ * type), so the name is synthesized from the simple_identifier inside the
+ * pattern rather than read blindly off "name:".
  */
 export const swiftConfig = {
     language: SupportedLanguages.Swift,
-    typeDeclarationNodes: ['class_declaration', 'struct_declaration', 'protocol_declaration'],
-    fieldNodeTypes: ['property_declaration'],
+    typeDeclarationNodes: ['class_declaration', 'protocol_declaration'],
+    fieldNodeTypes: ['property_declaration', 'protocol_property_declaration'],
     bodyNodeTypes: ['class_body', 'protocol_body'],
     defaultVisibility: 'internal',
     extractName(node) {
-        // property_declaration > pattern > simple_identifier
+        // property_declaration > pattern > simple_identifier, and
+        // protocol_property_declaration > name: (pattern ... simple_identifier).
+        // For protocol_property_declaration the pattern wraps a leading
+        // value_binding_pattern ("var") plus the simple_identifier — the loop
+        // below skips the binding keyword and returns the identifier.
         for (let i = 0; i < node.namedChildCount; i++) {
             const child = node.namedChild(i);
             if (child?.type === 'pattern') {
@@ -56,7 +71,17 @@ export const swiftConfig = {
         return findVisibility(node, SWIFT_VIS, 'internal', 'modifiers');
     },
     isStatic(node) {
-        return hasKeyword(node, 'static') || hasKeyword(node, 'class');
+        // `static`/`class` (type-level) modifiers live inside a `modifiers`
+        // wrapper for both property_declaration and protocol_property_declaration
+        // (e.g. `static var shared: P { get }`), so check the wrapper too.
+        // `hasKeyword` compares each direct child by `.text` equality: it matches a
+        // single-modifier wrapper (`modifiers.text === 'static'`) but fails for a
+        // multi-modifier wrapper (`private static` → `modifiers.text === 'private static'`),
+        // which `hasModifier` handles by descending into the wrapper's children.
+        return (hasKeyword(node, 'static') ||
+            hasKeyword(node, 'class') ||
+            hasModifier(node, 'modifiers', 'static') ||
+            hasModifier(node, 'modifiers', 'class'));
     },
     isReadonly(node) {
         // 'let' = constant/readonly, 'var' = variable

package/dist/core/ingestion/field-extractors/generic.d.ts

@@ -19,6 +19,10 @@ export interface FieldExtractionConfig {
     bodyNodeTypes: string[];
     /** Default visibility when no modifier is present */
     defaultVisibility: FieldVisibility;
+    /** Extract owner type name from a type declaration node. */
+    extractOwnerName?: (node: SyntaxNode) => string | undefined;
+    /** Find body nodes inside a type declaration node. */
+    findBodyNodes?: (node: SyntaxNode) => SyntaxNode[];
     /**
      * Extract field name from a field declaration node.
      * Use this for nodes that declare exactly one field.
@@ -35,6 +39,8 @@ export interface FieldExtractionConfig {
     extractType: (node: SyntaxNode) => string | undefined;
     /** Extract visibility from a field declaration node */
     extractVisibility: (node: SyntaxNode) => FieldVisibility;
+    /** Extract visibility for one field name from a multi-name declaration. */
+    extractVisibilityForName?: (node: SyntaxNode, name: string) => FieldVisibility;
     /** Check if a field is static */
     isStatic: (node: SyntaxNode) => boolean;
     /** Check if a field is readonly/final/const */

package/dist/core/ingestion/field-extractors/generic.js

@@ -21,10 +21,9 @@ export function createFieldExtractor(config) {
         extract(node, context) {
             if (!this.isTypeDeclaration(node))
                 return null;
-            const nameNode = node.childForFieldName('name');
-            if (!nameNode)
+            const ownerFqn = config.extractOwnerName?.(node) ?? node.childForFieldName('name')?.text;
+            if (!ownerFqn)
                 return null;
-            const ownerFqn = nameNode.text;
             const fields = [];
             // Find body container(s)
             const bodies = this.findBodies(node);
@@ -43,6 +42,8 @@ export function createFieldExtractor(config) {
         // private helpers
         // ------------------------------------------------------------------
         findBodies(node) {
+            if (config.findBodyNodes)
+                return config.findBodyNodes(node);
             const result = [];
             // Try named 'body' field first
             const bodyField = node.childForFieldName('body');
@@ -105,7 +106,7 @@ export function createFieldExtractor(config) {
             return {
                 name,
                 type,
-                visibility: config.extractVisibility(node),
+                visibility: config.extractVisibilityForName?.(node, name) ?? config.extractVisibility(node),
                 isStatic: config.isStatic(node),
                 isReadonly: config.isReadonly(node),
                 sourceFile: context.filePath,