arceus-s 1.6.4

package/dist/core/ingestion/method-extractors/configs/typescript-javascript.js

@@ -0,0 +1,338 @@
+// arc/src/core/ingestion/method-extractors/configs/typescript-javascript.ts
+// Verified against tree-sitter-typescript ^0.23.2, tree-sitter-javascript ^0.23.0
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { hasKeyword } from '../../field-extractors/configs/helpers.js';
+import { extractSimpleTypeName } from '../../type-extractors/shared.js';
+// ---------------------------------------------------------------------------
+// TS/JS helpers
+// ---------------------------------------------------------------------------
+const VISIBILITY_KEYWORDS = new Set(['public', 'private', 'protected']);
+/**
+ * Extract parameters from formal_parameters.
+ *
+ * Handles both TS node types (required_parameter, optional_parameter, rest_parameter)
+ * and JS node types (identifier, assignment_pattern, rest_pattern), plus destructured
+ * parameters (object_pattern, array_pattern) in both grammars.
+ */
+function extractTsJsParameters(node) {
+    const paramList = node.childForFieldName('parameters');
+    if (!paramList)
+        return [];
+    const params = [];
+    for (let i = 0; i < paramList.namedChildCount; i++) {
+        const param = paramList.namedChild(i);
+        if (!param)
+            continue;
+        switch (param.type) {
+            case 'required_parameter': {
+                const patternNode = param.childForFieldName('pattern');
+                if (!patternNode)
+                    break;
+                // Skip TS `this` parameter — it's a compile-time type constraint, not a real param
+                if (patternNode.type === 'this')
+                    break;
+                // Rest parameter: pattern is a rest_pattern (...args) — extract inner identifier
+                const isRest = patternNode.type === 'rest_pattern';
+                const nameNode = isRest ? patternNode.firstNamedChild : patternNode;
+                if (!nameNode)
+                    break;
+                // type field is a type_annotation — unwrap to get the inner type node
+                const typeAnnotation = param.childForFieldName('type');
+                const typeNode = typeAnnotation?.firstNamedChild;
+                // Default value: presence of a 'value' field means isOptional
+                const hasDefault = !!param.childForFieldName('value');
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode
+                        ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
+                        : null,
+                    rawType: typeNode?.text?.trim() ?? null,
+                    isOptional: hasDefault,
+                    isVariadic: isRest,
+                });
+                break;
+            }
+            case 'optional_parameter': {
+                const nameNode = param.childForFieldName('pattern');
+                if (!nameNode)
+                    break;
+                const typeAnnotation = param.childForFieldName('type');
+                const typeNode = typeAnnotation?.firstNamedChild;
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode
+                        ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
+                        : null,
+                    rawType: typeNode?.text?.trim() ?? null,
+                    isOptional: true,
+                    isVariadic: false,
+                });
+                break;
+            }
+            case 'rest_parameter': {
+                const nameNode = param.childForFieldName('pattern');
+                if (!nameNode)
+                    break;
+                const typeAnnotation = param.childForFieldName('type');
+                const typeNode = typeAnnotation?.firstNamedChild;
+                params.push({
+                    name: nameNode.text,
+                    type: typeNode
+                        ? (extractSimpleTypeName(typeNode) ?? typeNode.text?.trim() ?? null)
+                        : null,
+                    rawType: typeNode?.text?.trim() ?? null,
+                    isOptional: false,
+                    isVariadic: true,
+                });
+                break;
+            }
+            case 'identifier': {
+                // JS: bare parameter name, no type info
+                params.push({
+                    name: param.text,
+                    type: null,
+                    rawType: null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
+                break;
+            }
+            case 'assignment_pattern': {
+                // JS: param = defaultValue — the left side is the name, isOptional = true
+                const left = param.childForFieldName('left');
+                if (left) {
+                    params.push({
+                        name: left.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: true,
+                        isVariadic: false,
+                    });
+                }
+                break;
+            }
+            case 'rest_pattern': {
+                // JS: ...args
+                const inner = param.firstNamedChild;
+                if (inner) {
+                    params.push({
+                        name: inner.text,
+                        type: null,
+                        rawType: null,
+                        isOptional: false,
+                        isVariadic: true,
+                    });
+                }
+                break;
+            }
+            case 'object_pattern':
+            case 'array_pattern': {
+                // Destructured parameter — use full text as name
+                params.push({
+                    name: param.text,
+                    type: null,
+                    rawType: null,
+                    isOptional: false,
+                    isVariadic: false,
+                });
+                break;
+            }
+        }
+    }
+    return params;
+}
+/** Regex to extract @returns or @return from JSDoc comments: `@returns {Type}` */
+const JSDOC_RETURN_RE = /@returns?\s*\{([^}]+)\}/;
+/**
+ * Minimal sanitization for JSDoc return types — preserves generic wrappers
+ * (e.g. `Promise<User>`) so that extractReturnTypeName in call-processor
+ * can apply WRAPPER_GENERICS unwrapping. Only strips JSDoc-specific syntax markers.
+ */
+function sanitizeJsDocReturnType(raw) {
+    let type = raw.trim();
+    // Strip JSDoc nullable/non-nullable prefixes: ?User → User, !User → User
+    if (type.startsWith('?') || type.startsWith('!'))
+        type = type.slice(1);
+    // Strip module: prefix — module:models.User → models.User
+    if (type.startsWith('module:'))
+        type = type.slice(7);
+    // Reject unions (ambiguous)
+    if (type.includes('|'))
+        return undefined;
+    if (!type)
+        return undefined;
+    return type;
+}
+/**
+ * Walk backwards through preceding siblings looking for a JSDoc comment containing
+ * `@returns {Type}` or `@return {Type}`. Stops at the first non-comment named node
+ * (excluding decorators, which precede methods in TS/JS).
+ */
+function extractJsDocReturnType(node) {
+    let sibling = node.previousSibling;
+    while (sibling) {
+        if (sibling.type === 'comment') {
+            const match = JSDOC_RETURN_RE.exec(sibling.text);
+            if (match)
+                return sanitizeJsDocReturnType(match[1]);
+        }
+        else if (sibling.isNamed && sibling.type !== 'decorator')
+            break;
+        sibling = sibling.previousSibling;
+    }
+    return undefined;
+}
+/**
+ * Extract return type from return_type field, unwrapping type_annotation.
+ * Falls back to JSDoc `@returns {Type}` when the AST has no return type annotation.
+ *
+ * tree-sitter-typescript uses `return_type` as the field name (not `type` like JVM).
+ * The return_type field points to a type_annotation node that must be unwrapped.
+ */
+function extractTsJsReturnType(node) {
+    const returnType = node.childForFieldName('return_type');
+    if (returnType) {
+        if (returnType.type === 'type_annotation') {
+            const inner = returnType.firstNamedChild;
+            if (inner)
+                return inner.text?.trim();
+        }
+        return returnType.text?.trim();
+    }
+    // AST has no return type annotation — try JSDoc fallback
+    return extractJsDocReturnType(node);
+}
+/**
+ * Extract visibility from accessibility_modifier or #private name.
+ *
+ * tree-sitter-typescript emits accessibility_modifier as a named child of method nodes
+ * (not as a modifiers wrapper like JVM). Pass 1 scans for that child; pass 2 checks for
+ * ES2022 private_property_identifier (#name). Default: public.
+ */
+function extractTsJsVisibility(node) {
+    // Pass 1: check for accessibility_modifier named child (TS-specific)
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && child.type === 'accessibility_modifier') {
+            const t = child.text.trim();
+            if (VISIBILITY_KEYWORDS.has(t))
+                return t;
+        }
+    }
+    // Pass 2: ES2022 private methods (#name) are inherently private
+    const nameNode = node.childForFieldName('name');
+    if (nameNode && nameNode.type === 'private_property_identifier')
+        return 'private';
+    // No accessibility_modifier found — default to public.
+    // Note: tree-sitter-typescript does not wrap modifiers in a 'modifiers' node
+    // (unlike JVM), so there is no wrapper to scan.
+    return 'public';
+}
+/**
+ * Extract decorator names, prefixed with '@'.
+ *
+ * In tree-sitter-typescript, decorators are **siblings** of the method_definition in the
+ * class_body — they are NOT children of the method node. We find them by walking backwards
+ * from the method node through its preceding siblings in the parent body.
+ */
+function extractTsJsDecorators(node) {
+    const decorators = [];
+    // Walk backwards via previousNamedSibling to collect consecutive decorator siblings.
+    // This avoids the O(N) index-finding scan through the parent's children.
+    let sibling = node.previousNamedSibling;
+    while (sibling && sibling.type === 'decorator') {
+        const name = extractDecoratorName(sibling);
+        if (name)
+            decorators.unshift(name);
+        sibling = sibling.previousNamedSibling;
+    }
+    return decorators;
+}
+function extractDecoratorName(decorator) {
+    const expr = decorator.firstNamedChild;
+    if (!expr)
+        return undefined;
+    if (expr.type === 'call_expression') {
+        const fn = expr.childForFieldName('function');
+        return fn ? '@' + fn.text : undefined;
+    }
+    if (expr.type === 'identifier')
+        return '@' + expr.text;
+    if (expr.type === 'member_expression')
+        return '@' + expr.text;
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+// TS and JS share the same config base. TS-only node types (abstract_class_declaration,
+// interface_declaration, abstract_method_signature, method_signature, interface_body) are
+// included because the JS grammar never produces these nodes — they are harmless no-ops.
+// This mirrors the field extractor's typescript-javascript.ts shared pattern.
+//
+// Note: TS and JS share a method config but NOT a field extractor because the TS field
+// extractor needs a hand-written class for type_alias_declaration object literals and
+// nested type discovery. Methods have no such requirement.
+const shared = {
+    typeDeclarationNodes: [
+        'class_declaration',
+        'abstract_class_declaration',
+        'interface_declaration',
+    ],
+    // Note: TS constructors are method_definition nodes (name = 'constructor'), so no
+    // explicit constructor_declaration entry is needed (unlike JVM/C# configs).
+    // Known gaps:
+    //   - call_signature and construct_signature (e.g., interface Fn { (x: string): void; })
+    //     are not extracted — they have no name field and are uncommon in practice.
+    //   - class_expression (const Foo = class { ... }) — methods inside class expressions
+    //     are not discovered because class_expression is not in typeDeclarationNodes.
+    //   - declare module / declare global augmentations — methods inside ambient_module_declaration
+    //     wrappers are not surfaced because the top-level walker doesn't descend into them.
+    methodNodeTypes: [
+        'method_definition',
+        'method_signature',
+        'abstract_method_signature',
+        'function_declaration',
+        'generator_function_declaration',
+        'function_signature',
+    ],
+    bodyNodeTypes: ['class_body', 'interface_body'],
+    extractName(node) {
+        const nameNode = node.childForFieldName('name');
+        return nameNode?.text;
+    },
+    extractReturnType: extractTsJsReturnType,
+    extractParameters: extractTsJsParameters,
+    extractVisibility: extractTsJsVisibility,
+    isStatic(node) {
+        return hasKeyword(node, 'static');
+    },
+    isAbstract(node, ownerNode) {
+        // Explicit abstract keyword on the method itself
+        if (hasKeyword(node, 'abstract'))
+            return true;
+        // Interface methods are implicitly abstract — TS interfaces never have method bodies
+        // (unlike Java default methods), so no !body check needed
+        if (ownerNode.type === 'interface_declaration')
+            return true;
+        return false;
+    },
+    isFinal(_node) {
+        return false; // TS/JS has no final/sealed methods
+    },
+    extractAnnotations: extractTsJsDecorators,
+    isAsync(node) {
+        return hasKeyword(node, 'async');
+    },
+    isOverride(node) {
+        return hasKeyword(node, 'override');
+    },
+};
+export const typescriptMethodConfig = {
+    ...shared,
+    language: SupportedLanguages.TypeScript,
+};
+export const javascriptMethodConfig = {
+    ...shared,
+    language: SupportedLanguages.JavaScript,
+};

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

@@ -0,0 +1,11 @@
+import type { MethodExtractor, MethodExtractionConfig } from '../method-types.js';
+/**
+ * Create a MethodExtractor from a declarative config.
+ *
+ * @throws {Error} if `typeDeclarationNodes` contains a static-implying owner
+ *   type (companion_object / object_declaration / singleton_class) that is
+ *   not covered by `staticOwnerTypes`. The guard fires once per language at
+ *   provider construction to prevent silent `isStatic=false` regressions. See
+ *   `STATIC_IMPLYING_OWNER_TYPES` for the exact opt-out convention.
+ */
+export declare function createMethodExtractor(config: MethodExtractionConfig): MethodExtractor;

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

@@ -0,0 +1,205 @@
+// arc/src/core/ingestion/method-extractors/generic.ts
+import { logger } from '../../logger.js';
+/**
+ * Node types that imply static member semantics when they appear as the owner
+ * of a method (Kotlin companion objects, Kotlin top-level `object` declarations,
+ * Ruby `class << self` singleton classes). A config that lists any of these in
+ * `typeDeclarationNodes` MUST also include the same node type in
+ * `staticOwnerTypes` — otherwise methods inside these containers silently get
+ * `isStatic=false`, which is a correctness bug that previously only surfaced
+ * at analysis time on large repos.
+ *
+ * Opt-out: a config that sets `staticOwnerTypes: new Set()` (explicit empty
+ * set) signals "I handle static-ness entirely via isStatic()" and is exempt
+ * from the guard.
+ */
+const STATIC_IMPLYING_OWNER_TYPES = new Set([
+    'companion_object',
+    'object_declaration',
+    'singleton_class',
+]);
+/**
+ * Create a MethodExtractor from a declarative config.
+ *
+ * @throws {Error} if `typeDeclarationNodes` contains a static-implying owner
+ *   type (companion_object / object_declaration / singleton_class) that is
+ *   not covered by `staticOwnerTypes`. The guard fires once per language at
+ *   provider construction to prevent silent `isStatic=false` regressions. See
+ *   `STATIC_IMPLYING_OWNER_TYPES` for the exact opt-out convention.
+ */
+export function createMethodExtractor(config) {
+    // Runtime invariant: each static-implying container type declared in
+    // typeDeclarationNodes must be covered by staticOwnerTypes. An explicit
+    // empty Set is treated as intentional opt-out.
+    if (config.staticOwnerTypes === undefined) {
+        const missing = config.typeDeclarationNodes.filter((t) => STATIC_IMPLYING_OWNER_TYPES.has(t));
+        if (missing.length > 0) {
+            throw new Error(`[MethodExtractionConfig:${config.language}] typeDeclarationNodes includes static-implying owner type(s) ` +
+                `${JSON.stringify(missing)} but staticOwnerTypes is not set. Add ` +
+                `'staticOwnerTypes: new Set([${missing.map((t) => `'${t}'`).join(', ')}])' ` +
+                `to the config, or set 'staticOwnerTypes: new Set()' to opt out explicitly.`);
+        }
+    }
+    else {
+        const missing = config.typeDeclarationNodes.filter((t) => STATIC_IMPLYING_OWNER_TYPES.has(t) && !config.staticOwnerTypes.has(t));
+        // Explicit empty Set is the opt-out signal; don't second-guess it.
+        if (missing.length > 0 && config.staticOwnerTypes.size > 0) {
+            throw new Error(`[MethodExtractionConfig:${config.language}] typeDeclarationNodes includes static-implying owner type(s) ` +
+                `${JSON.stringify(missing)} that are missing from staticOwnerTypes. ` +
+                `Either add them to staticOwnerTypes, or set 'staticOwnerTypes: new Set()' to opt out explicitly.`);
+        }
+    }
+    const typeDeclarationSet = new Set(config.typeDeclarationNodes);
+    const methodNodeSet = new Set(config.methodNodeTypes);
+    const bodyNodeSet = new Set(config.bodyNodeTypes);
+    return {
+        language: config.language,
+        isTypeDeclaration(node) {
+            return typeDeclarationSet.has(node.type);
+        },
+        extract(node, context) {
+            if (!typeDeclarationSet.has(node.type))
+                return null;
+            // Resolve owner name: config hook → field-based → type_identifier → simple_identifier → "Companion"
+            let ownerName;
+            if (config.extractOwnerName) {
+                ownerName = config.extractOwnerName(node);
+            }
+            if (!ownerName) {
+                const nameField = node.childForFieldName('name');
+                if (nameField) {
+                    ownerName = nameField.text;
+                }
+                else {
+                    for (let i = 0; i < node.namedChildCount; i++) {
+                        const child = node.namedChild(i);
+                        if (child &&
+                            (child.type === 'type_identifier' ||
+                                child.type === 'simple_identifier' ||
+                                child.type === 'identifier')) {
+                            ownerName = child.text;
+                            break;
+                        }
+                    }
+                }
+            }
+            // Unnamed companion objects use "Companion" (Kotlin convention)
+            if (!ownerName && node.type === 'companion_object') {
+                ownerName = 'Companion';
+            }
+            if (!ownerName)
+                return null;
+            const methods = [];
+            const bodies = findBodies(node, bodyNodeSet);
+            for (const body of bodies) {
+                extractMethodsFromBody(body, node, context, config, methodNodeSet, methods);
+            }
+            // Extract primary constructor from the owner node itself (e.g. C# 12)
+            if (config.extractPrimaryConstructor) {
+                const primaryCtor = config.extractPrimaryConstructor(node, context);
+                if (primaryCtor)
+                    methods.push(primaryCtor);
+            }
+            return { ownerName, methods };
+        },
+        extractFromNode(node, context) {
+            if (!methodNodeSet.has(node.type))
+                return null;
+            return buildMethod(node, node, context, config);
+        },
+        ...(config.extractFunctionName ? { extractFunctionName: config.extractFunctionName } : {}),
+    };
+}
+function findBodies(node, bodyNodeSet) {
+    const result = [];
+    const bodyField = node.childForFieldName('body');
+    if (bodyField && bodyNodeSet.has(bodyField.type)) {
+        result.push(bodyField);
+        addNestedBodies(bodyField, bodyNodeSet, result);
+        return result;
+    }
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child && bodyNodeSet.has(child.type)) {
+            result.push(child);
+        }
+    }
+    if (result.length === 0 && bodyField) {
+        // Fallback: body field exists but its type is not in bodyNodeTypes.
+        // This may indicate a config typo — log for debugging if NODE_ENV is development.
+        if (process.env.NODE_ENV === 'development') {
+            logger.warn(`[MethodExtractor] body field type '${bodyField.type}' not in bodyNodeTypes for node '${node.type}'`);
+        }
+        result.push(bodyField);
+        addNestedBodies(bodyField, bodyNodeSet, result);
+    }
+    return result;
+}
+function addNestedBodies(parent, bodyNodeSet, out, seen) {
+    const visited = seen ?? new Set(out);
+    for (let i = 0; i < parent.namedChildCount; i++) {
+        const child = parent.namedChild(i);
+        if (child && bodyNodeSet.has(child.type) && !visited.has(child)) {
+            visited.add(child);
+            out.push(child);
+        }
+    }
+}
+function extractMethodsFromBody(body, ownerNode, context, config, methodNodeSet, out) {
+    for (let i = 0; i < body.namedChildCount; i++) {
+        let child = body.namedChild(i);
+        if (!child)
+            continue;
+        // C++ template methods are wrapped in template_declaration — unwrap to the inner node
+        if (child.type === 'template_declaration') {
+            const inner = child.namedChildren.find((c) => methodNodeSet.has(c.type));
+            if (inner)
+                child = inner;
+        }
+        if (methodNodeSet.has(child.type)) {
+            const method = buildMethod(child, ownerNode, context, config);
+            if (method)
+                out.push(method);
+        }
+        // Recurse into enum constant anonymous class bodies
+        if (child.type === 'enum_constant') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const innerBody = child.namedChild(j);
+                if (innerBody && innerBody.type === 'class_body') {
+                    extractMethodsFromBody(innerBody, ownerNode, context, config, methodNodeSet, out);
+                }
+            }
+        }
+    }
+}
+function buildMethod(node, ownerNode, context, config) {
+    const name = config.extractName(node);
+    if (!name)
+        return null;
+    const isAbstract = config.isAbstract(node, ownerNode);
+    let isFinal = config.isFinal(node);
+    // Domain invariant: abstract methods cannot be final
+    if (isAbstract)
+        isFinal = false;
+    // Static-owner detection is config-driven: each language declares which
+    // container node types imply static (e.g. Ruby singleton_class, Kotlin companion_object).
+    const isStatic = (config.staticOwnerTypes?.has(ownerNode.type) ?? false) || config.isStatic(node);
+    return {
+        name,
+        receiverType: config.extractReceiverType?.(node) ?? null,
+        returnType: config.extractReturnType(node) ?? null,
+        parameters: config.extractParameters(node),
+        visibility: config.extractVisibility(node),
+        isStatic,
+        isAbstract,
+        isFinal,
+        ...(config.isVirtual?.(node) ? { isVirtual: true } : {}),
+        ...(config.isOverride?.(node) ? { isOverride: true } : {}),
+        ...(config.isAsync?.(node) ? { isAsync: true } : {}),
+        ...(config.isPartial?.(node) ? { isPartial: true } : {}),
+        ...(config.isConst?.(node) ? { isConst: true } : {}),
+        annotations: config.extractAnnotations?.(node) ?? [],
+        sourceFile: context.filePath,
+        line: node.startPosition.row + 1,
+    };
+}

