arceus-s 1.6.4

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

@@ -0,0 +1,63 @@
+/**
+ * C# `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
+ *
+ * Second migration after Python — see `pythonScopeResolver` for the
+ * canonical shape.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
+import { csharpProvider } from '../csharp.js';
+import { csharpArityCompatibility, csharpMergeBindings, resolveCsharpImportTarget, } from './index.js';
+import { populateCsharpNamespaceSiblings } from './namespace-siblings.js';
+import { unwrapCsharpCollectionAccessor } from './accessor-unwrap.js';
+const csharpScopeResolver = {
+    language: SupportedLanguages.CSharp,
+    languageProvider: csharpProvider,
+    importEdgeReason: 'csharp-scope: using',
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
+        const ws = { fromFile, allFilePaths };
+        // `WorkspaceIndex` is an opaque `unknown` placeholder in the
+        // shared contract, so `ws` passes structurally without a cast.
+        return resolveCsharpImportTarget({ kind: 'namespace', localName: '_', importedName: '_', targetRaw }, ws);
+    },
+    // C# shadowing: local > using > using static. The per-scope id is
+    // unused by the C# implementation (shadowing is computed purely
+    // from the binding tier), so we don't need to synthesize a Scope.
+    mergeBindings: (existing, incoming) => [...csharpMergeBindings([...existing, ...incoming])],
+    // Adapter: csharpArityCompatibility uses (def, callsite); the
+    // contract is (callsite, def).
+    arityCompatibility: (callsite, def) => csharpArityCompatibility(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    populateOwners: (parsed) => populateClassOwnedMembers(parsed),
+    // C# uses `base` for super-class dispatch, not `super`. Match as a
+    // plain identifier (no `()` call like Python's `super(...)`) — `base`
+    // is a keyword-like receiver, not a callable.
+    isSuperReceiver: (text) => text.trim() === 'base',
+    // Same-namespace cross-file visibility — C# makes every type
+    // declared in `namespace X` visible to other files declaring the
+    // same namespace, without any `using` directive. See
+    // `namespace-siblings.ts` for the implementation.
+    populateNamespaceSiblings: populateCsharpNamespaceSiblings,
+    // C# is statically typed — type information is reliable. Field-
+    // fallback heuristic stays off (the type-binding layer already
+    // produces precise owner types); return-type propagation on is fine
+    // since signatures are authoritative.
+    fieldFallbackOnMethodLookup: false,
+    propagatesReturnTypesAcrossImports: true,
+    // `data.Values` / `data.Keys` on Dictionary-like receivers unwrap
+    // to the value / key element type. Other languages use method-call
+    // syntax for the same access and leave this hook undefined.
+    unwrapCollectionAccessor: unwrapCsharpCollectionAccessor,
+    // C# matches legacy DAG by collapsing member-call CALLS edges to
+    // `(caller, target)` — multiple `g.Greet(...)` sites from Main
+    // yield ONE edge, not one per site.
+    collapseMemberCallsByCallerTarget: true,
+    // C# hoists method return-type bindings to the enclosing Module
+    // scope so `propagateImportedReturnTypes` can mirror them across
+    // files. The compound-receiver walker needs to walk up from the
+    // class scope to find them; see the contract field for rationale.
+    hoistTypeBindingsToModule: true,
+};
+export { csharpScopeResolver };

package/dist/core/ingestion/languages/csharp/simple-hooks.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Trivial / no-op-ish hooks for the C# provider. Kept together because
+ * each is a few lines and they share a common theme: they make the
+ * provider's choice explicit rather than relying on "absence == default"
+ * so reviewers don't have to re-derive the analysis.
+ */
+import type { CaptureMatch, ParsedImport, Scope, ScopeId, ScopeTree, TypeRef } from '../../../../_shared/index.js';
+/** C# has block scope, but the central extractor's "innermost enclosing
+ *  scope" default already handles it correctly: class-body declarations
+ *  attach to the innermost Class scope, method-body declarations attach
+ *  to the innermost Function scope, and namespace-body declarations
+ *  attach to the innermost Namespace scope (which the scope query emits
+ *  for both `namespace X { }` and `namespace X;` forms).
+ *
+ *  Exception: **method return-type bindings** (`@type-binding.return`)
+ *  must hoist all the way to the Module scope. The default auto-hoist
+ *  in the central extractor only promotes one level (Function → its
+ *  parent). For C# methods the parent is always a Class, so without
+ *  this override the return binding gets stuck at the Class scope,
+ *  where it's invisible to:
+ *    - chain-follow's parent-chain walk in `followChainPostFinalize`
+ *      (tests: `var u = GetUser(); u.Save()` single-file);
+ *    - cross-file `propagateImportedReturnTypes`, which reads only
+ *      `sourceModule.typeBindings`.
+ *  Walking to Module restores both paths. */
+export declare function csharpBindingScopeFor(decl: CaptureMatch, innermost: Scope, tree: ScopeTree): ScopeId | null;
+/** `using` inside `namespace X { }` binds to that namespace's scope (its
+ *  types are visible only within that namespace's members). File-level
+ *  `using` delegates to the module default. Class-body `using` is not
+ *  legal C# — defensively handle it by attaching to the class if it
+ *  ever slips through.
+ *
+ *  `global using X;` (C# 10+) at the compilation_unit level is treated
+ *  as a file-scoped using for Unit 2's purposes; cross-file propagation
+ *  will be addressed if Unit 7's parity gate flags it. */
+export declare function csharpImportOwningScope(_imp: ParsedImport, innermost: Scope, _tree: ScopeTree): ScopeId | null;
+/** Look up `this` or `base` in the function scope's type bindings.
+ *
+ *  `this` and `base` are synthesized as type bindings on instance
+ *  methods during capture emission (`receiver-binding.ts`) — `this`
+ *  for every method inside a class/struct/record/interface body, and
+ *  `base` additionally for methods of a class-like type with an
+ *  explicit `base_list`. This hook therefore returns a non-null
+ *  `TypeRef` for instance-method bodies.
+ *
+ *  Returns `null` for:
+ *    - static methods (no `this` synthesized)
+ *    - free functions / module-level code (no enclosing class)
+ *    - non-Function scopes
+ *
+ *  Matches `pythonReceiverBinding`'s shape so the two provider
+ *  wirings stay symmetric. */
+export declare function csharpReceiverBinding(functionScope: Scope): TypeRef | null;

