@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-objective-c-analyzer-D23ACC2R.js

@@ -0,0 +1,1518 @@
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.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-objective-c-analyzer.ts
+var BARE_READ_SKIP = /* @__PURE__ */ new Set([
+  "self",
+  "super",
+  "nil",
+  "Nil",
+  "NULL",
+  "YES",
+  "NO",
+  "true",
+  "false",
+  "_cmd"
+]);
+var DECLARATOR_WRAPPERS = /* @__PURE__ */ new Set([
+  "array_declarator",
+  "pointer_declarator",
+  "parenthesized_declarator",
+  "attributed_declarator",
+  "abstract_pointer_declarator",
+  "abstract_block_pointer_declarator",
+  "block_pointer_declarator",
+  "function_declarator"
+]);
+function objcPartTarget(writtenPath) {
+  const segments = writtenPath.split("/").filter((segment) => segment.length > 0);
+  if (segments.length === 0) return writtenPath;
+  if (segments.length > 1) {
+    const module = segments[0];
+    const moduleDot = module.lastIndexOf(".");
+    return moduleDot > 0 ? module.slice(0, moduleDot) : module;
+  }
+  const file = segments[0];
+  const dot = file.lastIndexOf(".");
+  return dot > 0 ? file.slice(0, dot) : file;
+}
+function isUnterminatedDeclaration(node) {
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (child && child.isMissing && child.type === ";") return true;
+  }
+  return false;
+}
+function hasParseError(node) {
+  const stack = [node];
+  let guard = 0;
+  while (stack.length > 0 && guard++ < 2e4) {
+    const n = stack.pop();
+    if (!n) continue;
+    if (n.type === "ERROR") return true;
+    for (let i = 0; i < n.childCount; i++) {
+      const c = n.child(i);
+      if (c) stack.push(c);
+    }
+  }
+  return false;
+}
+var OBJC_FRAMEWORK_ORDER = ["UIKit", "AppKit", "Cocoa", "Foundation"];
+var OBJC_FRAMEWORK_PATTERNS = {
+  UIKit: ["ui_framework"],
+  AppKit: ["ui_framework"],
+  Cocoa: ["app_umbrella"],
+  Foundation: ["base_library"]
+};
+var OBJC_LINKAGE_UNIT_KINDS = /* @__PURE__ */ new Set([
+  ASTEngine.SymbolKind.Class,
+  ASTEngine.SymbolKind.Interface,
+  ASTEngine.SymbolKind.Struct,
+  ASTEngine.SymbolKind.Union,
+  ASTEngine.SymbolKind.Enum,
+  ASTEngine.SymbolKind.Type,
+  ASTEngine.SymbolKind.Function,
+  ASTEngine.SymbolKind.Variable,
+  ASTEngine.SymbolKind.Constant
+]);
+var OBJC_EXPORT_MARKERS = /* @__PURE__ */ new Set([
+  // Foundation's spelling of `extern __attribute__((visibility("default")))` —
+  // the marker every framework header uses for its published surface.
+  "FOUNDATION_EXPORT",
+  // C's own keyword for external linkage. One occurrence in the corpus, and the
+  // grammar has a node type for it, so leaving it out would be the arbitrary
+  // choice rather than the principled one.
+  "extern"
+]);
+var RealObjectiveCAnalyzer = class {
+  analyze(rootNode, content, filePath) {
+    const symbols = [];
+    const relationships = [];
+    const imports = [];
+    const exports = [];
+    const frameworks = /* @__PURE__ */ new Set();
+    const errors = [];
+    const walkStack = [
+      { node: rootNode, isExit: false, activeScope: "global", parentType: "", isInBody: false, owner: "", bindable: false }
+    ];
+    let valueFrame = null;
+    const blockFrameStack = [];
+    const globals = /* @__PURE__ */ new Set();
+    const classMembers = /* @__PURE__ */ new Map();
+    const classSuper = /* @__PURE__ */ new Map();
+    const internalLinkage = /* @__PURE__ */ new Set();
+    const exportMarkers = /* @__PURE__ */ new Map();
+    const exportLineByName = /* @__PURE__ */ new Map();
+    const enumCases = /* @__PURE__ */ new Set();
+    {
+      const preStack = [rootNode];
+      while (preStack.length > 0) {
+        const pn = preStack.pop();
+        if (!pn || pn.isMissing) continue;
+        if (pn.type === "enum_specifier") {
+          const elist = this.findChild(pn, (n) => n.type === "enumerator_list");
+          if (elist) {
+            for (let ei = 0; ei < elist.namedChildCount; ei++) {
+              const en = elist.namedChild(ei);
+              if (!en || en.type !== "enumerator") continue;
+              const nm = this.findChild(en, (n) => n.type === "identifier");
+              if (nm && nm.text.trim()) enumCases.add(nm.text);
+            }
+          }
+        }
+        if (pn.type === "class_interface" || pn.type === "class_implementation") {
+          const cn = this.findChild(pn, (n) => n.type === "identifier" || n.type === "type_identifier");
+          if (cn) {
+            let members = classMembers.get(cn.text);
+            if (!members) {
+              members = /* @__PURE__ */ new Set();
+              classMembers.set(cn.text, members);
+            }
+            const memStack = [pn];
+            while (memStack.length > 0) {
+              const mn = memStack.pop();
+              if (!mn) continue;
+              if (mn !== pn && (mn.type === "class_interface" || mn.type === "class_implementation" || mn.type === "protocol_declaration")) continue;
+              if (mn.type === "property_declaration" || mn.type === "instance_variable") {
+                const mname = this.findDeclaredName(mn);
+                if (mname) members.add(mname);
+              }
+              for (let mi = mn.namedChildCount - 1; mi >= 0; mi--) {
+                const mc = mn.namedChild(mi);
+                if (mc) memStack.push(mc);
+              }
+            }
+          }
+        }
+        for (let pi = pn.namedChildCount - 1; pi >= 0; pi--) {
+          const pc = pn.namedChild(pi);
+          if (pc) preStack.push(pc);
+        }
+      }
+    }
+    const bindValue = (name) => {
+      if (!name) return;
+      if (blockFrameStack.length > 0) blockFrameStack[blockFrameStack.length - 1].add(name);
+      else if (valueFrame) valueFrame.add(name);
+      else globals.add(name);
+    };
+    const isBoundValue = (name, owner) => {
+      for (let bi = blockFrameStack.length - 1; bi >= 0; bi--) {
+        if (blockFrameStack[bi].has(name)) return true;
+      }
+      if (valueFrame && valueFrame.has(name)) return true;
+      const cm = classMembers.get(owner);
+      if (cm && cm.has(name)) return true;
+      if (globals.has(name)) return true;
+      if (enumCases.has(name)) return true;
+      return false;
+    };
+    while (walkStack.length > 0) {
+      const state = walkStack.pop();
+      if (!state) continue;
+      if (state.isExit) {
+        blockFrameStack.pop();
+        continue;
+      }
+      const { node, isExit, activeScope, parentType, isInBody, owner, bindable } = state;
+      if (isExit || !node || node.isMissing) continue;
+      let nextActiveScope = activeScope;
+      let nextIsInBody = isInBody;
+      let nextOwner = owner;
+      let nextBindable = bindable;
+      if (node.type === "preproc_include") {
+        let modName = null;
+        let modNode = null;
+        let isSystem = false;
+        for (let ci = 0; ci < node.namedChildCount; ci++) {
+          const cn = node.namedChild(ci);
+          if (!cn) continue;
+          if (cn.type === "system_lib_string") {
+            isSystem = true;
+            const txt = cn.text;
+            if (txt.length >= 2) {
+              modName = txt.slice(1, txt.length - 1);
+              modNode = cn;
+            }
+          } else if (cn.type === "string_literal") {
+            const content2 = this.findChild(cn, (n) => n.type === "string_content");
+            modName = content2 ? content2.text : cn.text;
+            modNode = content2 ?? cn;
+          }
+          if (modName) break;
+        }
+        if (modName) {
+          if (modName.includes("UIKit")) frameworks.add("UIKit");
+          if (modName.includes("Foundation")) frameworks.add("Foundation");
+          if (modName.includes("AppKit")) frameworks.add("AppKit");
+          if (modName.includes("Cocoa")) frameworks.add("Cocoa");
+          imports.push({
+            module: modName,
+            items: [],
+            importType: "include",
+            lineNumber: node.startPosition.row + 1,
+            isExternal: isSystem || !modName.startsWith(".")
+          });
+          relationships.push({
+            source: "root",
+            target: modName,
+            type: ASTEngine.RelationshipType.Imports,
+            confidence: 1,
+            line_number: this.nodeLine(modNode ?? node),
+            metadata: {
+              relationshipType: "include_dependency",
+              isObjCImport: true,
+              isObjCModuleImport: false,
+              isImport: true,
+              isSystem,
+              module: modName,
+              fileLevel: true
+            }
+          });
+          relationships.push({
+            source: "root",
+            target: objcPartTarget(modName),
+            type: ASTEngine.RelationshipType.PartOf,
+            confidence: 1,
+            line_number: this.nodeLine(modNode ?? node),
+            metadata: {
+              partRole: "library",
+              partPath: modName,
+              isFileInclusion: true,
+              isObjCImport: true,
+              isObjCModuleImport: false,
+              isSystem,
+              fileLevel: true,
+              evidenceClass: "import_based"
+            }
+          });
+          relationships.push({
+            source: "root",
+            target: modName,
+            type: ASTEngine.RelationshipType.References,
+            confidence: 0.9,
+            line_number: this.nodeLine(modNode ?? node),
+            metadata: { isObjCImport: true, isObjCModuleImport: false, reasonCode: "include-target-not-resolved" }
+          });
+        }
+      }
+      if (node.type === "module_import") {
+        const nameNode = this.findChild(node, (n) => n.type === "identifier" || n.type === "type_identifier");
+        const modName = nameNode ? nameNode.text.trim() : "";
+        if (modName) {
+          imports.push({
+            module: modName,
+            items: [],
+            importType: "module",
+            lineNumber: node.startPosition.row + 1,
+            isExternal: true
+          });
+          relationships.push({
+            source: "root",
+            target: modName,
+            type: ASTEngine.RelationshipType.References,
+            confidence: 0.9,
+            line_number: this.nodeLine(nameNode ?? node),
+            // Its OWN code, not the include's: the target names a MODULE and nothing in this
+            // walk knows whether the build defines a module under that name. Pinned by
+            // objc/module-imports ("the sub-1.0 twin carries its OWN reason code").
+            metadata: { isObjCImport: true, isObjCModuleImport: true, reasonCode: "clang-module-name-not-resolved" }
+          });
+          relationships.push({
+            source: "root",
+            target: modName,
+            type: ASTEngine.RelationshipType.Imports,
+            confidence: 1,
+            line_number: this.nodeLine(nameNode ?? node),
+            metadata: {
+              relationshipType: "module_import",
+              isObjCImport: true,
+              isObjCModuleImport: true,
+              isImport: true,
+              isSystem: false,
+              module: modName,
+              fileLevel: true
+            }
+          });
+        }
+      }
+      if (node.type === "class_interface" || node.type === "class_implementation") {
+        const identNodes = [];
+        for (let ci = 0; ci < node.namedChildCount; ci++) {
+          const cn = node.namedChild(ci);
+          if (cn && cn.type === "identifier") identNodes.push(cn.text);
+        }
+        const nameNode = this.findChild(node, (n) => n.type === "identifier" || n.type === "type_identifier");
+        if (nameNode) {
+          nextActiveScope = nameNode.text;
+          nextOwner = nameNode.text;
+          let hasParen = false;
+          for (let ci = 0; ci < node.childCount; ci++) {
+            const c = node.child(ci);
+            if (c && !c.isNamed && c.type === "(") {
+              hasParen = true;
+              break;
+            }
+          }
+          const isCategory = hasParen;
+          if (isCategory) {
+            symbols.push({
+              name: nameNode.text,
+              kind: ASTEngine.SymbolKind.Extension,
+              range: this.getRange(node),
+              ownerName: activeScope !== "global" ? activeScope : void 0,
+              metadata: { objcSpecific: true, isCategory: true, categoryName: identNodes[1] }
+            });
+            for (const p of this.objcInheritanceLists(node).protocols) {
+              relationships.push({ source: nameNode.text, target: p.name, type: ASTEngine.RelationshipType.Implements, confidence: 1, line_number: this.nodeLine(p.node), metadata: { objcSpecific: true, isProtocol: true, isCategoryProtocol: true } });
+            }
+          } else {
+            const { superClass: superName, superNode, protocols: protocolList } = this.objcInheritanceLists(node);
+            const protocols = protocolList.map((p) => p.name);
+            if (superName) classSuper.set(nameNode.text, superName);
+            if (superName) {
+              relationships.push({ source: nameNode.text, target: superName, type: ASTEngine.RelationshipType.Extends, confidence: 1, line_number: this.nodeLine(superNode ?? nameNode), metadata: { objcSpecific: true } });
+            }
+            for (const p of protocolList) {
+              relationships.push({ source: nameNode.text, target: p.name, type: ASTEngine.RelationshipType.Implements, confidence: 1, line_number: this.nodeLine(p.node ?? nameNode), metadata: { objcSpecific: true, isProtocol: true } });
+            }
+            symbols.push({
+              name: nameNode.text,
+              kind: ASTEngine.SymbolKind.Class,
+              range: this.getRange(node),
+              ownerName: activeScope !== "global" ? activeScope : void 0,
+              metadata: { objcSpecific: true, type: node.type, superClass: superName, protocols }
+            });
+          }
+        }
+      } else if (node.type === "protocol_declaration") {
+        const nameNode = this.findChild(node, (n) => n.type === "identifier");
+        if (nameNode) {
+          nextActiveScope = nameNode.text;
+          symbols.push({
+            name: nameNode.text,
+            kind: ASTEngine.SymbolKind.Interface,
+            range: this.getRange(node),
+            metadata: { objcSpecific: true, isProtocol: true }
+          });
+          const refList = this.findChild(node, (n) => n.type === "protocol_reference_list");
+          if (refList) {
+            for (let ci = 0; ci < refList.namedChildCount; ci++) {
+              const cn = refList.namedChild(ci);
+              if (cn && cn.type === "identifier") {
+                relationships.push({ source: nameNode.text, target: cn.text, type: ASTEngine.RelationshipType.Extends, confidence: 1, line_number: this.nodeLine(cn), metadata: { objcSpecific: true, isProtocolInheritance: true } });
+              }
+            }
+          }
+        }
+      } else if (node.type === "method_declaration" || node.type === "method_definition") {
+        const sel = this.fullMethodSelector(node);
+        if (sel) {
+          nextActiveScope = sel;
+          if (node.type === "method_definition") {
+            valueFrame = /* @__PURE__ */ new Set();
+            nextBindable = true;
+          }
+          const isClassMethod = this.isClassMethodToken(node);
+          symbols.push({
+            name: sel,
+            kind: ASTEngine.SymbolKind.Method,
+            range: this.getRange(node),
+            ownerName: activeScope !== "global" ? activeScope : void 0,
+            complexity: this.calculateCyclomaticComplexity(node),
+            metadata: { objcSpecific: true, isClassMethod, isInstanceMethod: !isClassMethod, selector: sel }
+          });
+        }
+      } else if (node.type === "function_definition") {
+        const nameNode = this.findFunctionName(node);
+        if (nameNode) {
+          for (let si = 0; si < node.namedChildCount; si++) {
+            const sc = node.namedChild(si);
+            if (sc && sc.type === "storage_class_specifier" && sc.text.trim() === "static") {
+              internalLinkage.add(nameNode.text);
+              break;
+            }
+          }
+          nextActiveScope = nameNode.text;
+          valueFrame = /* @__PURE__ */ new Set();
+          nextOwner = "";
+          nextBindable = true;
+          globals.add(nameNode.text);
+          symbols.push({
+            name: nameNode.text,
+            kind: ASTEngine.SymbolKind.Function,
+            range: this.getRange(node),
+            complexity: this.calculateCyclomaticComplexity(node),
+            metadata: { objcSpecific: true }
+          });
+        }
+      } else if (node.type === "property_declaration") {
+        const nameNode = this.findDeclaredName(node);
+        if (nameNode) {
+          symbols.push({
+            name: nameNode,
+            kind: ASTEngine.SymbolKind.Property,
+            range: this.getRange(node),
+            ownerName: activeScope !== "global" ? activeScope : void 0,
+            metadata: { objcSpecific: true }
+          });
+        }
+      } else if (node.type === "instance_variable") {
+        const nameNode = this.findDeclaredName(node);
+        if (nameNode) {
+          symbols.push({
+            name: nameNode,
+            kind: ASTEngine.SymbolKind.Property,
+            range: this.getRange(node),
+            ownerName: activeScope !== "global" ? activeScope : void 0,
+            metadata: { objcSpecific: true, isInstanceVariable: true }
+          });
+        }
+      } else if (node.type === "struct_specifier" || node.type === "union_specifier") {
+        const sname = this.findChild(node, (n) => n.type === "type_identifier");
+        const tname = sname ? sname.text : this.typedefName(node);
+        const defines = !!this.findChild(node, (n) => n.type === "field_declaration_list") || node.parent != null && node.parent.type === "type_definition";
+        if (tname && defines) {
+          symbols.push({
+            name: tname,
+            kind: ASTEngine.SymbolKind.Struct,
+            range: this.getRange(node),
+            ownerName: activeScope !== "global" ? activeScope : void 0,
+            metadata: { objcSpecific: true, isCStruct: true }
+          });
+          const flist = this.findChild(node, (n) => n.type === "field_declaration_list");
+          if (flist) {
+            for (let fi = 0; fi < flist.namedChildCount; fi++) {
+              const fd = flist.namedChild(fi);
+              if (!fd || fd.type !== "field_declaration") continue;
+              const fname = this.deepFind(fd, (n) => n.type === "field_identifier");
+              if (fname && fname.text.trim()) {
+                symbols.push({
+                  name: fname.text,
+                  kind: ASTEngine.SymbolKind.Property,
+                  range: this.getRange(fd),
+                  ownerName: tname,
+                  metadata: { objcSpecific: true, isStructField: true }
+                });
+              }
+            }
+          }
+        }
+      } else if (node.type === "enum_specifier") {
+        const ename = this.findChild(node, (n) => n.type === "type_identifier");
+        const macroArgs = this.findChild(node, (n) => n.type === "macro_enum_arguments");
+        let macroName = null;
+        if (macroArgs) {
+          for (let i = macroArgs.namedChildCount - 1; i >= 0; i--) {
+            const c = macroArgs.namedChild(i);
+            if (c && c.text && c.text.trim()) {
+              macroName = c.text.trim();
+              break;
+            }
+          }
+        }
+        const tname = macroName ?? (ename ? ename.text : this.typedefName(node));
+        const defines = !!this.findChild(node, (n) => n.type === "enumerator_list") || node.parent != null && node.parent.type === "type_definition";
+        if (tname && defines) {
+          symbols.push({
+            name: tname,
+            kind: ASTEngine.SymbolKind.Enum,
+            range: this.getRange(node),
+            ownerName: activeScope !== "global" ? activeScope : void 0,
+            metadata: { objcSpecific: true, isCEnum: true }
+          });
+          const elist = this.findChild(node, (n) => n.type === "enumerator_list");
+          if (elist) {
+            for (let ei = 0; ei < elist.namedChildCount; ei++) {
+              const en = elist.namedChild(ei);
+              if (!en || en.type !== "enumerator") continue;
+              const mname = this.findChild(en, (n) => n.type === "identifier");
+              if (mname && mname.text.trim()) {
+                symbols.push({
+                  name: mname.text,
+                  kind: ASTEngine.SymbolKind.EnumMember,
+                  range: this.getRange(en),
+                  ownerName: tname,
+                  metadata: { objcSpecific: true }
+                });
+              }
+            }
+          }
+        }
+      } else if (node.type === "type_definition") {
+        let alias = null;
+        for (let ti = 0; ti < node.namedChildCount; ti++) {
+          const tc = node.namedChild(ti);
+          if (tc && (tc.type === "type_identifier" || tc.type === "identifier")) alias = tc;
+        }
+        const hasAggregate = !!this.findChild(node, (n) => n.type === "struct_specifier" || n.type === "union_specifier" || n.type === "enum_specifier");
+        if (alias && !hasAggregate) {
+          symbols.push({
+            name: alias.text,
+            kind: ASTEngine.SymbolKind.Type,
+            range: this.getRange(node),
+            ownerName: activeScope !== "global" ? activeScope : void 0,
+            metadata: { objcSpecific: true, isTypedef: true }
+          });
+        }
+      } else if (node.type === "block_literal") {
+        if (nextBindable) blockFrameStack.push(/* @__PURE__ */ new Set());
+      } else if (node.type === "declaration" && activeScope === "global") {
+        if (!isUnterminatedDeclaration(node) && !hasParseError(node)) {
+          let exportMarker = null;
+          let storageStatic = false;
+          for (let si = 0; si < node.namedChildCount; si++) {
+            const sc = node.namedChild(si);
+            if (!sc || sc.type !== "storage_class_specifier") continue;
+            const st = sc.text.trim();
+            if (st === "static") storageStatic = true;
+            if (!exportMarker && OBJC_EXPORT_MARKERS.has(st)) exportMarker = st;
+          }
+          for (let di = 0; di < node.namedChildCount; di++) {
+            const dc = node.namedChild(di);
+            if (!dc) continue;
+            let dname = null;
+            const isPrototype = dc.type === "function_declarator" || (dc.type === "pointer_declarator" || dc.type === "array_declarator" || dc.type === "parenthesized_declarator" || dc.type === "attributed_declarator") && this.declaratorChainHasFunctionDeclarator(dc);
+            if (dc.type === "init_declarator") {
+              dname = this.declaratorName(dc);
+            } else if (dc.type === "identifier") {
+              dname = dc.text;
+            } else if (isPrototype || dc.type === "pointer_declarator" || dc.type === "array_declarator" || dc.type === "parenthesized_declarator" || dc.type === "attributed_declarator") {
+              dname = this.declaratorName(dc);
+            }
+            if (dname) {
+              symbols.push({
+                name: dname,
+                kind: isPrototype ? ASTEngine.SymbolKind.Function : ASTEngine.SymbolKind.Variable,
+                range: this.getRange(node),
+                metadata: isPrototype ? { objcSpecific: true, isCFunctionPrototype: true } : { objcSpecific: true }
+              });
+              globals.add(dname);
+              if (storageStatic) internalLinkage.add(dname);
+              if (exportMarker) {
+                exportMarkers.set(dname, exportMarker);
+                exportLineByName.set(dname, this.nodeLine(node));
+              }
+            }
+          }
+        }
+      } else if (node.type === "declaration" && nextBindable) {
+        for (let di = 0; di < node.namedChildCount; di++) {
+          const dc = node.namedChild(di);
+          if (!dc) continue;
+          if (dc.type === "init_declarator") {
+            const dname = this.declaratorName(dc);
+            if (dname) bindValue(dname);
+          } else if (dc.type === "identifier") {
+            bindValue(dc.text);
+          } else if (dc.type === "pointer_declarator" || dc.type === "array_declarator" || dc.type === "parenthesized_declarator" || dc.type === "attributed_declarator") {
+            const dname = this.declaratorName(dc);
+            if (dname) bindValue(dname);
+          }
+        }
+      } else if ((node.type === "method_parameter" || node.type === "parameter_declaration") && nextBindable) {
+        const pname = this.declaratorName(node);
+        if (pname) bindValue(pname);
+      } else if (node.type === "for_statement" && nextBindable) {
+        const cc = node.childCount;
+        for (let fi = 0; fi < cc; fi++) {
+          const fc = node.child(fi);
+          if (fc && !fc.isNamed && fc.type === "in" && fi > 0) {
+            for (let fj = fi - 1; fj >= 0; fj--) {
+              const pc = node.child(fj);
+              if (pc && pc.isNamed) {
+                if (pc.type === "identifier") bindValue(pc.text);
+                break;
+              }
+            }
+            break;
+          }
+        }
+      } else if (node.type === "message_expression") {
+        const msgSel = this.fullMessageSelector(node);
+        if (msgSel && activeScope !== "global" && isInBody) {
+          const firstKw = msgSel.split(":")[0];
+          if (firstKw === "alloc" || firstKw === "new") {
+            let receiverLeaf = null;
+            let recvTargetNode = null;
+            const receiver = node.namedChild(0);
+            if (receiver) {
+              if (receiver.type === "identifier" || receiver.type === "type_identifier") {
+                const keyword = receiver.text === "self" || receiver.text === "super" ? receiver.text : null;
+                if (keyword) {
+                  const resolved = keyword === "self" ? owner : classSuper.get(owner);
+                  if (resolved && resolved !== "global") {
+                    receiverLeaf = resolved;
+                    recvTargetNode = receiver;
+                  }
+                } else {
+                  receiverLeaf = receiver.text;
+                  recvTargetNode = receiver;
+                }
+              } else if (receiver.type === "message_expression") {
+                const innerSel = this.findChild(receiver, (n) => n.type === "identifier");
+                if (innerSel && (innerSel.text === "alloc" || innerSel.text === "new")) {
+                  const innerRecv = receiver.namedChild(0);
+                  if (innerRecv && (innerRecv.type === "identifier" || innerRecv.type === "type_identifier")) {
+                    receiverLeaf = innerRecv.text;
+                    recvTargetNode = innerRecv;
+                  }
+                }
+              }
+            }
+            if (receiverLeaf) {
+              relationships.push({ source: activeScope, target: receiverLeaf, type: ASTEngine.RelationshipType.Instantiates, confidence: 0.9, line_number: this.nodeLine(recvTargetNode ?? node), metadata: { isObjCAlloc: true, reasonCode: "allocator-receiver-not-cross-file-checked" } });
+            }
+          } else {
+            relationships.push({
+              source: activeScope,
+              target: msgSel,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.95,
+              line_number: this.nodeLine(this.fullMessageSelectorNode(node) ?? node),
+              metadata: { isMessageExpression: true, reasonCode: "dynamic-dispatch-selector" }
+            });
+          }
+          const msgKids = [];
+          for (let mi = 0; mi < node.childCount; mi++) {
+            const mc = node.child(mi);
+            if (!mc || !mc.isNamed || mc.type !== "identifier") continue;
+            const nxt = mi + 1 < node.childCount ? node.child(mi + 1) : null;
+            msgKids.push({ n: mc, isKeyword: !!(nxt && !nxt.isNamed && nxt.type === ":") });
+          }
+          const recvNode = node.namedChild(0);
+          const hasKeyword = msgKids.some((k) => k.isKeyword);
+          let lastNonRecv = -1;
+          if (!hasKeyword) {
+            for (let ki = msgKids.length - 1; ki >= 0; ki--) {
+              if (!this.sameNode(msgKids[ki].n, recvNode)) {
+                lastNonRecv = ki;
+                break;
+              }
+            }
+          }
+          for (let ki = 0; ki < msgKids.length; ki++) {
+            const kk = msgKids[ki];
+            if (kk.isKeyword || ki === lastNonRecv) continue;
+            const ktext = kk.n.text.trim();
+            if (!ktext || BARE_READ_SKIP.has(ktext)) continue;
+            if (this.sameNode(kk.n, recvNode)) {
+              if (ktext === "self" || ktext === "super") continue;
+            }
+            if (isBoundValue(ktext, nextOwner)) {
+              relationships.push({
+                source: activeScope,
+                target: ktext,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: 0.9,
+                line_number: this.nodeLine(kk.n),
+                metadata: { isBareRead: true, isMessageArgument: !this.sameNode(kk.n, recvNode), reasonCode: "value-read-by-scope-inference" }
+              });
+            }
+          }
+        }
+      } else if (node.type === "call_expression") {
+        const funcNode = node.childForFieldName("function") ?? this.findChild(node, (n) => n.type === "identifier");
+        const inAtDirective = (() => {
+          let p = node.parent;
+          let g = 0;
+          while (p && g++ < 3) {
+            if (p.type === "at_expression") return true;
+            if (p.type === "message_expression" || p.type === "call_expression") return false;
+            p = p.parent;
+          }
+          return false;
+        })();
+        if (funcNode && activeScope !== "global" && isInBody && !(inAtDirective && funcNode.text === "protocol")) {
+          if (funcNode.type === "field_expression") {
+            const fieldNode = funcNode.childForFieldName("field") ?? this.findChild(funcNode, (n) => n.type === "field_identifier");
+            if (fieldNode && fieldNode.text.trim()) {
+              relationships.push({
+                source: activeScope,
+                target: fieldNode.text,
+                type: ASTEngine.RelationshipType.Calls,
+                confidence: 0.95,
+                line_number: this.nodeLine(fieldNode),
+                metadata: { isFieldInvocation: true, reasonCode: "field-callee-kind-not-determined" }
+              });
+            }
+          } else {
+            relationships.push({
+              source: activeScope,
+              target: funcNode.text,
+              type: ASTEngine.RelationshipType.Calls,
+              confidence: 0.95,
+              line_number: this.nodeLine(funcNode),
+              metadata: { isCFunctionCall: true }
+            });
+          }
+        }
+      } else if (node.type === "field_expression" && activeScope !== "global" && isInBody) {
+        const field = node.childForFieldName("field") ?? this.findChild(node, (n) => n.type === "field_identifier");
+        if (field && field.text.trim()) {
+          if (parentType !== "assignment_expression") {
+            relationships.push({
+              source: activeScope,
+              target: field.text,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.9,
+              line_number: this.nodeLine(field),
+              // Honesty §4.1: sub-1.0 rows carry their own machine-readable code, and
+              // `uses` has ONE — the read is exact (the field name is in the source) and
+              // what the row infers is WHICH binding the name denotes, resolved against
+              // the enclosing class's members. The `calls` rows for the same node keep a
+              // different word (`field-callee-kind-not-determined`), because the call is
+              // about the callable's KIND and the read is about the binding
+              // (objc/generics-and-reason-codes pins the family, objc/field-invocation
+              // pins that the two labels on one node are told apart by their flags).
+              metadata: { isFieldRead: true, relationshipType: "field_access", reasonCode: "value-read-by-scope-inference" }
+            });
+          }
+        }
+      } else if (node.type === "identifier" && nextBindable && activeScope !== "global") {
+        const text = node.text.trim();
+        if (text && !BARE_READ_SKIP.has(text)) {
+          const parent = node.parent;
+          const ptype = parent ? parent.type : "";
+          let isName = false;
+          if (ptype === "method_declaration" || ptype === "method_definition" || ptype === "method_parameter" || ptype === "parameter_declaration" || ptype === "property_implementation" || ptype === "selector_expression" || ptype === "function_declarator" || ptype === "message_expression" || ptype === "declaration") {
+            isName = true;
+          } else if (ptype === "call_expression" && parent && parent.namedChild(0) && this.sameNode(parent.namedChild(0), node)) {
+            isName = true;
+          } else if (ptype === "assignment_expression" && parent && parent.namedChild(0) && this.spanContains(parent.namedChild(0), node)) {
+            isName = true;
+          } else if (ptype === "for_statement" && parent && this.isForInVariable(parent, node)) {
+            isName = true;
+          } else if (this.isDeclaratorName(node) || this.isParameterDeclaredName(node)) {
+            isName = true;
+          }
+          if (!isName && isBoundValue(text, nextOwner)) {
+            relationships.push({
+              source: activeScope,
+              target: text,
+              type: ASTEngine.RelationshipType.Uses,
+              confidence: 0.9,
+              line_number: this.nodeLine(node),
+              // Honesty §4.1: the read is exact — the identifier is in the source — and what
+              // the row INFERS is which binding the name denotes (parameter, body local,
+              // same-file ivar/property, file global). That is the whole of the doubt, so it
+              // is the whole of the code (objc/generics-and-reason-codes pins the word).
+              metadata: { isBareRead: true, reasonCode: "value-read-by-scope-inference" }
+            });
+          }
+        }
+      }
+      const childCount = node.namedChildCount;
+      nextIsInBody = nextIsInBody || node.type === "method_definition" || node.type === "method_declaration" || node.type === "function_definition" || node.type === "block_literal";
+      if (node.type === "block_literal" && nextBindable) {
+        walkStack.push({ node, isExit: true, activeScope: nextActiveScope, parentType: node.type, isInBody: nextIsInBody, owner: nextOwner, bindable: nextBindable });
+      }
+      for (let i = childCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) {
+          walkStack.push({ node: child, isExit: false, activeScope: nextActiveScope, parentType: node.type, isInBody: nextIsInBody, owner: nextOwner, bindable: nextBindable });
+        }
+      }
+    }
+    const uniqueSymbolsMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < symbols.length; i++) {
+      const s = symbols[i];
+      const catKey = s.kind === ASTEngine.SymbolKind.Extension && s.metadata?.isCategory ? `:${s.metadata?.categoryName ?? ""}` : "";
+      uniqueSymbolsMap.set(`${s.kind}:${s.ownerName || ""}:${s.name}${catKey}`, s);
+    }
+    const uniqueSymbols = Array.from(uniqueSymbolsMap.values());
+    const uniqueRelMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < relationships.length; i++) {
+      const rk = `${relationships[i].type}|${relationships[i].source}->${relationships[i].target}`;
+      const prev = uniqueRelMap.get(rk);
+      if (prev) {
+        const pm = prev.metadata ?? {};
+        const nm = relationships[i].metadata ?? {};
+        if (nm.isFieldRead) pm.isFieldRead = true;
+        if (nm.isBareRead) pm.isBareRead = true;
+        prev.metadata = pm;
+        if (prev.line_number === void 0 && relationships[i].line_number !== void 0) {
+          prev.line_number = relationships[i].line_number;
+        }
+      } else {
+        uniqueRelMap.set(rk, relationships[i]);
+      }
+    }
+    const uniqueRelationships = Array.from(uniqueRelMap.values());
+    const relKeySet = new Set(uniqueRelMap.keys());
+    for (const s of uniqueSymbols) {
+      if (s.ownerName || s.scope) continue;
+      if (s.kind === ASTEngine.SymbolKind.Extension) continue;
+      if (!OBJC_LINKAGE_UNIT_KINDS.has(s.kind)) continue;
+      if (internalLinkage.has(s.name)) continue;
+      const key = `${ASTEngine.RelationshipType.Exports}|root->${s.name}`;
+      if (relKeySet.has(key)) continue;
+      relKeySet.add(key);
+      const marker = exportMarkers.get(s.name);
+      uniqueRelationships.push({
+        source: "root",
+        target: s.name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        ...exportLineByName.has(s.name) ? { line_number: exportLineByName.get(s.name) } : s.range?.startLine ? { line_number: s.range.startLine } : {},
+        metadata: {
+          relationshipType: "module_export",
+          isExport: true,
+          isObjCExport: true,
+          fileLevel: true,
+          ...marker ? { exportMarker: marker } : {}
+        }
+      });
+    }
+    for (const s of uniqueSymbols) {
+      const _owner = s.ownerName || s.scope;
+      if (_owner) {
+        const key = `${ASTEngine.RelationshipType.Contains}|${_owner}->${s.name}`;
+        if (!relKeySet.has(key)) {
+          relKeySet.add(key);
+          uniqueRelationships.push({
+            source: _owner,
+            target: s.name,
+            type: ASTEngine.RelationshipType.Contains,
+            confidence: 1,
+            // M59.A7: the line of the name this edge NAMES — the member's own declared
+            // name line, taken from the symbol's range (the symbol and the edge come from
+            // one selection: the same node named both).
+            ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+            metadata: { isContained: true }
+          });
+        }
+      }
+    }
+    const classNameSet = /* @__PURE__ */ new Set();
+    for (const s of uniqueSymbols) {
+      if (s.kind === ASTEngine.SymbolKind.Class) classNameSet.add(s.name);
+    }
+    const baseByClass = /* @__PURE__ */ new Map();
+    for (const r of uniqueRelationships) {
+      if (r.type === ASTEngine.RelationshipType.Extends && classNameSet.has(String(r.source)) && !r.metadata?.isProtocolInheritance) {
+        const t = String(r.target);
+        if (t && t !== "NSObject" && t !== "NSProxy") baseByClass.set(String(r.source), t);
+      }
+    }
+    const methodsByOwner = /* @__PURE__ */ new Map();
+    for (const s of uniqueSymbols) {
+      if (s.kind === ASTEngine.SymbolKind.Method && s.ownerName) {
+        let names = methodsByOwner.get(s.ownerName);
+        if (!names) {
+          names = /* @__PURE__ */ new Set();
+          methodsByOwner.set(s.ownerName, names);
+        }
+        names.add(s.name);
+      }
+    }
+    for (const s of uniqueSymbols) {
+      if (s.kind !== ASTEngine.SymbolKind.Method || !s.ownerName) continue;
+      const base = baseByClass.get(s.ownerName);
+      if (!base) continue;
+      const inFileBaseMethods = classNameSet.has(base) ? methodsByOwner.get(base) : void 0;
+      if (inFileBaseMethods?.has(s.name)) {
+        const key = `${ASTEngine.RelationshipType.Overrides}|${s.ownerName}.${s.name}->${base}.${s.name}`;
+        if (!relKeySet.has(key)) {
+          relKeySet.add(key);
+          uniqueRelationships.push({
+            source: `${s.ownerName}.${s.name}`,
+            target: `${base}.${s.name}`,
+            type: ASTEngine.RelationshipType.Overrides,
+            confidence: 0.95,
+            // M59.A7: the OVERRIDING member's own declaration line (the base's copy lives
+            // in another translation unit, and the row is written here).
+            ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+            // The VERIFIED branch names its own evidence: the superclass is declared in THIS
+            // file and declares the same full selector, so this row is a verification. The
+            // guessed branch below keeps `first-parent-guess` — one code for both would call
+            // a verification a guess (objc/selector-attributes pins the pair).
+            metadata: { isOverride: true, reasonCode: "verified-base-declared-in-file" }
+          });
+        }
+      } else if (!classNameSet.has(base)) {
+        const key = `${ASTEngine.RelationshipType.Overrides}|${s.ownerName}.${s.name}->${base}.${s.name}`;
+        if (!relKeySet.has(key)) {
+          relKeySet.add(key);
+          uniqueRelationships.push({
+            source: `${s.ownerName}.${s.name}`,
+            target: `${base}.${s.name}`,
+            type: ASTEngine.RelationshipType.Overrides,
+            confidence: 0.5,
+            ...s.range?.startLine ? { line_number: s.range.startLine } : {},
+            metadata: { isOverride: true, reasonCode: "first-parent-guess" }
+          });
+        }
+      }
+    }
+    const fileFunctions = /* @__PURE__ */ new Set();
+    for (const s of uniqueSymbols) {
+      if (s.kind === ASTEngine.SymbolKind.Function) fileFunctions.add(s.name);
+    }
+    for (const r of uniqueRelationships) {
+      if (r.type !== ASTEngine.RelationshipType.Calls) continue;
+      const md = r.metadata ?? {};
+      if (!md.isCFunctionCall || md.reasonCode) continue;
+      if (!fileFunctions.has(String(r.target))) md.reasonCode = "callee-not-resolved-in-unit";
+    }
+    const publishedNames = /* @__PURE__ */ new Set();
+    for (const s of uniqueSymbols) if (s.name) publishedNames.add(s.name);
+    for (const r of uniqueRelationships) {
+      if (r.type !== ASTEngine.RelationshipType.Uses) continue;
+      const md = r.metadata ?? {};
+      if (md.isBareRead !== true || md.isFieldRead === true) continue;
+      const leaf = String(r.target ?? "");
+      if (!leaf || !r.source || publishedNames.has(leaf)) continue;
+      r.target = `${r.source}${BINDING_SEP}${leaf}`;
+      md.localBinding = true;
+    }
+    this.classifyEvidenceTier(uniqueRelationships);
+    {
+      const seenExportNames = /* @__PURE__ */ new Set();
+      for (let i = 0; i < uniqueSymbols.length; i++) {
+        const s = uniqueSymbols[i];
+        if (s.ownerName) continue;
+        if (s.kind === ASTEngine.SymbolKind.Extension) continue;
+        if (seenExportNames.has(s.name)) continue;
+        seenExportNames.add(s.name);
+        exports.push({ name: s.name, kind: s.kind, range: s.range, visibility: internalLinkage.has(s.name) ? "private" : "public" });
+      }
+    }
+    const detectedFrameworks = [...frameworks];
+    detectedFrameworks.sort((a, b) => {
+      const ra = OBJC_FRAMEWORK_ORDER.indexOf(a);
+      const rb = OBJC_FRAMEWORK_ORDER.indexOf(b);
+      if (ra === -1 && rb === -1) return a < b ? -1 : a > b ? 1 : 0;
+      if (ra === -1) return 1;
+      if (rb === -1) return -1;
+      return ra - rb;
+    });
+    const frameworkPatterns = detectedFrameworks.map((f) => ({
+      framework: f,
+      patterns: OBJC_FRAMEWORK_PATTERNS[f] ?? ["usage"]
+    }));
+    return {
+      language: "objective-c",
+      symbols: uniqueSymbols,
+      relationships: uniqueRelationships,
+      imports,
+      exports,
+      errors,
+      metadata: {
+        complexity: uniqueSymbols.length,
+        linesOfCode: content.split("\n").length,
+        detectedFrameworks,
+        framework: detectedFrameworks.length > 0 ? detectedFrameworks[0] : void 0,
+        frameworkPatterns
+      }
+    };
+  }
+  /**
+   * Evidence-tier classification — same rules as the swift/dart/csharp
+   * family (see swift wave #266 for the full rationale).
+   */
+  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 === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (type === "imports" || type === "references") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (type === "part_of") {
+        md.evidenceClass = "import_based";
+        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 = (r.confidence ?? 0) >= 0.9 ? "structural" : "inferred";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  /**
+   * Per-symbol cyclomatic complexity (managed-OO family contract — csharp
+   * #264 wave precedent). The objc grammar is a C superset, so the node set
+   * mirrors the C analyzer's exactly: branch constructs + short-circuit
+   * &&/|| operators only; base 1. Probe-verified against the pinned wasm
+   * (do_statement confirmed present, 2026-08-30).
+   */
+  calculateCyclomaticComplexity(node) {
+    let complexity = 1;
+    const complexityNodes = /* @__PURE__ */ new Set([
+      "if_statement",
+      "for_statement",
+      "while_statement",
+      "do_statement",
+      "case_statement",
+      "conditional_expression"
+    ]);
+    const stack = [node];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 2e5) {
+      const n = stack.pop();
+      if (complexityNodes.has(n.type)) complexity++;
+      else if (n.type === "binary_expression") {
+        const op = n.childForFieldName("operator");
+        if (op && (op.text === "&&" || op.text === "||")) complexity++;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const c = n.namedChild(i);
+        if (c) stack.push(c);
+      }
+    }
+    return complexity;
+  }
+  /**
+   * OC-E helpers: bare-identifier read classification. web-tree-sitter
+   * returns fresh wrappers per accessor call, so node identity is compared
+   * by span (start/end offsets), never by reference.
+   */
+  sameNode(a, b) {
+    if (!a || !b) return false;
+    return a.startIndex === b.startIndex && a.endIndex === b.endIndex;
+  }
+  spanContains(outer, inner) {
+    if (!outer || !inner) return false;
+    return outer.startIndex <= inner.startIndex && outer.endIndex >= inner.endIndex;
+  }
+  /**
+   * True when the identifier is the DECLARED name of an init_declarator
+   * (`int y = ...`, `int arr[10] = ...`, `Counter g = ...`): climb through
+   * name-wrapping declarators (array/pointer/parenthesized); the name is
+   * the declarator subtree under the init_declarator's FIRST named child.
+   * Initializer values live outside that subtree and stay reads.
+   */
+  isDeclaratorName(node) {
+    let cur = node;
+    let p = node.parent ?? null;
+    while (p && DECLARATOR_WRAPPERS.has(p.type) && cur) {
+      cur = p;
+      p = p.parent ?? null;
+    }
+    if (!p || p.type !== "init_declarator" || !cur) return false;
+    const head = p.namedChild(0);
+    return !!head && this.spanContains(head, cur);
+  }
+  /**
+   * OC-E: true when the identifier is the DECLARED NAME of a parameter
+   * (`void (^handler)(NSString *)`, `NSString *name`, `int n`). Structural, not
+   * textual: climb the name-wrapping declarators and require that the node we
+   * land on IS the enclosing parameter's own `declarator` field — a declarator
+   * subtree holds no expressions, so nothing inside it can be a value read, and
+   * OC-E's rule is that "declaration names" are names, never reads.
+   *
+   * The direct `identifier < parameter_declaration` shape was already covered by
+   * the parent-type test. The BLOCK-POINTER parameter is the shape that leaked:
+   * its name nests `identifier < block_pointer_declarator <
+   * parenthesized_declarator < function_declarator < parameter_declaration`, so
+   * neither the parent-type test nor isDeclaratorName (which needs an
+   * init_declarator) could see it, and the declaration line was published as a
+   * `uses` read. Measured before the fix (script/m14/tmp/oc-callee-uses.ts):
+   * `void register_block(void (^handler)(NSString *)) { int x = 0; }` emitted
+   * `uses register_block -> handler` with NO read anywhere in the file — while
+   * the C analyzer, handed the same function-pointer parameter, emits nothing
+   * (family parity), and the M12 fixture read it as a false positive against a
+   * truth that only counts the call.
+   */
+  isParameterDeclaredName(node) {
+    let cur = node;
+    let p = node.parent ?? null;
+    while (p && DECLARATOR_WRAPPERS.has(p.type) && cur) {
+      cur = p;
+      p = p.parent ?? null;
+    }
+    if (!p || !cur) return false;
+    if (p.type !== "parameter_declaration" && p.type !== "method_parameter") return false;
+    const declared = p.childForFieldName("declarator");
+    if (!declared) return p.type === "method_parameter";
+    return this.spanContains(declared, cur);
+  }
+  /**
+   * True when the identifier is a for-in loop variable
+   * (`for (id x in items)`): the named sibling directly preceding the
+   * anonymous `in` token.
+   */
+  isForInVariable(forNode, node) {
+    const cc = forNode.childCount;
+    for (let i = 0; i < cc; i++) {
+      const c = forNode.child(i);
+      if (c && !c.isNamed && c.type === "in" && i > 0) {
+        for (let j = i - 1; j >= 0; j--) {
+          const pc = forNode.child(j);
+          if (pc && pc.isNamed) return this.sameNode(pc, node);
+        }
+        return false;
+      }
+    }
+    return false;
+  }
+  /**
+   * The bound name declared by an init_declarator, method_parameter, or
+   * parameter_declaration: the declarator identifier (through wrappers for
+   * arrays/pointers; first document-order identifier for parameters, where
+   * type names are type_identifier and `id` is a typedefed_specifier).
+   */
+  declaratorName(node) {
+    if (node.type === "init_declarator") {
+      const head = node.namedChild(0);
+      if (!head) return null;
+      const stack2 = [head];
+      while (stack2.length > 0) {
+        const c = stack2.pop();
+        if (c.type === "identifier") return c.text;
+        for (let i = c.namedChildCount - 1; i >= 0; i--) {
+          const ch = c.namedChild(i);
+          if (ch) stack2.push(ch);
+        }
+      }
+      return null;
+    }
+    const direct = this.findChild(node, (n) => n.type === "identifier");
+    if (direct) return direct.text;
+    const stack = [node];
+    while (stack.length > 0) {
+      const c = stack.pop();
+      if (c.type === "identifier") return c.text;
+      for (let i = c.namedChildCount - 1; i >= 0; i--) {
+        const ch = c.namedChild(i);
+        if (ch) stack.push(ch);
+      }
+    }
+    return null;
+  }
+  /**
+   * OC-D: the typedef alias naming an anonymous aggregate
+   * (`typedef struct {...} Size` -> "Size"): the LAST type_identifier
+   * child directly under the enclosing type_definition.
+   */
+  typedefName(node) {
+    const p = node.parent;
+    if (!p || p.type !== "type_definition") return null;
+    let alias = null;
+    for (let i = 0; i < p.namedChildCount; i++) {
+      const c = p.namedChild(i);
+      if (c && (c.type === "type_identifier" || c.type === "identifier")) alias = c;
+    }
+    return alias ? alias.text : null;
+  }
+  // Walk struct_declaration → struct_declarator → (pointer/reference) →
+  // identifier to find the declared property/ivar name.
+  findDeclaredName(node) {
+    const walkForIdentifier = (n) => {
+      if (!n) return null;
+      if (n.type === "identifier") return n;
+      for (let i = 0; i < n.namedChildCount; i++) {
+        const found = walkForIdentifier(n.namedChild(i));
+        if (found) return found;
+      }
+      return null;
+    };
+    const idNode = walkForIdentifier(node);
+    if (!idNode) return null;
+    const structDecl = this.findChild(node, (n) => n.type === "struct_declaration");
+    if (structDecl) {
+      const sd = this.findChild(structDecl, (n) => n.type === "struct_declarator");
+      if (sd) {
+        const deep = walkForIdentifier(sd);
+        if (deep) return deep.text;
+      }
+    }
+    return idNode.text;
+  }
+  /**
+   * OBJCD9: does this declarator subtree reach a `function_declarator`?
+   *
+   * A declaration is a function PROTOTYPE when its declarator chain contains one,
+   * whatever wraps it: `void f(int)` nests the declarator bare, `NSString * f(d)`
+   * nests it under a `pointer_declarator`. The wrapper is a return type, not a
+   * different kind of thing, and the pre-fix arm list read the wrapper as if it
+   * were. Structural — `node.type` and a pre-order walk — with no text test and
+   * no regex.
+   */
+  declaratorChainHasFunctionDeclarator(node) {
+    const stack = [node];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 1e4) {
+      const c = stack.pop();
+      if (c.type === "function_declarator") return true;
+      if (c.type === "parameter_list") continue;
+      for (let i = c.namedChildCount - 1; i >= 0; i--) {
+        const ch = c.namedChild(i);
+        if (ch) stack.push(ch);
+      }
+    }
+    return false;
+  }
+  /**
+   * OBJCD5: the defining name of a function_definition — the first
+   * function_declarator in document order that is NOT inside the body
+   * (compound_statement), then its first identifier child. Handles the
+   * pointer_declarator > function_declarator nesting of pointer-return C
+   * helpers. The head always precedes any parameter-nested function-pointer
+   * declarator in the tree, so pre-order first-hit is exact (probe-verified
+   * against the pinned tree-sitter-objc, 2026-09).
+   */
+  findFunctionName(node) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const c = stack.pop();
+      if (c.type === "compound_statement") continue;
+      if (c.type === "function_declarator") {
+        const id = this.findChild(c, (n) => n.type === "identifier");
+        return id || c;
+      }
+      for (let i = c.namedChildCount - 1; i >= 0; i--) {
+        const child = c.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return null;
+  }
+  // The `+`/`-` sign is an anonymous token child of a method node
+  // (`method_declaration [-:"-"] [;:";"]`) — scan the non-named children for
+  // the `+` token. Pure AST, never source-text scanning.
+  isClassMethodToken(node) {
+    const count = node.childCount;
+    for (let i = 0; i < count; i++) {
+      const c = node.child(i);
+      if (c && !c.isNamed && c.type === "+") return true;
+    }
+    return false;
+  }
+  /**
+   * OBJCD7: full ObjC selector of a method_declaration/method_definition.
+   * The pinned grammar nests keyword identifiers at the TOP level of the
+   * method node (parameter locals live INSIDE the method_parameter nodes,
+   * probe-verified 2026-09): `- (void)storeImage:(UIImage*)image
+   * forName:(NSString*)name` -> top-level children are identifier
+   * "storeImage", method_parameter, identifier "forName", method_parameter.
+   * A keyword gets ':' when the NEXT named sibling is a method_parameter.
+   *
+   * A selector is that keyword chain and NOTHING ELSE. The grammar also puts a
+   * method's TRAILING ANNOTATION MACROS at the method node's top level as bare
+   * identifiers with no `method_parameter` after them:
+   *
+   *   method_declaration "- (instancetype)initWithBaseURL:(NSURL *)url
+   *                           sessionConfiguration:(NSURLSessionConfiguration *)c
+   *                           NS_DESIGNATED_INITIALIZER;"
+   *     identifier        "initWithBaseURL"
+   *     method_parameter  ":(NSURL *)url"
+   *     identifier        "sessionConfiguration"
+   *     method_parameter  ":(NSURLSessionConfiguration *)c"
+   *     identifier        "NS_DESIGNATED_INITIALIZER"   <- an annotation, not a keyword
+   *
+   * Concatenating every top-level identifier published
+   * `initWithBaseURL:sessionConfiguration:NS_DESIGNATED_INITIALIZER` — a symbol
+   * no class in the world declares, and an `overrides` TARGET
+   * (`AFURLSessionManager.<that name>`) that resolves to nothing. Measured over
+   * the admitted universe by script/m60/objc-selector-integrity.ts before this
+   * fix: 79 method nodes in 29 files (NS_REFINED_FOR_SWIFT 62,
+   * NS_DESIGNATED_INITIALIZER 15, NS_SWIFT_NOTHROW 2) and 109 fabricated
+   * `overrides` targets.
+   *
+   * So the chain STOPS at the first bare identifier: after a keyword it is an
+   * annotation; with no keyword seen it is the zero-argument selector and
+   * anything after it is an annotation too. The alternative reading — a bare
+   * identifier BEFORE the keywords is the selector — is not a guess: the same
+   * probe counted the shapes of all 2,891 method nodes and `bareThenKeyword` is
+   * 0, `bareOnlyMulti` 0, `keywordChain` 1,595, `singleBare` 1,217,
+   * `bareAfterKeyword` 79. The rule is the grammar's, and the census is what
+   * would refute it.
+   */
+  fullMethodSelector(node) {
+    let sel = "";
+    const count = node.namedChildCount;
+    for (let i = 0; i < count; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "identifier") {
+        const next = i + 1 < count ? node.namedChild(i + 1) : null;
+        if (next && next.type === "method_parameter") {
+          sel += c.text + ":";
+          continue;
+        }
+        if (sel === "") sel = c.text;
+        break;
+      }
+    }
+    return sel;
+  }
+  /**
+   * OBJCD7: full selector of a message_expression. The grammar flattens
+   * keywords and arguments as SIBLINGS; a keyword is an identifier whose
+   * NEXT child is an anonymous ':' token (the colons are direct anonymous
+   * children of message_expression, probe-verified 2026-09). Zero-argument
+   * messages have no ':' — the selector is then the LAST identifier child
+   * (receiver identifiers live inside nested nodes for complex receivers;
+   * `[foo bar]` -> bar, `[self.imageTable removeAllObjects]` ->
+   * removeAllObjects, `[[Foo alloc] init]` -> init).
+   */
+  /**
+   * The FIRST selector node of a message send — the same selection `fullMessageSelector`
+   * builds its text from, returned as a NODE.
+   *
+   * The M59.A7 contract is that a relationship's `line_number` is the line of the NAME it
+   * names, and a name captured as a string has no line. swift's round paid for this lesson
+   * with a surviving `calls Endpoint -> method` edge that claimed the CONVERTED site's line,
+   * because the text and the line came from two different selections; here they come from one
+   * walk, and the equivalence probe re-checks that the node's own text is a prefix of the
+   * published selector (a keyword send) or equal to it (a zero-argument send).
+   */
+  fullMessageSelectorNode(node) {
+    let firstKeyword = null;
+    let lastIdentifier = null;
+    const count = node.childCount;
+    for (let i = 0; i < count; i++) {
+      const c = node.child(i);
+      if (!c) continue;
+      if (c.isNamed && c.type === "identifier") {
+        const nxt = i + 1 < count ? node.child(i + 1) : null;
+        if (nxt && !nxt.isNamed && nxt.type === ":") {
+          if (!firstKeyword) firstKeyword = c;
+        } else {
+          lastIdentifier = c;
+        }
+      }
+    }
+    return firstKeyword ?? lastIdentifier;
+  }
+  /**
+   * The 1-based line a node is WRITTEN on. The unit of the M59.A7 contract, and deliberately
+   * computed from the node itself: two runs of the same file must produce the same number.
+   */
+  nodeLine(n) {
+    return n.startPosition.row + 1;
+  }
+  /**
+   * OC-ONT-6 — the three lists Objective-C spells with ONE token sequence.
+   *
+   * `@interface Cache <KeyType, ObjectType> : Store <KeyType, ObjectType> <CacheProtocol>`
+   * has three `parameterized_arguments` children, and the pinned grammar names all three
+   * identically: the class's own lightweight-generic TYPE PARAMETERS, its superclass's TYPE
+   * ARGUMENTS, and its ADOPTED PROTOCOLS. Reading every list as an adoption list published
+   * `implements Cache -> KeyType` / `-> ObjectType` — the class's own type parameters as
+   * protocols, names no file declares (objc/generics-and-reason-codes).
+   *
+   * The lists are separated by POSITION, and position is exact here rather than heuristic
+   * because the pinned grammar keeps the `:` and `(` tokens as direct children:
+   *
+   *   1. a list BEFORE the `:` is part of the DECLARATION — the class's own type parameters,
+   *      never a protocol;
+   *   2. the FIRST list after the `:` is the superclass's type ARGUMENTS exactly when every
+   *      name in it is one of those parameters, and is otherwise the adoption list: the
+   *      ordinary `@interface Plain : NSObject <NSCopying>` declares no parameters, so its
+   *      single list adopts;
+   *   3. every later list is an adoption list.
+   *
+   * A class EXTENSION re-declares the enclosing class's parameters in front of its `()`
+   * (`@interface Cache <KeyType, ObjectType> ()`), so its lists are all declaration-region
+   * and none adopts; a CATEGORY is the mirror image — `@interface Plain (Trim)
+   * <NSFastEnumeration>` — and its list sits AFTER the `(`, so a category's lists all adopt.
+   * The two positions are mirrors, which is why the rule cannot be "a list before the paren"
+   * alone (objc/generics-and-reason-codes pins both).
+   *
+   * The same partition is re-derived independently in
+   * script/m60/objc-construct-site-probe.ts so the F5 differential compares two derivations
+   * rather than one against itself.
+   */
+  objcInheritanceLists(node) {
+    const membersOf = (pa) => {
+      const out = [];
+      for (let i = 0; i < pa.namedChildCount; i++) {
+        const m = pa.namedChild(i);
+        if (m && (m.type === "type_identifier" || m.type === "identifier" || m.type === "type_name")) {
+          out.push({ name: m.text, node: m });
+        }
+      }
+      return out;
+    };
+    let colonIdx = -1;
+    let parenIdx = -1;
+    const lists = [];
+    for (let ci = 0; ci < node.childCount; ci++) {
+      const c = node.child(ci);
+      if (!c) continue;
+      if (!c.isNamed && c.type === ":" && colonIdx < 0) {
+        colonIdx = ci;
+        continue;
+      }
+      if (!c.isNamed && c.type === "(" && parenIdx < 0) {
+        parenIdx = ci;
+        continue;
+      }
+      if (c.isNamed && c.type === "parameterized_arguments") lists.push({ node: c, idx: ci });
+    }
+    const isCategory = parenIdx >= 0 && (colonIdx < 0 || parenIdx < colonIdx);
+    const isDeclarationRegion = (idx) => colonIdx >= 0 ? idx < colonIdx : isCategory && idx < parenIdx;
+    const typeParams = [];
+    for (const l of lists) {
+      if (!isDeclarationRegion(l.idx)) continue;
+      for (const m of membersOf(l.node)) typeParams.push(m.name);
+    }
+    const paramSet = new Set(typeParams);
+    let superClass = null;
+    let superNode = null;
+    const protocols = [];
+    let argsConsumed = false;
+    for (let ci = 0; ci < node.childCount; ci++) {
+      const c = node.child(ci);
+      if (!c) continue;
+      if (colonIdx >= 0 && ci > colonIdx && superClass === null && c.isNamed && (c.type === "identifier" || c.type === "type_identifier")) {
+        superClass = c.text;
+        superNode = c;
+        continue;
+      }
+      if (!c.isNamed || c.type !== "parameterized_arguments") continue;
+      if (isDeclarationRegion(ci)) continue;
+      const mem = membersOf(c);
+      if (colonIdx >= 0 && !argsConsumed && mem.length > 0 && mem.every((m) => paramSet.has(m.name))) {
+        argsConsumed = true;
+        continue;
+      }
+      for (const m of mem) protocols.push(m);
+      if (colonIdx >= 0) argsConsumed = true;
+    }
+    return { superClass, superNode, typeParams, protocols };
+  }
+  fullMessageSelector(node) {
+    let sel = "";
+    let lastId = null;
+    const count = node.childCount;
+    for (let i = 0; i < count; i++) {
+      const c = node.child(i);
+      if (!c) continue;
+      if (c.isNamed && c.type === "identifier") {
+        const nxt = i + 1 < count ? node.child(i + 1) : null;
+        if (nxt && !nxt.isNamed && nxt.type === ":") {
+          sel += c.text + ":";
+        } else {
+          lastId = c.text;
+        }
+      }
+    }
+    if (sel) return sel;
+    return lastId ?? "";
+  }
+  // Pure cursor helper protecting V8 from GC Thrashing
+  findChild(node, predicate) {
+    const count = node.namedChildCount;
+    for (let i = 0; i < count; i++) {
+      const child = node.namedChild(i);
+      if (child && predicate(child)) return child;
+    }
+    return null;
+  }
+  // Deep pre-order variant of findChild (first document-order match in the
+  // subtree, including the node itself).
+  deepFind(node, predicate) {
+    const stack = [node];
+    while (stack.length > 0) {
+      const c = stack.pop();
+      if (predicate(c)) return c;
+      for (let i = c.namedChildCount - 1; i >= 0; i--) {
+        const ch = c.namedChild(i);
+        if (ch) stack.push(ch);
+      }
+    }
+    return null;
+  }
+  getRange(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
+    };
+  }
+};
+export {
+  RealObjectiveCAnalyzer
+};