@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/real-dart-analyzer-7LZ5LCMW.js

@@ -0,0 +1,3944 @@
+import {
+  ASTEngine
+} from "./chunk-V44PGPA6.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import {
+  BINDING_SEP
+} from "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-dart-analyzer.ts
+import * as path from "path";
+import { existsSync, readFileSync, readdirSync } from "fs";
+var DART_CITATION_ROOTS = /* @__PURE__ */ new Set([
+  "override",
+  "deprecated",
+  "Deprecated",
+  "pragma",
+  "deprecated_member_use",
+  "mustCallSuper",
+  "protected",
+  "required",
+  "immutable",
+  "factory",
+  "optionalTypeArgs",
+  "visibleForTesting",
+  "visibleForOverriding",
+  "doNotStore",
+  "doNotSubmit",
+  "mustBeOverridden",
+  "redeclare",
+  "nonVirtual",
+  "recordUse",
+  "target",
+  "Target",
+  "Metadata",
+  "Object",
+  "String",
+  "int",
+  "double",
+  "bool",
+  "List",
+  "Map",
+  "Set",
+  "Future",
+  "FutureOr",
+  "Stream",
+  "Function",
+  "Iterable",
+  "Duration",
+  "DateTime",
+  "Exception",
+  "Error",
+  "StackTrace",
+  "RegExp",
+  "Uri",
+  "BigInt",
+  "Symbol",
+  "Type",
+  "Null",
+  "Never",
+  "void",
+  "dynamic",
+  "print",
+  "identical",
+  "identityHashCode"
+]);
+var DART_CITATION_TYPE_SHAPED_LABELS = /* @__PURE__ */ new Set([
+  "calls",
+  "uses",
+  "instantiates",
+  "extends",
+  "implements",
+  "overrides",
+  "mixes_in",
+  "part_of",
+  // `renders` names a CLASS (the component a `build` method returns), so its target is a
+  // type-shaped claim exactly like `extends`/`implements` are.
+  "renders"
+]);
+function stripWhitespace(text) {
+  let out = "";
+  for (let i = 0; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    const ws = c === 32 || c === 9 || c === 10 || c === 13 || c === 11 || c === 12 || c >= 160 && (c === 160 || c === 5760 || c >= 8192 && c <= 8202 || c === 8232 || c === 8233 || c === 8239 || c === 8287 || c === 12288 || c === 65279);
+    if (!ws) out += text[i];
+  }
+  return out;
+}
+function isDottedIdentifier(s) {
+  const identStart = (c) => c >= 97 && c <= 122 || c >= 65 && c <= 90 || c === 95 || c === 36;
+  const identPart = (c) => c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 95 || c === 36;
+  if (s.length === 0 || !identStart(s.charCodeAt(0))) return false;
+  let prevDot = false;
+  for (let i = 1; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 46) {
+      if (prevDot) return false;
+      prevDot = true;
+      continue;
+    }
+    if (!identPart(c)) return false;
+    prevDot = false;
+  }
+  return !prevDot;
+}
+function isPlainIdentifier(s) {
+  if (s.length === 0) return false;
+  const start = s.charCodeAt(0);
+  if (!(start >= 97 && start <= 122 || start >= 65 && start <= 90 || start === 95 || start === 36)) return false;
+  for (let i = 1; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (!(c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 95 || c === 36)) return false;
+  }
+  return true;
+}
+function stripNullableSuffix(text) {
+  let end = text.length;
+  while (end > 0 && text.charCodeAt(end - 1) === 63) end--;
+  return end === text.length ? text : text.slice(0, end);
+}
+function typeNameWithoutArguments(text) {
+  const lt = text.indexOf("<");
+  if (lt <= 0) return text;
+  if (text.charCodeAt(text.length - 1) !== 62) return text;
+  let depth = 0;
+  for (let i = lt; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    if (c === 60) depth++;
+    else if (c === 62) {
+      depth--;
+      if (depth === 0 && i !== text.length - 1) return text;
+    }
+  }
+  if (depth !== 0) return text;
+  const head = text.slice(0, lt);
+  return isPlainIdentifier(head) ? head : text;
+}
+function unquote(text) {
+  if (text.length >= 2) {
+    const first = text[0];
+    if ((first === '"' || first === "'") && text[text.length - 1] === first) {
+      return text.slice(1, -1);
+    }
+  }
+  return text;
+}
+function stripCommentMarkers(text) {
+  if (text.startsWith("///")) return text.slice(3).trimStart();
+  if (text.startsWith("//")) return text.slice(2).trimStart();
+  if (text.startsWith("/*")) {
+    const end = text.endsWith("*/") ? text.length - 2 : text.length;
+    return text.slice(2, end).trim();
+  }
+  return text.trim();
+}
+function isCapitalized(text) {
+  if (text.length === 0) return false;
+  const code = text.charCodeAt(0);
+  return code >= 65 && code <= 90;
+}
+var IMPLICIT_DYNAMIC_TYPE = "dynamic";
+var DART_UNNAMED_EXTENSION = "unnamed_extension";
+var DART_TYPE_MENTION_DOUBLE_COUNTED = /* @__PURE__ */ new Set([
+  // heritage — `extends` / `implements` / `with` (extractClassHeritage)
+  "superclass",
+  "interfaces",
+  "mixins",
+  // a mixin `on`-base is an `extends` edge (DARTD14), and a mixin-application
+  // class publishes its base and its with-list through the same extractor
+  "mixin_declaration",
+  "mixin_application",
+  // construction is `instantiates`
+  "new_expression",
+  "const_object_expression",
+  "constructor_invocation",
+  "redirecting_factory_constructor_signature",
+  // `class Box<T>` DECLARES a type variable; it does not mention a type
+  "type_parameter",
+  // parse damage: not a fact about a well-formed program
+  "ERROR"
+]);
+var R7_PLACEHOLDER_NAME = "unknown";
+var DART_OBJECT_TYPE = "Object";
+var DART_OBJECT_INTERFACE_MEMBERS = /* @__PURE__ */ new Set([
+  "toString",
+  "hashCode",
+  "runtimeType",
+  "noSuchMethod",
+  "operator =="
+]);
+function scopeOwnerName(scopes) {
+  for (let i = scopes.length - 1; i >= 0; i--) {
+    if (scopes[i].kind === "class" /* Class */) return scopes[i].name;
+  }
+  return void 0;
+}
+function scopeString(scopes) {
+  const parts = [];
+  for (let i = 1; i < scopes.length; i++) {
+    const s = scopes[i];
+    if (s.kind !== "global" /* Global */) parts.push(s.name);
+  }
+  return parts.join(".");
+}
+var DARt_COMPANION_CACHE = /* @__PURE__ */ new WeakMap();
+function dartCompanionFor(projectIndex) {
+  if (!projectIndex?.typeMembers) return void 0;
+  const key = projectIndex;
+  const hit = DARt_COMPANION_CACHE.get(key);
+  if (hit) return hit;
+  const out = /* @__PURE__ */ new Map();
+  const closure = (t, seen) => {
+    const cached = out.get(t);
+    if (cached) return cached;
+    if (seen.has(t)) return /* @__PURE__ */ new Set();
+    seen.add(t);
+    const members = new Set(projectIndex.typeMembers.get(t) ?? []);
+    for (const b of projectIndex.typeBases?.get(t) ?? []) for (const m of closure(b, seen)) members.add(m);
+    out.set(t, members);
+    return members;
+  };
+  for (const t of projectIndex.typeKinds?.keys() ?? []) closure(t, /* @__PURE__ */ new Set());
+  DARt_COMPANION_CACHE.set(key, out);
+  return out;
+}
+var DART_PROJECT_ROOT_CACHE = /* @__PURE__ */ new Map();
+var DART_PROJECT_FACTS_CACHE = /* @__PURE__ */ new Map();
+var DART_WALK_SKIP = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  ".dart_tool",
+  ".symlinks",
+  "build",
+  "coverage",
+  ".pub-cache",
+  "out"
+]);
+function dartProjectRootOf(filePath) {
+  const start = path.dirname(path.resolve(filePath));
+  const seen = [];
+  let dir = start;
+  for (let i = 0; i < 64; i++) {
+    const cached = DART_PROJECT_ROOT_CACHE.get(dir);
+    if (cached !== void 0) {
+      for (const d of seen) DART_PROJECT_ROOT_CACHE.set(d, cached);
+      return cached;
+    }
+    seen.push(dir);
+    if (existsSync(path.join(dir, ".git"))) {
+      if (DART_PROJECT_ROOT_CACHE.size > 2e4) DART_PROJECT_ROOT_CACHE.clear();
+      for (const d of seen) DART_PROJECT_ROOT_CACHE.set(d, dir);
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (DART_PROJECT_ROOT_CACHE.size > 2e4) DART_PROJECT_ROOT_CACHE.clear();
+  for (const d of seen) DART_PROJECT_ROOT_CACHE.set(d, null);
+  return null;
+}
+function isDartLibraryName(text) {
+  if (text.length === 0) return false;
+  const first = text.charCodeAt(0);
+  if (first < 97 || first > 122) return false;
+  for (let i = 1; i < text.length; i++) {
+    const c = text.charCodeAt(i);
+    const ok = c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 95;
+    if (!ok) return false;
+  }
+  return true;
+}
+function dartPubspecName(file) {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  let lineStart = 0;
+  for (let i = 0; i <= text.length; i++) {
+    if (i < text.length && text.charCodeAt(i) !== 10) continue;
+    const line = text.slice(lineStart, i);
+    lineStart = i + 1;
+    if (!line.startsWith("name:")) continue;
+    let v = 5;
+    while (v < line.length && (line.charCodeAt(v) === 32 || line.charCodeAt(v) === 9)) v++;
+    let end = v;
+    while (end < line.length) {
+      const c = line.charCodeAt(end);
+      if (c === 32 || c === 9 || c === 13 || c === 35) break;
+      end++;
+    }
+    const value = line.slice(v, end);
+    return isDartLibraryName(value) ? value : null;
+  }
+  return null;
+}
+function dartProjectFacts(projectRoot) {
+  const hit = DART_PROJECT_FACTS_CACHE.get(projectRoot);
+  if (hit) return hit;
+  const facts = {
+    packageRoots: /* @__PURE__ */ new Map(),
+    sdkLib: existsSync(path.join(projectRoot, "sdk", "lib")),
+    dartLibs: /* @__PURE__ */ new Map()
+  };
+  const stack = [projectRoot];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (DART_WALK_SKIP.has(entry.name)) continue;
+        stack.push(path.join(dir, entry.name));
+        continue;
+      }
+      if (entry.name !== "pubspec.yaml" || !entry.isFile()) continue;
+      const name = dartPubspecName(path.join(dir, entry.name));
+      if (name === null || facts.packageRoots.has(name)) continue;
+      const rel = path.relative(projectRoot, dir);
+      facts.packageRoots.set(name, rel.split(path.sep).join("/"));
+    }
+  }
+  if (DART_PROJECT_FACTS_CACHE.size >= 64) DART_PROJECT_FACTS_CACHE.clear();
+  DART_PROJECT_FACTS_CACHE.set(projectRoot, facts);
+  return facts;
+}
+function dartRepoRelPath(projectRoot, absPath) {
+  const rel = path.relative(projectRoot, path.resolve(absPath));
+  if (rel.length === 0 || path.isAbsolute(rel)) return null;
+  if (rel === ".." || rel.startsWith(`..${path.sep}`)) return null;
+  return rel.split(path.sep).join("/");
+}
+function dartJoinInside(baseRel, tail) {
+  const base = baseRel.length === 0 ? "" : `${baseRel}/`;
+  const norm = path.posix.normalize(`${base}${tail}`);
+  if (norm.length === 0 || norm === "." || norm === ".." || norm.startsWith("../")) return null;
+  return norm;
+}
+function dartImportTargetPath(projectRoot, filePath, uri) {
+  if (uri.length === 0) return null;
+  if (uri.startsWith("package:")) {
+    const rest = uri.slice(8);
+    const slash = rest.indexOf("/");
+    if (slash <= 0 || slash === rest.length - 1) return null;
+    const pkg = rest.slice(0, slash);
+    const sub = rest.slice(slash + 1);
+    if (!isDartLibraryName(pkg)) return null;
+    const packageRoot = dartProjectFacts(projectRoot).packageRoots.get(pkg);
+    if (packageRoot === void 0) return null;
+    return dartJoinInside(packageRoot, `lib/${sub}`);
+  }
+  if (uri.startsWith("dart:")) {
+    const lib = uri.slice(5);
+    if (!isDartLibraryName(lib)) return null;
+    const facts = dartProjectFacts(projectRoot);
+    if (!facts.sdkLib) return null;
+    const cached = facts.dartLibs.get(lib);
+    if (cached !== void 0) return cached;
+    const rel = `sdk/lib/${lib}/${lib}.dart`;
+    const found = existsSync(path.join(projectRoot, rel)) ? rel : null;
+    facts.dartLibs.set(lib, found);
+    return found;
+  }
+  if (uri.indexOf(":") >= 0) return null;
+  const abs = path.resolve(path.dirname(path.resolve(filePath)), uri);
+  return dartRepoRelPath(projectRoot, abs);
+}
+function isCapitalisedIdentifier(name) {
+  if (name.length === 0) return false;
+  const first = name.charCodeAt(0);
+  if (first < 65 || first > 90) return false;
+  for (let i = 1; i < name.length; i++) {
+    const c = name.charCodeAt(i);
+    if (c >= 65 && c <= 90) continue;
+    if (c >= 97 && c <= 122) continue;
+    if (c >= 48 && c <= 57) continue;
+    if (c === 95 || c === 36) continue;
+    return false;
+  }
+  return true;
+}
+var RealDartAnalyzer = class _RealDartAnalyzer {
+  analyze(rootNode, content, filePath, context) {
+    this.scopeDeclIndex.clear();
+    this.methodComplexityCache.clear();
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const errors = [];
+    const frameworks = { Dart: true };
+    const patterns = {};
+    const scopes = [{ name: "__global__", kind: "global" /* Global */ }];
+    const library = this.libraryName(rootNode, filePath);
+    const moduleName = library.name;
+    const projectRoot = dartProjectRootOf(filePath);
+    const librarySite = {
+      moduleName,
+      filePath,
+      projectRoot,
+      moduleIdentity: projectRoot === null ? null : dartRepoRelPath(projectRoot, filePath)
+    };
+    symbols.push({
+      name: moduleName,
+      kind: ASTEngine.SymbolKind.Module,
+      // THE LIBRARY'S URI. Strategy 1 of the shared resolver matches `qualified_name` exactly,
+      // so publishing the path here is what lets an import edge name this file. Unset when the
+      // file is not inside a checkout: then the engine's own synthesis (`<scope>.<name>`) is
+      // what it always was, and the edges keep their specifier targets (see LIBRARY IDENTITY).
+      ...librarySite.moduleIdentity === null ? {} : { qualifiedName: librarySite.moduleIdentity },
+      range: library.directive ? this.nodeToRange(library.directive) : { startLine: 1, startColumn: 1, endLine: 1, endColumn: 1, startIndex: 0, endIndex: 0 },
+      visibility: "public",
+      scope: moduleName,
+      metadata: { nodeType: library.directive ? library.directive.type : "implicit_library" }
+    });
+    if (rootNode.hasError) {
+      const errStack = [rootNode];
+      while (errStack.length > 0) {
+        const n = errStack.pop();
+        if (n.type === "ERROR" || n.isMissing) {
+          errors.push({
+            message: `Syntax ${n.type} detected. The Brain Engine is bypassing this broken node.`,
+            range: this.nodeToRange(n),
+            severity: "warning"
+          });
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) errStack.push(child);
+        }
+      }
+    }
+    const stack = [{ node: rootNode, scopes, functionDepth: 0 }];
+    let cyclomaticComplexity = 1;
+    const seenMembers = /* @__PURE__ */ new Map();
+    const nameLines = /* @__PURE__ */ new Map();
+    while (stack.length > 0) {
+      const { node, scopes: frameScopes, functionDepth } = stack.pop();
+      const scopeStack = [...frameScopes];
+      let nextFunctionDepth = functionDepth;
+      const t = node.type;
+      if (t === "if_statement" || t === "for_statement" || t === "while_statement" || t === "do_statement" || t === "switch_statement_case" || t === "switch_expression_case" || t === "catch_clause" || t === "conditional_expression" || t === "logical_and_expression" || t === "logical_or_expression") {
+        cyclomaticComplexity++;
+      }
+      switch (t) {
+        case "class_definition": {
+          const name = node.childForFieldName("name")?.text || (this.findChildByType(node, "mixin_application_class") ? this.findDescendantByType(node, "identifier")?.text : void 0);
+          if (name) {
+            const comments = this.collectComments(node);
+            const isSealed = this.hasModifier(node, "sealed");
+            const isBase = this.hasModifier(node, "base");
+            const isInterfaceClass = this.hasModifier(node, "interface");
+            const isFinalClass = this.hasModifier(node, "final");
+            const isAbstract = this.hasModifier(node, "abstract") || isSealed;
+            symbols.push({
+              name,
+              kind: ASTEngine.SymbolKind.Class,
+              range: this.nodeToRange(node),
+              scope: scopeString(scopeStack),
+              visibility: name.startsWith("_") ? "private" : "public",
+              comments,
+              isAbstract,
+              genericParameters: this.extractTypeParameters(node),
+              metadata: { isClass: true, isAbstract, isSealed, isBase, isInterfaceClass, isFinalClass }
+            });
+            scopeStack.push({ name, kind: "class" /* Class */ });
+            this.extractClassHeritage(node, name, relationships, patterns);
+            this.extractRenderRelationships(node, name, relationships);
+          }
+          break;
+        }
+        case "mixin_declaration": {
+          const name = node.childForFieldName("name")?.text || this.findChildByType(node, "identifier")?.text;
+          if (name) {
+            const comments = this.collectComments(node);
+            patterns["Mixins"] = true;
+            symbols.push({
+              name,
+              kind: ASTEngine.SymbolKind.Mixin,
+              range: this.nodeToRange(node),
+              scope: scopeString(scopeStack),
+              visibility: name.startsWith("_") ? "private" : "public",
+              comments,
+              metadata: { isMixin: true }
+            });
+            scopeStack.push({ name, kind: "class" /* Class */ });
+            this.extractClassHeritage(node, name, relationships, patterns);
+          }
+          break;
+        }
+        case "extension_declaration": {
+          const targetType = this.extensionTargetType(node);
+          const name = this.extensionPublishedName(node);
+          if (name) {
+            const comments = this.collectComments(node);
+            patterns["Extensions"] = true;
+            symbols.push({
+              name,
+              kind: ASTEngine.SymbolKind.Extension,
+              range: this.nodeToRange(node),
+              scope: scopeString(scopeStack),
+              visibility: name.startsWith("_") ? "private" : "public",
+              comments,
+              metadata: { isExtension: true, targetType, isUnnamedExtension: !node.childForFieldName("name") }
+            });
+            scopeStack.push({ name, kind: "class" /* Class */ });
+          }
+          break;
+        }
+        case "extension_type_declaration": {
+          const name = node.childForFieldName("name")?.text;
+          if (name) {
+            const comments = this.collectComments(node);
+            const rep = this.findChildByType(node, "representation_declaration");
+            const repType = this.representationTypeName(rep);
+            patterns["Extensions"] = true;
+            symbols.push({
+              name,
+              kind: ASTEngine.SymbolKind.Extension,
+              range: this.nodeToRange(node),
+              scope: scopeString(scopeStack),
+              visibility: name.startsWith("_") ? "private" : "public",
+              comments,
+              metadata: { isExtension: true, isExtensionType: true, representationType: repType }
+            });
+            scopeStack.push({ name, kind: "class" /* Class */ });
+            const repName = rep?.childForFieldName("name")?.text;
+            if (rep && repName && repName !== "_") {
+              const repRange = this.nodeToRange(rep);
+              const repNameNode = rep.childForFieldName("name");
+              if (repNameNode) nameLines.set(dartNameLineKey(repName, repRange), this.nodeLine(repNameNode));
+              symbols.push({
+                name: repName,
+                kind: ASTEngine.SymbolKind.Property,
+                range: repRange,
+                scope: name,
+                ownerName: name,
+                ownerKind: ASTEngine.SymbolKind.Extension,
+                visibility: repName.startsWith("_") ? "private" : "public",
+                metadata: { isRepresentationField: true, dataType: repType }
+              });
+            }
+            this.extractClassHeritage(node, name, relationships, patterns);
+          }
+          break;
+        }
+        case "enum_declaration": {
+          const name = node.childForFieldName("name")?.text;
+          if (name) {
+            const comments = this.collectComments(node);
+            symbols.push({
+              name,
+              kind: ASTEngine.SymbolKind.Enum,
+              range: this.nodeToRange(node),
+              scope: scopeString(scopeStack),
+              visibility: name.startsWith("_") ? "private" : "public",
+              comments,
+              metadata: { isEnum: true }
+            });
+            const body = this.findChildByType(node, "enum_body");
+            if (body) {
+              for (let i = 0; i < body.namedChildCount; i++) {
+                const c = body.namedChild(i);
+                if (c && c.type === "enum_constant") {
+                  const mname = c.childForFieldName("name")?.text;
+                  if (mname) {
+                    symbols.push({
+                      name: mname,
+                      kind: ASTEngine.SymbolKind.EnumMember,
+                      range: this.nodeToRange(c),
+                      scope: name,
+                      ownerName: name,
+                      ownerKind: ASTEngine.SymbolKind.Enum,
+                      visibility: mname.startsWith("_") ? "private" : "public",
+                      metadata: { isEnumMember: true }
+                    });
+                  }
+                }
+              }
+            }
+            this.extractClassHeritage(node, name, relationships, patterns);
+            scopeStack.push({ name, kind: "class" /* Class */ });
+          }
+          break;
+        }
+        case "type_alias": {
+          const nameNode = node.childForFieldName("name") || this.findChildByType(node, "type_identifier");
+          const name = nameNode?.text;
+          if (name && name !== "Function") {
+            const comments = this.collectComments(node);
+            symbols.push({
+              name,
+              kind: ASTEngine.SymbolKind.TypeAlias,
+              range: this.nodeToRange(node),
+              scope: scopeString(scopeStack),
+              visibility: name.startsWith("_") ? "private" : "public",
+              comments,
+              metadata: { isTypeAlias: true }
+            });
+          }
+          break;
+        }
+        case "declaration": {
+          const sig = this.findSignatureIn(node);
+          if (sig) {
+            if (this.isConstructorSignature(sig.type)) {
+              const owner = scopeOwnerName(scopeStack);
+              if (owner && this.isRealConstructor(sig, owner)) {
+                this.processConstructor(node, sig, owner, symbols, relationships, patterns);
+              } else if (owner) {
+                this.processFunctionOrMethod(node, sig, symbols, scopeStack, patterns, seenMembers, nameLines);
+              }
+            } else {
+              this.processFunctionOrMethod(node, sig, symbols, scopeStack, patterns, seenMembers, nameLines);
+            }
+          } else {
+            this.processFieldOrVariable(node, symbols, scopeStack, nameLines);
+          }
+          break;
+        }
+        case "method_signature":
+        case "function_signature":
+        case "getter_signature":
+        case "setter_signature":
+        case "function_declaration": {
+          if (node.parent?.type === "declaration") break;
+          if (node.parent?.type === "method_signature") break;
+          if (t === "function_signature" && node.parent?.type === "lambda_expression") break;
+          const owner = scopeOwnerName(scopeStack);
+          const inner = this.findInnerSignature(node);
+          if (owner && this.isConstructorSignature(inner.type) && this.isRealConstructor(inner, owner)) {
+            this.processConstructor(node, inner, owner, symbols, relationships, patterns);
+          } else if (owner || t === "function_declaration") {
+            this.processFunctionOrMethod(node, node, symbols, scopeStack, patterns, seenMembers, nameLines);
+          } else if (t === "function_signature" || t === "getter_signature" || t === "setter_signature") {
+            this.processTopLevelFunction(node, symbols, scopeStack, patterns, nameLines, seenMembers);
+          }
+          break;
+        }
+        case "constructor_signature":
+        case "factory_constructor_signature":
+        case "constant_constructor_signature":
+        case "redirecting_factory_constructor_signature": {
+          const ptype = node.parent?.type;
+          if (ptype === "declaration" || ptype === "method_signature") break;
+          const owner = scopeOwnerName(scopeStack);
+          if (owner && this.isRealConstructor(node, owner)) {
+            this.processConstructor(node, node, owner, symbols, relationships, patterns);
+          } else if (owner) {
+            this.processFunctionOrMethod(node, node, symbols, scopeStack, patterns, seenMembers, nameLines);
+          }
+          break;
+        }
+        case "initialized_identifier_list":
+        case "static_final_declaration_list": {
+          const parent = node.parent;
+          if (parent && parent.type === "program") {
+            this.processTopLevelVariables(node, symbols, scopeStack, nameLines);
+          }
+          break;
+        }
+        case "import_specification":
+        case "library_export":
+        case "part_directive":
+        case "part_of_directive": {
+          this.processImportExport(node, imports, exports, frameworks, relationships, librarySite);
+          break;
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) {
+          stack.push({ node: child, scopes: scopeStack, functionDepth: nextFunctionDepth });
+        }
+      }
+    }
+    this.addContainmentRelationships(symbols, relationships, nameLines);
+    this.extractOverrideRelationships(symbols, relationships, context?.overrideCompanion, nameLines, context?.projectIndex);
+    this.extractExpressionRelationships(rootNode, relationships, moduleName, symbols, context?.projectIndex);
+    {
+      const seenRel = /* @__PURE__ */ new Set();
+      const uniq = [];
+      for (const r of relationships) {
+        if (r.source === R7_PLACEHOLDER_NAME || r.target === R7_PLACEHOLDER_NAME || r.from === R7_PLACEHOLDER_NAME || r.to === R7_PLACEHOLDER_NAME) continue;
+        const key = `${r.type}|${r.source}|${r.target}|${r.confidence}`;
+        const scope = r.metadata?.localBindingScope;
+        const dedupKey = scope !== void 0 && scope !== null ? `${key}|${scope}` : key;
+        if (seenRel.has(dedupKey)) continue;
+        seenRel.add(dedupKey);
+        uniq.push(r);
+      }
+      relationships.splice(0, relationships.length, ...uniq);
+    }
+    this.classifyEvidenceTier(relationships);
+    {
+      const fieldTypeByClass = /* @__PURE__ */ new Map();
+      for (const s of symbols) {
+        if ((s.metadata ?? {}).isField && s.ownerName) {
+          const dt = s.metadata.dataType;
+          if (dt) fieldTypeByClass.set(`${s.ownerName}.${s.name}`, dt);
+        }
+      }
+      for (const s of symbols) {
+        if (s.kind === ASTEngine.SymbolKind.Constructor && s.ownerName) {
+          for (const p of s.parameters ?? []) {
+            if (p.type === IMPLICIT_DYNAMIC_TYPE) {
+              const ft = fieldTypeByClass.get(`${s.ownerName}.${p.name}`);
+              if (ft) p.type = ft;
+            }
+          }
+        }
+      }
+    }
+    const architecturalScore = Math.min(100, Math.max(0, 100 - errors.length * 5));
+    const detectedPatterns = Object.keys(patterns);
+    const detectedFrameworks = Object.keys(frameworks);
+    const frameworkPatterns = detectedPatterns.map((p) => ({
+      framework: "Dart",
+      patterns: [{ type: "usage", detected: true, description: p }]
+    }));
+    if (process.env.BB_DART_CITATION === "1") {
+      for (const r of relationships) {
+        const t = String(r.target ?? "");
+        if (!DART_CITATION_ROOTS.has(t)) continue;
+        const md = r.metadata ?? {};
+        const isAnnotation = md.isAnnotation === true;
+        const label = String(r.type);
+        const typeShaped = DART_CITATION_TYPE_SHAPED_LABELS.has(label) && isCapitalisedIdentifier(t);
+        if (!isAnnotation && !typeShaped) continue;
+        md.languageNamespace = [t];
+        md.languageNamespacePolicy = "strict-absent";
+        r.metadata = md;
+      }
+    }
+    for (let i = relationships.length - 1; i >= 0; i--) {
+      const r = relationships[i];
+      const target = String(r.target ?? "");
+      const source = String(r.source ?? "");
+      if (target.length === 0 || source.length === 0) relationships.splice(i, 1);
+    }
+    return {
+      language: "dart",
+      symbols,
+      relationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        complexity: symbols.length + relationships.length,
+        linesOfCode: content.split("\n").length,
+        cyclomaticComplexity,
+        framework: detectedFrameworks.length > 1 ? detectedFrameworks[1] : detectedFrameworks[0],
+        patterns: detectedPatterns,
+        detectedFrameworks,
+        frameworkPatterns,
+        architecturalInsights: [],
+        architecturalScore,
+        codeQuality: errors.length === 0 ? "Excellent" : "Fair",
+        hasTypeInference: true,
+        hasFrameworkIntelligence: true,
+        analysisVersion: "4.0.0-m12.11-family-contract"
+      }
+    };
+  }
+  // ============================================================================
+  // SYMBOL PROCESSORS
+  // ============================================================================
+  processConstructor(node, sig, owner, symbols, relationships, patterns) {
+    const isFactory = sig.type === "factory_constructor_signature" || sig.type === "redirecting_factory_constructor_signature";
+    const isConst = sig.type === "constant_constructor_signature";
+    if (isFactory) patterns["Factory"] = true;
+    let isNamed = false;
+    let namedSegment;
+    const directIds = this.directIdentifiers(sig);
+    const named = directIds.find((id) => id !== owner);
+    if (named) {
+      isNamed = true;
+      namedSegment = named;
+    }
+    const params = this.extractParameters(sig);
+    const comments = this.collectComments(node);
+    const annotations = this.extractAnnotations(node);
+    symbols.push({
+      name: "constructor",
+      kind: ASTEngine.SymbolKind.Constructor,
+      range: this.nodeToRange(node),
+      scope: owner,
+      ownerName: owner,
+      ownerKind: ASTEngine.SymbolKind.Class,
+      visibility: "public",
+      parameters: params,
+      comments,
+      decorators: annotations,
+      metadata: { isFactory, isConst, isNamed, namedSegment, isConstructor: true }
+    });
+    if (isFactory && sig.type === "redirecting_factory_constructor_signature") {
+      const parts = [];
+      const partNodes = [];
+      let pastEquals = false;
+      for (let i = 0; i < sig.childCount; i++) {
+        const c = sig.child(i);
+        if (!c) continue;
+        if (!pastEquals) {
+          if (!c.isNamed && c.type === "=") pastEquals = true;
+          continue;
+        }
+        if (c.isNamed && (c.type === "type_identifier" || c.type === "identifier")) {
+          parts.push(c.text);
+          partNodes.push(c);
+        }
+      }
+      const redirectTarget = parts.length <= 1 ? parts[0] : parts[parts.length - 2];
+      const redirectNode = partNodes.length <= 1 ? partNodes[0] : partNodes[partNodes.length - 2];
+      if (redirectTarget) {
+        relationships.push({
+          source: owner,
+          target: redirectTarget,
+          type: ASTEngine.RelationshipType.Instantiates,
+          confidence: 0.95,
+          line_number: this.nodeLine(redirectNode),
+          metadata: { isFactoryRedirection: true }
+        });
+      }
+    }
+  }
+  processFunctionOrMethod(node, sig, symbols, scopeStack, patterns, seenMembers, nameLines) {
+    const inner = this.findInnerSignature(sig);
+    const nameNode = this.signatureNameNode(inner);
+    const name = this.signatureName(inner);
+    if (!name) return;
+    const owner = scopeOwnerName(scopeStack);
+    const isGetter0 = inner.type === "getter_signature";
+    const isSetter0 = inner.type === "setter_signature";
+    const dedupKey = `${owner ?? "module"}:${name}:${isGetter0 ? "get" : isSetter0 ? "set" : "fn"}`;
+    const isGetter = isGetter0;
+    const isSetter = isSetter0;
+    if (isGetter || isSetter) patterns["Getters and Setters"] = true;
+    const params = this.extractParameters(inner);
+    const returnType = this.extractReturnType(inner);
+    const isAsync = this.isAsyncSignature(node, inner);
+    const isStatic = this.hasModifier(node, "static") || this.hasModifier(inner, "static");
+    const isAbstract = !this.hasBody(node) && (this.hasModifier(node, "abstract") || owner !== void 0);
+    const comments = this.collectComments(node);
+    const annotations = this.extractAnnotations(node);
+    if (isAsync || returnType && returnType.startsWith("Future")) patterns["Async Programming"] = true;
+    const kind = isGetter || isSetter ? ASTEngine.SymbolKind.Property : owner ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function;
+    const symbol = {
+      name,
+      kind,
+      range: this.rangeIncludingBody(node, inner),
+      scope: scopeString(scopeStack),
+      ownerName: owner,
+      ownerKind: owner ? scopeOwnerKind(scopeStack) : void 0,
+      visibility: name.startsWith("_") ? "private" : "public",
+      parameters: params,
+      returnType,
+      comments,
+      decorators: annotations,
+      isStatic,
+      isAsync,
+      isAbstract,
+      complexity: this.methodComplexity(node),
+      metadata: { isGetter, isSetter, isStatic, isAsync, isAbstract, hasBody: this.hasBody(node) }
+    };
+    if (!this.registerCallable(symbols, seenMembers, dedupKey, symbol, nameLines, nameNode)) return;
+    scopeStack.push({ name, kind: "function" /* Function */ });
+  }
+  /**
+   * One symbol per (scope,name,kind), LAST declaration wins (DARTD20 — the
+   * family dup-key ruling; #753). Both producers of callable symbols use this:
+   * a duplicate is a compile error in Dart, so the analyzer's answer for the
+   * shape is a deterministic contract, and the family's (settled by python
+   * #748) is that the LAST declaration owns the name. Returns false when the
+   * symbol REPLACED an earlier one, so the caller can skip its scope push.
+   */
+  registerCallable(symbols, seenMembers, dedupKey, symbol, nameLines, nameNode) {
+    if (nameNode) nameLines.set(dartNameLineKey(symbol.name, symbol.range), this.nodeLine(nameNode));
+    const priorIdx = seenMembers.get(dedupKey);
+    if (priorIdx !== void 0) {
+      symbols[priorIdx] = symbol;
+      return false;
+    }
+    seenMembers.set(dedupKey, symbols.length);
+    symbols.push(symbol);
+    return true;
+  }
+  processTopLevelFunction(node, symbols, scopeStack, patterns, nameLines, seenMembers) {
+    const nameNode = node.childForFieldName("name") || this.findChildByType(node, "identifier");
+    if (!nameNode) return;
+    const name = nameNode.text;
+    const params = this.extractParameters(node);
+    const returnType = this.extractReturnType(node);
+    const isAsync = this.isAsyncSignature(node, node);
+    if (isAsync || returnType && returnType.startsWith("Future")) patterns["Async Programming"] = true;
+    const comments = this.collectComments(node);
+    const isAccessor = node.type === "getter_signature" || node.type === "setter_signature";
+    const range = this.rangeIncludingBody(node, node);
+    const symbol = {
+      name,
+      kind: isAccessor ? ASTEngine.SymbolKind.Property : ASTEngine.SymbolKind.Function,
+      range,
+      scope: scopeString(scopeStack),
+      visibility: name.startsWith("_") ? "private" : "public",
+      parameters: params,
+      returnType,
+      comments,
+      isAsync,
+      complexity: this.methodComplexity(node),
+      metadata: {
+        isAsync,
+        isGetter: node.type === "getter_signature",
+        isSetter: node.type === "setter_signature",
+        isTopLevelFunction: !isAccessor,
+        isTopLevelAccessor: isAccessor
+      }
+    };
+    const accessorKind = node.type === "getter_signature" ? "get" : node.type === "setter_signature" ? "set" : "fn";
+    if (!this.registerCallable(symbols, seenMembers, `module:${name}:${accessorKind}`, symbol, nameLines, nameNode)) return;
+    scopeStack.push({ name, kind: "function" /* Function */ });
+  }
+  processFieldOrVariable(node, symbols, scopeStack, nameLines) {
+    const declList = this.findChildByType(node, "initialized_identifier_list") || this.findChildByType(node, "static_final_declaration_list") || (node.type === "initialized_identifier_list" || node.type === "static_final_declaration_list" ? node : void 0);
+    if (!declList) return;
+    const owner = scopeOwnerName(scopeStack);
+    const isStatic = this.hasModifier(node, "static") || node.type === "static_final_declaration_list";
+    const isFinal = this.hasModifier(node, "final") || node.type === "static_final_declaration_list";
+    const isConst = this.hasModifier(node, "const");
+    const isLate = this.hasModifier(node, "late");
+    const dataType = this.extractFieldType(node, declList);
+    const declRange = this.nodeToRange(node);
+    for (let i = 0; i < declList.namedChildCount; i++) {
+      const child = declList.namedChild(i);
+      if (!child) continue;
+      let name;
+      let nameNode = null;
+      if (child.type === "initialized_identifier" || child.type === "static_final_declaration") {
+        nameNode = this.findChildByType(child, "identifier");
+        name = nameNode?.text;
+      } else if (child.type === "identifier") {
+        name = child.text;
+        nameNode = child;
+      }
+      if (!name) continue;
+      nameLines.set(dartNameLineKey(name, declRange), this.nodeLine(nameNode ?? child));
+      const kind = owner ? ASTEngine.SymbolKind.Property : isConst || isFinal ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Variable;
+      symbols.push({
+        name,
+        kind,
+        range: declRange,
+        scope: scopeString(scopeStack),
+        ownerName: owner,
+        ownerKind: owner ? scopeOwnerKind(scopeStack) : void 0,
+        visibility: name.startsWith("_") ? "private" : "public",
+        isStatic,
+        metadata: { isStatic, isFinal, isConst, isLate, dataType, isField: owner !== void 0 }
+      });
+    }
+  }
+  processTopLevelVariables(node, symbols, scopeStack, nameLines) {
+    const isFinal = this.hasModifier(node, "final") || this.hasModifier(node.parent, "final");
+    const isConst = this.hasModifier(node, "const") || this.hasModifier(node.parent, "const");
+    const dataType = this.extractFieldType(node, node);
+    const declRange = this.nodeToRange(node);
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (!child) continue;
+      let name;
+      let nameNode = null;
+      if (child.type === "initialized_identifier" || child.type === "static_final_declaration") {
+        nameNode = this.findChildByType(child, "identifier");
+        name = nameNode?.text;
+      } else if (child.type === "identifier") {
+        name = child.text;
+        nameNode = child;
+      }
+      if (!name) continue;
+      nameLines.set(dartNameLineKey(name, declRange), this.nodeLine(nameNode ?? child));
+      symbols.push({
+        name,
+        kind: isConst || isFinal ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Variable,
+        range: declRange,
+        scope: scopeString(scopeStack),
+        visibility: name.startsWith("_") ? "private" : "public",
+        metadata: { isStatic: false, isFinal, isConst, dataType, isField: false, isTopLevelVariable: true }
+      });
+    }
+  }
+  processImportExport(node, imports, exports, frameworks, relationships, site) {
+    const targetOf = (uri2) => site.projectRoot === null ? null : dartImportTargetPath(site.projectRoot, site.filePath, uri2);
+    const outsideProject = (uri2) => {
+      if (site.projectRoot === null) return false;
+      if (uri2.startsWith("package:")) {
+        const rest = uri2.slice(8);
+        const slash = rest.indexOf("/");
+        if (slash <= 0) return false;
+        const pkg = rest.slice(0, slash);
+        if (!isDartLibraryName(pkg)) return false;
+        return dartProjectFacts(site.projectRoot).packageRoots.get(pkg) === void 0;
+      }
+      if (uri2.startsWith("dart:")) {
+        const lib = uri2.slice(5);
+        if (!isDartLibraryName(lib)) return false;
+        return !dartProjectFacts(site.projectRoot).sdkLib;
+      }
+      return uri2.indexOf(":") >= 0;
+    };
+    const claimMeta = (uri2, resolved) => resolved === null && outsideProject(uri2) ? { importOutsideProject: true } : {};
+    if (node.type === "part_directive" || node.type === "part_of_directive") {
+      const uriNode2 = this.findDescendantByType(node, "string_literal") || this.findDescendantByType(node, "uri");
+      const uri2 = uriNode2 ? unquote(uriNode2.text) : "";
+      if (!uri2 && node.type === "part_of_directive") {
+        const named = this.findChildByType(node, "dotted_identifier_list");
+        if (named) {
+          relationships.push({
+            source: site.moduleName,
+            target: stripWhitespace(named.text),
+            type: ASTEngine.RelationshipType.PartOf,
+            confidence: 1,
+            line_number: this.nodeLine(named),
+            metadata: { partRole: "part", isNamedLibrary: true }
+          });
+        }
+        return;
+      }
+      if (uri2) {
+        const resolved = targetOf(uri2);
+        imports.push({ module: uri2, source: uri2, imported: ["*"], isPart: true, range: this.nodeToRange(node) });
+        if (resolved !== null) {
+          relationships.push({
+            source: site.moduleName,
+            target: resolved,
+            type: ASTEngine.RelationshipType.PartOf,
+            confidence: 1,
+            line_number: this.nodeLine(uriNode2),
+            metadata: { partRole: node.type === "part_of_directive" ? "part" : "library" }
+          });
+        }
+      }
+      return;
+    }
+    const isExport = node.type === "library_export" || node.text.startsWith("export");
+    const uriNode = this.findDescendantByType(node, "string_literal") || this.findDescendantByType(node, "uri");
+    const uri = uriNode ? unquote(uriNode.text) : "";
+    if (!uri) return;
+    if (uri.startsWith("package:flutter/")) frameworks["Flutter"] = true;
+    if (uri.startsWith("package:angular/")) frameworks["AngularDart"] = true;
+    if (isExport) {
+      const resolved = targetOf(uri);
+      relationships.push({
+        source: site.moduleName,
+        target: resolved ?? uri,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        line_number: this.nodeLine(uriNode),
+        metadata: { ...claimMeta(uri, resolved) }
+      });
+    } else {
+      const resolved = targetOf(uri);
+      imports.push({ module: uri, source: uri, imported: ["*"], isTypeOnly: false, range: this.nodeToRange(node) });
+      relationships.push({
+        source: site.moduleName,
+        target: resolved ?? `${uri}:*`,
+        type: ASTEngine.RelationshipType.Imports,
+        confidence: 1,
+        line_number: this.nodeLine(uriNode),
+        metadata: { ...claimMeta(uri, resolved) }
+      });
+    }
+  }
+  // ============================================================================
+  // RELATIONSHIP PASSES
+  // ============================================================================
+  addContainmentRelationships(symbols, relationships, nameLines) {
+    for (const symbol of symbols) {
+      if (symbol.ownerName) {
+        const qualified = symbol.scope ? `${symbol.scope}.${symbol.name}` : symbol.name;
+        relationships.push({
+          source: symbol.ownerName,
+          target: qualified,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          // The member's OWN NAME line — the name node when the producers could
+          // hand one over (a wrapped declaration moves it off the start line),
+          // the declaration start otherwise (php stamps contains the same way).
+          line_number: nameLines.get(dartNameLineKey(symbol.name, symbol.range)) ?? symbol.range?.startLine,
+          metadata: {}
+        });
+      }
+    }
+  }
+  extractOverrideRelationships(symbols, relationships, overrideCompanion, nameLines, projectIndex) {
+    const byName = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (s.kind === ASTEngine.SymbolKind.Constructor) continue;
+      const list = byName.get(s.name) ?? [];
+      list.push(s);
+      byName.set(s.name, list);
+    }
+    const companionForPass2 = overrideCompanion ?? dartCompanionFor(projectIndex);
+    const seesProject = companionForPass2 !== void 0;
+    const heritageByClass = /* @__PURE__ */ new Map();
+    const firstHeritage = /* @__PURE__ */ new Map();
+    for (const r of relationships) {
+      if (!r.source || !r.target) continue;
+      const type = r.type ?? r.relationshipType ?? "";
+      if (type === "extends" || type === "implements" || type === "uses" || type === "mixes_in") {
+        const list = heritageByClass.get(r.source) ?? [];
+        if (!list.includes(r.target)) list.push(r.target);
+        heritageByClass.set(r.source, list);
+        if (!firstHeritage.has(r.source)) firstHeritage.set(r.source, r.target);
+      }
+    }
+    const basesOf = /* @__PURE__ */ new Map();
+    for (const r of relationships) {
+      const type = r.type ?? r.relationshipType ?? "";
+      if (type !== "extends" && type !== "implements") continue;
+      if (!r.source || !r.target) continue;
+      const list = basesOf.get(r.source) ?? [];
+      if (!list.includes(r.target)) list.push(r.target);
+      basesOf.set(r.source, list);
+    }
+    const baseOrder = /* @__PURE__ */ new Map();
+    for (const r of relationships) {
+      const type = r.type ?? r.relationshipType ?? "";
+      const isBase = type === "extends" || type === "implements" || type === "mixes_in";
+      if (!isBase || !r.source || !r.target) continue;
+      const list = baseOrder.get(r.source) ?? [];
+      if (!list.includes(r.target)) list.push(r.target);
+      baseOrder.set(r.source, list);
+    }
+    const exposedCache = /* @__PURE__ */ new Map();
+    const exposing = /* @__PURE__ */ new Set();
+    const exposed = (cls) => {
+      const cached = exposedCache.get(cls);
+      if (cached) return cached;
+      if (exposing.has(cls)) return /* @__PURE__ */ new Set();
+      exposing.add(cls);
+      const out = /* @__PURE__ */ new Set();
+      for (const [name, syms] of byName) if (syms.some((bm) => bm.ownerName === cls)) out.add(name);
+      for (const b of basesOf.get(cls) ?? []) for (const m of exposed(b)) out.add(m);
+      exposing.delete(cls);
+      exposedCache.set(cls, out);
+      return out;
+    };
+    const declares = (base, method) => {
+      if (exposed(base).has(method)) return true;
+      const companion = companionForPass2?.get(base);
+      return !!companion && companion.has(method);
+    };
+    const TYPE_KINDS = /* @__PURE__ */ new Set([
+      ASTEngine.SymbolKind.Class,
+      ASTEngine.SymbolKind.Interface,
+      ASTEngine.SymbolKind.Enum,
+      ASTEngine.SymbolKind.Type
+    ]);
+    const inFileTypes = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (typeof s.name === "string" && s.name && TYPE_KINDS.has(s.kind)) inFileTypes.add(s.name);
+    }
+    const seenOverride = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if ((s.kind === ASTEngine.SymbolKind.Method || s.kind === ASTEngine.SymbolKind.Property) && s.ownerName) {
+        if (s.isStatic) continue;
+        const heritage = heritageByClass.get(s.ownerName);
+        if (!heritage || heritage.length === 0) continue;
+        let target = null;
+        const seenCls = /* @__PURE__ */ new Set();
+        const queue = [...heritage];
+        while (queue.length > 0 && !target) {
+          const base = queue.shift();
+          if (seenCls.has(base)) continue;
+          seenCls.add(base);
+          if (declares(base, s.name)) {
+            target = base;
+            break;
+          }
+          for (const h of heritageByClass.get(base) ?? []) queue.push(h);
+        }
+        let confidence = 0.95;
+        let metadata = { isOverride: true, relationshipType: "method_override" };
+        if (target) {
+        } else if (companionForPass2 && heritage.length > 0) {
+          const seen2 = /* @__PURE__ */ new Set();
+          const q2 = [...heritage];
+          while (q2.length > 0 && !target) {
+            const base = q2.shift();
+            if (seen2.has(base)) continue;
+            seen2.add(base);
+            if (this.companionHas(companionForPass2, base, s.name)) {
+              target = base;
+              break;
+            }
+            for (const h of heritageByClass.get(base) ?? []) q2.push(h);
+          }
+        }
+        if (!target) {
+          const hasOverrideAnn = (s.decorators ?? []).some((d) => d.includes("@override"));
+          if (hasOverrideAnn) {
+            const rawFirst = firstHeritage.get(s.ownerName) ?? null;
+            const first = rawFirst === DART_OBJECT_TYPE && !DART_OBJECT_INTERFACE_MEMBERS.has(s.name) ? (baseOrder.get(s.ownerName) ?? []).find((b) => b !== DART_OBJECT_TYPE) ?? null : rawFirst;
+            const indexKnowsBase = first !== null && companionForPass2?.has(first) === true;
+            const refuted = first !== null && !declares(first, s.name) && (byName.get(s.name)?.some((bm) => bm.ownerName === first) ?? false) === false && (heritageByClass.has(first) || inFileTypes.has(first) || indexKnowsBase);
+            if (!refuted) {
+              target = first;
+              confidence = 0.8;
+              metadata = seesProject || first === DART_OBJECT_TYPE ? { isOverride: true, relationshipType: "method_override", isExternalBase: true } : { isOverride: true, relationshipType: "method_override", baseBeyondRunScope: String(first) };
+              if (first !== null && first !== DART_OBJECT_TYPE && DART_OBJECT_INTERFACE_MEMBERS.has(s.name)) {
+                target = DART_OBJECT_TYPE;
+                const projectPublishesObject = companionForPass2 !== void 0 && this.companionHas(companionForPass2, DART_OBJECT_TYPE, s.name);
+                metadata = {
+                  isOverride: true,
+                  relationshipType: "method_override",
+                  ...projectPublishesObject ? {} : { isExternalBase: true },
+                  isObjectInterfaceBase: true,
+                  firstHeritageParent: first
+                };
+                if (projectPublishesObject) confidence = 0.95;
+              }
+            }
+          }
+        }
+        if (!target) continue;
+        const key = `${s.ownerName}.${s.name}->${target}.${s.name}`;
+        if (seenOverride.has(key)) continue;
+        seenOverride.add(key);
+        relationships.push({
+          source: `${s.ownerName}.${s.name}`,
+          target: `${target}.${s.name}`,
+          type: ASTEngine.RelationshipType.Overrides,
+          confidence,
+          // The overriding METHOD's own name line — the node that names the
+          // edge, not the base it shadows (and not a wrapped start line).
+          line_number: nameLines?.get(dartNameLineKey(s.name, s.range)) ?? s.range?.startLine,
+          metadata
+        });
+      }
+    }
+  }
+  /** Companion lookup with leaf-name fallback (bases may arrive qualified). */
+  companionHas(companion, base, method) {
+    if (companion.get(base)?.has(method)) return true;
+    const leaf = base.includes(".") ? base.split(".").pop() : base;
+    return leaf !== base && !!companion.get(leaf)?.has(method);
+  }
+  /**
+   * The whole-tree EXPRESSION pass: `calls`, `uses`, `instantiates` and
+   * `references`.
+   *
+   * Named for what it reads rather than for when it was written. It began as the
+   * call pass, but it is also the only traversal that already knows, at every
+   * node, which declaration encloses it (`current`/`owner`, the family attribution
+   * rule), and a type mention's SOURCE is the same question a call's source is.
+   * A second traversal would have had to re-derive that attribution, and two
+   * copies of one rule are two rules that drift.
+   *
+   * `projectIndex` is LAST and it must stay last — the same hazard
+   * `extractOverrideRelationships` documents: an optional parameter inserted
+   * earlier silently swapped the ones after it.
+   */
+  extractExpressionRelationships(node, relationships, moduleName, symbols, projectIndex) {
+    const importAliases = this.collectImportAliases(node);
+    const visibleTypes = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      const kind = s.kind;
+      const isType = kind === ASTEngine.SymbolKind.Class || kind === ASTEngine.SymbolKind.Mixin || kind === ASTEngine.SymbolKind.Extension || kind === ASTEngine.SymbolKind.Enum || kind === ASTEngine.SymbolKind.TypeAlias;
+      if (!isType) continue;
+      if (kind === ASTEngine.SymbolKind.Extension && s.metadata?.isUnnamedExtension) continue;
+      if (s.name) visibleTypes.add(s.name);
+    }
+    const fileTypes = new Set(visibleTypes);
+    const libraryScope = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (s.ownerName) continue;
+      if (fileTypes.has(s.name)) continue;
+      if (s.kind === ASTEngine.SymbolKind.EnumMember) continue;
+      if (s.name) libraryScope.add(s.name);
+    }
+    for (const t of projectIndex?.typeKinds?.keys?.() ?? []) visibleTypes.add(String(t));
+    const namedCtors = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (s.kind === ASTEngine.SymbolKind.Constructor && s.ownerName) {
+        const seg = s.metadata?.namedSegment;
+        if (seg) namedCtors.add(`${s.ownerName}.${seg}`);
+      }
+    }
+    const membersByOwner = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (!s.ownerName) continue;
+      let set = membersByOwner.get(s.ownerName);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        membersByOwner.set(s.ownerName, set);
+      }
+      set.add(s.name);
+    }
+    const topLevelValues = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (s.ownerName) continue;
+      if (s.kind === ASTEngine.SymbolKind.Variable || s.kind === ASTEngine.SymbolKind.Constant || s.kind === ASTEngine.SymbolKind.Function || s.kind === ASTEngine.SymbolKind.Property) {
+        topLevelValues.add(s.name);
+      }
+    }
+    const superByClass = /* @__PURE__ */ new Map();
+    {
+      const pre = [node];
+      while (pre.length > 0) {
+        const cn = pre.pop();
+        if (!cn) continue;
+        if (cn.type === "class_definition") {
+          const nm = cn.childForFieldName?.("name")?.text;
+          const sup = this.findChildByType(cn, "superclass");
+          if (nm && sup) {
+            const base = this.resolvedHeritageNames(sup)[0];
+            if (base) superByClass.set(nm, base);
+          }
+        }
+        for (let i = cn.namedChildCount - 1; i >= 0; i--) {
+          const ch = cn.namedChild(i);
+          if (ch) pre.push(ch);
+        }
+      }
+    }
+    const fileQualified = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      if (s.ownerName) fileQualified.add(`${s.ownerName}.${s.name}`);
+    }
+    const indexDeclares = (typeName, member) => {
+      const set = projectIndex?.typeMembers?.get?.(typeName);
+      if (set instanceof Set) return set.has(member);
+      if (Array.isArray(set)) return set.includes(member);
+      return false;
+    };
+    const declaringOwner = (member, from, memberNodesByOwner) => {
+      const seen = /* @__PURE__ */ new Set();
+      let cur = from;
+      while (cur && !seen.has(cur)) {
+        seen.add(cur);
+        if (memberNodesByOwner.get(cur)?.has(member)) return cur;
+        cur = superByClass.get(cur) ?? null;
+      }
+      return null;
+    };
+    const typeKindByName = /* @__PURE__ */ new Map();
+    const fieldTypeByField = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (!s.ownerName) continue;
+      const dt = String(s.metadata?.dataType ?? "");
+      if (isPlainIdentifier(dt)) fieldTypeByField.set(`${s.ownerName}.${s.name}`, dt);
+    }
+    const qualifiedTarget = (ownerText, member) => {
+      if (!ownerText || !member) return { target: null, cause: "receiverUnnamed" };
+      if (!visibleTypes.has(ownerText)) {
+        if (!isCapitalized(ownerText)) return { target: null, cause: "receiverTypeUnknown" };
+        return { target: `${ownerText}.${member}`, cause: null, typeName: ownerText, claim: ownerText };
+      }
+      const declared = declaringOwner(member, ownerText, membersByOwner);
+      if (declared) {
+        const spelling = `${declared}.${member}`;
+        if (fileQualified.has(spelling)) return { target: spelling, cause: null };
+        return { target: null, cause: "receiverInFileNotSpelled" };
+      }
+      if (indexDeclares(ownerText, member)) return { target: `${ownerText}.${member}`, cause: null };
+      return { target: null, cause: "receiverMemberOutsideRun" };
+    };
+    const receiverCut = (q) => {
+      if (q.claim !== void 0) return { baseBeyondRunScope: q.claim };
+      return q.cause ? { receiverCause: q.cause, ...q.typeName ? { receiverType: q.typeName } : {} } : {};
+    };
+    const plainTypeName = (text) => {
+      const leaf = stripNullableSuffix(String(text ?? ""));
+      return isPlainIdentifier(leaf) ? leaf : void 0;
+    };
+    const headOwner = (head, enclosing, localTypes) => {
+      const t = head?.type;
+      if (t === "this") return enclosing;
+      if (t === "super") return superByClass.get(enclosing ?? "") ?? null;
+      const text = this.headNameText(head);
+      if (text === null) return null;
+      const localType = localTypes.get(text);
+      if (localType) return localType;
+      const fieldType = fieldTypeByField.get(`${enclosing ?? ""}.${text}`);
+      if (fieldType) return fieldType;
+      return text;
+    };
+    const receiverOwnerMeta = (head, enclosing, localTypes, localEvidence) => {
+      const t = head?.type;
+      if (t === "this" || t === "super") return null;
+      const text = this.headNameText(head);
+      if (text === null) return null;
+      const classLikeType = (name) => {
+        if (name === "dynamic" || name === "void" || name === "Never") return null;
+        const kind = typeKindByName.get(name);
+        if (kind === void 0) return name;
+        if (kind === "class" || kind === "enum") return name;
+        return null;
+      };
+      const localType = localTypes.get(text);
+      if (localType) {
+        const evidence = localEvidence.get(text);
+        const owner2 = classLikeType(localType);
+        return evidence && owner2 ? { owner: owner2, ownerEvidence: evidence } : null;
+      }
+      const fieldType = fieldTypeByField.get(`${enclosing ?? ""}.${text}`);
+      const owner = fieldType ? classLikeType(fieldType) : null;
+      if (owner) return { owner, ownerEvidence: "field" };
+      return null;
+    };
+    for (const s of symbols) {
+      if (s.ownerName) continue;
+      const kind = String(s.kind ?? "");
+      if (kind === "class" || kind === "enum" || kind === "mixin" || kind === "extension" || kind === "extension_type" || kind === "type_alias" || kind === "type") {
+        if (s.name) typeKindByName.set(s.name, kind);
+      }
+    }
+    const resolveCurrent = (n, current) => {
+      if (n.type === "function_signature" && n.parent?.type === "lambda_expression") {
+        return current;
+      }
+      let sig = null;
+      if (this.isSignatureNode(n.type)) {
+        sig = n;
+      } else if (n.type === "declaration") {
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (c && this.isSignatureNode(c.type)) {
+            sig = c;
+            break;
+          }
+        }
+      }
+      if (sig) {
+        const inner = this.findInnerSignature(sig);
+        if (this.isConstructorSignature(sig.type) || this.isConstructorSignature(inner.type)) {
+          if (this.isRealConstructor(inner, this.enclosingTypeName(inner))) return "constructor";
+        }
+        const nm = this.signatureName(inner);
+        if (nm) return nm;
+      }
+      return current;
+    };
+    const resolveOwner = (n, owner) => {
+      const t = n.type;
+      if (t === "class_definition" || t === "enum_declaration") {
+        const nm = n.childForFieldName?.("name")?.text;
+        return nm || owner;
+      }
+      if (t === "extension_declaration" || t === "extension_type_declaration") {
+        return this.extensionPublishedName(n) || owner;
+      }
+      if (t === "mixin_declaration") {
+        const id = this.findChildByType(n, "identifier");
+        return id ? id.text : owner;
+      }
+      if (t === "type_alias") {
+        const nm = n.childForFieldName?.("name")?.text || this.findChildByType(n, "type_identifier")?.text;
+        return nm || owner;
+      }
+      return owner;
+    };
+    const visitNode = (n, current, owner, locals, localTypes, localEvidence, localElements, insideCollected) => {
+      const prev = current;
+      const prevOwner = owner;
+      const t = n.type;
+      current = resolveCurrent(n, current);
+      owner = resolveOwner(n, owner);
+      let childLocals = locals;
+      let childLocalTypes = localTypes;
+      let childLocalEvidence = localEvidence;
+      let childLocalElements = localElements;
+      let childInsideCollected = insideCollected;
+      if (t === "function_body" || t === "function_expression_body" || t === "block") {
+        let bound = null;
+        let boundTypes = null;
+        if (!insideCollected) {
+          const own = this.collectDartLocals(n);
+          if (own.size > 0) bound = own;
+          const ownTypes = this.collectDartLocalTypes(n);
+          if (ownTypes.size > 0) boundTypes = ownTypes;
+        }
+        const sig = n.previousNamedSibling;
+        if (sig) {
+          const sigNames = this.collectDartLocals(sig);
+          if (sigNames.size > 0) {
+            if (!bound) bound = /* @__PURE__ */ new Set();
+            for (const nm of sigNames) bound.add(nm);
+          }
+          const sigTypes = this.collectDartParameterTypes(sig);
+          if (sigTypes.size > 0) {
+            if (!boundTypes) boundTypes = /* @__PURE__ */ new Map();
+            for (const [nm, ty] of sigTypes) boundTypes.set(nm, ty);
+          }
+        }
+        if (bound) {
+          childLocals = new Set(locals);
+          for (const nm of bound) childLocals.add(nm);
+        }
+        if (boundTypes) {
+          childLocalTypes = new Map(localTypes);
+          childLocalEvidence = new Map(localEvidence);
+          childLocalElements = new Map(localElements);
+          for (const [nm, ty] of boundTypes) {
+            childLocalTypes.set(nm, ty.type);
+            childLocalEvidence.set(nm, ty.evidence);
+            if (ty.element) childLocalElements.set(nm, ty.element);
+            if (ty.keyElement) childLocalElements.set(`${nm}\0key`, ty.keyElement);
+          }
+        }
+        const awaitTypes = this.collectAwaitLocalTypes(n, childLocalElements, childLocalTypes);
+        if (awaitTypes.size > 0) {
+          childLocalTypes = new Map(childLocalTypes);
+          childLocalEvidence = new Map(childLocalEvidence);
+          childLocalElements = new Map(childLocalElements);
+          for (const [nm, ty] of awaitTypes) {
+            childLocalTypes.set(nm, ty);
+            childLocalEvidence.set(nm, "annotation");
+            childLocalElements.set(nm, ty);
+          }
+        }
+        if (!insideCollected) childInsideCollected = true;
+      }
+      if (t === "for_statement") {
+        const parts = this.findChildByType(n, "for_loop_parts");
+        if (parts) {
+          const hasWrittenType = (parts.namedChildren ?? []).some((c) => c?.type === "type_identifier");
+          const nameNode = parts.childForFieldName?.("name");
+          const valueNode = parts.childForFieldName?.("value");
+          if (!hasWrittenType && nameNode && valueNode && !childLocalTypes.has(nameNode.text)) {
+            let element;
+            let link;
+            const sel = valueNode.nextNamedSibling;
+            if (sel && sel.type === "selector") {
+              const ids = [];
+              const linkStack = [sel];
+              while (linkStack.length > 0) {
+                const x = linkStack.pop();
+                if (x.type === "identifier") {
+                  ids.push(x.text);
+                  continue;
+                }
+                for (const c of x.namedChildren ?? []) if (c) linkStack.push(c);
+              }
+              link = ids.find((t2) => t2 === "values" || t2 === "keys");
+            }
+            if (link === "values") element = localElements.get(valueNode.text);
+            else if (link === "keys") element = localElements.get(`${valueNode.text}\0key`);
+            else element = localElements.get(valueNode.text);
+            if (element) {
+              childLocalTypes = new Map(childLocalTypes);
+              childLocalTypes.set(nameNode.text, element);
+              childLocalEvidence = new Map(childLocalEvidence);
+              childLocalEvidence.set(nameNode.text, "annotation");
+            }
+          }
+        }
+      }
+      if (t === "initializers") {
+        const par = n.parent;
+        if (par) {
+          for (let k = 0; k < par.namedChildCount; k++) {
+            const sib = par.namedChild(k);
+            if (sib && (sib.type === "constructor_signature" || sib.type === "method_signature" || sib.type === "function_signature")) {
+              const bound = this.collectDartLocals(sib);
+              if (bound.size > 0) {
+                childLocals = new Set(locals);
+                for (const nm of bound) childLocals.add(nm);
+              }
+              break;
+            }
+          }
+        }
+      }
+      if ((t === "function_body" || t === "block" || t === "function_expression_body") && current === prev) {
+        const prevSib = n.previousNamedSibling;
+        if (prevSib) {
+          const sigSource = resolveCurrent(prevSib, current);
+          if (sigSource !== current) current = sigSource;
+        }
+      }
+      const callSource = current || owner || moduleName;
+      if (t === "constructor_invocation" || t === "new_expression" || t === "const_object_expression") {
+        const typeNode = this.findChildByType(n, "type_identifier");
+        if (typeNode && isCapitalized(typeNode.text)) {
+          relationships.push({
+            source: callSource,
+            target: typeNode.text,
+            type: ASTEngine.RelationshipType.Instantiates,
+            confidence: 0.95,
+            line_number: this.nodeLine(typeNode),
+            metadata: { isConstructorInvocation: true }
+          });
+        }
+      }
+      if (t === "selector" && this.findChildByType(n, "argument_part")) {
+        const { head, links } = this.invocationChain(n);
+        if (links.length === 0) {
+          const leafNode = this.resolveSelectorCalleeNode(n);
+          const leaf = leafNode?.text ?? null;
+          if (leaf) {
+            if (this.isDartGlobalBuiltin(leaf)) {
+            } else if (isCapitalized(leaf) && this.selectorIsBareCall(n)) {
+              relationships.push({
+                source: callSource,
+                target: leaf,
+                type: ASTEngine.RelationshipType.Instantiates,
+                confidence: 0.95,
+                line_number: this.nodeLine(leafNode),
+                metadata: {}
+              });
+            } else {
+              const isBinding = locals.has(leaf);
+              const q0 = isBinding ? { target: null, cause: null } : qualifiedTarget(owner, leaf);
+              const q = q0.cause === "receiverMemberOutsideRun" && libraryScope.has(leaf) ? { target: null, cause: "libraryScopeCallee" } : q0;
+              relationships.push({
+                source: callSource,
+                target: q.target ?? (isBinding ? `${callSource}${BINDING_SEP}${leaf}` : leaf),
+                type: ASTEngine.RelationshipType.Calls,
+                confidence: 0.9,
+                line_number: this.nodeLine(leafNode),
+                // Metadata only, for the marker half. No row is added or removed and no
+                // confidence moves, so this cannot change WHICH edges exist; it makes an
+                // existing population queryable, which is what M14 §4 asks of a heuristic
+                // edge.
+                metadata: {
+                  ...isBinding ? { isLocalRead: true, localBinding: true } : {},
+                  ...q.target ? { qualifier: "enclosing" } : {},
+                  // THE RECEIVER CUT, on the rows that stayed bare and only there — a row that
+                  // resolved already says how it resolved (`qualifier`), and a binding has no
+                  // receiver question to answer.
+                  ...isBinding ? {} : receiverCut(q)
+                }
+              });
+            }
+          }
+        } else {
+          const method = links[links.length - 1];
+          const before = links.length > 1 ? links[links.length - 2] : this.headNameText(head);
+          const headText = this.headNameText(head);
+          const calleeNode = n.previousNamedSibling ? this.lastIdentifierNode(n.previousNamedSibling) : null;
+          if (this.isDartGlobalBuiltin(method)) {
+          } else if (links.length === 1 && isCapitalized(method) && headText !== null && !isCapitalized(headText) && head !== null && (head.type === "identifier" || head.type === "type_identifier")) {
+            relationships.push({
+              source: callSource,
+              target: method,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.95,
+              line_number: this.nodeLine(calleeNode),
+              metadata: { isNamedConstructor: true, isPrefixQualified: true }
+            });
+          } else if (before !== null && isCapitalized(before) && namedCtors.has(`${before}.${method}`)) {
+            relationships.push({
+              source: callSource,
+              target: before,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.95,
+              line_number: this.nodeLine(calleeNode),
+              metadata: { isNamedConstructor: true }
+            });
+          } else {
+            const ownerCand = links.length > 1 ? before : headOwner(head, owner, localTypes);
+            const ownMeta = links.length > 1 ? null : receiverOwnerMeta(head, owner, localTypes, localEvidence);
+            const q = qualifiedTarget(ownerCand, method);
+            relationships.push({
+              source: callSource,
+              target: q.target ?? method,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.9,
+              line_number: this.nodeLine(calleeNode),
+              // Same reason as the bare-call arm above: a leaf that the enclosing
+              // function binds is a binding, and the row is labelled so a consumer
+              // can tell it from a call to a declared member.
+              //
+              // 2026-10-08 — DELIBERATELY NOT re-spelled as a binding, and the reason is a
+              // finding rather than an omission. This arm runs for a chain of TWO or more
+              // links (`a.b.c()`), where the leaf is resolved against the RECEIVER, not
+              // against the enclosing function: the `locals` set consulted here is the
+              // enclosing function's, so `isLocalRead` on this arm answers a question about
+              // the WRONG SCOPE whenever `links.length > 1`. The target cannot be re-spelled
+              // to `#` for the same reason — for a chain the leaf may genuinely name a
+              // declaration reachable through the receiver, and `qualifiedTarget` is the rule
+              // that decides it. Named, not fixed: a one-link chain reaches the bare-call arm
+              // above and IS re-spelled; the multi-link case needs its own measurement of how
+              // often `locals.has(method)` is true where no receiver member exists.
+              metadata: {
+                ...locals.has(method) ? { isLocalRead: true } : {},
+                ...q.target ? { qualifier: "chain" } : {},
+                ...receiverCut(q),
+                // THE STORE'S CHANNEL (see `receiverOwnerMeta`): the exactly-known receiver
+                // type plus the evidence class. Additive — the target spelling above is
+                // unchanged, so nothing here can move an edge.
+                ...ownMeta ?? {}
+              }
+            });
+          }
+        }
+      }
+      if (t === "annotation") {
+        this.emitAnnotationReferences(n, relationships, current, owner, moduleName, importAliases);
+      }
+      if (t === "selector" && !this.findChildByType(n, "argument_part")) {
+        const memberNode = this.linkMemberNode(n);
+        const member = memberNode?.text ?? null;
+        if (member && !this.isDartGlobalBuiltin(member)) {
+          const next = n.nextNamedSibling;
+          const nextIsArgs = !!next && next.type === "selector" && !!this.findChildByType(next, "argument_part");
+          if (!nextIsArgs && !this.selectorIsLhsWrite(n)) {
+            const head = n.previousNamedSibling;
+            const headText = this.headNameText(head);
+            if (headText !== null && isCapitalized(headText) && namedCtors.has(`${headText}.${member}`)) {
+              relationships.push({
+                source: callSource,
+                target: headText,
+                type: ASTEngine.RelationshipType.Instantiates,
+                confidence: 0.95,
+                line_number: this.nodeLine(memberNode),
+                metadata: { isNamedConstructor: true, isTearOff: true }
+              });
+            } else {
+              const ownMeta = receiverOwnerMeta(head, owner, localTypes, localEvidence);
+              const q = qualifiedTarget(headOwner(head, owner, localTypes), member);
+              relationships.push({
+                source: callSource,
+                target: q.target ?? member,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: 0.9,
+                line_number: this.nodeLine(memberNode),
+                metadata: q.target ? { isMemberRead: true, qualifier: "head", ...receiverCut(q), ...ownMeta ?? {} } : { isMemberRead: true, ...receiverCut(q), ...ownMeta ?? {} }
+              });
+            }
+          }
+        }
+      }
+      if (t === "qualified" && this.isPatternTestConstant(n)) {
+        const segs = n.text.split(".");
+        const member = segs[segs.length - 1];
+        const head = segs.length > 1 ? typeNameWithoutArguments(segs[segs.length - 2]) : null;
+        if (member && !this.isDartGlobalBuiltin(member) && member !== head) {
+          if (head !== null && isCapitalized(head) && (namedCtors.has(`${head}.${member}`) || member === "new")) {
+            relationships.push({
+              source: callSource,
+              target: head,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.95,
+              line_number: this.nodeLine(n),
+              metadata: member === "new" ? { isConstructorReference: true, isConstantPattern: true } : { isNamedConstructor: true, isConstantPattern: true }
+            });
+          } else {
+            const q = qualifiedTarget(head, member);
+            relationships.push({
+              source: callSource,
+              target: q.target ?? member,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.9,
+              line_number: this.nodeLine(n),
+              metadata: q.target ? { isMemberRead: true, isConstantPattern: true, qualifier: "pattern", ...receiverCut(q) } : { isMemberRead: true, isConstantPattern: true, ...receiverCut(q) }
+            });
+          }
+        }
+      }
+      if (t === "identifier") {
+        const txt = n.text;
+        const ptype = n.parent?.type ?? "";
+        const memberLink = ptype === "unconditional_assignable_selector" || ptype === "conditional_assignable_selector" || ptype === "cascade_selector" || ptype === "selector";
+        const next = n.nextNamedSibling;
+        const nextIsCall = !!next && next.type === "selector" && !!this.findChildByType(next, "argument_part");
+        const declName = this.isDartDeclNameParent(ptype) || this.isDartDeclaredName(n);
+        const isWrite = this.selectorIsLhsWrite(n);
+        const isLabel = ptype === "labeled_statement" || ptype === "break_statement" || ptype === "continue_statement";
+        const isFieldInitTarget = ptype === "field_initializer" && (() => {
+          const first = n.parent?.namedChild(0);
+          return !!first && first.startIndex === n.startIndex && first.endIndex === n.endIndex;
+        })();
+        const isAnnotationName = ptype === "annotation" || ptype === "scoped_identifier" && n.parent?.parent?.type === "annotation";
+        if (txt === "this" || txt === "super") {
+        } else if (!memberLink && !nextIsCall && !declName && !isWrite && !isLabel && !isFieldInitTarget && !isAnnotationName) {
+          const isDeclaredMember = !!owner && (membersByOwner.get(owner)?.has(txt) ?? false);
+          if (!locals.has(txt) && isDeclaredMember) {
+            const q = qualifiedTarget(owner, txt);
+            relationships.push({
+              source: callSource,
+              target: q.target ?? txt,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.6,
+              line_number: this.nodeLine(n),
+              metadata: q.target ? { isBareRead: true, qualifier: "enclosing", ...receiverCut(q) } : { isBareRead: true, ...receiverCut(q) }
+            });
+          } else if (locals.has(txt)) {
+            relationships.push({
+              source: callSource,
+              target: `${callSource}${BINDING_SEP}${txt}`,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.9,
+              line_number: this.nodeLine(n),
+              // A read of a PARAMETER is a binding too: `locals` holds the function's bound
+              // names (parameters and `var`s alike), which is why both land here.
+              metadata: { isLocalRead: true, localBinding: true, ...this.localBindingScope(n, txt) ?? {} }
+            });
+          } else if (this.isPatternTestConstant(n)) {
+            relationships.push({
+              source: callSource,
+              target: txt,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.9,
+              line_number: this.nodeLine(n),
+              metadata: { isConstantPattern: true, isPatternTest: true }
+            });
+          } else if (!isDeclaredMember && topLevelValues.has(txt)) {
+            relationships.push({
+              source: callSource,
+              target: txt,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.9,
+              line_number: this.nodeLine(n),
+              metadata: { isGlobalRead: true }
+            });
+          }
+        }
+      }
+      if (t === "initializer_list_entry") {
+        let headIsSuper = false;
+        let headIsThis = false;
+        let headNode = null;
+        const firstRaw = n.child(0);
+        if (firstRaw && !firstRaw.isNamed && (firstRaw.text === "super" || firstRaw.text === "this")) {
+          headIsSuper = firstRaw.text === "super";
+          headIsThis = firstRaw.text === "this";
+          headNode = firstRaw;
+        } else {
+          const firstNamed = n.namedChild(0);
+          if (firstNamed && (firstNamed.type === "super" || firstNamed.type === "this")) {
+            headIsSuper = firstNamed.type === "super";
+            headIsThis = firstNamed.type === "this";
+            headNode = firstNamed;
+          }
+        }
+        if (headIsSuper && owner) {
+          const base = superByClass.get(owner);
+          if (base) {
+            relationships.push({
+              source: callSource,
+              target: base,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.95,
+              line_number: this.nodeLine(headNode),
+              metadata: { isSuperConstructor: true }
+            });
+          }
+        } else if (headIsThis && owner) {
+          relationships.push({
+            source: callSource,
+            target: owner,
+            type: ASTEngine.RelationshipType.Instantiates,
+            confidence: 0.95,
+            line_number: this.nodeLine(headNode),
+            metadata: { isRedirectingConstructor: true }
+          });
+        }
+      }
+      if (t === "redirection" && owner) {
+        let rSuper = false;
+        let rThis = false;
+        let headTok = null;
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c) continue;
+          if (c.type === "this") {
+            rThis = true;
+            headTok = c;
+            break;
+          }
+          if (c.type === "super") {
+            rSuper = true;
+            headTok = c;
+            break;
+          }
+          if (c.type === "identifier" || c.type === "type_identifier" || c.type === "arguments") continue;
+          break;
+        }
+        if (rSuper) {
+          const base = superByClass.get(owner);
+          if (base) {
+            relationships.push({
+              source: callSource,
+              target: base,
+              type: ASTEngine.RelationshipType.Instantiates,
+              confidence: 0.95,
+              line_number: this.nodeLine(headTok),
+              metadata: { isSuperConstructor: true }
+            });
+          }
+        } else if (rThis) {
+          relationships.push({
+            source: callSource,
+            target: owner,
+            type: ASTEngine.RelationshipType.Instantiates,
+            confidence: 0.95,
+            line_number: this.nodeLine(headTok),
+            metadata: { isRedirectingConstructor: true }
+          });
+        }
+      }
+      if (t === "identifier") {
+        const parent = n.parent;
+        const ptype = parent?.type ?? "";
+        if (!this.isDartDeclNameParent(ptype) && ptype !== "label" && !this.isDartDeclaredName(n)) {
+          const nx = n.nextNamedSibling;
+          if (nx && (nx.type === "selector" && this.isIndexSelector(nx) || this.isIndexAssignable(nx))) {
+            relationships.push({
+              source: callSource,
+              target: n.text,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.9,
+              line_number: this.nodeLine(n),
+              metadata: { isSubscriptBase: true }
+            });
+          } else if (this.isInsideTemplateSubstitution(n)) {
+            const isLocal = locals.has(n.text);
+            relationships.push({
+              source: callSource,
+              target: isLocal ? `${callSource}${BINDING_SEP}${n.text}` : n.text,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.9,
+              line_number: this.nodeLine(n),
+              metadata: isLocal ? { isInterpolationRead: true, isLocalRead: true, localBinding: true, ...this.localBindingScope(n, n.text) ?? {} } : { isInterpolationRead: true }
+            });
+          }
+        }
+      }
+      if (t === "identifier_dollar_escaped") {
+        const raw = n.text;
+        const name = raw.startsWith("$") ? raw.slice(1) : raw;
+        if (name) {
+          const isLocal = locals.has(name);
+          relationships.push({
+            source: callSource,
+            target: isLocal ? `${callSource}${BINDING_SEP}${name}` : name,
+            type: ASTEngine.RelationshipType.Uses,
+            confidence: 0.9,
+            line_number: this.nodeLine(n),
+            metadata: isLocal ? { isInterpolationRead: true, isLocalRead: true, localBinding: true, ...this.localBindingScope(n, name) ?? {} } : { isInterpolationRead: true }
+          });
+        }
+      }
+      if (t === "cascade_section") {
+        let sectionAssigns = false;
+        for (let i = 0; i < n.childCount; i++) {
+          const c = n.child(i);
+          if (c && !c.isNamed && c.text === "=") {
+            sectionAssigns = true;
+            break;
+          }
+        }
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c) continue;
+          if (c.type !== "cascade_selector" && c.type !== "unconditional_assignable_selector" && c.type !== "conditional_assignable_selector" && c.type !== "selector") continue;
+          const next = n.namedChild(i + 1);
+          if (next && next.type === "argument_part") {
+            const idNode = this.lastIdentifierNode(c);
+            const id = idNode?.text ?? null;
+            if (id && !this.isDartGlobalBuiltin(id)) {
+              relationships.push({
+                source: callSource,
+                target: id,
+                type: ASTEngine.RelationshipType.Calls,
+                confidence: 0.9,
+                line_number: this.nodeLine(idNode),
+                metadata: { isCascade: true }
+              });
+            }
+          } else if (!sectionAssigns) {
+            const idNode = this.lastIdentifierNode(c);
+            const id = idNode?.text ?? null;
+            if (id && !this.isDartGlobalBuiltin(id)) {
+              relationships.push({
+                source: callSource,
+                target: id,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: 0.9,
+                line_number: this.nodeLine(idNode),
+                metadata: { isMemberRead: true, isCascade: true }
+              });
+            }
+          }
+        }
+      }
+      if (t === "type_identifier") {
+        this.collectTypeMention(n, callSource, relationships, visibleTypes, fileTypes);
+      }
+      return [current, owner, childLocals, childLocalTypes, childLocalEvidence, childLocalElements, childInsideCollected];
+    };
+    const processNode = (root, current, owner, locals, localTypes, localEvidence, localElements, insideCollected) => {
+      const work = [
+        [root, current, owner, locals, localTypes, localEvidence, localElements, insideCollected]
+      ];
+      while (work.length > 0) {
+        const [n2, cur, own, loc, types, evid, elems, inside] = work.pop();
+        const [cur2, own2, loc2, types2, evid2, elems2, inside2] = visitNode(n2, cur, own, loc, types, evid, elems, inside);
+        const kids = n2.namedChildren ?? [];
+        for (let i = kids.length - 1; i >= 0; i--) {
+          const child = kids[i];
+          if (child) work.push([child, cur2, own2, loc2, types2, evid2, elems2, inside2]);
+        }
+      }
+    };
+    processNode(node, null, null, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), false);
+  }
+  // ============================================================================
+  // `references` — A DECLARATION MENTIONS A TYPE
+  // ============================================================================
+  /**
+   * One type mention, read off ONE node. No recursion, no state: everything it
+   * needs (`source`, the type set, the row sink) arrives as an argument, so the
+   * rule below is the whole rule and a reader does not have to reconstruct a walk
+   * to know what a `references` edge claims.
+   *
+   * ## WHAT IS CLAIMED
+   *
+   * `X references T` means: the declaration `X` names the type `T` in a TYPE
+   * POSITION, and `T` binds to a type declaration this run can see.
+   *
+   * Dart is statically typed, and a type position is a grammatical position, not
+   * a convention — the grammar has a dedicated node (`type_identifier`) that never
+   * appears where a value identifier appears. So the mention is a PARSE FACT, not
+   * a name-shape guess. What is not a parse fact is the BINDING of that name to a
+   * declaration, which is why the edge is published only when the name resolves
+   * and carries 0.95 rather than 1.0 — the same derivation `instantiates` is
+   * published at, for the same reason (a syntactic role plus a resolved name).
+   *
+   * ## WHY RESOLUTION IS A GATE AND NOT A REPORT
+   *
+   * Measured over 1,000 corpus files across 5 repositories: 75,769 type mentions
+   * outside heritage clauses, of which 3,460 (4.57%) name a type the same file
+   * declares. The other 95.43% name `String`, `Widget`, `Future` — real types, in
+   * `dart:core` and the Flutter SDK, declared in files this per-file run has not
+   * read. Publishing those would make the label mostly a list of SDK types, at
+   * ~22x the edge count, and every one of them an endpoint no symbol in the index
+   * can bind. A narrow graph that is true beats a wide graph that is not, so the
+   * unresolvable majority is deliberately unread, and the number is stated rather
+   * than left to be discovered downstream.
+   *
+   * A `projectIndex` widens the gate to every type the run can see
+   * (`src/ast/project-index.ts` `typeKinds`), which is how the differential's
+   * `--dart-deps=direct` runs measure more than production does. Production does
+   * not supply one for `.dart`: `parallel-indexer.ts` `PROJECT_INDEX_EXTENSIONS`
+   * names only `.sol`. So the published set is file-local in production and grows
+   * with an index — recorded per row in `isIndexResolved` so the two answers are
+   * distinguishable in the store rather than conflated.
+   *
+   * ## WHAT IS NOT A REFERENCE
+   *
+   * Measured parent-position inventory (the probe that produced it is
+   * `validation/m14/fixtures/dart/type-position-probe.ts`):
+   *
+   *   published — formal_parameter, normal_parameter_type, super_formal_parameter,
+   *     constructor_param (a `this.x` parameter's type), function_signature /
+   *     getter_signature / setter_signature / operator_signature (return types),
+   *     type_arguments (`List<T>`, `Map<K,V>`), function_type, record_type_field,
+   *     type_cast (`as T`), type_test (`is T`), try_statement (`on T catch`),
+   *     initialized_variable_definition, typed_identifier, for_loop_parts,
+   *     declaration (a field's type), program (a top-level `const String x`),
+   *     qualified (the LEAF of `prefix.Type`), constructor_tearoff (`http.Client`
+   *     used as a value), extension_declaration (`on T`), representation_declaration
+   *     (an extension type's representation type), type_alias (`typedef A = B`),
+   *     type_bound (`<T extends B>`), object_pattern / variable_pattern / cast_pattern
+   *     (a Dart 3 pattern's type), record_type.
+   *
+   *   NOT published, each for a stated reason:
+   *     superclass / interfaces / mixins / mixin_declaration / mixin_application —
+   *       heritage already publishes `extends` / `implements` / `uses`, and a second
+   *       label for the same fact double-counts it.
+   *     new_expression / const_object_expression / constructor_invocation /
+   *       redirecting_factory_constructor_signature — construction already publishes
+   *       `instantiates`.
+   *     type_parameter — `class Box<T>` DECLARES a type variable; it does not
+   *       mention a type. A mention of `T` inside that class resolves to the type
+   *       VARIABLE, which is what `isTypeParameterShadowed` refuses.
+   *     ERROR — nothing inside a parse-error region is a fact about a well-formed
+   *       program, and this analyzer's error policy is to publish what survived the
+   *       parse, not what the recovery invented.
+   *
+   * The last one is the reason this method checks the PARENT at all: in this
+   * grammar `type_identifier` only ever appears in a type position, so the node
+   * type alone would publish the double-counted positions above.
+   */
+  collectTypeMention(n, source, relationships, visibleTypes, fileTypes) {
+    const parent = n.parent;
+    const position = parent ? parent.type : "";
+    if (DART_TYPE_MENTION_DOUBLE_COUNTED.has(position)) return;
+    const name = n.text;
+    if (!name || name === IMPLICIT_DYNAMIC_TYPE) return;
+    if (name === source) return;
+    if (this.isUnnamedExtensionSubject(n)) return;
+    if (!visibleTypes.has(name)) return;
+    if (this.isTypeParameterShadowed(n, name)) return;
+    relationships.push({
+      source,
+      target: name,
+      type: ASTEngine.RelationshipType.References,
+      confidence: 0.95,
+      line_number: this.nodeLine(n),
+      metadata: {
+        isTypeMention: true,
+        typePosition: position,
+        isIndexResolved: !fileTypes.has(name)
+      }
+    });
+  }
+  /**
+   * Is `name` bound by a TYPE PARAMETER of an enclosing declaration?
+   * `class Box<T> { T value; }` — `T` here is the type variable the class
+   * introduced, so the mention is not a reference to a declared type even when
+   * something in the project is also called `T`.
+   */
+  isTypeParameterShadowed(n, name) {
+    let cur = n.parent;
+    let guard = 0;
+    while (cur && guard++ < 32) {
+      const tp = this.findChildByType(cur, "type_parameters");
+      if (tp) {
+        for (let i = 0; i < tp.namedChildCount; i++) {
+          const c = tp.namedChild(i);
+          if (!c || c.type !== "type_parameter") continue;
+          const declared = c.childForFieldName?.("name")?.text ?? this.findChildByType(c, "type_identifier")?.text;
+          if (declared === name) return true;
+        }
+      }
+      cur = cur.parent;
+    }
+    return false;
+  }
+  // ============================================================================
+  // CLASS HERITAGE
+  // ============================================================================
+  extractClassHeritage(node, className, relationships, patterns) {
+    const mixinAppCls = this.findChildByType(node, "mixin_application_class");
+    if (mixinAppCls) {
+      const app = this.findChildByType(mixinAppCls, "mixin_application");
+      if (app) {
+        const baseNode = this.resolvedHeritageNodes(app)[0] ?? null;
+        if (baseNode) {
+          relationships.push({
+            source: className,
+            target: baseNode.text,
+            type: ASTEngine.RelationshipType.Extends,
+            confidence: 1,
+            line_number: this.nodeLine(baseNode),
+            metadata: {}
+          });
+        }
+        const mx = this.findChildByType(app, "mixins");
+        if (mx) {
+          patterns["Mixins"] = true;
+          for (const ti of this.resolvedHeritageNodes(mx)) {
+            relationships.push({
+              source: className,
+              target: ti.text,
+              type: ASTEngine.RelationshipType.MixesIn,
+              confidence: 1,
+              line_number: this.nodeLine(ti),
+              metadata: { isMixin: true }
+            });
+          }
+        }
+      }
+    }
+    if (node.type === "mixin_declaration") {
+      const onNodes = this.resolvedHeritageNodes(node).filter((n) => n.text !== className);
+      for (const baseNode of onNodes) {
+        relationships.push({
+          source: className,
+          target: baseNode.text,
+          type: ASTEngine.RelationshipType.References,
+          confidence: 1,
+          line_number: this.nodeLine(baseNode),
+          metadata: { isMixinOn: true, isTypeMention: true, typePosition: "mixin_on_clause" }
+        });
+      }
+    }
+    const superclass = this.findChildByType(node, "superclass");
+    if (superclass) {
+      const baseNode = this.resolvedHeritageNodes(superclass)[0] ?? null;
+      if (baseNode) {
+        relationships.push({
+          source: className,
+          target: baseNode.text,
+          type: ASTEngine.RelationshipType.Extends,
+          confidence: 1,
+          line_number: this.nodeLine(baseNode),
+          metadata: {}
+        });
+      }
+    }
+    const interfaces = this.findChildByType(node, "interfaces");
+    if (interfaces) {
+      for (const ti of this.resolvedHeritageNodes(interfaces)) {
+        relationships.push({
+          source: className,
+          target: ti.text,
+          type: ASTEngine.RelationshipType.Implements,
+          confidence: 1,
+          line_number: this.nodeLine(ti),
+          metadata: { isImplements: true }
+        });
+      }
+    }
+    let mixinsNode = superclass ? this.findChildByType(superclass, "mixins") : void 0;
+    if (!mixinsNode) mixinsNode = this.findChildByType(node, "mixins");
+    if (mixinsNode) {
+      patterns["Mixins"] = true;
+      for (const ti of this.resolvedHeritageNodes(mixinsNode)) {
+        relationships.push({
+          source: className,
+          target: ti.text,
+          type: ASTEngine.RelationshipType.MixesIn,
+          confidence: 1,
+          line_number: this.nodeLine(ti),
+          metadata: { isMixin: true }
+        });
+      }
+    }
+  }
+  // ============================================================================
+  // `renders` — A COMPONENT RENDERS ANOTHER COMPONENT
+  // ============================================================================
+  //
+  // THE CONTRACT (`src/ast/types.ts:131-140`): *"A component RENDERS another component: source = the
+  // rendering symbol, target = the rendered component."* The fleet's OTHER lanes publish it in
+  // three different languages and ALL THREE use this shape — the RENDERING SYMBOL as the source and
+  // the RENDERED COMPONENT'S NAME as the target:
+  //
+  //   · typescript/js (`real-typescript-analyzer.ts:6758`, `real-javascript-analyzer.ts:2667`):
+  //     source = the enclosing component function, target = the JSX tag name, and a LOWERCASE tag is
+  //     NOT a component (the language's own capitalization convention).
+  //   · clojure (`real-clojure-analyzer.ts:1584`): source = the enclosing fn, target = the component
+  //     symbol inside a hiccup vector — a VECTOR LITERAL, an EXISTING node type, no grammar change.
+  //   · csharp (`real-csharp-analyzer.ts:2285`): source = the rendering context, target = the
+  //     component named by a TYPE ARGUMENT — an EXISTING node type, no grammar change.
+  //
+  // ⇒⇒ THE VALUE IS NOT JSX-SPECIFIC, AND FOR DART THE CONSTRUCT IS FLUTTER'S `build` METHOD:
+  // `class Home extends StatelessWidget { Widget build(BuildContext context) => Scaffold(); }`
+  // `Home` IS the component and `Scaffold` IS the component it renders — the structural analogue of
+  // a React component returning `<Scaffold/>`. Dart has no JSX, so the syntax that carries the
+  // construct is the rendering ENTRY POINT, which is what the `build` method is.
+  //
+  // THE TRIGGER, AND WHY IT IS NOT THE METHOD NAME ALONE:
+  //   · the method is named `build` (Flutter's rendering entry point), AND
+  //   · its DECLARED RETURN TYPE is `Widget` — the framework's own marker, the same kind of
+  //     language-level convention the JS lane reads off capitalization. Without it, any class with
+  //     a `build()` method would qualify, including the protobuf-style message builders whose
+  //     `build()` returns a message and not a component.
+  // The measured populations behind both halves are in
+  // `validation/m14/measurements/dart-extended-constructs-2026-10-21.json`.
+  //
+  // WHAT DOES NOT FIRE, each for its own reason (and each pinned by the fixture):
+  //   · a `build` method whose body returns a VARIABLE or a CALL — no component is NAMED, so there
+  //     is nothing to render (the nearest construct, a call, stays a `calls` row);
+  //   · a `build` method whose declared return type is not `Widget` — not a rendering host;
+  //   · a construction that is NOT the returned expression — it is a `calls`/`instantiates` row,
+  //     because the widget tree is not the return value;
+  //   · a LOWERCASE name — Dart's class-naming convention, the same test the JS lane applies to a
+  //     JSX tag (`<div>` is an intrinsic, not a component).
+  extractRenderRelationships(node, className, relationships) {
+    const classBody = node.childForFieldName("body");
+    if (!classBody) return;
+    for (const member of classBody.namedChildren) {
+      if (!member || member.type !== "method_signature") continue;
+      const fsig = member.namedChildren.find((k) => k && k.type === "function_signature");
+      if (!fsig) continue;
+      if (fsig.childForFieldName("name")?.text !== "build") continue;
+      const first = fsig.namedChild(0);
+      const declared = first && (first.type === "type_identifier" || first.type === "type") ? first.text : "";
+      if (declared !== "Widget") continue;
+      let body = member.nextNamedSibling;
+      while (body && body.type !== "function_body" && body.type !== "method_signature") {
+        body = body.nextNamedSibling;
+      }
+      if (!body || body.type !== "function_body") continue;
+      const block = body.namedChildren.find((k) => k && k.type === "block");
+      const ret = (block ?? body).namedChildren.find((k) => k && k.type === "return_statement");
+      const expr = ret ? ret.namedChild(0) : body.namedChildren.find((k) => k && k.type !== "comment") ?? null;
+      const target = this.renderedComponentName(expr);
+      if (!target) continue;
+      relationships.push({
+        source: className,
+        target,
+        type: ASTEngine.RelationshipType.Renders,
+        confidence: 0.9,
+        line_number: this.nodeLine(expr),
+        metadata: { isRenderHost: true, renderHost: "build", renderTarget: target }
+      });
+    }
+  }
+  /**
+   * THE NAME OF THE COMPONENT A CONSTRUCTION EXPRESSION NAMES — dart spells a construction three
+   * ways and all three name the type: `const T()` is a `const_object_expression`, `new T()` is a
+   * `new_expression`, and the modern `T()` is a BARE `identifier` FOLLOWED BY A `selector` (the
+   * call). A bare identifier with NO selector is a VARIABLE, not a construction — that distinction
+   * is the refusal, and it is why the selector is checked rather than the identifier alone.
+   */
+  renderedComponentName(expr) {
+    if (!expr) return null;
+    let name = null;
+    if (expr.type === "const_object_expression" || expr.type === "new_expression") {
+      const t = expr.childForFieldName("type") ?? expr.namedChildren.find((k) => k && (k.type === "type_identifier" || k.type === "identifier"));
+      name = t ? t.text : null;
+    } else if (expr.type === "identifier") {
+      const sib = expr.nextNamedSibling;
+      name = sib && sib.type === "selector" ? expr.text : null;
+    }
+    if (!name) return null;
+    const first = name[0];
+    if (!first || first === first.toLowerCase()) return null;
+    return name;
+  }
+  // ============================================================================
+  // EVIDENCE TIERS
+  // ============================================================================
+  /**
+   * Evidence-tier classification (family contract — mirrors csharp/java/rust;
+   * M14 section D requires >=2 distinct evidenceClass values). Same rules as
+   * the managed-OO family: structural (grammar clauses, conf 1.0) |
+   * usage_contextual (calls, mixin uses) | import_based (import/export/part
+   * directives) | inferred (confidence < 1 edges).
+   */
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const type = r.type ?? r.relationshipType ?? "";
+      const md = r.metadata ?? {};
+      if (type === "contains") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (type === "imports" || type === "exports") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (type === "part_of") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (type === "mixes_in") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (type === "calls" || type === "uses") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (type === "instantiates" || type === "extends" || type === "implements") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.9 ? "structural" : "inferred";
+        continue;
+      }
+      if (type === "overrides") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (type === "renders") {
+        md.evidenceClass = "usage_contextual";
+        continue;
+      }
+      if (type === "references") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  // ============================================================================
+  // HELPERS
+  // ============================================================================
+  /**
+   * The library this file declares: its name, the node that declared it, and which of
+   * the three directive forms it was.
+   *
+   * `library X;` names the library X. No `library` directive means the file is an
+   * implicit library named by its stem (Dart spec). `library;` — legal, and 101 of a
+   * 3,000-file sample — declares a library with NO name, so the stem there is this
+   * analyzer's convention and the caller records it as `kind: "unnamed"` rather than
+   * letting a consumer read it as a declared fact.
+   *
+   * The declared name is read from the parse tree, never from a regex over the text,
+   * because it is frequently DOTTED: `_fe_analyzer_shared.scanner.characters`, which a
+   * first-token match truncates to `_fe_analyzer_shared` — a name no other file imports.
+   * The corpus measurement that established the three frequencies and the `annotation`
+   * case is `validation/m14/fixtures/dart/library-directive-census.ts`; the
+   * `annotation` case is why the child must pass an IDENTIFIER shape test rather than
+   * being taken as text.
+   *
+   * Only a DIRECT child of `program` is considered: a `library_name` anywhere else in
+   * the tree is a declaration inside a part or a raw string (52 of 3,000 sampled files
+   * carry `library X;` inside a `'''...'''` test fixture, which is not a directive at
+   * all), not this file's library. Measured: no sampled file has more than one
+   * top-level `library_name`, so "first valid" is not a choice between two candidates.
+   */
+  libraryName(rootNode, filePath) {
+    const stem = path.basename(filePath, path.extname(filePath));
+    for (let i = 0; i < rootNode.namedChildCount; i++) {
+      const child = rootNode.namedChild(i);
+      if (!child || child.type !== "library_name") continue;
+      if (child.namedChildCount === 0) return { name: stem, directive: child, kind: "unnamed" };
+      for (let j = 0; j < child.namedChildCount; j++) {
+        const nameNode = child.namedChild(j);
+        if (!nameNode) continue;
+        const declared = stripWhitespace(nameNode.text);
+        if (declared.length > 0 && isDottedIdentifier(declared)) {
+          return { name: declared, directive: child, kind: "named" };
+        }
+      }
+    }
+    return { name: stem, directive: null, kind: "implicit" };
+  }
+  isDartGlobalBuiltin(name) {
+    if (name === "print" || name === "assert" || name === "identical") return true;
+    if (name === "toString" || name === "hashCode" || name === "runtimeType" || name === "noSuchMethod") return true;
+    return false;
+  }
+  selectorIsBareCall(selector) {
+    const prev = selector.previousNamedSibling;
+    if (!prev) return false;
+    return prev.type === "identifier" || prev.type === "type_identifier";
+  }
+  resolveSelectorCallee(selector) {
+    return this.resolveSelectorCalleeNode(selector)?.text ?? null;
+  }
+  /** Node form of `resolveSelectorCallee` — the CALLEE identifier is the node
+   *  that names a call/instantiates edge (M60 line contract). */
+  resolveSelectorCalleeNode(selector) {
+    const prev = selector.previousNamedSibling;
+    if (!prev) return null;
+    if (prev.type === "unconditional_assignable_selector" || prev.type === "conditional_assignable_selector" || prev.type === "selector") {
+      const inner = this.findChildByType(prev, "identifier");
+      if (inner) return inner;
+      return this.lastIdentifierNode(prev);
+    }
+    if (prev.type === "identifier" || prev.type === "type_identifier") {
+      return prev;
+    }
+    return null;
+  }
+  lastIdentifier(node) {
+    return this.lastIdentifierNode(node)?.text ?? null;
+  }
+  /**
+   * Node form of `lastIdentifier`: the identifier that NAMES a cascade link's
+   * edge is also the node whose line the edge carries (M60 line contract), so
+   * both views come from ONE traversal and cannot disagree.
+   */
+  lastIdentifierNode(node) {
+    let result = null;
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "identifier" || n.type === "type_identifier") result = n;
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return result;
+  }
+  /**
+   * DT-A/DT-F: the member identifier of a link selector
+   * (`unconditional_assignable_selector` / `conditional_assignable_selector`
+   * child holding `method` in `obj.method`, `?.value`, `..length`).
+   */
+  linkMember(sel) {
+    return this.linkMemberNode(sel)?.text ?? null;
+  }
+  /** Node form of `linkMember`: the member identifier itself is the node that
+   *  NAMES a member-read/tear-off edge (M60 line contract). */
+  linkMemberNode(sel) {
+    const probe = sel.type === "selector" ? this.namedChildrenOf(sel) : [sel];
+    for (const c of probe) {
+      if (c.type === "unconditional_assignable_selector" || c.type === "conditional_assignable_selector" || c.type === "cascade_selector") {
+        const id = this.findChildByType(c, "identifier") ?? this.findChildByType(c, "type_identifier");
+        if (id) return id;
+      }
+    }
+    return null;
+  }
+  namedChildrenOf(n) {
+    const out = [];
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c = n.namedChild(i);
+      if (c) out.push(c);
+    }
+    return out;
+  }
+  /**
+   * DT-A: receiver chain of an invocation, walking back through
+   * link-selector siblings from the argument-carrying selector.
+   * `P.Foo.bar()` -> head `P`, links [`Foo`, `bar`]; bare `foo()` ->
+   * head `foo`, no links.
+   */
+  invocationChain(argsSelector) {
+    const links = [];
+    let c = argsSelector.previousNamedSibling;
+    while (c) {
+      if (c.type === "selector") {
+        const m = this.linkMember(c);
+        if (!m) break;
+        links.unshift(m);
+        c = c.previousNamedSibling;
+      } else if (c.type === "unconditional_assignable_selector" || c.type === "conditional_assignable_selector") {
+        const id = this.findChildByType(c, "identifier") ?? this.findChildByType(c, "type_identifier");
+        if (!id) break;
+        links.unshift(id.text);
+        c = c.previousNamedSibling;
+      } else break;
+    }
+    return { head: c, links };
+  }
+  headNameText(head) {
+    if (head && (head.type === "identifier" || head.type === "type_identifier")) return head.text;
+    return null;
+  }
+  /**
+   * DT-F: true when the selector sits in an assignment LHS write position
+   * with a plain `=` operator (`a.b = c` writes b; `a.b += c` and `a.b ??= c`
+   * read it). Span-matched like the C analyzer's LHS gate.
+   */
+  selectorIsLhsWrite(sel) {
+    let p = sel.parent;
+    let guard = 0;
+    while (p && guard++ < 16) {
+      if (p.type === "assignment_expression") {
+        let opText = null;
+        for (let i = 0; i < p.childCount; i++) {
+          const c = p.child(i);
+          if (c && !c.isNamed && c.text.includes("=")) {
+            opText = c.text;
+            break;
+          }
+        }
+        if (opText !== "=") return false;
+        const lhs = p.namedChild(0);
+        if (lhs && lhs.startIndex <= sel.startIndex && lhs.endIndex >= sel.endIndex) return true;
+        return false;
+      }
+      if (p.type === "function_body" || p.type === "block" || p.type === "class_body" || p.type === "program" || p.type === "declaration") return false;
+      p = p.parent;
+    }
+    return false;
+  }
+  /** DT-F: declaration-name positions whose identifiers are binds, never reads. */
+  isDartDeclNameParent(ptype) {
+    return ptype === "formal_parameter" || ptype === "constructor_param" || ptype === "function_signature" || ptype === "method_signature" || ptype === "getter_signature" || ptype === "setter_signature" || ptype === "type_alias" || ptype === "label" || // #752: field / static-field declaration names (`int count = 0;`,
+    // `static final int x = 1;`) — the declaration is a BIND, not a read.
+    ptype === "initialized_identifier" || ptype === "static_final_declaration" || ptype === "class_definition" || ptype === "enum_declaration" || ptype === "mixin_declaration" || ptype === "extension_declaration" || // M60 (#933 triage): `enum_declaration` covered the enum's OWN name but
+    // not each VALUE's node, so every enum constant was published as a bare
+    // read of its own enum (`uses Shape -> circle` at the declaration line,
+    // confidence 0.6). The M12 harness files sub-threshold facts as
+    // `unknown`, never as false positives, which is how it survived the
+    // lane's whole fixture and mutant program — probe-verified node shape:
+    // `(enum_body (enum_constant (identifier)))`. The constant's ARGUMENTS
+    // are outside this gate and stay ordinary reads.
+    ptype === "enum_constant" || // DARTD21: an extension type's container name AND its representation
+    // field name (`extension type X._(T object$)`) are declarations.
+    ptype === "extension_type_declaration" || ptype === "representation_declaration" || // DARTD22: a signature's OWN name binds, and the constructor-shaped
+    // signatures were the one family missing from this set. A constructor
+    // `Real()` and an UNTYPED METHOD `untypedMethod()` parse into the same
+    // node, and in both the leading `identifier` is the declared name — so
+    // without this row every one of them published a bare read of ITSELF
+    // (`uses untypedMethod -> untypedMethod` at 0.6). Before DARTD22 the same
+    // node was published as a member called `constructor`, so the read was
+    // invisible: the source and the target were two different wrong names and
+    // cancelled out. Fixing only the symbol left the self-loop visible, which
+    // is why the row belongs here and not in the constructor dispatch.
+    ptype === "constructor_signature" || ptype === "factory_constructor_signature" || ptype === "constant_constructor_signature" || ptype === "redirecting_factory_constructor_signature";
+  }
+  /**
+   * DT-F+ (#752): the names a function scope binds locally — its own
+   * declarators plus formal / constructor / catch parameters. Used by the
+   * bare-member-read gate so a name the CURRENT FUNCTION binds suppresses the
+   * member read (CGD15 parity: a local is not a member, #299 — a false edge is
+   * worse than a missing one). O(subtree), no regex.
+   */
+  /**
+   * THE DECLARED TYPE OF EVERY LOCAL A SUBTREE BINDS (`collectDartLocals`' twin).
+   *
+   * The NAME set answers "is this a local", which is what suppresses a false member read.
+   * It cannot answer "what IS this local", which is what makes a call target determinate:
+   * `r.getOrders()` with `void run(OrderRepository r)` names `OrderRepository.getOrders`, and
+   * without the type the edge can only say `getOrders` — the bare-name population the
+   * incoming gate counts as ambiguous whenever any other declaration in the PROJECT shares
+   * the name.
+   *
+   * Two shapes, and both are read off the GRAMMAR rather than guessed from text:
+   *
+   *   local_variable_declaration   the declared type is a direct child (`extractFieldType`,
+   *                                the same reader fields use — `Baz y = Baz();`). It is
+   *                                `undefined` for `var x = Widget();`, so the fallback below
+   *                                is not a convenience: it is the only reading available.
+   *   initialized_variable_definition
+   *                                no declared type, so the INITIALIZER names it when it is a
+   *                                construction (`Widget()`), which is a fact about the source
+   *                                and not an inference about the program.
+   *
+   * `Widget? w` is deliberately NOT reduced (`extractFieldType` does not know the nullable
+   * wrapper) and a generic type is refused by `plainTypeName` — a receiver typed `List<int>`
+   * resolves through a type argument this pass has not read, and naming the wrong declaration
+   * is worse than naming none.
+   */
+  collectDartLocalTypes(root) {
+    const out = /* @__PURE__ */ new Map();
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      const t = n.type;
+      if (t === "for_loop_parts") {
+        const nameNode = n.childForFieldName?.("name");
+        const iterable = n.childForFieldName?.("value");
+        const inferred = (n.namedChildren ?? []).some((c) => c?.type === "inferred_type");
+        if (nameNode && iterable && !inferred) {
+          const nameIdx = (n.namedChildren ?? []).findIndex(
+            (c) => c && c.startIndex === nameNode.startIndex && c.endIndex === nameNode.endIndex
+          );
+          for (let i = 0; i < nameIdx; i++) {
+            const c = n.namedChild(i);
+            if (c && c.type === "type_identifier") {
+              const plain = stripNullableSuffix(c.text);
+              if (isPlainIdentifier(plain)) out.set(nameNode.text, { type: plain, evidence: "annotation" });
+              break;
+            }
+          }
+        }
+      }
+      if (t === "catch_clause") {
+        const prev = n.previousNamedSibling;
+        const typeNode = prev && (prev.type === "type_identifier" || prev.type === "nullable_type") ? prev : void 0;
+        const typeLeaf = typeNode ? typeNode.type === "type_identifier" ? typeNode.text : this.findChildByType(typeNode, "type_identifier")?.text : void 0;
+        const typeName = typeLeaf ? stripNullableSuffix(String(typeLeaf)) : void 0;
+        const params = this.findChildByType(n, "catch_parameters");
+        if (typeName && isPlainIdentifier(typeName) && params) {
+          for (const c of params.namedChildren ?? []) {
+            if (c && c.type === "identifier") out.set(c.text, { type: typeName, evidence: "annotation" });
+          }
+        }
+      }
+      if (t === "local_variable_declaration" || t === "declaration" || t === "initialized_variable_definition") {
+        const name = n.childForFieldName?.("name")?.text ?? this.findChildByType(n, "initialized_variable_definition")?.childForFieldName?.("name")?.text;
+        if (name && !out.has(name)) {
+          const explicit = this.extractFieldType(n, n);
+          const typeName = explicit ? stripNullableSuffix(String(explicit)) : this.constructedTypeName(n);
+          if (typeName && isPlainIdentifier(typeName)) {
+            let element;
+            const args = this.findChildByType(n, "type_arguments");
+            let keyElement;
+            if (args) {
+              const argsIds = [];
+              const argStack = [args];
+              while (argStack.length > 0) {
+                const a = argStack.pop();
+                if (a.type === "type_identifier") {
+                  argsIds.push(a.text);
+                  continue;
+                }
+                for (const c of a.namedChildren ?? []) if (c) argStack.push(c);
+              }
+              if (_RealDartAnalyzer.DART_ELEMENT_CONTAINERS.has(typeName)) element = argsIds[0];
+              else if (_RealDartAnalyzer.DART_MAP_CONTAINERS.has(typeName)) {
+                keyElement = argsIds[0];
+                element = argsIds[1];
+              }
+            }
+            out.set(name, { type: typeName, evidence: explicit ? "annotation" : "assignment", ...element ? { element } : {}, ...keyElement ? { keyElement } : {} });
+          }
+        }
+      }
+      for (const c of n.namedChildren ?? []) if (c) stack.push(c);
+    }
+    const awaits = [];
+    const awaitStack = [root];
+    while (awaitStack.length > 0) {
+      const n = awaitStack.pop();
+      if (n.type === "initialized_variable_definition") {
+        const nameNode = n.childForFieldName?.("name");
+        const value = n.childForFieldName?.("value");
+        if (nameNode && value && value.type === "await_expression") {
+          const operand = this.findChildByType(value, "identifier");
+          if (operand) awaits.push({ name: nameNode.text, operand: operand.text });
+        }
+      }
+      for (const c of n.namedChildren ?? []) if (c) awaitStack.push(c);
+    }
+    for (let round = 0; round < 3 && awaits.length > 0; round++) {
+      let changed = false;
+      for (const a of awaits) {
+        if (out.has(a.name)) continue;
+        const fut = out.get(a.operand);
+        if (!fut || !fut.element) continue;
+        if (!_RealDartAnalyzer.DART_ELEMENT_CONTAINERS.has(fut.type)) continue;
+        out.set(a.name, { type: fut.element, evidence: "annotation" });
+        changed = true;
+      }
+      if (!changed) break;
+    }
+    return out;
+  }
+  /**
+   * AWAITED LOCALS: `final repo = await pending;` where the awaited variable's type is written as
+   * `Future<Repo>` — the awaited VALUE's type is the future's type argument (written evidence, the
+   * `annotation` class). Returns the declarations to type; the caller applies them to the body scope
+   * so SIBLING statements see them. Grammar note: `await pending` parses as
+   * `unary_expression > await_expression > identifier` (probed), not as a bare await_expression.
+   */
+  collectAwaitLocalTypes(root, localElements, localTypes) {
+    const out = /* @__PURE__ */ new Map();
+    const decls = [];
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "initialized_variable_definition") {
+        const nameNode = n.childForFieldName?.("name");
+        const valueRaw = n.childForFieldName?.("value");
+        const awaitNode = valueRaw && valueRaw.type === "unary_expression" ? this.findChildByType(valueRaw, "await_expression") : valueRaw;
+        if (nameNode && awaitNode && awaitNode.type === "await_expression") {
+          const operand = this.findChildByType(awaitNode, "identifier");
+          if (operand) decls.push({ name: nameNode.text, operand: operand.text });
+        }
+      }
+      for (const c of n.namedChildren ?? []) if (c) stack.push(c);
+    }
+    for (let round = 0; round < 3 && decls.length > 0; round++) {
+      let changed = false;
+      for (const d of decls) {
+        if (out.has(d.name) || localTypes.has(d.name)) continue;
+        const fut = localTypes.get(d.operand) ?? "";
+        const element = localElements.get(d.operand);
+        if (!element) continue;
+        if (fut !== "Future" && fut !== "FutureOr") continue;
+        out.set(d.name, element);
+        changed = true;
+      }
+      if (!changed) break;
+    }
+    return out;
+  }
+  /** The type a variable's INITIALIZER constructs: `var x = Widget()` -> `Widget`.
+   *  `new`/`const` expressions and a bare capitalized callee are all constructions in
+   *  Dart, and a lowercase callee is a function call whose RESULT type this pass has not
+   *  read — so it returns undefined rather than the callee's name. */
+  constructedTypeName(n) {
+    const value = n.childForFieldName?.("value");
+    if (!value) return void 0;
+    const head = value.type === "constructor_invocation" || value.type === "new_expression" || value.type === "const_object_expression" ? this.findChildByType(value, "type_identifier") : value.type === "identifier" || value.type === "type_identifier" ? value : null;
+    const text = head?.text;
+    if (!text || !isCapitalized(text)) return void 0;
+    return text;
+  }
+  /**
+   * PARAMETER DECLARED TYPES, from the signature node the body follows.
+   *
+   * `extractParameters` is the reader the symbol payload already uses (and its fixture
+   * asserts), so a parameter is typed here exactly as it is typed on the symbol — one
+   * reader, two consumers. A parameter whose type is not a plain identifier contributes
+   * nothing, which is the conservative half of the rule.
+   */
+  /** Container types whose ELEMENT type this lane can read from a written type argument. */
+  static DART_ELEMENT_CONTAINERS = /* @__PURE__ */ new Set([
+    "List",
+    "Iterable",
+    "Set",
+    "Queue",
+    "Stream",
+    "Iterator",
+    "ListQueue",
+    "DoubleLinkedQueue",
+    // `Future<T>`: the AWAITED value is T, and `await f` is written evidence of exactly the same
+    // class as a declared local — it types the receiver of the statements after the await.
+    "Future",
+    "FutureOr"
+  ]);
+  /** Map types whose KEY/VALUE type arguments this lane can read (value = `element`, key = `keyElement`). */
+  static DART_MAP_CONTAINERS = /* @__PURE__ */ new Set([
+    "Map",
+    "HashMap",
+    "LinkedHashMap",
+    "SplayTreeMap",
+    "UnmodifiableMapView"
+  ]);
+  collectDartParameterTypes(sig) {
+    const out = /* @__PURE__ */ new Map();
+    let params = [];
+    try {
+      params = this.extractParameters(sig) ?? [];
+    } catch {
+      return out;
+    }
+    for (const p of params) {
+      const name = String(p?.name ?? "");
+      const typeName = stripNullableSuffix(String(p?.type ?? ""));
+      if (name && isPlainIdentifier(typeName)) out.set(name, { type: typeName, evidence: "param" });
+    }
+    const stack = [sig];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "formal_parameter" || n.type === "constructor_param" || n.type === "super_formal_parameter") {
+        const nameNode = n.childForFieldName?.("name") ?? this.findChildByType(n, "identifier");
+        const typeNode = this.findChildByType(n, "type_identifier");
+        const args = this.findChildByType(n, "type_arguments");
+        const argsIds = args ? (args.namedChildren ?? []).filter((c) => c && c.type === "type_identifier") : [];
+        const base = typeNode ? stripNullableSuffix(typeNode.text) : "";
+        if (nameNode && argsIds.length > 0 && _RealDartAnalyzer.DART_ELEMENT_CONTAINERS.has(base)) {
+          const prev = out.get(nameNode.text);
+          if (prev) prev.element = argsIds[0].text;
+          else out.set(nameNode.text, { type: base, evidence: "param", element: argsIds[0].text });
+        } else if (nameNode && argsIds.length >= 2 && _RealDartAnalyzer.DART_MAP_CONTAINERS.has(base)) {
+          const prev = out.get(nameNode.text);
+          if (prev) {
+            prev.keyElement = argsIds[0].text;
+            prev.element = argsIds[1].text;
+          } else out.set(nameNode.text, { type: base, evidence: "param", keyElement: argsIds[0].text, element: argsIds[1].text });
+        }
+        continue;
+      }
+      for (const c of n.namedChildren ?? []) if (c) stack.push(c);
+    }
+    return out;
+  }
+  /** The import aliases this file declares (`import 'x.dart' as _i1;`). Only the identifier that
+   *  is a DIRECT child of `import_specification` is an alias — the specifier's own identifiers sit
+   *  inside `configurable_uri`/`uri`, which is why the walk stops at those nodes. */
+  collectImportAliases(root) {
+    const out = /* @__PURE__ */ new Set();
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "import_specification") {
+        for (const c of n.namedChildren ?? []) {
+          if (c && c.type === "identifier") out.add(c.text);
+        }
+        continue;
+      }
+      if (n.type === "uri" || n.type === "configurable_uri" || n.type === "string_literal") continue;
+      for (const c of n.namedChildren ?? []) if (c) stack.push(c);
+    }
+    return out;
+  }
+  collectDartLocals(root) {
+    const out = /* @__PURE__ */ new Set();
+    const stack = [root];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "identifier" && this.isDartDeclaredName(n)) out.add(n.text);
+      if (n.type === "formal_parameter" || n.type === "constructor_param" || n.type === "super_formal_parameter" || n.type === "catch_parameters") {
+        const id = this.findChildByType(n, "identifier");
+        if (id) out.add(id.text);
+      }
+      if (n.type === "for_loop_parts") {
+        for (let i = 0; i < n.childCount; i++) {
+          const c = n.child(i);
+          if (c && !c.isNamed && c.text === "in") {
+            for (let j = 0; j < i; j++) {
+              const pc = n.child(j);
+              if (pc && pc.isNamed && pc.type === "identifier") out.add(pc.text);
+            }
+            break;
+          }
+        }
+      }
+      if (n.type === "variable_pattern") {
+        const id = this.deepIdentifier(n);
+        if (id) out.add(id.text);
+      }
+      if (n.type === "rest_pattern") {
+        const id = this.deepIdentifier(n);
+        if (id) out.add(id.text);
+      }
+      if (n.type === "constant_pattern" && this.isBindingPatternContext(n)) {
+        const id = this.deepIdentifier(n);
+        if (id) out.add(id.text);
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out;
+  }
+  /**
+   * DT2: first document-order `identifier` in a subtree (pattern contents
+   * nest — direct-child lookup misses `var (a, b)`-style bindings).
+   */
+  deepIdentifier(n) {
+    const stack = [n];
+    while (stack.length > 0) {
+      const c = stack.pop();
+      if (c.type === "identifier") return c;
+      for (let i = c.namedChildCount - 1; i >= 0; i--) {
+        const ch = c.namedChild(i);
+        if (ch) stack.push(ch);
+      }
+    }
+    return null;
+  }
+  /**
+   * DARTGAP2: is this node a CONSTANT being TESTED by a pattern — i.e. a position whose
+   * owed relationship is a `uses` read of the constant, not a declaration and not a binding?
+   *
+   * The qualified form (`case M.off:`) is already read by the `qualified`-under-`constant_pattern`
+   * branch (3d4d7fa4). This predicate covers the BARE identifier and the RELATIONAL operand.
+   * The shapes are not inferred from the Dart spec — they were probed against the PINNED grammar
+   * (`validation/m14/fixtures/dart/pattern-forms-probe.ts`):
+   *
+   *   case kOne:               (switch_statement_case (case_builtin) (constant_pattern (identifier)))
+   *   if (x case kOne)         (if_statement (identifier) (constant_pattern (identifier)))
+   *   if (x case kNested?)     (if_statement (identifier) (null_check_pattern (constant_pattern (identifier))))
+   *   if (x case kOne!)        (if_statement (identifier) (null_assert_pattern (constant_pattern (identifier))))
+   *   if (x case >= kOne)      (if_statement (identifier) (relational_operator) (identifier))
+   *                            — tree-sitter-dart has NO `relational_pattern` wrapper, so the
+   *                            operand is a direct child of the `if_statement` whose previous
+   *                            NAMED sibling is the operator; the same shape appears under
+   *                            `switch_statement_case` (probed) and `switch_expression_case`.
+   *   case [kOne, 2]           (list_pattern (constant_pattern (identifier)) (constant_pattern (decimal_integer_literal)))
+   *   case {'a': kOne}         (map_pattern (string_literal) (constant_pattern (identifier)))
+   *   case (kOne, 2)           (record_pattern (constant_pattern (identifier)) (constant_pattern (decimal_integer_literal)))
+   *
+   * THREE EXCLUSIONS, each measured rather than assumed:
+   *   * BINDING context. `var (int a, int b) = ...` parses its names as `variable_pattern`, so
+   *     they never reach this predicate — but a destructuring declaration can still hold a
+   *     `constant_pattern`, and `isBindingPatternContext` is the ONE rule that already decides
+   *     that question for the binding collector. Reused rather than re-spelled.
+   *   * `...rest` in `final [int f, ...rest] = ...` parses as
+   *     `(rest_pattern (constant_pattern (identifier)))` — probed. That identifier is the BINDING
+   *     being declared, not a constant being tested, so reading it would fabricate a use of the
+   *     very name being bound.
+   *   * the `_` wildcard parses as `constant_pattern (identifier "_")` in map patterns (probed:
+   *     `{'b': _}`). `_` is not a constant and no declaration is named by it.
+   */
+  isPatternTestConstant(n) {
+    const id = n.type === "identifier" ? n : null;
+    const p = n.parent;
+    if (!p) return false;
+    if (p.type === "constant_pattern") {
+      if (id && id.text === "_") return false;
+      if (p.parent?.type === "rest_pattern") return false;
+      return !this.isBindingPatternContext(p);
+    }
+    if (p.type === "if_statement" || p.type === "switch_statement_case" || p.type === "switch_expression_case") {
+      return n.previousNamedSibling?.type === "relational_operator";
+    }
+    return false;
+  }
+  /**
+   * DT2: is this pattern node inside a BINDING context? Only structural
+   * descent counts: a `var (a, b)` destructuring binds through record /
+   * list / map wrappers to the declaration (or for-in head). A case TEST
+   * (`InvitationStatus.declined => ...` inside `var x = switch ...`)
+   * crosses a switch/if boundary — it tests, never binds, even when the
+   * whole switch initializes a variable.
+   */
+  isBindingPatternContext(n) {
+    let p = n.parent;
+    let guard = 0;
+    while (p && guard++ < 8) {
+      const t = p.type;
+      if (t === "pattern_variable_declaration" || t === "for_loop_parts") return true;
+      if (t !== "record_pattern" && t !== "list_pattern" && t !== "map_pattern" && t !== "constant_pattern" && t !== "variable_pattern") return false;
+      p = p.parent;
+    }
+    return false;
+  }
+  /**
+   * THE DECLARATION A LOCAL READ BINDS TO — the innermost enclosing scope that declares the
+   * name, and the identity that makes two reads of the same name DIFFERENT facts when they
+   * read DIFFERENT declarations.
+   *
+   * WHY IT EXISTS. A local read's spelling is `<callable>\u0000<name>`, and the CALLABLE is the
+   * enclosing FUNCTION — so two reads of two different declarations that share a name inside one
+   * function spell IDENTICALLY. The relationship dedup key (`type|source|target|confidence`)
+   * carried no line, so the two collapsed into one row and the second was LOST: a resolution
+   * loss wearing a dedup's clothes.
+   *
+   * THE SCOPE RULE, measured on the dart lane's own `nested-block-shadows-member` fixture (its
+   * line numbers are the fixture's):
+   *
+   *     44:  int value = 0;    // the FIELD
+   *     47:  var value = 1;    // the BODY local
+   *     48:  print(value);      // -> the body local
+   *     50:    var value = 2;  // the NESTED declaration, shadowing the body local
+   *     51:    print(value);    // -> the NESTED local
+   *     53:  print(value);      // -> the BODY local again
+   *
+   * Dart's block scope: an inner declaration shadows an outer binding of the same name for the
+   * whole of the inner block. So the read at 51 reads a DIFFERENT declaration from the reads at
+   * 48 and 53 — and the read at 53 reads the SAME declaration as the read at 48, so those two
+   * are ONE relationship and must still collapse.
+   *
+   * WHY A BLOCK'S OWN DECLARATIONS, not its whole subtree. The scope of a declaration is the
+   * block that holds it, so the nested block's `value` is NOT a declaration of the outer block.
+   * A subtree scan would find it and attribute the read at 53 to the nested declaration — which
+   * is the same class of mistake as the analyzer's own `heritageByClass` comment records
+   * ("a `uses` edge is evidence that a type is relevant to this file — but it is not a BASE").
+   *
+   * THE RESULT IS A SCOPE IDENTITY, not a line: the enclosing scope's own start position, plus
+   * the declaration's own line. Two reads of the SAME declaration share it; two reads of
+   * DIFFERENT declarations do not. It rides the row as `localBindingScope` and joins the dedup
+   * key ONLY for a `localBinding` row — every other row keeps its key byte for byte, so the
+   * 192,761-row payload-pollution dedup is untouched.
+   */
+  localBindingScope(n, name) {
+    let p = n.parent;
+    let guard = 0;
+    while (p && guard++ < 64) {
+      if (p.type === "block" || p.type === "function_body") {
+        const decl = this.scopeOwnDeclaration(p, name, n.startIndex);
+        if (decl !== null) {
+          return { localBindingScope: `${p.startIndex}:${decl}` };
+        }
+      }
+      p = p.parent;
+    }
+    return null;
+  }
+  // ══ THE SCOPE-DECLARATION INDEX — ONE WALK PER SCOPE, NOT ONE WALK PER READ.
+  //
+  // `scopeOwnDeclaration` used to walk the ENTIRE subtree of the enclosing scope for EVERY local
+  // read. On ordinary files that is invisible; on a file of deeply nested statements it is fatal,
+  // because each of the N reads walks a subtree that contains most of the file, so the pass is
+  // O(N × subtree) — quadratic in DEPTH. Measured on `deep_nesting_statement_test.dart`
+  // (350,435 B, 130,042 nodes): the raw tree walk costs 187 ms (0.0014 ms/node) while the analyzer
+  // spent ~3.8 ms per node-visit, and this function is where that went.
+  //
+  // The fix is the same shape the gate's `addKey` fix had: PAY ONCE. A scope's own declarations are
+  // a property of the SCOPE, so they are indexed on first use and every later read is a lookup.
+  // The key is `${startIndex}:${endIndex}:${type}` and NOT the node object, because web-tree-sitter
+  // hands out FRESH wrappers on every traversal — a memo keyed on the object would never hit and
+  // would grow without bound. A memo that never hits is a leak with extra steps.
+  //
+  // The index is cleared at the top of `analyze()`: an analyzer instance outlives one file, and a
+  // cache that outlived it would serve one file's declarations to the next file's reads.
+  scopeDeclIndex = /* @__PURE__ */ new Map();
+  /**
+   * THE DECLARATION OF `name` THAT BELONGS TO THIS SCOPE — the block's OWN declarations, not
+   * the ones in a nested block (a nested block is a DIFFERENT scope, and a declaration there
+   * does not belong to this one). Returns the declaration's START INDEX, which is all the caller
+   * needs (`<scopeStart>:<declStart>`), so no node is retained.
+   */
+  scopeOwnDeclaration(scope, name, before) {
+    const key = `${scope.startIndex}:${scope.endIndex}:${scope.type}`;
+    let index = this.scopeDeclIndex.get(key);
+    if (!index) {
+      index = /* @__PURE__ */ new Map();
+      const walk = (n, depth) => {
+        if (depth > 64) return;
+        for (let i = 0; i < n.namedChildCount; i++) {
+          const c = n.namedChild(i);
+          if (!c) continue;
+          if (c.type === "block" || c.type === "function_body" || c.type === "class_body") continue;
+          if (c.type === "identifier" && this.isDartDeclaredName(c)) {
+            const arr = index.get(c.text);
+            if (arr) arr.push(c.startIndex);
+            else index.set(c.text, [c.startIndex]);
+          }
+          walk(c, depth + 1);
+        }
+      };
+      walk(scope, 0);
+      this.scopeDeclIndex.set(key, index);
+    }
+    const starts = index.get(name);
+    if (!starts || starts.length === 0) return null;
+    let best = -1;
+    for (const s of starts) if (s < before && s > best) best = s;
+    return best < 0 ? null : best;
+  }
+  /**
+   * DT-F: is this identifier the DECLARED name of its definition
+   * (`var q = ...`, `int xs[3]`, `int xs[3] = ...`)? Names precede the
+   * first `=` child; values follow it. Definitions without `=` bind every
+   * identifier they directly hold.
+   */
+  isDartDeclaredName(n) {
+    const parent = n.parent;
+    if (!parent) return false;
+    const ptype = parent.type;
+    if (ptype !== "initialized_variable_definition" && ptype !== "static_final_declaration") return false;
+    let eqIdx = -1;
+    let myIdx = -1;
+    for (let i = 0; i < parent.childCount; i++) {
+      const c = parent.child(i);
+      if (!c) continue;
+      if (!c.isNamed && c.text === "=" && eqIdx === -1) eqIdx = i;
+      if (c.isNamed && c.startIndex === n.startIndex && c.endIndex === n.endIndex) myIdx = i;
+    }
+    if (myIdx === -1) return false;
+    if (eqIdx === -1) return true;
+    return myIdx < eqIdx;
+  }
+  /** DT-F: is this selector an index operation (`xs[0]` parses the index
+   *  as a member-less selector holding brackets)? Member selectors name a
+   *  member; argument selectors invoke. Bounded shape scan, never regex. */
+  isIndexSelector(sel) {
+    if (this.linkMember(sel) !== null) return false;
+    if (this.findChildByType(sel, "argument_part")) return false;
+    return this.subtreeHasBracket(sel);
+  }
+  /** DT-F: is this assignable an index target (`xs[3] = 4` wraps the base
+   *  and index in assignable_expression)? Same member-less + bracket test
+   *  applied to the node itself. */
+  isIndexAssignable(sel) {
+    if (sel.type !== "unconditional_assignable_selector" && sel.type !== "conditional_assignable_selector") return false;
+    if (this.findChildByType(sel, "identifier") ?? this.findChildByType(sel, "type_identifier")) return false;
+    return this.subtreeHasBracket(sel);
+  }
+  subtreeHasBracket(sel) {
+    const stack = [sel];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 32) {
+      const c = stack.pop();
+      if (!c.isNamed && (c.text === "[" || c.text === "?[")) return true;
+      for (let i = 0; i < c.childCount; i++) {
+        const ch = c.child(i);
+        if (ch) stack.push(ch);
+      }
+    }
+    return false;
+  }
+  /** DT-F: bounded ancestor climb — is this node inside string interpolation? */
+  isInsideTemplateSubstitution(n) {
+    let p = n.parent;
+    let guard = 0;
+    while (p && guard++ < 8) {
+      if (p.type === "template_substitution") return true;
+      if (p.type === "function_body" || p.type === "block" || p.type === "class_body" || p.type === "program" || p.type === "declaration") return false;
+      p = p.parent;
+    }
+    return false;
+  }
+  isSignatureNode(type) {
+    return type === "function_signature" || type === "method_signature" || type === "getter_signature" || type === "setter_signature" || type === "constructor_signature" || type === "factory_constructor_signature" || type === "constant_constructor_signature" || type === "redirecting_factory_constructor_signature" || type === "operator_signature";
+  }
+  isConstructorSignature(type) {
+    return type === "constructor_signature" || type === "factory_constructor_signature" || type === "constant_constructor_signature" || type === "redirecting_factory_constructor_signature";
+  }
+  /**
+   * Is this constructor-shaped signature actually a CONSTRUCTOR, or is it a
+   * METHOD the grammar has no node for?
+   *
+   * ## The shape the grammar cannot distinguish
+   *
+   * `tree-sitter-dart` has no node for a method declared WITHOUT a return
+   * type. `class A { noRetType() { } }` parses as
+   *
+   *     method_signature
+   *       constructor_signature      <- an UNTYPED METHOD
+   *         identifier  noRetType
+   *         formal_parameter_list
+   *
+   * which is structurally identical to a real constructor `A()`. Reading the
+   * node TYPE alone therefore publishes every untyped method in the corpus as a
+   * `constructor` symbol named `constructor`, and the method's own name is never
+   * published at all. MEASURED over a 600-file stride sample of the corpus at
+   * 35,090 `.dart` files: 1,197 constructor-shaped signatures, of which 521
+   * (43.5%) are untyped methods, spread over 56 files — and one file,
+   * `dart-sdk/pkg/analyzer/test/src/summary/elements/type_inference_test.dart`,
+   * holds 91 of them, all collapsed onto the single name
+   * `TypeInferenceElementTest.constructor`. `validation/m14/fixtures/dart/
+   * untyped-method-census.ts` is the census and the discriminator cross-tab.
+   *
+   * ## Why the PARENT is not the test
+   *
+   * "Is the inner signature's parent a `method_signature`?" looks like the
+   * discriminator and is not: the grammar ALSO wraps real constructors that
+   * way (`A.named(int a)`, `factory A.f() = A.named`), so it would misclassify
+   * 559 real constructors as methods. The cross-tab in the census prints both.
+   *
+   * ## The test that IS exact — the language's own naming rule
+   *
+   * A constructor is named after its class, and the unnamed one is spelled
+   * `.new`. A MEMBER may not share its class's name — that is a compile error —
+   * so
+   *
+   *     lead === ownerName  ||  lead === "new"
+   *
+   * holds for every constructor and for no method. It is a property of the
+   * declaration's own text, not of the grammar's node choice, so it survives a
+   * grammar upgrade that re-shapes the wrapper.
+   *
+   * The census measures it as exact on both classes: 662 constructors and 535
+   * untyped methods, with no cell of the contingency table requiring a choice.
+   *
+   * ## An ownerless signature is NOT decided here
+   *
+   * An `extension type` declares constructors too (`Ext1.name1(this i);`), and
+   * `scopeOwnerName` resolves no enclosing type for one. Returning true there
+   * would keep the current behaviour — a constructor published without an owner
+   * — which is right, and is not this method's business to change. The 14
+   * ownerless rows in the census are counted, not silently folded into either
+   * class.
+   */
+  isRealConstructor(sig, owner) {
+    if (!owner) return true;
+    const lead = this.signatureName(sig);
+    if (lead === null) return true;
+    return lead === "new" || lead === owner;
+  }
+  /**
+   * The name of the type a signature is declared in, read from the PARENT chain.
+   *
+   * The symbol pass has a `scopeStack` already carrying this, so it passes the
+   * owner in. The relationship passes have no scope stack — they walk with
+   * their own `current`/`owner` cursors — so they need it derived from the tree.
+   * The two must agree or an edge's source and the symbol it names are decided
+   * by different rules, which is how `resolveCurrent` came to publish the
+   * literal `constructor` for every untyped method's body while the symbol pass
+   * published the method under its own name.
+   *
+   * The owner resolution is the analyzer's, not the grammar's: `class_definition`
+   * and `enum_declaration` carry a `name` FIELD, while `mixin_declaration` and
+   * `extension_declaration` carry a direct `identifier` child. A lookup that read
+   * only the name field would resolve no owner for a mixin and send every
+   * untyped mixin method down the ownerless path.
+   */
+  enclosingTypeName(node) {
+    let n = node;
+    let guard = 0;
+    while (n && guard++ < 64) {
+      const t = n.type;
+      if (t === "class_definition" || t === "enum_declaration" || t === "mixin_declaration" || t === "extension_declaration" || t === "extension_type_declaration") {
+        const named = n.childForFieldName("name");
+        if (named) return named.text;
+        const id = this.findChildByType(n, "identifier");
+        if (id) return id.text;
+        return void 0;
+      }
+      n = n.parent;
+    }
+    return void 0;
+  }
+  signatureName(inner) {
+    const nameNode = inner.childForFieldName("name");
+    if (nameNode) return nameNode.text;
+    if (inner.type === "operator_signature") {
+      const opTok = this.operatorTokenNode(inner);
+      return opTok ? `operator ${opTok.text}` : null;
+    }
+    const id = this.findChildByType(inner, "identifier");
+    return id ? id.text : null;
+  }
+  /** The operator symbol token of an `operator_signature`.
+   *
+   *  This locates the `operator` KEYWORD and takes the token after it. It must NOT
+   *  hardcode a child index: the return type in front of the keyword is not one
+   *  node but a variable number of them. A plain `bool` is a single
+   *  `type_identifier`, so `child(2)` is the operator token — but a SCOPED return
+   *  type (`core$_.bool`, `ns.bool`) is a `scoped_identifier` the grammar splits,
+   *  which shifts every later child by one.
+   *
+   *  Measured: `extension ByteString$$Methods on ByteString { core$_.bool
+   *  operator >(ByteString byteString) { ... } }` in ok_http's JNI bindings, where
+   *  `child(2)` then names the member after the return type's last segment and
+   *  publishes `operator bool` — a member name that names a TYPE, on a class that
+   *  has no such member, while the real `operator >` went missing. Scanning for
+   *  the keyword is invariant to how the return type is spelled. */
+  operatorTokenNode(inner) {
+    for (let i = 0; i < inner.childCount; i++) {
+      const c = inner.child(i);
+      if (c && !c.isNamed && c.text === "operator") return inner.child(i + 1);
+    }
+    return null;
+  }
+  /** Node form of `signatureName`: the node that names a member edge is also
+   *  the node whose LINE the edge carries (M60 line contract). For an operator
+   *  overload the naming node is the operator TOKEN — its line, not its text,
+   *  is what the synthesised spelling contributes. */
+  signatureNameNode(inner) {
+    const nameNode = inner.childForFieldName("name");
+    if (nameNode) return nameNode;
+    if (inner.type === "operator_signature") {
+      return this.operatorTokenNode(inner);
+    }
+    return this.findChildByType(inner, "identifier");
+  }
+  findSignatureIn(node) {
+    const stack = [node];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 64) {
+      const n = stack.pop();
+      if (this.isSignatureNode(n.type)) return n;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return null;
+  }
+  findInnerSignature(node) {
+    if (node.type !== "method_signature") return node;
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (this.isSignatureNode(n.type) && n.type !== "method_signature") {
+        return n;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return node;
+  }
+  hasBody(node) {
+    const sib = node.nextNamedSibling;
+    if (sib && (sib.type === "function_body" || sib.type === "block")) return true;
+    return this.findChildByType(node, "function_body") !== null;
+  }
+  rangeIncludingBody(node, sig) {
+    const range = this.nodeToRange(node);
+    let sib = node.nextSibling;
+    let guard = 0;
+    while (sib && guard++ < 8) {
+      if (sib.type === "function_body" || sib.type === "block") {
+        range.endLine = sib.endPosition.row + 1;
+        range.endColumn = sib.endPosition.column + 1;
+        range.endIndex = sib.endIndex;
+        break;
+      }
+      if (sib.type === "}" || sib.type === "class_body" || sib.type === "extension_body") break;
+      sib = sib.nextSibling;
+    }
+    return range;
+  }
+  isAsyncSignature(node, sig) {
+    const body = this.findChildByType(node, "function_body");
+    if (body) {
+      if (this.hasToken(body, "async")) return true;
+    } else {
+      const sib = node.nextSibling;
+      if (sib && sib.type === "function_body" && this.hasToken(sib, "async")) return true;
+    }
+    return false;
+  }
+  hasToken(node, token) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && (c.type === token || c.text === token)) return true;
+    }
+    return false;
+  }
+  hasModifier(node, modifier) {
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && (c.type === modifier || c.text === modifier)) return true;
+    }
+    if (node.parent && node.parent.type === "declaration") {
+      for (let i = 0; i < node.parent.childCount; i++) {
+        const c = node.parent.child(i);
+        if (c && (c.type === modifier || c.text === modifier)) return true;
+      }
+    }
+    return false;
+  }
+  extractParameters(node) {
+    const out = [];
+    const paramsNode = node.type === "formal_parameter_list" ? node : this.findChildByType(node, "formal_parameter_list");
+    if (!paramsNode) return out;
+    const stack = [paramsNode];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === "formal_parameter" || n.type === "constructor_param" || n.type === "typed_identifier") {
+        const nameNode = n.childForFieldName("name") || this.findChildByType(n, "identifier");
+        if (nameNode && nameNode.text !== "this" && nameNode.text !== "super") {
+          let typeText;
+          if (n.type === "typed_identifier") {
+            typeText = this.firstTypeIdentifier(n, false)?.text;
+          } else {
+            const kids = [];
+            for (let i = 0; i < n.namedChildCount; i++) {
+              const c = n.namedChild(i);
+              if (c) kids.push(c);
+            }
+            const nameIdx = kids.findIndex(
+              (c) => (
+                // web-tree-sitter creates a NEW wrapper object per access, so
+                // reference equality always fails (same trap extractReturnType's
+                // KAD2 sweep fixed) — compare byte spans.
+                nameNode && c.startIndex === nameNode.startIndex && c.endIndex === nameNode.endIndex
+              )
+            );
+            for (let i = 0; i < nameIdx; i++) {
+              const c = kids[i];
+              if (c.type === "type_identifier" || c.type === "function_type" || c.type === "nullable_type" || c.type === "void_type" || c.type === "record_type") {
+                typeText = c.text;
+                break;
+              }
+            }
+          }
+          let group;
+          let p = n.parent;
+          while (p && p.type !== "optional_formal_parameters") p = p.parent;
+          if (p && p.type === "optional_formal_parameters") group = p;
+          const isNamed = group ? group.text.startsWith("{") : false;
+          const isOptional = group !== void 0;
+          const hasDefault = n.text.includes("=");
+          const already = out.some((p2) => p2.name === nameNode.text);
+          if (!already) out.push({ name: nameNode.text, type: typeText ?? IMPLICIT_DYNAMIC_TYPE, isOptional, isNamed });
+        }
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out;
+  }
+  extractReturnType(node) {
+    const voidType = this.findChildByType(node, "void_type");
+    if (voidType) return "void";
+    const nameNode = node.childForFieldName("name");
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (nameNode && c.startIndex === nameNode.startIndex && c.endIndex === nameNode.endIndex) break;
+      if (c.type === "type_identifier" || c.type === "void_type" || c.type === "record_type") return c.text;
+    }
+    return void 0;
+  }
+  extractFieldType(node, declList) {
+    const candidates = [node, declList];
+    for (const cand of candidates) {
+      for (let i = 0; i < cand.namedChildCount; i++) {
+        const c = cand.namedChild(i);
+        if (!c) continue;
+        if (c.type === "type_identifier" || c.type === "void_type" || c.type === "record_type") {
+          return c.text;
+        }
+      }
+    }
+    return void 0;
+  }
+  /** The representation type's leaf name (`extension type X(objc.ObjCObject o)`
+   *  -> `ObjCObject`): alias-free like every other type name this lane emits
+   *  (DARTD1/DARTD2), since the first identifier is the IMPORT PREFIX. */
+  representationTypeName(rep) {
+    if (!rep) return void 0;
+    const nameNode = rep.childForFieldName("name");
+    let leaf;
+    for (let i = 0; i < rep.namedChildCount; i++) {
+      const c = rep.namedChild(i);
+      if (!c) continue;
+      if (nameNode && c.startIndex === nameNode.startIndex && c.endIndex === nameNode.endIndex) break;
+      if (c.type === "type_identifier" || c.type === "void_type") leaf = c.text;
+    }
+    return leaf;
+  }
+  extractTypeParameters(node) {
+    const tp = this.findChildByType(node, "type_parameters");
+    if (!tp) return void 0;
+    const out = [];
+    for (let i = 0; i < tp.namedChildCount; i++) {
+      const c = tp.namedChild(i);
+      if (c && c.type === "type_parameter") out.push(c.text);
+    }
+    return out.length > 0 ? out : void 0;
+  }
+  extensionTargetType(node) {
+    const name = node.childForFieldName("name")?.text;
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c || c.type === "extension_body" || c.type === "identifier") continue;
+      if (c.type === "type_identifier" || c.type === "void_type") {
+        if (c.text === name) continue;
+        return c.text;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * THE NAME AN EXTENSION IS PUBLISHED UNDER — ONE rule at BOTH sites that need it (the symbol
+   * emitter and `resolveOwner`), because a member whose published scope and whose container's name
+   * disagree is a `contains` edge that names nothing.
+   *
+   * A named extension is published under its own name. An unnamed one has none, so it takes the
+   * family's synthesized spelling — see `DART_UNNAMED_EXTENSION` for why borrowing the target
+   * type's name was a defect rather than untidiness, and what it cost. The `undefined` fallback is
+   * `DART_UNNAMED_EXTENSION` itself, mirroring java's `anonymous_class` (real-java-analyzer.ts):
+   * a declaration that HAS members and no name still needs an owner string, and the alternative is
+   * leaking those members into whatever scope surrounded them.
+   */
+  extensionPublishedName(node) {
+    const declared = node.childForFieldName?.("name")?.text;
+    if (declared) return declared;
+    const target = this.extensionTargetType(node);
+    return target ? `${DART_UNNAMED_EXTENSION}_${target}` : DART_UNNAMED_EXTENSION;
+  }
+  /**
+   * Is this `type_identifier` the `on` SUBJECT of the UNNAMED extension that encloses it?
+   *
+   * The subject is part of the extension's own identity — `extensionPublishedName` derives the
+   * published name FROM it — so it is not a mention the body makes. Only an UNNAMED extension is
+   * covered: `extension M on M2 {}` publishes `M -> M2` and must keep doing so (pinned by
+   * `verify-dart-references.ts`).
+   */
+  isUnnamedExtensionSubject(n) {
+    const parent = n.parent;
+    if (!parent || parent.type !== "extension_declaration") return false;
+    return parent.childForFieldName?.("name")?.text === void 0;
+  }
+  extractAnnotations(node) {
+    const annotations = [];
+    let prev = node.previousNamedSibling;
+    let guard = 0;
+    while (prev && guard++ < 8) {
+      if (prev.type === "annotation") {
+        annotations.unshift(prev.text);
+        prev = prev.previousNamedSibling;
+      } else {
+        break;
+      }
+    }
+    return annotations.length > 0 ? annotations : void 0;
+  }
+  // ============================================================================
+  // ANNOTATION REFERENCES — the type a `@...` names is a `references` edge
+  // ============================================================================
+  /**
+   * Emit one `references` row per (annotation, decorated declaration) pair.
+   *
+   * THE RULES, each from the pinned grammar (see `annotation-shapes-probe.ts`):
+   *
+   *   TARGET — the annotation's `name` field, read as written and WITHOUT its `@`, arguments
+   *   or type arguments. For `@prefix.Qualified` the target is the LEAF the `name` field names,
+   *   not the import alias: this lane strips alias prefixes everywhere heritage and type
+   *   mentions are spelled (DT-B/DAD1/DAD2 — `_i2.Mixin` is `Mixin`), and an annotation alias
+   *   is the same alias. (Java keeps the full path because Java's qualifier is a package, not
+   *   an import alias; the two lanes' conventions differ for a reason.)
+   *
+   *   SOURCE — the declaration the annotation DECORATES, because an annotation node has no
+   *   name of its own. Three carrier shapes, all probed:
+   *     child form      `@deprecated class C` -> annotation is a CHILD of `class_definition`;
+   *                     `enum Kind { @deprecated old }` -> child of `enum_constant`;
+   *                     `@deprecated final x = 1;` -> child of `local_variable_declaration`.
+   *     sibling form    inside `class_body` and `program` the annotation is a SIBLING of the
+   *                     declaration (`class_body (annotation) (method_signature)`), so the
+   *                     carrier is the next non-annotation sibling.
+   *     signature-param form  `void f(@required int x)` -> annotation is a CHILD of
+   *                     `formal_parameter`; the carrier is the enclosing callable, because a
+   *                     parameter publishes no symbol (DARTD8) and the annotation is a fact
+   *                     about the declaration that carries it.
+   *   Multi-declarator fields (`@JsonKey(...) int a = 1, b = 2;`) publish ONE row per
+   *   declarator, matching the symbol model (each declarator is its own property).
+   *
+   *   CONFIDENCE 0.95, `evidenceClass: structural`: the annotation's type name is WRITTEN at
+   *   the declaration, not inferred. `annotatedKind` is the carrier's grammar node type so a
+   *   consumer can tell a class annotation from a parameter annotation — the node type alone
+   *   cannot.
+   *
+   * NOT A CLAIM, and not an unresolvable-target exemption: the row is an ordinary `references`
+   * edge and the project's resolver decides whether the annotation type has exactly one
+   * in-project declaration (`@override` is dart:core's, so it will read unresolved in a
+   * per-file run and resolve under an index — the same treatment every out-of-file type
+   * mention gets on this label).
+   */
+  emitAnnotationReferences(ann, relationships, current, owner, moduleName, importAliases) {
+    const nameNode = ann.childForFieldName?.("name") ?? this.findChildByType(ann, "identifier");
+    if (!nameNode) return;
+    const target = this.annotationTargetSpelling(nameNode, importAliases);
+    if (!target) return;
+    const carriers = this.annotationCarriers(ann, current, owner, moduleName);
+    for (const carrier of carriers) {
+      relationships.push({
+        source: carrier.name,
+        target,
+        type: ASTEngine.RelationshipType.References,
+        confidence: 0.95,
+        // The NAME is written on the annotation's line; the declaration's header is another.
+        line_number: this.nodeLine(nameNode),
+        metadata: {
+          relationshipType: "annotation",
+          isAnnotation: true,
+          annotatedKind: carrier.kind
+        }
+      });
+    }
+  }
+  /**
+   * The annotation's TYPE name, as this lane spells types.
+   *
+   * A `scoped_identifier` is ONE grammar shape for two different Dart facts, and the alias table
+   * is what tells them apart:
+   *
+   *   `@_i1.TestFor()`                  the qualifier is an IMPORT ALIAS -> the type is the LEAF
+   *                                     (`TestFor`), and publishing `_i1.TestFor` would name an
+   *                                     alias no declaration has.
+   *   `@TestFor.async_value_nullable_pattern`
+   *                                     the qualifier is the TYPE and the member selects a named
+   *                                     CONSTRUCTOR (riverpod's `@TestFor.<lint>()` family) or a
+   *                                     static; the type is the QUALIFIER. Taking the leaf here
+   *                                     published a target named after a constructor, which is
+   *                                     neither a type nor a declaration — and on a file whose
+   *                                     stem matched the constructor it even produced a
+   *                                     self-reference row (`async_value_nullable_pattern ->
+   *                                     async_value_nullable_pattern`), measured by the corpus
+   *                                     gate as UNEXPLAINED.
+   *
+   * Non-scoped names: the name field's own text. Arguments and type arguments are separate
+   * children and never enter the target.
+   */
+  annotationTargetSpelling(nameNode, importAliases) {
+    if (nameNode.type === "identifier" || nameNode.type === "type_identifier") return nameNode.text;
+    if (nameNode.type === "scoped_identifier") {
+      const scope = nameNode.childForFieldName?.("scope")?.text ?? (nameNode.namedChildren ?? []).find((c) => c?.type === "identifier")?.text;
+      const leaf = nameNode.childForFieldName?.("name")?.text ?? [...nameNode.namedChildren ?? []].reverse().find((c) => c?.type === "identifier")?.text;
+      if (scope && importAliases.has(scope)) return leaf ?? null;
+      return scope ?? leaf ?? null;
+    }
+    const id = this.findChildByType(nameNode, "identifier") ?? this.findChildByType(nameNode, "type_identifier");
+    return id ? id.text : null;
+  }
+  /**
+   * The declarations one annotation decorates, with the grammar node type of each carrier.
+   * EMPTY when the position publishes no name this lane can attribute to — a library
+   * directive's annotation (`library @TestOn('vm');`) is deliberately not attributed: the
+   * library node is the module symbol, and an edge from the module to the annotation type
+   * would be a claim about a directive the lane has not placed in this family.
+   */
+  annotationCarriers(ann, current, owner, moduleName) {
+    const parent = ann.parent;
+    if (!parent) return [];
+    const p = parent.type;
+    if (p === "class_definition" || p === "mixin_declaration" || p === "enum_declaration" || p === "extension_declaration" || p === "extension_type_declaration") {
+      const nm = parent.childForFieldName?.("name")?.text ?? this.findChildByType(parent, "identifier")?.text;
+      return nm ? [{ name: nm, kind: p }] : [];
+    }
+    if (p === "enum_constant") {
+      const nm = parent.childForFieldName?.("name")?.text ?? this.findChildByType(parent, "identifier")?.text;
+      return nm ? [{ name: nm, kind: p }] : [];
+    }
+    if (p === "type_alias") {
+      const nm = parent.childForFieldName?.("name")?.text ?? this.findChildByType(parent, "type_identifier")?.text;
+      return nm ? [{ name: nm, kind: p }] : [];
+    }
+    if (p === "library_name") {
+      const declared = this.findChildByType(parent, "dotted_identifier_list");
+      const name = declared ? stripWhitespace(declared.text) : moduleName;
+      return name ? [{ name, kind: "library_annotation" }] : [];
+    }
+    if (p === "local_variable_declaration") {
+      const carrier = current ?? owner;
+      return carrier ? [{ name: carrier, kind: p }] : [];
+    }
+    if (p === "formal_parameter" || p === "constructor_param" || p === "super_formal_parameter") {
+      let sig = parent;
+      let guard = 0;
+      while (sig && guard++ < 8) {
+        if (this.isSignatureNode(sig.type)) break;
+        sig = sig.parent;
+      }
+      if (sig) {
+        if (sig.parent?.type === "lambda_expression" || sig.parent?.type === "function_expression") {
+          return current ? [{ name: current, kind: "lambda_parameter" }] : [];
+        }
+        const inner = this.findInnerSignature(sig);
+        if (this.isConstructorSignature(sig.type) || this.isConstructorSignature(inner.type)) {
+          return this.isRealConstructor(inner, this.enclosingTypeName(inner)) ? [{ name: "constructor", kind: "constructor_param" }] : [];
+        }
+        const nm = this.signatureName(inner);
+        return nm ? [{ name: nm, kind: "parameter_annotation" }] : [];
+      }
+      return current ? [{ name: current, kind: "parameter_annotation" }] : [];
+    }
+    if (p === "class_body" || p === "program" || p === "enum_body") {
+      let sib = ann.nextNamedSibling;
+      let guard = 0;
+      while (sib && sib.type === "annotation" && guard++ < 16) sib = sib.nextNamedSibling;
+      let modGuard = 0;
+      while (sib && sib.type.endsWith("_builtin") && modGuard++ < 8) sib = sib.nextNamedSibling;
+      return sib ? this.carriersOfDeclarationNode(sib) : [];
+    }
+    return [];
+  }
+  /** The names a declaration node publishes, for the annotation sibling form. */
+  carriersOfDeclarationNode(node) {
+    if (node.type === "type_identifier" || node.type === "void_type" || node.type === "nullable_type" || node.type === "function_type" || node.type === "inferred_type") {
+      const after = node.nextNamedSibling;
+      if (after && (after.type === "initialized_identifier_list" || after.type === "static_final_declaration_list")) {
+        return this.carriersOfDeclarationNode(after);
+      }
+      return [];
+    }
+    if (node.type === "initialized_identifier_list" || node.type === "static_final_declaration_list") {
+      const out2 = [];
+      for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c) continue;
+        const id = this.findChildByType(c, "identifier");
+        if (id) out2.push({ name: id.text, kind: node.type });
+      }
+      return out2;
+    }
+    const t = node.type;
+    if (t === "class_definition" || t === "mixin_declaration" || t === "enum_declaration" || t === "extension_declaration" || t === "extension_type_declaration" || t === "type_alias") {
+      const nm = node.childForFieldName?.("name")?.text ?? this.findChildByType(node, "identifier")?.text;
+      return nm ? [{ name: nm, kind: t }] : [];
+    }
+    let decl = node;
+    if (decl.type === "declaration") {
+      for (let i = 0; i < decl.namedChildCount; i++) {
+        const c = decl.namedChild(i);
+        if (c && this.isSignatureNode(c.type)) {
+          decl = c;
+          break;
+        }
+      }
+    }
+    if (this.isSignatureNode(decl.type)) {
+      const inner = this.findInnerSignature(decl);
+      if (this.isConstructorSignature(decl.type) || this.isConstructorSignature(inner.type)) {
+        return this.isRealConstructor(inner, this.enclosingTypeName(inner)) ? [{ name: "constructor", kind: "constructor_signature" }] : [];
+      }
+      const nm = this.signatureName(inner);
+      return nm ? [{ name: nm, kind: inner.type }] : [];
+    }
+    const out = [];
+    const stack = [node];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 64) {
+      const c = stack.pop();
+      if (c.type === "initialized_identifier" || c.type === "static_final_declaration") {
+        const id = this.findChildByType(c, "identifier");
+        if (id) out.push({ name: id.text, kind: node.type });
+        continue;
+      }
+      for (let i = c.namedChildCount - 1; i >= 0; i--) {
+        const ch = c.namedChild(i);
+        if (ch && (ch.type === "initialized_identifier_list" || ch.type === "static_final_declaration_list" || ch.type === "initialized_identifier" || ch.type === "static_final_declaration")) {
+          stack.push(ch);
+        }
+      }
+    }
+    return out;
+  }
+  collectComments(node) {
+    const comments = [];
+    let sibling = node.previousSibling;
+    let guard = 0;
+    while (sibling && guard++ < 12) {
+      if (sibling.type === "comment" || sibling.type === "documentation_comment") {
+        comments.unshift(stripCommentMarkers(sibling.text));
+        sibling = sibling.previousSibling;
+      } else if (sibling.type === "annotation") {
+        sibling = sibling.previousSibling;
+      } else {
+        break;
+      }
+    }
+    return comments.length > 0 ? comments : void 0;
+  }
+  directIdentifiers(node) {
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (c && (c.type === "identifier" || c.type === "type_identifier")) out.push(c.text);
+    }
+    return out;
+  }
+  // ══ CYCLOMATIC COMPLEXITY IS COMPUTED ONCE PER FUNCTION, NOT ONCE PER CALL.
+  //
+  // `methodComplexity` walks the node's whole subtree, and `processTopLevelFunction` calls it for
+  // every function-like node. In a file of DEEPLY NESTED statements those subtrees OVERLAP — every
+  // nested function's walk includes everything below it — so the pass is O(functions × nodes). The
+  // accessor counter measured it: **103,034,258 `.type` reads** on a 130,042-node file, with
+  // `.text` at 1,596 and 1 MB of characters materialised, and the stack named this function. (That
+  // also FALSIFIED the `.text` hypothesis: the materialisation was never the cost; the re-walking
+  // was, and each visit pays ~10 `.type` reads that cross into WASM.)
+  //
+  // A function's complexity is a pure property of its subtree, so it is cached by the node's stable
+  // SPAN — `startIndex:endIndex:type`, never the node object, because web-tree-sitter hands out
+  // fresh wrappers. Cleared per file in `analyze()`.
+  methodComplexityCache = /* @__PURE__ */ new Map();
+  methodComplexity(node) {
+    const cacheKey = `${node.startIndex}:${node.endIndex}:${node.type}`;
+    const cached = this.methodComplexityCache.get(cacheKey);
+    if (cached !== void 0) return cached;
+    let c = 1;
+    const stack = [node];
+    let sib = node.nextNamedSibling;
+    let guard = 0;
+    while (sib && guard++ < 8) {
+      if (sib.type === "function_body" || sib.type === "block" || sib.type === "function_expression_body") {
+        stack.push(sib);
+        break;
+      }
+      if (sib.type === "class_body" || sib.type === "extension_body" || sib.type === "}" || sib.type === "declaration" || sib.type === "method_signature" || sib.type === "function_signature") break;
+      sib = sib.nextNamedSibling;
+    }
+    guard = 0;
+    while (stack.length > 0 && guard++ < 2e5) {
+      const n = stack.pop();
+      if (n.type === "if_statement" || n.type === "for_statement" || n.type === "while_statement" || n.type === "do_statement" || n.type === "switch_statement_case" || n.type === "switch_expression_case" || n.type === "catch_clause" || n.type === "conditional_expression" || n.type === "logical_and_expression" || n.type === "logical_or_expression") {
+        c++;
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    this.methodComplexityCache.set(cacheKey, c);
+    return c;
+  }
+  firstTypeIdentifier(node, excludeMixins) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (excludeMixins && c.type === "mixins") continue;
+      if (c.type === "type_identifier") {
+        return c;
+      }
+      if (c.type === "identifier") return c;
+    }
+    return null;
+  }
+  /**
+   * Resolved heritage names (DAD1/DAD2 contract): the real class names from a
+   * heritage clause, with import-alias prefixes dropped and generic arguments
+   * excluded.
+   *
+   * tree-sitter-dart parses a qualified supertype FLAT: `extends _i1.SmartFake`
+   * is superclass > [_i1, `.`, SmartFake] — adjacent type_identifiers joined by
+   * an anonymous `.` token where the FIRST is the import-alias container, not a
+   * class name (the mocktail shape: `class _FakeX_0 extends _i1.SmartFake
+   * implements _i2.Database`). Taking the first raw identifier named the base
+   * after the alias (DAD1); enumerating all type_identifiers leaked the alias
+   * into implements targets (DAD2).
+   *
+   * Rule over RAW children (anonymous tokens carry the disambiguation):
+   * keep type_identifier/identifier nodes whose next raw sibling is NOT a `.`
+   * token — a `.` means this name is an alias prefix; `,` or end-of-clause or
+   * type_arguments means it is a real name. type_arguments are generic
+   * arguments, never bases; mixins are handled separately as `uses`.
+   * Probed shapes (dart-heritage-shapes.ts, 2026-09-03):
+   *   `_i1.SmartFake`            -> [SmartFake]
+   *   `Alpha, Beta`              -> [Alpha, Beta]
+   *   `_i2.Database, _i3.Future` -> [Database, Future]
+   *   `generics.Map<String, int>`-> [Map]
+   */
+  resolvedHeritageNames(node) {
+    return this.resolvedHeritageNodes(node).map((n) => n.text);
+  }
+  /** Node form of `resolvedHeritageNames` — the heritage-name node IS the node
+   *  that names an extends/implements/uses edge (M60 line contract), so text
+   *  and line come from one selection. */
+  resolvedHeritageNodes(node) {
+    const out = [];
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (!c) continue;
+      if (c.type === "type_arguments" || c.type === "mixins") continue;
+      if (c.type !== "type_identifier" && c.type !== "identifier") continue;
+      const next = node.child(i + 1);
+      if (next && next.type === ".") continue;
+      out.push(c);
+    }
+    return out;
+  }
+  allTypeIdentifiers(node) {
+    const out = [];
+    const stack = [node];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 64) {
+      const n = stack.pop();
+      if (n.type === "type_identifier" && n.parent && n.parent.type !== "type_arguments") {
+        out.push(n);
+      } else if (n.type === "identifier" && n.parent && n.parent.type === "mixins") {
+        out.push(n);
+      }
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return out;
+  }
+  findChildByType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === type) return child;
+    }
+    return null;
+  }
+  findDescendantByType(node, type) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      if (n.type === type) return n;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return null;
+  }
+  /**
+   * M60 (#929 lineage, dart lane): the line a relationship CLAIMS is the line
+   * of the node that NAMES its target — the base clause for extends/implements,
+   * the declared member for contains, the callee for calls, the constructed
+   * class for instantiates, the overriding method for overrides, the uri
+   * literal for an import/export/part, the redirect target for a factory
+   * redirection. No node means NO field (absent is honest; `0` is the M59
+   * fabrication).
+   */
+  nodeLine(node) {
+    if (!node) return void 0;
+    return node.startPosition.row + 1;
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+};
+function dartNameLineKey(name, range) {
+  return `${name}|${range?.startIndex ?? -1}|${range?.endIndex ?? -1}`;
+}
+function scopeOwnerKind(scopes) {
+  for (let i = scopes.length - 1; i >= 0; i--) {
+    if (scopes[i].kind === "class" /* Class */) {
+      return ASTEngine.SymbolKind.Class;
+    }
+  }
+  return void 0;
+}
+export {
+  DART_CITATION_ROOTS,
+  RealDartAnalyzer
+};