cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/csharp/receiver-binding.js

@@ -0,0 +1,142 @@
+"use strict";
+/**
+ * Synthesize `@type-binding.self` captures for C# instance methods —
+ * one for `this` (always on non-static methods inside a type
+ * declaration) and optionally one for `base` (only on class methods
+ * when the enclosing class has an explicit base in its `base_list`).
+ *
+ * Mirrors `languages/python/receiver-binding.ts` in structure. The
+ * tree-sitter-c-sharp grammar doesn't give us a clean `.scm` pattern
+ * for "this-receiver on every instance method inside an enclosing
+ * type" because the binding isn't a parameter — it's an implicit
+ * receiver. Synthesis in code is the same approach Python uses for
+ * `self` / `cls`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeCsharpReceiverBinding = synthesizeCsharpReceiverBinding;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const TYPE_DECL_NODE_TYPES = new Set([
+    'class_declaration',
+    'struct_declaration',
+    'record_declaration',
+    'interface_declaration',
+]);
+const FUNCTION_NODE_TYPES = new Set([
+    'method_declaration',
+    'constructor_declaration',
+    'destructor_declaration',
+    'operator_declaration',
+    'conversion_operator_declaration',
+    'local_function_statement',
+]);
+/** Walk up to the enclosing type declaration, stopping at any other
+ *  function-like node (nested local functions shouldn't leak `this`
+ *  from an outer class to an inner closure). */
+function findEnclosingTypeDeclaration(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (TYPE_DECL_NODE_TYPES.has(cur.type))
+            return cur;
+        // A local function nested inside another method still sees `this`
+        // from the enclosing class — don't break on function-like nodes.
+        cur = cur.parent;
+    }
+    return null;
+}
+function typeName(typeNode) {
+    return typeNode.childForFieldName('name')?.text ?? null;
+}
+/** First entry in the type's `base_list`, read as raw type text. C#
+ *  allows generic and qualified bases (`Foo<T>`, `N.M.Base`); we keep
+ *  that form so downstream interpretation can strip generics and
+ *  qualifiers consistently. A record primary-constructor base wraps
+ *  its type and constructor arguments in `primary_constructor_base_type`,
+ *  so read its `type` field instead of leaking `(args)` into the binding.
+ *  Returns null when the type has no base (or an empty base_list). */
+function firstBaseText(typeNode) {
+    for (let i = 0; i < typeNode.namedChildCount; i++) {
+        const child = typeNode.namedChild(i);
+        if (child === null || child.type !== 'base_list')
+            continue;
+        const firstBase = child.namedChild(0);
+        if (firstBase === null)
+            return null;
+        return firstBase.type === 'primary_constructor_base_type'
+            ? (firstBase.childForFieldName('type')?.text ?? firstBase.text)
+            : firstBase.text;
+    }
+    return null;
+}
+function isStaticMethod(fnNode) {
+    // A `static` modifier appears as a named `modifier` child whose text
+    // is exactly "static". collectModifierTexts in field-extractors
+    // handles this, but duplicating the tiny scan here keeps the
+    // receiver-binding module dependency-free.
+    for (let i = 0; i < fnNode.namedChildCount; i++) {
+        const child = fnNode.namedChild(i);
+        if (child !== null && child.type === 'modifier' && child.text.trim() === 'static')
+            return true;
+    }
+    return false;
+}
+/**
+ * Build zero, one, or two `@type-binding.self` matches for `fnNode`:
+ *
+ *  - Returns `null` if the function is free (no enclosing type),
+ *    static, or the enclosing type has no resolvable name.
+ *  - Returns one match (`this`) for non-static methods inside a
+ *    class/struct/record/interface.
+ *  - Returns two matches (`this` + `base`) only when the function
+ *    lives in a `class_declaration` (or `record_declaration`) that has
+ *    at least one base entry. Structs cannot inherit classes;
+ *    interfaces cannot call `base.X`.
+ *
+ *  The caller is responsible for guaranteeing
+ *  `FUNCTION_NODE_TYPES.has(fnNode.type)`.
+ */
+function synthesizeCsharpReceiverBinding(fnNode) {
+    if (!FUNCTION_NODE_TYPES.has(fnNode.type))
+        return [];
+    if (isStaticMethod(fnNode))
+        return [];
+    const enclosingType = findEnclosingTypeDeclaration(fnNode);
+    if (enclosingType === null)
+        return [];
+    const enclosingName = typeName(enclosingType);
+    if (enclosingName === null)
+        return [];
+    // Anchor the synthesized captures to a node clearly *inside* the
+    // function's scope (not at the method's start position, which maps
+    // to the enclosing class scope via positionIndex). The method's
+    // `body` field is the block statement — its range is guaranteed to
+    // be inside the function scope. If the method has no body (interface
+    // declaration, `abstract`), skip — there's no function scope to
+    // attach the binding to.
+    const anchorNode = fnNode.childForFieldName('body');
+    if (anchorNode === null)
+        return [];
+    const out = [];
+    out.push(buildReceiverMatch(anchorNode, 'this', enclosingName));
+    // `base` applies only to class / record methods with an explicit
+    // base class. `struct` can't inherit a class; `interface` can't
+    // call `base.X`. The first entry of `base_list` is the base class
+    // (interfaces follow); we can't statically distinguish the two here,
+    // but `base.X` only compiles when the first entry IS a class, so we
+    // trust the source — if the user wrote `base.X` in a class with
+    // interface-only bases, their code wouldn't compile anyway.
+    if (enclosingType.type === 'class_declaration' || enclosingType.type === 'record_declaration') {
+        const baseText = firstBaseText(enclosingType);
+        if (baseText !== null) {
+            out.push(buildReceiverMatch(anchorNode, 'base', baseText));
+        }
+    }
+    return out;
+}
+function buildReceiverMatch(anchorNode, name, typeText) {
+    const m = {
+        '@type-binding.self': (0, ast_helpers_js_1.nodeToCapture)('@type-binding.self', anchorNode),
+        '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', anchorNode, name),
+        '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', anchorNode, typeText),
+    };
+    return m;
+}