package/dist/core/ingestion/languages/csharp/simple-hooks.js

@@ -0,0 +1,76 @@
+/**
+ * Trivial / no-op-ish hooks for the C# provider. Kept together because
+ * each is a few lines and they share a common theme: they make the
+ * provider's choice explicit rather than relying on "absence == default"
+ * so reviewers don't have to re-derive the analysis.
+ */
+// ─── bindingScopeFor ──────────────────────────────────────────────────────
+/** C# has block scope, but the central extractor's "innermost enclosing
+ *  scope" default already handles it correctly: class-body declarations
+ *  attach to the innermost Class scope, method-body declarations attach
+ *  to the innermost Function scope, and namespace-body declarations
+ *  attach to the innermost Namespace scope (which the scope query emits
+ *  for both `namespace X { }` and `namespace X;` forms).
+ *
+ *  Exception: **method return-type bindings** (`@type-binding.return`)
+ *  must hoist all the way to the Module scope. The default auto-hoist
+ *  in the central extractor only promotes one level (Function → its
+ *  parent). For C# methods the parent is always a Class, so without
+ *  this override the return binding gets stuck at the Class scope,
+ *  where it's invisible to:
+ *    - chain-follow's parent-chain walk in `followChainPostFinalize`
+ *      (tests: `var u = GetUser(); u.Save()` single-file);
+ *    - cross-file `propagateImportedReturnTypes`, which reads only
+ *      `sourceModule.typeBindings`.
+ *  Walking to Module restores both paths. */
+export function csharpBindingScopeFor(decl, innermost, tree) {
+    if (decl['@type-binding.return'] !== undefined) {
+        let cur = innermost;
+        while (cur !== undefined && cur.kind !== 'Module') {
+            const parentId = cur.parent ?? null;
+            if (parentId === null)
+                break;
+            cur = tree.getScope(parentId);
+        }
+        if (cur !== undefined && cur.kind === 'Module')
+            return cur.id;
+    }
+    return null;
+}
+// ─── importOwningScope ────────────────────────────────────────────────────
+/** `using` inside `namespace X { }` binds to that namespace's scope (its
+ *  types are visible only within that namespace's members). File-level
+ *  `using` delegates to the module default. Class-body `using` is not
+ *  legal C# — defensively handle it by attaching to the class if it
+ *  ever slips through.
+ *
+ *  `global using X;` (C# 10+) at the compilation_unit level is treated
+ *  as a file-scoped using for Unit 2's purposes; cross-file propagation
+ *  will be addressed if Unit 7's parity gate flags it. */
+export function csharpImportOwningScope(_imp, innermost, _tree) {
+    if (innermost.kind === 'Namespace' || innermost.kind === 'Class' || innermost.kind === 'Function')
+        return innermost.id;
+    return null;
+}
+// ─── receiverBinding ──────────────────────────────────────────────────────
+/** Look up `this` or `base` in the function scope's type bindings.
+ *
+ *  `this` and `base` are synthesized as type bindings on instance
+ *  methods during capture emission (`receiver-binding.ts`) — `this`
+ *  for every method inside a class/struct/record/interface body, and
+ *  `base` additionally for methods of a class-like type with an
+ *  explicit `base_list`. This hook therefore returns a non-null
+ *  `TypeRef` for instance-method bodies.
+ *
+ *  Returns `null` for:
+ *    - static methods (no `this` synthesized)
+ *    - free functions / module-level code (no enclosing class)
+ *    - non-Function scopes
+ *
+ *  Matches `pythonReceiverBinding`'s shape so the two provider
+ *  wirings stay symmetric. */
+export function csharpReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('this') ?? functionScope.typeBindings.get('base') ?? null;
+}