package/dist/core/ingestion/method-types.d.ts

@@ -0,0 +1,90 @@
+import type { SupportedLanguages } from '../../_shared/index.js';
+import type { FieldVisibility } from './field-types.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
+export type MethodVisibility = FieldVisibility;
+export interface ParameterInfo {
+    name: string;
+    type: string | null;
+    /** Full type text including generic/template args (e.g. 'vector<int>', 'List<String>').
+     *  Used by typeTagForId for overload disambiguation where generic args matter.
+     *  Falls back to `type` when not set. */
+    rawType?: string | null;
+    isOptional: boolean;
+    isVariadic: boolean;
+}
+export interface MethodInfo {
+    name: string;
+    receiverType: string | null;
+    returnType: string | null;
+    parameters: ParameterInfo[];
+    visibility: MethodVisibility;
+    isStatic: boolean;
+    isAbstract: boolean;
+    isFinal: boolean;
+    isVirtual?: boolean;
+    isOverride?: boolean;
+    isAsync?: boolean;
+    isPartial?: boolean;
+    isConst?: boolean;
+    annotations: string[];
+    sourceFile: string;
+    line: number;
+}
+export interface MethodExtractorContext {
+    filePath: string;
+    language: SupportedLanguages;
+}
+export interface ExtractedMethods {
+    ownerName: string;
+    methods: MethodInfo[];
+}
+export interface MethodExtractor {
+    language: SupportedLanguages;
+    extract(node: SyntaxNode, context: MethodExtractorContext): ExtractedMethods | null;
+    isTypeDeclaration(node: SyntaxNode): boolean;
+    /** Extract method info from a standalone method node (e.g. Go top-level method_declaration). */
+    extractFromNode?(node: SyntaxNode, context: MethodExtractorContext): MethodInfo | null;
+    /** Extract function name + label from an AST node during parent-walk.
+     *  Languages with non-standard AST structures (e.g. C/C++ declarator
+     *  unwrapping, Swift init/deinit, Rust impl_item) provide this hook
+     *  to replace the generic name-field lookup.
+     *  Return null to fall through to the generic extractor. */
+    extractFunctionName?(node: SyntaxNode): {
+        funcName: string | null;
+        label: import('../../_shared/index.js').NodeLabel;
+    } | null;
+}
+export interface MethodExtractionConfig {
+    language: SupportedLanguages;
+    typeDeclarationNodes: string[];
+    methodNodeTypes: string[];
+    bodyNodeTypes: string[];
+    extractName: (node: SyntaxNode) => string | undefined;
+    extractReturnType: (node: SyntaxNode) => string | undefined;
+    extractParameters: (node: SyntaxNode) => ParameterInfo[];
+    extractVisibility: (node: SyntaxNode) => MethodVisibility;
+    isStatic: (node: SyntaxNode) => boolean;
+    isAbstract: (node: SyntaxNode, ownerNode: SyntaxNode) => boolean;
+    isFinal: (node: SyntaxNode) => boolean;
+    extractAnnotations?: (node: SyntaxNode) => string[];
+    extractReceiverType?: (node: SyntaxNode) => string | undefined;
+    isVirtual?: (node: SyntaxNode) => boolean;
+    isOverride?: (node: SyntaxNode) => boolean;
+    isAsync?: (node: SyntaxNode) => boolean;
+    isPartial?: (node: SyntaxNode) => boolean;
+    isConst?: (node: SyntaxNode) => boolean;
+    /** Owner node types where member functions are effectively static (e.g.
+     *  Ruby singleton_class, Kotlin companion_object / object_declaration).
+     *  When the ownerNode matches one of these types, isStatic is forced true. */
+    staticOwnerTypes?: ReadonlySet<string>;
+    /** Resolve the owner name from a standalone method node (e.g. Go receiver type). */
+    extractOwnerName?: (node: SyntaxNode) => string | undefined;
+    /** Extract a primary constructor from the owner node itself (e.g. C# 12 class Point(int x, int y)). */
+    extractPrimaryConstructor?: (ownerNode: SyntaxNode, context: MethodExtractorContext) => MethodInfo | null;
+    /** Extract function name + label from an AST node during parent-walk.
+     *  Passed through to the MethodExtractor by createMethodExtractor. */
+    extractFunctionName?: (node: SyntaxNode) => {
+        funcName: string | null;
+        label: import('../../_shared/index.js').NodeLabel;
+    } | null;
+}

package/dist/core/ingestion/method-types.js

@@ -0,0 +1,2 @@
+// arc/src/core/ingestion/method-types.ts
+export {};

package/dist/core/ingestion/model/field-registry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Field Registry
+ *
+ * Owner-scoped field/property index extracted from SymbolTable.
+ * Stores Property symbols keyed by `ownerNodeId\0fieldName` for O(1) lookup.
+ */
+import type { SymbolDefinition } from '../../../_shared/index.js';
+export interface FieldRegistry {
+    /** Look up a field/property by its owning class nodeId and field name. */
+    lookupFieldByOwner(ownerNodeId: string, fieldName: string): SymbolDefinition | undefined;
+}
+export interface MutableFieldRegistry extends FieldRegistry {
+    /** Register a field/property under its owner. */
+    register(ownerNodeId: string, fieldName: string, def: SymbolDefinition): void;
+    /** Clear all entries. */
+    clear(): void;
+}
+export declare const createFieldRegistry: () => MutableFieldRegistry;