package/dist/core/code/engine/core/ingestion/languages/csharp/resolution-config.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Per-workspace config for C# scope-resolution import targeting.
+ *
+ * Loaded once per analyze pass via `csharpScopeResolver.loadResolutionConfig`
+ * and threaded into `resolveCsharpImportTarget`. The pure gate predicates live
+ * in `../../csharp-namespace-gate.ts` (shared with the legacy DAG resolver).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCsharpResolutionConfig = loadCsharpResolutionConfig;
+const language_config_js_1 = require("../../language-config.js");
+async function loadCsharpResolutionConfig(repoRoot) {
+    const scan = await (0, language_config_js_1.scanCSharpProject)(repoRoot);
+    return {
+        csharpConfigs: scan.configs,
+        namespaces: (0, language_config_js_1.csharpScanToEvidence)(scan),
+    };
+}

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

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const qualified_type_names_js_1 = require("./qualified-type-names.js");
+const csharp_js_1 = require("../csharp.js");
+const index_js_2 = require("./index.js");
+const namespace_siblings_js_1 = require("./namespace-siblings.js");
+const resolution_config_js_1 = require("./resolution-config.js");
+const accessor_unwrap_js_1 = require("./accessor-unwrap.js");
+const csharpScopeResolver = {
+    // Construction is keyword-prefixed: `new Service(db).doWork()` (#2708).
+    constructionSyntax: { keyword: 'new' },
+    language: index_js_1.SupportedLanguages.CSharp,
+    languageProvider: csharp_js_1.csharpProvider,
+    importEdgeReason: 'csharp-scope: using',
+    loadResolutionConfig: (repoPath) => (0, resolution_config_js_1.loadCsharpResolutionConfig)(repoPath),
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
+        const config = resolutionConfig;
+        const ws = {
+            fromFile,
+            allFilePaths,
+            csharpConfigs: config?.csharpConfigs,
+            namespaces: config?.namespaces,
+        };
+        // `WorkspaceIndex` is an opaque `unknown` placeholder in the
+        // shared contract, so `ws` passes structurally without a cast.
+        return (0, index_js_2.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) => [...(0, index_js_2.csharpMergeBindings)([...existing, ...incoming])],
+    // Adapter: csharpArityCompatibility uses (def, callsite); the
+    // contract is (callsite, def).
+    arityCompatibility: (callsite, def) => (0, index_js_2.csharpArityCompatibility)(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize),
+    populateOwners: (parsed) => {
+        (0, walkers_js_1.populateClassOwnedMembers)(parsed);
+        // Sidecar-only namespace tagging (does NOT touch qualifiedName) so the
+        // qualified constructor resolver can break same-tail collisions like
+        // `new B.Foo()` by matching the explicit qualifier (#2046).
+        (0, qualified_type_names_js_1.populateCsharpNamespacePrefixes)(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: namespace_siblings_js_1.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.
+    elementTypeOf: accessor_unwrap_js_1.unwrapCsharpElementType,
+    // 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,
+    freeCallsRequireInstanceOwnership: 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,
+};
+exports.csharpScopeResolver = csharpScopeResolver;

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

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpBindingScopeFor = csharpBindingScopeFor;
+exports.csharpImportOwningScope = csharpImportOwningScope;
+exports.csharpReceiverBinding = csharpReceiverBinding;
+// ─── 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. */
+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. */
+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. */
+function csharpReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('this') ?? functionScope.typeBindings.get('base') ?? null;
+}

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

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * 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).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.csharpProvider = void 0;
+const index_js_1 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const csharp_js_1 = require("../class-extractors/configs/csharp.js");
+const language_provider_js_1 = require("../language-provider.js");
+const csharp_js_2 = require("../type-extractors/csharp.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const csharp_js_3 = require("../import-resolvers/configs/csharp.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const generic_js_2 = require("../call-extractors/generic.js");
+const csharp_js_4 = require("../call-extractors/configs/csharp.js");
+const generic_js_3 = require("../field-extractors/generic.js");
+const csharp_js_5 = require("../field-extractors/configs/csharp.js");
+const generic_js_4 = require("../method-extractors/generic.js");
+const csharp_js_6 = require("../method-extractors/configs/csharp.js");
+const generic_js_5 = require("../variable-extractors/generic.js");
+const csharp_js_7 = require("../variable-extractors/configs/csharp.js");
+const csharp_js_8 = require("../cfg/visitors/csharp.js");
+const index_js_2 = require("./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',
+]);
+exports.csharpProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.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: tree_sitter_queries_js_1.CSHARP_QUERIES,
+    typeConfig: csharp_js_2.typeConfig,
+    exportChecker: export_detection_js_1.csharpExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(csharp_js_3.csharpImportConfig),
+    mroStrategy: 'implements-split',
+    callExtractor: (0, generic_js_2.createCallExtractor)(csharp_js_4.csharpCallConfig),
+    fieldExtractor: (0, generic_js_3.createFieldExtractor)(csharp_js_5.csharpConfig),
+    methodExtractor: (0, generic_js_4.createMethodExtractor)(csharp_js_6.csharpMethodConfig),
+    variableExtractor: (0, generic_js_5.createVariableExtractor)(csharp_js_7.csharpVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(csharp_js_1.csharpClassConfig),
+    // ── XML doc comments (`///`) → description (issue #2270) ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)(),
+    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: index_js_2.emitCsharpScopeCaptures,
+    cfgVisitor: (0, csharp_js_8.createCsharpCfgVisitor)(),
+    interpretImport: index_js_2.interpretCsharpImport,
+    interpretTypeBinding: index_js_2.interpretCsharpTypeBinding,
+    bindingScopeFor: index_js_2.csharpBindingScopeFor,
+    importOwningScope: index_js_2.csharpImportOwningScope,
+    mergeBindings: (_scope, bindings) => (0, index_js_2.csharpMergeBindings)(bindings),
+    receiverBinding: index_js_2.csharpReceiverBinding,
+    arityCompatibility: index_js_2.csharpArityCompatibility,
+    resolveImportTarget: index_js_2.resolveCsharpImportTarget,
+});