package/dist/core/ingestion/languages/csharp.d.ts

@@ -0,0 +1,8 @@
+/**
+ * C# language provider.
+ *
+ * C# uses named imports (using directives), modifier-based export detection,
+ * and an implements-split MRO strategy for multiple interface implementation.
+ * Interface names follow the I-prefix convention (e.g., IDisposable).
+ */
+export declare const csharpProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/csharp.js

@@ -0,0 +1,201 @@
+/**
+ * C# language provider.
+ *
+ * C# uses named imports (using directives), modifier-based export detection,
+ * and an implements-split MRO strategy for multiple interface implementation.
+ * Interface names follow the I-prefix convention (e.g., IDisposable).
+ */
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { csharpClassConfig } from '../class-extractors/configs/csharp.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as csharpConfig } from '../type-extractors/csharp.js';
+import { csharpExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { csharpImportConfig } from '../import-resolvers/configs/csharp.js';
+import { extractCSharpNamedBindings } from '../named-bindings/csharp.js';
+import { CSHARP_QUERIES } from '../tree-sitter-queries.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { csharpCallConfig } from '../call-extractors/configs/csharp.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { csharpConfig as csharpFieldConfig } from '../field-extractors/configs/csharp.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { csharpMethodConfig } from '../method-extractors/configs/csharp.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { csharpVariableConfig } from '../variable-extractors/configs/csharp.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+import { emitCsharpScopeCaptures, interpretCsharpImport, interpretCsharpTypeBinding, csharpBindingScopeFor, csharpImportOwningScope, csharpMergeBindings, csharpReceiverBinding, csharpArityCompatibility, resolveCsharpImportTarget, } from './csharp/index.js';
+const BUILT_INS = new Set([
+    'Console',
+    'WriteLine',
+    'ReadLine',
+    'Write',
+    'Task',
+    'Run',
+    'Wait',
+    'WhenAll',
+    'WhenAny',
+    'FromResult',
+    'Delay',
+    'ContinueWith',
+    'ConfigureAwait',
+    'GetAwaiter',
+    'GetResult',
+    'ToString',
+    'GetType',
+    'Equals',
+    'GetHashCode',
+    'ReferenceEquals',
+    'Add',
+    'Remove',
+    'Contains',
+    'Clear',
+    'Count',
+    'Any',
+    'All',
+    'Where',
+    'Select',
+    'SelectMany',
+    'OrderBy',
+    'OrderByDescending',
+    'GroupBy',
+    'First',
+    'FirstOrDefault',
+    'Single',
+    'SingleOrDefault',
+    'Last',
+    'LastOrDefault',
+    'ToList',
+    'ToArray',
+    'ToDictionary',
+    'AsEnumerable',
+    'AsQueryable',
+    'Aggregate',
+    'Sum',
+    'Average',
+    'Min',
+    'Max',
+    'Distinct',
+    'Skip',
+    'Take',
+    'String',
+    'Format',
+    'IsNullOrEmpty',
+    'IsNullOrWhiteSpace',
+    'Concat',
+    'Join',
+    'Trim',
+    'TrimStart',
+    'TrimEnd',
+    'Split',
+    'Replace',
+    'StartsWith',
+    'EndsWith',
+    'Convert',
+    'ToInt32',
+    'ToDouble',
+    'ToBoolean',
+    'ToByte',
+    'Math',
+    'Abs',
+    'Ceiling',
+    'Floor',
+    'Round',
+    'Pow',
+    'Sqrt',
+    'Dispose',
+    'Close',
+    'TryParse',
+    'Parse',
+    'AddRange',
+    'RemoveAt',
+    'RemoveAll',
+    'FindAll',
+    'Exists',
+    'TrueForAll',
+    'ContainsKey',
+    'TryGetValue',
+    'AddOrUpdate',
+    'Throw',
+    'ThrowIfNull',
+]);
+export const csharpProvider = defineLanguage({
+    id: SupportedLanguages.CSharp,
+    extensions: ['.cs'],
+    entryPointPatterns: [
+        /^(Get|Post|Put|Delete|Patch)/,
+        /Action$/,
+        /^On[A-Z]/,
+        /Async$/,
+        /^Configure$/,
+        /^ConfigureServices$/,
+        /^Handle$/,
+        /^Execute$/,
+        /^Invoke$/,
+        /^Map[A-Z]/,
+        /Service$/,
+        /^Seed/,
+    ],
+    astFrameworkPatterns: [
+        {
+            framework: 'aspnet',
+            entryPointMultiplier: 3.2,
+            reason: 'aspnet-attribute',
+            patterns: [
+                '[ApiController]',
+                '[HttpGet]',
+                '[HttpPost]',
+                '[HttpPut]',
+                '[HttpDelete]',
+                '[Route]',
+                '[Authorize]',
+                '[AllowAnonymous]',
+            ],
+        },
+        {
+            framework: 'signalr',
+            entryPointMultiplier: 2.8,
+            reason: 'signalr-attribute',
+            patterns: ['[HubMethodName]', ': Hub', ': Hub<'],
+        },
+        {
+            framework: 'blazor',
+            entryPointMultiplier: 2.5,
+            reason: 'blazor-attribute',
+            patterns: ['@page', '[Parameter]', '@inject'],
+        },
+        {
+            framework: 'efcore',
+            entryPointMultiplier: 2.0,
+            reason: 'efcore-pattern',
+            patterns: ['DbContext', 'DbSet<', 'OnModelCreating'],
+        },
+    ],
+    treeSitterQueries: CSHARP_QUERIES,
+    typeConfig: csharpConfig,
+    exportChecker: csharpExportChecker,
+    importResolver: createImportResolver(csharpImportConfig),
+    namedBindingExtractor: extractCSharpNamedBindings,
+    interfaceNamePattern: /^I[A-Z]/,
+    mroStrategy: 'implements-split',
+    callExtractor: createCallExtractor(csharpCallConfig),
+    fieldExtractor: createFieldExtractor(csharpFieldConfig),
+    methodExtractor: createMethodExtractor(csharpMethodConfig),
+    variableExtractor: createVariableExtractor(csharpVariableConfig),
+    classExtractor: createClassExtractor(csharpClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.CSharp),
+    builtInNames: BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    // C# is the second migration after Python. See ./csharp/index.ts for
+    // the full per-hook rationale and the canonical capture vocabulary
+    // in ./csharp/query.ts (CSHARP_SCOPE_QUERY constant).
+    emitScopeCaptures: emitCsharpScopeCaptures,
+    interpretImport: interpretCsharpImport,
+    interpretTypeBinding: interpretCsharpTypeBinding,
+    bindingScopeFor: csharpBindingScopeFor,
+    importOwningScope: csharpImportOwningScope,
+    mergeBindings: (_scope, bindings) => csharpMergeBindings(bindings),
+    receiverBinding: csharpReceiverBinding,
+    arityCompatibility: csharpArityCompatibility,
+    resolveImportTarget: resolveCsharpImportTarget,
+});

package/dist/core/ingestion/languages/dart.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Dart Language Provider
+ *
+ * Dart traits:
+ *   - importSemantics: 'wildcard-leaf' (Dart imports bring everything public into scope)
+ *   - exportChecker: public if no leading underscore
+ *   - Dart SDK imports (dart:*) and external packages are skipped
+ *   - enclosingFunctionFinder: Dart's tree-sitter grammar places function_body
+ *     as a sibling of function_signature/method_signature (not as a child).
+ *     The hook resolves the enclosing function by inspecting the previous sibling.
+ */
+export declare const dartProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/dart.js

@@ -0,0 +1,138 @@
+/**
+ * Dart Language Provider
+ *
+ * Dart traits:
+ *   - importSemantics: 'wildcard-leaf' (Dart imports bring everything public into scope)
+ *   - exportChecker: public if no leading underscore
+ *   - Dart SDK imports (dart:*) and external packages are skipped
+ *   - enclosingFunctionFinder: Dart's tree-sitter grammar places function_body
+ *     as a sibling of function_signature/method_signature (not as a child).
+ *     The hook resolves the enclosing function by inspecting the previous sibling.
+ */
+import { FUNCTION_NODE_TYPES } from '../utils/ast-helpers.js';
+import { SupportedLanguages } from '../../../_shared/index.js';
+import { createClassExtractor } from '../class-extractors/generic.js';
+import { dartClassConfig } from '../class-extractors/configs/dart.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as dartConfig } from '../type-extractors/dart.js';
+import { dartExportChecker } from '../export-detection.js';
+import { createImportResolver } from '../import-resolvers/resolver-factory.js';
+import { dartImportConfig } from '../import-resolvers/configs/dart.js';
+import { DART_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { dartConfig as dartFieldConfig } from '../field-extractors/configs/dart.js';
+import { createMethodExtractor } from '../method-extractors/generic.js';
+import { dartMethodConfig } from '../method-extractors/configs/dart.js';
+import { createVariableExtractor } from '../variable-extractors/generic.js';
+import { dartVariableConfig } from '../variable-extractors/configs/dart.js';
+import { createCallExtractor } from '../call-extractors/generic.js';
+import { dartCallConfig } from '../call-extractors/configs/dart.js';
+import { createHeritageExtractor } from '../heritage-extractors/generic.js';
+/**
+ * Resolve the enclosing function from a `function_body` node by looking at its
+ * previous sibling.  In Dart's tree-sitter grammar, function_signature and
+ * function_body are siblings under program or class_body, unlike most languages
+ * where the function declaration wraps both.
+ *
+ * Extracts the function name inline — Dart uses function_signature and
+ * method_signature (which wraps function_signature) as its FUNCTION_NODE_TYPES.
+ */
+const dartEnclosingFunctionFinder = (node) => {
+    if (node.type !== 'function_body')
+        return null;
+    const prev = node.previousSibling;
+    if (!prev || !FUNCTION_NODE_TYPES.has(prev.type))
+        return null;
+    // method_signature wraps function_signature — unwrap to reach the name
+    let target = prev;
+    let label = 'Function';
+    if (prev.type === 'method_signature') {
+        label = 'Method';
+        for (let i = 0; i < prev.childCount; i++) {
+            const c = prev.child(i);
+            if (c?.type === 'function_signature') {
+                target = c;
+                break;
+            }
+        }
+    }
+    const funcName = target.childForFieldName?.('name')?.text ?? null;
+    return funcName ? { funcName, label } : null;
+};
+const BUILT_INS = new Set([
+    'setState',
+    'mounted',
+    'debugPrint',
+    'runApp',
+    'showDialog',
+    'showModalBottomSheet',
+    'Navigator',
+    'push',
+    'pushNamed',
+    'pushReplacement',
+    'pop',
+    'maybePop',
+    'ScaffoldMessenger',
+    'showSnackBar',
+    'deactivate',
+    'reassemble',
+    'debugDumpApp',
+    'debugDumpRenderTree',
+    'then',
+    'catchError',
+    'whenComplete',
+    'listen',
+]);
+export const dartProvider = defineLanguage({
+    id: SupportedLanguages.Dart,
+    extensions: ['.dart'],
+    entryPointPatterns: [
+        /^main$/,
+        /^build$/,
+        /^createState$/,
+        /^initState$/,
+        /^dispose$/,
+        /^didChangeDependencies$/,
+        /^didUpdateWidget$/,
+        /^runApp$/,
+        /^onEvent$/,
+        /^mapEventToState$/,
+    ],
+    astFrameworkPatterns: [
+        {
+            framework: 'flutter',
+            entryPointMultiplier: 2.5,
+            reason: 'flutter-widget',
+            patterns: [
+                'StatelessWidget',
+                'StatefulWidget',
+                'BuildContext',
+                'Widget build',
+                'ChangeNotifier',
+                'GetxController',
+                'Cubit<',
+                'Bloc<',
+                'ConsumerWidget',
+            ],
+        },
+        {
+            framework: 'riverpod',
+            entryPointMultiplier: 2.8,
+            reason: 'riverpod-pattern',
+            patterns: ['@riverpod', 'ref.watch', 'ref.read', 'AsyncNotifier', 'Notifier'],
+        },
+    ],
+    treeSitterQueries: DART_QUERIES,
+    typeConfig: dartConfig,
+    exportChecker: dartExportChecker,
+    importResolver: createImportResolver(dartImportConfig),
+    importSemantics: 'wildcard-leaf',
+    callExtractor: createCallExtractor(dartCallConfig),
+    fieldExtractor: createFieldExtractor(dartFieldConfig),
+    methodExtractor: createMethodExtractor(dartMethodConfig),
+    variableExtractor: createVariableExtractor(dartVariableConfig),
+    classExtractor: createClassExtractor(dartClassConfig),
+    heritageExtractor: createHeritageExtractor(SupportedLanguages.Dart),
+    enclosingFunctionFinder: dartEnclosingFunctionFinder,
+    builtInNames: BUILT_INS,
+});

package/dist/core/ingestion/languages/go/arity-metadata.d.ts

@@ -0,0 +1,8 @@
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+export interface GoArityMetadata {
+    readonly parameterCount?: number;
+    readonly requiredParameterCount?: number;
+    readonly parameterTypes?: readonly string[];
+}
+export declare function computeGoDeclarationArity(node: SyntaxNode): GoArityMetadata;
+export declare function computeGoCallArity(callNode: SyntaxNode): number;

package/dist/core/ingestion/languages/go/arity-metadata.js

@@ -0,0 +1,37 @@
+export function computeGoDeclarationArity(node) {
+    const params = node.childForFieldName('parameters');
+    if (params === null)
+        return {};
+    let count = 0;
+    let required = 0;
+    const types = [];
+    for (let i = 0; i < params.namedChildCount; i++) {
+        const param = params.namedChild(i);
+        if (param === null)
+            continue;
+        if (param.type === 'parameter_declaration') {
+            const typeNode = param.childForFieldName('type');
+            const typeName = typeNode === null ? '' : typeNode.text;
+            const names = param.namedChildren.filter((c) => c.type === 'identifier');
+            const n = Math.max(1, names.length);
+            for (let j = 0; j < n; j++) {
+                count++;
+                required++;
+                types.push(typeName);
+            }
+        }
+        if (param.type === 'variadic_parameter_declaration') {
+            const typeNode = param.childForFieldName('type');
+            const typeName = typeNode === null ? '...' : `...${typeNode.text}`;
+            count++;
+            types.push(typeName);
+        }
+    }
+    return { parameterCount: count, requiredParameterCount: required, parameterTypes: types };
+}
+export function computeGoCallArity(callNode) {
+    const args = callNode.childForFieldName('arguments');
+    if (args === null)
+        return 0;
+    return args.namedChildCount;
+}

package/dist/core/ingestion/languages/go/arity.d.ts

@@ -0,0 +1,2 @@
+import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
+export declare function goArityCompatibility(def: SymbolDefinition, callsite: Callsite): 'compatible' | 'unknown' | 'incompatible';

package/dist/core/ingestion/languages/go/arity.js

@@ -0,0 +1,14 @@
+export function goArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    if (!Number.isFinite(callsite.arity) || callsite.arity < 0)
+        return 'unknown';
+    const variadic = def.parameterTypes?.some((t) => t.startsWith('...')) ?? false;
+    if (min !== undefined && callsite.arity < min)
+        return 'incompatible';
+    if (max !== undefined && callsite.arity > max && !variadic)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/ingestion/languages/go/cache-stats.d.ts

@@ -0,0 +1,7 @@
+export declare function recordGoCacheHit(): void;
+export declare function recordGoCacheMiss(): void;
+export declare function getGoCaptureCacheStats(): {
+    readonly hits: number;
+    readonly misses: number;
+};
+export declare function resetGoCaptureCacheStats(): void;

package/dist/core/ingestion/languages/go/cache-stats.js

@@ -0,0 +1,15 @@
+let hits = 0;
+let misses = 0;
+export function recordGoCacheHit() {
+    hits++;
+}
+export function recordGoCacheMiss() {
+    misses++;
+}
+export function getGoCaptureCacheStats() {
+    return { hits, misses };
+}
+export function resetGoCaptureCacheStats() {
+    hits = 0;
+    misses = 0;
+}

package/dist/core/ingestion/languages/go/captures.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitGoScopeCaptures(sourceText: string, _filePath: string, cachedTree?: unknown): readonly CaptureMatch[];