package/dist/core/code/engine/core/ingestion/languages/dart/arity-metadata.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Compute arity metadata from a Dart function-like node, reusing
+ * `dartMethodConfig.extractParameters` so scope-extracted defs carry the
+ * same semantics as the legacy parse-worker path. Mirror of
+ * `languages/swift/arity-metadata.ts` (and C#'s `computeCsharpArityMetadata`).
+ *
+ * Dart has no variadic parameters, so `parameterCount` is always the param
+ * total and the required count falls out of the optional flag:
+ * `requiredParameterCount = total − optionalCount`, where a non-`required`
+ * named param or an optional positional (`[...]`) param is optional.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeDartArityMetadata = computeDartArityMetadata;
+const dart_js_1 = require("../../method-extractors/configs/dart.js");
+/**
+ * `fnNode` is the declaration WRAPPER node (`method_signature` /
+ * `declaration` / a top-level `function_signature` / `constructor_signature`).
+ * `dartMethodConfig.extractParameters` descends to the inner signature
+ * internally, so the wrapper is the correct node to pass.
+ */
+function computeDartArityMetadata(fnNode) {
+    const params = dart_js_1.dartMethodConfig.extractParameters?.(fnNode) ?? [];
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isOptional)
+            optionalCount++;
+        if (p.type !== null)
+            types.push(p.type);
+    }
+    const total = params.length;
+    return {
+        parameterCount: total,
+        requiredParameterCount: total - optionalCount,
+        parameterTypes: types.length > 0 ? types : undefined,
+    };
+}

package/dist/core/code/engine/core/ingestion/languages/dart/arity.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Dart arity compatibility (count-primary, labels soft) — mirror of
+ * `languages/swift/arity.ts`.
+ *
+ * Dart parameters come in four flavours: required positional, optional
+ * positional (`[...]`), named (`{...}`), and required-named
+ * (`{required ...}`). `dartMethodConfig.extractParameters` collapses these
+ * into `isOptional` (a non-`required` named/optional-positional param is
+ * optional), which `computeDartArityMetadata` turns into
+ * `requiredParameterCount = total − optionalCount`. Named arguments are
+ * unordered and matched on COUNT only here — label-precise dispatch is left
+ * to the type-binding layer (Swift's documented "labels soft" decision).
+ * Dart has no variadic parameters, so the max bound always applies.
+ *
+ * NOTE arg order: `(def, callsite)` — matches the `LanguageProvider` hook.
+ * The `ScopeResolver` wires an adapter that flips the order to `(callsite, def)`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dartArityCompatibility = dartArityCompatibility;
+function dartArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (argCount === undefined || !Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/code/engine/core/ingestion/languages/dart/built-ins.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Dart built-in / framework names whose calls the legacy DAG suppresses
+ * (Flutter / Dart-SDK members not part of the indexed workspace). The
+ * registry-primary capture walk skips emitting call references for these so
+ * its CALLS graph matches the legacy DAG — which suppresses built-in-named
+ * calls via `isBuiltInName` BEFORE resolution, for both free and member calls.
+ *
+ * Leaf module: shared by the provider (`builtInNames`) and `captures.ts`
+ * without an import cycle (`dart.ts` → `dart/index.ts` → `captures.ts`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DART_BUILT_INS = void 0;
+exports.DART_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',
+]);

package/dist/core/code/engine/core/ingestion/languages/dart/cache-stats.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Dev-mode (`PROF_SCOPE_RESOLUTION=1`) cache hit/miss counters for the
+ * cross-phase scope-captures parse cache. A module-level `PROF` const folds
+ * increments to dead code in production so `captures.ts` stays branch-free.
+ * Mirror of `languages/swift/cache-stats.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordCacheHit = recordCacheHit;
+exports.recordCacheMiss = recordCacheMiss;
+exports.getDartCaptureCacheStats = getDartCaptureCacheStats;
+exports.resetDartCaptureCacheStats = resetDartCaptureCacheStats;
+const PROF = process.env.PROF_SCOPE_RESOLUTION === '1';
+let CACHE_HITS = 0;
+let CACHE_MISSES = 0;
+function recordCacheHit() {
+    if (PROF)
+        CACHE_HITS++;
+}
+function recordCacheMiss() {
+    if (PROF)
+        CACHE_MISSES++;
+}
+function getDartCaptureCacheStats() {
+    return { hits: CACHE_HITS, misses: CACHE_MISSES };
+}
+function resetDartCaptureCacheStats() {
+    CACHE_HITS = 0;
+    CACHE_MISSES = 0;
+}