@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-r-analyzer-ZGAIDVI4.js

@@ -0,0 +1,2596 @@
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-r-analyzer.ts
+var LEFT_BINDING_OPERATORS = /* @__PURE__ */ new Set(["<-", "<<-", "="]);
+var RIGHT_BINDING_OPERATORS = /* @__PURE__ */ new Set(["->", "->>"]);
+var ASSIGNMENT_OPERATORS = /* @__PURE__ */ new Set([...LEFT_BINDING_OPERATORS, ...RIGHT_BINDING_OPERATORS]);
+var NAMESPACE_OPERATORS = /* @__PURE__ */ new Set(["::", ":::"]);
+var APPLY_FAMILY = /* @__PURE__ */ new Set([
+  "apply",
+  "sapply",
+  "lapply",
+  "vapply",
+  "mapply",
+  "rapply",
+  "tapply",
+  "Map",
+  "mapply",
+  "Reduce",
+  "Filter",
+  "Negate"
+]);
+var TIDYVERSE_NSE = /* @__PURE__ */ new Set([
+  "mutate",
+  "select",
+  "filter",
+  "summarise",
+  "summarize",
+  "group_by",
+  "arrange",
+  "aes",
+  "vars",
+  "transmute",
+  "distinct",
+  "slice",
+  "pull",
+  "rename",
+  "relocate"
+]);
+var REACTIVE_CONSTRUCTORS = /* @__PURE__ */ new Set([
+  "reactive",
+  "observe",
+  "observeEvent",
+  "eventReactive",
+  "reactiveVal",
+  "reactiveValues",
+  "reactiveExpr",
+  "reactivePoll",
+  "reactiveFileReader",
+  "bindCache",
+  "freezeReactiveValue"
+]);
+var STATISTICAL_MODELS = /* @__PURE__ */ new Set(["lm", "glm", "summary", "glm.nb", "MASS::rlm"]);
+var DATA_FRAME_CONSTRUCTORS = /* @__PURE__ */ new Set(["data.frame", "tibble", "as.data.frame", "data.table"]);
+var ERROR_HANDLERS = /* @__PURE__ */ new Set(["tryCatch", "withCallingHandlers", "try", "tryCatch"]);
+var CLEANUP_HANDLERS = /* @__PURE__ */ new Set(["on.exit", "onLoad", "onUnload"]);
+var NSE_CAPTURERS = /* @__PURE__ */ new Set([
+  "substitute",
+  "quote",
+  "bquote",
+  "match.call",
+  "match.arg",
+  "enquo",
+  "enquos",
+  "expr",
+  "enexpr",
+  "eval",
+  "rlang::enquo",
+  "ensym",
+  "enname",
+  "quo",
+  "quos"
+]);
+var CLASS_MEMBER_LISTS = /* @__PURE__ */ new Set(["public", "private", "active"]);
+var R5_MEMBER_LISTS = /* @__PURE__ */ new Set(["fields", "methods"]);
+var DATA_MEMBER_LISTS = /* @__PURE__ */ new Set(["fields"]);
+var PACKAGE_NAMESPACE_SUBTYPES = /* @__PURE__ */ new Set([
+  "library_import",
+  "library_dependency",
+  "namespace_access"
+]);
+function isPackageNameShape(name) {
+  if (name.length === 0) return false;
+  const first = name.charCodeAt(0);
+  const firstIsLetter = first >= 65 && first <= 90 || first >= 97 && first <= 122;
+  if (!firstIsLetter) return false;
+  if (name.length === 1) return true;
+  const last = name.charCodeAt(name.length - 1);
+  const lastIsAlnum = last >= 65 && last <= 90 || last >= 97 && last <= 122 || last >= 48 && last <= 57;
+  if (!lastIsAlnum) return false;
+  for (let i = 1; i < name.length - 1; i++) {
+    const c = name.charCodeAt(i);
+    const ok = c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 46;
+    if (!ok) return false;
+  }
+  return true;
+}
+var PACKAGE_NAMESPACE_LABELS = /* @__PURE__ */ new Set([
+  ASTEngine.RelationshipType.Imports,
+  ASTEngine.RelationshipType.References
+]);
+var RealRAnalyzer = class {
+  /**
+   * UTF-16 code-unit index -> byte offset, set for the duration of an `analyze` call and
+   * cleared on return, so that every `getRange` call populates `byteStart`/`byteEnd`
+   * without each of them having to be handed the source text.
+   */
+  byteOffsetOf = null;
+  analyze(rootNode, content, filePath) {
+    const symbols = [];
+    const imports = [];
+    const exports = [];
+    const relationships = [];
+    const declaredTypes = /* @__PURE__ */ new Set();
+    const metadata = {
+      detectedFrameworks: [],
+      patterns: [],
+      architecturalInsights: [],
+      cyclomaticComplexity: 1,
+      linesOfCode: 0,
+      dataManipulationIntensity: 0,
+      statisticalFocus: 0,
+      codeQuality: "excellent",
+      architecturalScore: 100
+    };
+    if (!rootNode) return { symbols, imports, errors: [] };
+    const nonAscii = [];
+    const surplus = [];
+    for (let i = 0, extra = 0; i < content.length; i++) {
+      const c = content.charCodeAt(i);
+      if (c < 128) continue;
+      const cp = c >= 55296 && c <= 56319 ? content.codePointAt(i) : c;
+      const units = cp > 65535 ? 2 : 1;
+      const bytes = cp <= 127 ? 1 : cp <= 2047 ? 2 : cp <= 65535 ? 3 : 4;
+      nonAscii.push(i);
+      surplus.push(extra);
+      extra += bytes - units;
+      if (units === 2) i++;
+    }
+    const byteOffset = (utf16Index) => {
+      if (nonAscii.length === 0) return utf16Index;
+      let lo = 0;
+      let hi = nonAscii.length - 1;
+      let lastBefore = -1;
+      while (lo <= hi) {
+        const mid = lo + hi >> 1;
+        if (nonAscii[mid] <= utf16Index) {
+          lastBefore = mid;
+          lo = mid + 1;
+        } else {
+          hi = mid - 1;
+        }
+      }
+      return lastBefore < 0 ? utf16Index : utf16Index + surplus[lastBefore];
+    };
+    this.byteOffsetOf = byteOffset;
+    const symbolLine = /* @__PURE__ */ new Map();
+    const memberLine = /* @__PURE__ */ new Map();
+    const classDecls = /* @__PURE__ */ new Map();
+    const ambiguity = {
+      callsUnresolvedScope: 0,
+      callsAttributedThroughClosure: 0,
+      heuristicS3Generic: 0,
+      // A call whose callee is not a name at all -- `(if (uplo == "U") triu else
+      // tril)(x)`. Counted, because the alternative is that these vanish from the totals
+      // and a reader cannot tell "no such calls" from "not measured".
+      callsToUnnameableCallee: 0,
+      // `uses` accounting. The three numbers the `uses` surface cannot hide behind:
+      // a member read already carried by `calls`, a member WRITE, and a read with no
+      // enclosing named symbol to attribute to. Each is counted rather than dropped,
+      // for the reason the counter above states.
+      memberReadsSuppressedByCall: 0,
+      memberWrites: 0,
+      memberReadsUnresolvedScope: 0,
+      memberReadsWithComputedIndex: 0,
+      // `overrides` accounting, for the same reason: the pass declines to assert an edge
+      // when no EARLIER declaration of the base name exists in the file, and the count of
+      // those declines is otherwise indistinguishable from "there was nothing to inherit".
+      overridesEdgesEmitted: 0,
+      overridesBasesNotDeclaredEarlierInFile: 0
+    };
+    if (rootNode.hasError) {
+      const errStack = [rootNode];
+      while (errStack.length > 0) {
+        const n = errStack.pop();
+        if (n.type === "ERROR" || n.isMissing) {
+          if (!metadata.errors) metadata.errors = [];
+          metadata.errors.push({
+            message: n.type === "ERROR" ? `Unrecoverable syntax region: tree-sitter-r could not parse this subtree. Extraction continued on a best-effort basis, so symbols and relationships inside this range may be missing.` : `Missing ${n.type} token: the source is syntactically incomplete at this point. Extraction continued on a best-effort basis.`,
+            range: this.getRange(n),
+            severity: "warning"
+          });
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) errStack.push(child);
+        }
+      }
+    }
+    let loc = 1;
+    for (let i = 0; i < content.length; i++) {
+      if (content[i] === "\n") loc++;
+    }
+    metadata.linesOfCode = loc;
+    const EXIT_MARKER = /* @__PURE__ */ Symbol("r-exit");
+    const stack = [rootNode];
+    const fnStack = [];
+    while (stack.length > 0) {
+      const item = stack.pop();
+      if (item === EXIT_MARKER) {
+        fnStack.pop();
+        continue;
+      }
+      if (!item) continue;
+      const current = item;
+      const type = current.type;
+      if (type === "binary_operator") {
+        this.handleBinaryOperator(current, symbols, exports, relationships, metadata, declaredTypes, fnStack.length > 0);
+      } else if (type === "call") {
+        this.handleCall(current, symbols, imports, exports, relationships, metadata, declaredTypes, ambiguity, fnStack);
+      } else if (type === "comment") {
+        this.handleComment(current, metadata);
+      } else if (type === "function_definition") {
+        const fnParent = current.parent;
+        const isNestedWrapper = fnParent && fnParent.type === "function_definition";
+        const isAssignmentTarget = fnParent && fnParent.type === "binary_operator" && this.assignmentTarget(fnParent) === current;
+        if (!isNestedWrapper && !isAssignmentTarget) {
+          this.pushIfUnique(metadata.patterns, "Anonymous Functions");
+        }
+        fnStack.push({ node: current, attribution: this.resolveFunctionOwner(current) });
+        stack.push(EXIT_MARKER);
+      } else if (type === "subset" || type === "subset2") {
+        this.pushIfUnique(metadata.patterns, "Vectorized Subsetting");
+        if (type === "subset2" && this.stringSubsetIndex(current)) {
+          this.handleMemberRead(current, fnStack, relationships, ambiguity);
+        }
+      } else if (type === "extract_operator") {
+        this.handleMemberRead(current, fnStack, relationships, ambiguity);
+      } else if (type === "unary_operator" && current.childForFieldName("operator")?.text === "~") {
+        this.pushIfUnique(metadata.patterns, "Formula Interface");
+        if (metadata.statisticalFocus !== void 0) metadata.statisticalFocus += 10;
+      }
+      if (type === "if_statement" || type === "for_statement" || type === "while_statement" || type === "repeat_statement") {
+        if (metadata.cyclomaticComplexity !== void 0) {
+          metadata.cyclomaticComplexity++;
+        }
+      }
+      if (type === "if_statement" && this.isStaticallyFalseCondition(current)) {
+        const elseBranch = current.childForFieldName("alternative");
+        if (elseBranch) {
+          for (let i = elseBranch.childCount - 1; i >= 0; i--) {
+            const c = elseBranch.child(i);
+            if (c) stack.push(c);
+          }
+        }
+        continue;
+      }
+      for (let i = current.childCount - 1; i >= 0; i--) {
+        const child = current.child(i);
+        if (child) {
+          stack.push(child);
+        }
+      }
+    }
+    for (const s of symbols) {
+      if (!symbolLine.has(s.name)) symbolLine.set(s.name, this.nameLineOf(s, content));
+      if (s.kind !== ASTEngine.SymbolKind.Class) continue;
+      const line = s.range.startLine;
+      const bases = s.metadata?.baseClasses ?? [];
+      const parent = s.metadata?.parent;
+      const all = Array.isArray(parent) ? parent : bases;
+      const decls = classDecls.get(s.name) ?? [];
+      decls.push({ line, endLine: s.range.endLine, members: /* @__PURE__ */ new Map(), bases: all });
+      classDecls.set(s.name, decls);
+    }
+    for (const decls of classDecls.values()) decls.sort((a, b) => a.line - b.line);
+    for (const s of symbols) {
+      if (!s.ownerName) continue;
+      if (s.kind !== ASTEngine.SymbolKind.Method && s.kind !== ASTEngine.SymbolKind.Property) continue;
+      const line = this.nameLineOf(s, content);
+      const decls = classDecls.get(s.ownerName);
+      if (!decls?.length) continue;
+      let owner = decls.find((d) => line >= d.line && line <= d.endLine);
+      if (!owner) {
+        const prior = decls.filter((d) => d.line < line);
+        owner = prior.length ? prior[prior.length - 1] : decls[0];
+      }
+      if (!owner.members.has(s.name)) owner.members.set(s.name, line);
+    }
+    for (const e of exports) {
+      this.pushRel(
+        relationships,
+        "global",
+        e.name,
+        ASTEngine.RelationshipType.Exports,
+        1,
+        { rSpecific: true, relationshipSubType: "roxygen_export", declaredKind: e.kind },
+        symbolLine.get(e.name) ?? null
+      );
+    }
+    let overridesEdges = 0;
+    let overridesBasesUnresolved = 0;
+    for (const [className, decls] of classDecls) {
+      for (const decl of decls) {
+        if (!decl.members.size || !decl.bases.length) continue;
+        for (const base of decl.bases) {
+          const prior = (classDecls.get(base) ?? []).filter((d) => d.line < decl.line);
+          const baseDecl = prior.length ? prior[prior.length - 1] : null;
+          if (!baseDecl) {
+            overridesBasesUnresolved++;
+            continue;
+          }
+          for (const member of baseDecl.members.keys()) {
+            if (!decl.members.has(member)) continue;
+            overridesEdges++;
+            this.pushRel(relationships, className, member, ASTEngine.RelationshipType.Overrides, 0.95, {
+              rSpecific: true,
+              relationshipSubType: "object_system_method_override",
+              overridingMember: `${className}$${member}`,
+              overriddenMember: `${base}$${member}`,
+              overriddenClass: base,
+              reasonCode: "base_class_declared_in_same_file",
+              reason: `\`${className}$${member}\` shadows \`${base}$${member}\`, whose class is declared earlier in this file, so the shadowing member is provably an override`
+              // The OVERRIDING declaration's line, not the overridden one's. Taking the
+              // line out of `baseDecl` instead of `decl` put `BC -overrides-> x` on AC's
+              // `x` at R6/tests/testthat/test-portable-inheritance.R:194, four lines
+              // above the `BC` that declares it.
+            }, decl.members.get(member));
+          }
+        }
+      }
+    }
+    ambiguity.overridesBasesNotDeclaredEarlierInFile = overridesBasesUnresolved;
+    ambiguity.overridesEdgesEmitted = overridesEdges;
+    this.detectFrameworksFromImports(imports, metadata);
+    const containsKeys = /* @__PURE__ */ new Set();
+    for (const rel of relationships) {
+      if (rel.type === ASTEngine.RelationshipType.Contains && rel.source && rel.target) {
+        containsKeys.add(`${rel.source}${rel.target}`);
+      }
+    }
+    for (const s of symbols) {
+      const _owner = s.ownerName || s.scope || "global";
+      if (_owner) {
+        const key = `${_owner}${s.name}`;
+        if (containsKeys.has(key)) continue;
+        containsKeys.add(key);
+        this.pushRel(
+          relationships,
+          _owner,
+          s.name,
+          ASTEngine.RelationshipType.Contains,
+          1,
+          {},
+          symbolLine.get(s.name) ?? s.range
+        );
+      }
+    }
+    const uniqueRelationships = [];
+    const relationshipKeys = /* @__PURE__ */ new Set();
+    for (const rel of relationships) {
+      const key = `${rel.type || rel.relationshipType || ""}${rel.source || rel.from || ""}${rel.target || rel.to || ""}`;
+      if (relationshipKeys.has(key)) continue;
+      relationshipKeys.add(key);
+      uniqueRelationships.push(rel);
+    }
+    this.certifyPackageNamespaces(uniqueRelationships, symbols);
+    const overridesInResult = uniqueRelationships.filter(
+      (r) => (r.type || r.relationshipType) === ASTEngine.RelationshipType.Overrides
+    ).length;
+    const uniqueImports = [];
+    const importKeys = /* @__PURE__ */ new Set();
+    for (const imp of imports) {
+      const r = imp.range;
+      const key = `${imp.module ?? ""}${r ? `${r.startLine}:${r.startColumn}-${r.endLine}:${r.endColumn}` : ""}`;
+      if (importKeys.has(key)) continue;
+      importKeys.add(key);
+      uniqueImports.push(imp);
+    }
+    metadata.architecturalInsights = [
+      `r.ambiguity.callsUnresolvedScope=${ambiguity.callsUnresolvedScope}`,
+      `r.ambiguity.callsAttributedThroughClosure=${ambiguity.callsAttributedThroughClosure}`,
+      `r.ambiguity.heuristicS3Generic=${ambiguity.heuristicS3Generic}`
+    ];
+    metadata.callAttribution = {
+      unresolvedScope: ambiguity.callsUnresolvedScope,
+      throughClosure: ambiguity.callsAttributedThroughClosure,
+      heuristicS3Generic: ambiguity.heuristicS3Generic,
+      unnameableCallee: ambiguity.callsToUnnameableCallee ?? 0,
+      memberReadsSuppressedByCall: ambiguity.memberReadsSuppressedByCall,
+      memberWrites: ambiguity.memberWrites,
+      memberReadsUnresolvedScope: ambiguity.memberReadsUnresolvedScope,
+      memberReadsWithComputedIndex: ambiguity.memberReadsWithComputedIndex,
+      // Counts what the RESULT carries, after the (type, source, target) collapse — not the
+      // emissions the pass made. See `overridesInResult` above; the two disagree by exactly the
+      // number of times two bases of one class declare the same member name.
+      overridesEdgesEmitted: overridesInResult,
+      /** The pass's raw emission count, before the collapse. */
+      overridesEmissionsBeforeDedup: ambiguity.overridesEdgesEmitted,
+      /** Emissions collapsed into an edge already present: 23 over the lane's corpus, not lost. */
+      overridesEmissionsCollapsedByDedup: ambiguity.overridesEdgesEmitted - overridesInResult,
+      // Bases named by `inherit=`/`contains=`/`parent=` that no EARLIER declaration of
+      // that name in the same file satisfies. Counted rather than dropped so a reader can
+      // see how much of the inheritance graph this pass declines to assert.
+      overridesBasesNotDeclaredEarlierInFile: ambiguity.overridesBasesNotDeclaredEarlierInFile
+    };
+    this.byteOffsetOf = null;
+    return {
+      symbols,
+      imports: uniqueImports,
+      relationships: uniqueRelationships,
+      exports,
+      metadata,
+      errors: metadata.errors || []
+    };
+  }
+  detectFrameworksFromImports(imports, metadata) {
+    let hasTidyverse = false;
+    let hasGgplot2 = false;
+    let hasShiny = false;
+    let hasPlumber = false;
+    let hasDataTable = false;
+    let hasRcpp = false;
+    for (let i = 0; i < imports.length; i++) {
+      const module = imports[i].module;
+      if (module === "dplyr" || module === "ggplot2" || module === "tidyr" || module === "tidyverse")
+        hasTidyverse = true;
+      if (module === "ggplot2") hasGgplot2 = true;
+      if (module === "shiny") hasShiny = true;
+      if (module === "plumber") hasPlumber = true;
+      if (module === "data.table") hasDataTable = true;
+      if (module === "Rcpp") hasRcpp = true;
+    }
+    if (hasTidyverse) this.pushIfUnique(metadata.detectedFrameworks, "Tidyverse");
+    if (hasGgplot2) this.pushIfUnique(metadata.detectedFrameworks, "ggplot2");
+    if (hasShiny) {
+      this.pushIfUnique(metadata.detectedFrameworks, "Shiny");
+      if (!metadata.frameworkPatterns) metadata.frameworkPatterns = [];
+      metadata.frameworkPatterns.push({ framework: "Shiny", pattern: "ui/server" });
+    }
+    if (hasPlumber) this.pushIfUnique(metadata.detectedFrameworks, "Plumber");
+    if (hasDataTable) this.pushIfUnique(metadata.detectedFrameworks, "data.table");
+    if (hasRcpp) this.pushIfUnique(metadata.detectedFrameworks, "Rcpp");
+  }
+  pushIfUnique(arr, value) {
+    if (!arr) return;
+    let exists = false;
+    for (let i = 0; i < arr.length; i++) {
+      if (arr[i] === value) {
+        exists = true;
+        break;
+      }
+    }
+    if (!exists) arr.push(value);
+  }
+  // ---------------------------------------------------------------- assignments
+  /**
+   * The two SIDES of an assignment, without deciding which is a declaration.
+   *
+   * `<-`/`<<-`/`=` bind their LEFT operand. `->`/`->>` bind their RIGHT operand and
+   * nothing else — the left side is always a VALUE.
+   *
+   * This is not a stylistic choice, it is what R does, and it was measured
+   * against R 4.4.3's own runtime rather than assumed:
+   *
+   *     2 -> b          OK, binds b
+   *     2 ->> cc        OK, binds cc
+   *     identity(1) -> gg   OK, binds gg
+   *     bb -> 2         Error: invalid (do_set) left-hand side to assignment
+   *     cc ->> 2        Error: invalid (do_set) left-hand side to assignment
+   *
+   * R desugars both rightward forms to `<-`(value, name) at parse time, so a
+   * name on the LEFT of `->` is not a declaration — it is a runtime error, and
+   * publishing a symbol for it would invent a binding R refuses to make.
+   * tree-sitter-r does NOT desugar (it keeps `->` as an operator), which is
+   * exactly why the two sides have to be distinguished here.
+   *
+   * An earlier revision of this analyzer read whichever side happened to be an
+   * identifier. That published `variable e` for `e -> 6` — a construct R
+   * rejects. Caught by the R oracle, not by the fixtures, because the fixture
+   * had been written to match the same wrong belief.
+   */
+  assignmentSides(node) {
+    const operator = node.childForFieldName("operator")?.text;
+    if (operator === void 0) return { target: null, value: null };
+    const lhs = node.childForFieldName("lhs");
+    const rhs = node.childForFieldName("rhs");
+    if (LEFT_BINDING_OPERATORS.has(operator)) return { target: lhs ?? null, value: rhs ?? null };
+    if (RIGHT_BINDING_OPERATORS.has(operator)) return { target: rhs ?? null, value: lhs ?? null };
+    return { target: null, value: null };
+  }
+  /**
+   * The IDENTIFIER node an assignment binds, or null when it binds something
+   * other than a simple name. `->>` is handled here too; it was absent from the
+   * operator set entirely, so rightward superassignment produced no symbol.
+   */
+  assignmentTarget(node) {
+    const { target } = this.assignmentSides(node);
+    return target && target.type === "identifier" ? target : null;
+  }
+  handleBinaryOperator(node, symbols, exports, relationships, metadata, declaredTypes, insideFunction) {
+    const operator = node.childForFieldName("operator")?.text;
+    if (operator === void 0) return;
+    if (operator === "%>%" || operator === "|>") {
+      this.pushIfUnique(metadata.patterns, "Pipe Operations");
+      if (metadata.dataManipulationIntensity !== void 0) metadata.dataManipulationIntensity += 20;
+    }
+    if (!ASSIGNMENT_OPERATORS.has(operator)) return;
+    const { target: targetNode, value } = this.assignmentSides(node);
+    if (!targetNode || !value) return;
+    if (targetNode.type === "call") {
+      this.handleS7Assignment(node, targetNode, value, symbols, relationships, metadata, insideFunction);
+      return;
+    }
+    if (targetNode.type === "string") {
+      const strName = this.unquoteString(targetNode.text);
+      if (!strName) return;
+      if (insideFunction) return;
+      if (this.hasLocalBoundary(node)) return;
+      symbols.push({
+        name: strName,
+        kind: value.type === "function_definition" ? ASTEngine.SymbolKind.Function : ASTEngine.SymbolKind.Variable,
+        range: this.getRange(node),
+        docstring: this.extractDocstring(node),
+        metadata: { rSpecific: true, quotedAssignmentTarget: true, declarationOperator: node.childForFieldName("operator")?.text }
+      });
+      return;
+    }
+    if (targetNode.type !== "identifier") return;
+    const name = this.unquoteIdentifier(targetNode.text);
+    if (!name) return;
+    const doc = this.extractDocstring(node);
+    if (insideFunction) return;
+    if (this.hasLocalBoundary(node)) return;
+    if (value.type === "function_definition") {
+      const isS3Method = name.indexOf(".") > 0;
+      symbols.push({
+        name,
+        kind: isS3Method ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function,
+        range: this.getRange(node),
+        signature: this.extractSignature(value),
+        docstring: doc,
+        parameters: this.extractParameters(value),
+        metadata: { rSpecific: true, isS3Method, declarationOperator: operator }
+      });
+      if (isS3Method) {
+        this.pushIfUnique(metadata.patterns, "S3 Object System");
+        const toName = name.substring(0, name.indexOf("."));
+        this.pushRel(
+          relationships,
+          name,
+          toName,
+          ASTEngine.RelationshipType.Implements,
+          0.8,
+          {
+            relationshipSubType: "s3_method",
+            reasonCode: "s3_dotted_name_convention",
+            reason: "R registers S3 methods by the `generic.class` naming convention; the generic itself is not declared in this file, so the target is inferred from the name."
+          },
+          node
+        );
+      }
+      if (doc && this.roxygenHasTag(doc, "@export"))
+        exports.push({ name, kind: isS3Method ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function });
+      return;
+    }
+    if (value.type === "call") {
+      const handled = this.handleClassSystemAssignment(
+        node,
+        name,
+        value,
+        symbols,
+        exports,
+        relationships,
+        metadata,
+        declaredTypes,
+        doc,
+        insideFunction
+      );
+      if (handled) return;
+    }
+    symbols.push({
+      name,
+      kind: this.isAllCapsName(name) ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Variable,
+      range: this.getRange(node),
+      docstring: doc,
+      metadata: { rSpecific: true, declarationOperator: operator }
+    });
+    if (doc && this.roxygenHasTag(doc, "@export"))
+      exports.push({ name, kind: this.isAllCapsName(name) ? ASTEngine.SymbolKind.Constant : ASTEngine.SymbolKind.Variable });
+  }
+  /**
+   * Declare an R5 reference class from its constructor call, for BOTH spellings.
+   *
+   * R5's `setRefClass("Name", fields=, methods=, contains=)` registers a generator under
+   * the DECLARED name whether or not the call is bound to a variable — reference classes
+   * are registered in the package's namespace at evaluation time. The corpus says so
+   * plainly: `r-Rcpp/R/00_classes.R` declares `C++Field`, `C++OverloadedMethods` and
+   * `C++Constructor` as BARE statements, and the analyzer published none of them, because
+   * the only path that recognised the constructor was the assignment-RHS one. The loss is
+   * not only three symbols: a statement-form class's `contains=` clause produced no
+   * `extends`/`mixes_in` edge either.
+   *
+   * `rangeNode` is the node the symbol's range is taken from: the assignment when the call
+   * is bound to a name (the declaration begins at the binding), the CALL itself when it is
+   * a statement.
+   *
+   * The class name must be a literal string in the first positional argument. An R5 class
+   * whose name is computed at runtime (`setRefClass(Class, ...)` in a factory) has no
+   * publishable identity, and naming it after a variable would fabricate a declaration —
+   * so those publish nothing, deliberately.
+   */
+  declareR5Class(rangeNode, name, callNode, symbols, exports, relationships, declaredTypes, doc, patterns) {
+    const baseClasses = this.extractNamedArguments(callNode, "contains");
+    const composesList = this.compositionClauseIsList(callNode, "contains");
+    symbols.push({
+      name,
+      kind: ASTEngine.SymbolKind.Class,
+      range: this.getRange(rangeNode),
+      docstring: doc,
+      metadata: { rSpecific: true, type: "R5", isR5Class: true, baseClasses }
+    });
+    declaredTypes.add(name);
+    if (patterns) this.pushIfUnique(patterns, "R5 Reference Classes");
+    for (const bc of baseClasses) {
+      const type = composesList ? ASTEngine.RelationshipType.MixesIn : ASTEngine.RelationshipType.Extends;
+      const subType = composesList ? "r5_composes" : "r5_inherits";
+      this.pushRel(relationships, name, bc, type, 1, { relationshipSubType: subType }, this.namedArgumentNode(callNode, "contains", bc));
+    }
+    this.extractR5Members(callNode, name, symbols, relationships, doc);
+    if (doc && this.roxygenHasTag(doc, "@export")) exports.push({ name, kind: ASTEngine.SymbolKind.Class });
+  }
+  /** Returns true when the call was recognized as a class-system constructor. */
+  handleClassSystemAssignment(node, name, callNode, symbols, exports, relationships, metadata, declaredTypes, doc, insideFunction) {
+    const fnNode = callNode.childForFieldName("function");
+    const fnName = this.calleeName(fnNode);
+    if (fnName === "R6Class") {
+      const baseClasses = this.extractNamedArguments(callNode, "inherit");
+      symbols.push({
+        name,
+        kind: ASTEngine.SymbolKind.Class,
+        range: this.getRange(node),
+        docstring: doc,
+        metadata: { rSpecific: true, type: "R6", isR6Class: true, baseClasses }
+      });
+      declaredTypes.add(name);
+      for (const bc of baseClasses) {
+        this.pushRel(relationships, name, bc, ASTEngine.RelationshipType.Extends, 1, { relationshipSubType: "r6_inherits" }, this.namedArgumentNode(callNode, "inherit", bc));
+      }
+      this.extractR6Members(callNode, name, symbols, relationships, doc);
+      if (doc && this.roxygenHasTag(doc, "@export")) exports.push({ name, kind: ASTEngine.SymbolKind.Class });
+      return true;
+    }
+    if (fnName === "setRefClass") {
+      this.declareR5Class(node, name, callNode, symbols, exports, relationships, declaredTypes, doc, metadata.patterns);
+      return true;
+    }
+    if (fnName === "moduleServer") {
+      symbols.push({
+        name,
+        kind: ASTEngine.SymbolKind.Function,
+        // Mapped as functional component
+        range: this.getRange(node),
+        docstring: doc,
+        metadata: { rSpecific: true, isShinyModuleServer: true, framework: "Shiny" }
+      });
+      this.pushIfUnique(metadata.patterns, "Shiny Modules");
+      if (doc && this.roxygenHasTag(doc, "@export")) exports.push({ name, kind: ASTEngine.SymbolKind.Function });
+      return true;
+    }
+    if (fnName === "cppFunction" || fnName === "cxxfunction") {
+      symbols.push({
+        name,
+        kind: ASTEngine.SymbolKind.Function,
+        range: this.getRange(node),
+        docstring: doc,
+        metadata: { rSpecific: true, isInlineCpp: true, crossLanguage: "cpp" }
+      });
+      this.pushIfUnique(metadata.patterns, "Rcpp / Inline C++");
+      if (doc && this.roxygenHasTag(doc, "@export")) exports.push({ name, kind: ASTEngine.SymbolKind.Function });
+      return true;
+    }
+    if (REACTIVE_CONSTRUCTORS.has(fnName)) {
+      symbols.push({
+        name,
+        kind: ASTEngine.SymbolKind.Function,
+        range: this.getRange(node),
+        docstring: doc,
+        metadata: { rSpecific: true, isReactive: true, reactiveType: fnName }
+      });
+      return true;
+    }
+    if (fnName === "new_class" || fnName === "new_base_class") {
+      const s7Args = this.getArgumentsNode(callNode);
+      const declaredNode = this.stringArgumentNodeAt(s7Args, 0);
+      const declared = declaredNode ? this.stringNodeText(declaredNode) : void 0;
+      const className = declared || name;
+      const classNameNode = declaredNode ?? node;
+      symbols.push({
+        name: className,
+        kind: ASTEngine.SymbolKind.Class,
+        range: this.getRange(node),
+        docstring: doc,
+        metadata: { rSpecific: true, type: "S7", isS7Class: true, parent: this.extractNamedArguments(callNode, "parent") }
+      });
+      declaredTypes.add(className);
+      this.pushIfUnique(metadata.patterns, "S7 Object System");
+      if (declared && declared !== name) {
+        symbols.push({
+          name,
+          kind: ASTEngine.SymbolKind.Variable,
+          range: this.getRange(node),
+          docstring: doc,
+          metadata: { rSpecific: true, isS7ClassBinding: true, boundClass: className }
+        });
+        this.pushRel(relationships, name, className, ASTEngine.RelationshipType.References, 1, { rSpecific: true, relationshipSubType: "s7_class_binding" }, classNameNode);
+      }
+      for (const parent of this.extractNamedArguments(callNode, "parent")) {
+        this.pushRel(relationships, className, parent, ASTEngine.RelationshipType.Extends, 1, { rSpecific: true, relationshipSubType: "s7_parent" }, this.namedArgumentNode(callNode, "parent", parent));
+      }
+      const propertyHolder = this.namedArgumentValue(callNode, "properties");
+      if (propertyHolder && propertyHolder.type === "call" && this.calleeName(propertyHolder.childForFieldName("function")) === "list") {
+        const entries = this.getArgumentsNode(propertyHolder);
+        if (entries) {
+          for (let i = 0; i < entries.namedChildCount; i++) {
+            const entry = entries.namedChild(i);
+            if (entry?.type !== "argument") continue;
+            const propName = entry.childForFieldName("name");
+            if (!propName) continue;
+            const prop = this.unquoteIdentifier(propName.text);
+            symbols.push({
+              name: prop,
+              kind: ASTEngine.SymbolKind.Property,
+              range: this.getRange(propName),
+              ownerName: className,
+              ownerKind: ASTEngine.SymbolKind.Class,
+              docstring: "",
+              metadata: { rSpecific: true, isS7Property: true, objectSystem: "S7" }
+            });
+            this.pushRel(relationships, className, prop, ASTEngine.RelationshipType.Contains, 1, { rSpecific: true, relationshipSubType: "s7_property" }, propName);
+          }
+        }
+      }
+      if (doc && this.roxygenHasTag(doc, "@export")) {
+        exports.push({ name, kind: declared && declared !== name ? ASTEngine.SymbolKind.Variable : ASTEngine.SymbolKind.Class });
+      }
+      return true;
+    }
+    if (fnName === "setGeneric" || fnName === "setMethod" || fnName === "setClass" || fnName === "setValidity") {
+      symbols.push({
+        name,
+        kind: ASTEngine.SymbolKind.Variable,
+        range: this.getRange(node),
+        docstring: doc,
+        metadata: {
+          rSpecific: true,
+          isS4Binding: true,
+          bindingFor: fnName,
+          note: "R binds the S4 generator/definition to this name; the declaration itself is emitted under its declared class/generic name."
+        }
+      });
+      this.pushRel(relationships, name, name, ASTEngine.RelationshipType.References, 1, { rSpecific: true, relationshipSubType: "s4_binding" }, node);
+      return true;
+    }
+    return false;
+  }
+  sameNode(a, b) {
+    if (!a || !b) return false;
+    return a.startIndex === b.startIndex && a.endIndex === b.endIndex;
+  }
+  /**
+   * Push one relationship, stamping `line_number` with the 1-based line of the
+   * node that NAMES the edge.
+   *
+   * M59.A7 (#825) established this convention across the analyzer family (33 of
+   * 44 analyzers carry it): the line is the node the edge's TARGET is written as
+   * — a call's callee leaf, a member's own entry, a base class's argument — not
+   * the construct that merely contains it. A missing line is honest, so a call
+   * with no node to ask omits the field rather than writing a fabricated 0.
+   * The R analyzer previously carried no line on any edge, so every R
+   * relationship was unlocatable in the graph and the LSP.
+   */
+  pushRel(out, source, target, type, confidence, metadata, namingNode) {
+    if (!source || !target) return;
+    const rel = { source, target, type, confidence, metadata };
+    let line;
+    if (typeof namingNode === "number") line = namingNode;
+    else if (namingNode) {
+      const row = namingNode.startPosition?.row;
+      line = typeof row === "number" ? row + 1 : namingNode.startLine;
+    }
+    if (typeof line === "number" && Number.isFinite(line) && line > 0) rel.line_number = line;
+    out.push(rel);
+  }
+  /**
+   * CERTIFY THE EDGES WHOSE TARGET IS A PACKAGE NAMESPACE — R's base and dependency packages are
+   * not repositories in this corpus, so no key space it can build will ever answer them.
+   *
+   * THE DEFECT THIS CLOSES. `library(cli)` and `cli::cli_abort()` reach the graph as a dependency
+   * on `cli`, and the arbiter reads `imports`/`references` target `cli` and finds no declaration
+   * of it anywhere in the project — which is TRUE, and which is what `unresolved` means. The lane
+   * measures this class at **660 of its 8,785-edge residual** on its own 400-file draw
+   * (`validation/m14/verification/R-FIX.md` §3: `imports:bare-name 330 · references:bare-name
+   * 330`, top targets `cli 61 · withr 38 · lifecycle 19 · utils 18 · testthat 14 · Rcpp 13`), while
+   * publishing NOTHING the arbiter reads. This is the fleet's finding (a) in its claim form: the
+   * analyzer already HOLDS the namespace — it is the edge's target — and never declares it.
+   *
+   * WHY THIS IS NOT A BLANKET EXTERNAL MARKER, and the distinction is the one that matters. The
+   * claim does not say "this did not resolve". It says **the target's ROOT is a language
+   * namespace, and here is the closed list of packages this FILE names** — decidable from R's own
+   * semantics, because `library(x)` LOADS a package and `x::f` is only legal when `x` IS one. It is
+   * the shape five other lanes already carry: hcl's `BUILTIN_ROOTS`, python's
+   * `PY_BUILTIN_NAMESPACE` (whose class is this class in its own words — *"Python's runtime
+   * namespace is not a project, so `dict`, `tuple`, `object` … can never be answered by any key
+   * space this corpus builds"*), zig's `["std"]`, powershell's `["System"]`, graphql's built-in
+   * scalars. The evidence list is the file's own dependency set, so widening it is a visible act on
+   * the edge rather than an opaque boolean (property 2 of `NAMESPACE_CLAIM_KEY`).
+   *
+   * FIVE GUARDS, each evidential, mirroring the python lane's `certifyLanguageNamespaceRoutes`:
+   *   1. the edge's SUBTYPE is one whose target is a package by construction
+   *      (`PACKAGE_NAMESPACE_SUBTYPES`) — never inferred from the spelling alone;
+   *   2. the target IS in the file's declared package list — the claim's evidence;
+   *   3. the target is package-name-shaped (`isPackageNameShape`) as well as listed;
+   *   4. the file does not DECLARE the name itself — `cli <- function(...)` makes `cli` a
+   *      declaration in this file and the claim would then be false;
+   *   5. the edge carries no claim already (`languageNamespace` is undefined), so an edge that
+   *      another mechanism already explains keeps that mechanism.
+   *
+   * THE TARGET IS NEVER REWRITTEN AND NO PRE-EXISTING FIELD CHANGES: one additive metadata key.
+   * Every other byte of every edge this lane emitted is identical, which is what makes the
+   * before/after table a measurement of this claim and of nothing else.
+   *
+   * WHAT IT CANNOT DO, stated here rather than discovered later. The analyzer sees ONE FILE, so
+   * guard 4 covers only the file's own declarations: where the PROJECT declares a symbol that
+   * shares a package's name — `methods()` in S7, the `Matrix` CLASS in the Matrix package — the
+   * claim still wins and the edge reads `externalVerified` instead of `resolved`. That is 40 edges
+   * on the 400-file draw, each one a name-coincidence in ANOTHER file (gate intent:
+   * `arbitraryTwin`, the class this programme's brief calls the cross-file hazard), and they are
+   * enumerated in `namespace-claim-price.ts` and in the report rather than absorbed.
+   */
+  certifyPackageNamespaces(relationships, symbols) {
+    const packages = /* @__PURE__ */ new Set();
+    for (const rel of relationships) {
+      const label = String(rel.type || rel.relationshipType || "");
+      if (!PACKAGE_NAMESPACE_LABELS.has(label)) continue;
+      const md = rel.metadata ?? {};
+      if (!PACKAGE_NAMESPACE_SUBTYPES.has(String(md.relationshipSubType ?? ""))) continue;
+      const tgt = String(rel.target ?? "");
+      if (isPackageNameShape(tgt)) packages.add(tgt);
+    }
+    if (packages.size === 0) return 0;
+    const roots = [...packages].sort();
+    const declaredHere = /* @__PURE__ */ new Set();
+    for (const s of symbols) {
+      const name = String(s?.name ?? "");
+      if (name.length > 0) declaredHere.add(name);
+    }
+    let certified = 0;
+    for (const rel of relationships) {
+      const md = rel.metadata;
+      if (!md || typeof md !== "object") continue;
+      if (md.languageNamespace !== void 0) continue;
+      const label = String(rel.type || rel.relationshipType || "");
+      if (!PACKAGE_NAMESPACE_LABELS.has(label)) continue;
+      if (!PACKAGE_NAMESPACE_SUBTYPES.has(String(md.relationshipSubType ?? ""))) continue;
+      const tgt = String(rel.target ?? "");
+      if (!packages.has(tgt)) continue;
+      if (declaredHere.has(tgt)) continue;
+      md.languageNamespace = [...roots];
+      certified++;
+    }
+    return certified;
+  }
+  /**
+   * The bare name a call/namespace refers to, read from grammar FIELDS.
+   *
+   *   identifier          -> its own text
+   *   namespace_operator -> the `rhs` field (`R6::R6Class` -> `R6Class`,
+   *                         `R6:::R6Class` -> `R6Class`, `base::sqrt` -> `sqrt`)
+   *   extract_operator   -> the `rhs` field (`obj$method` -> `method`)
+   *
+   * The previous `fnNode.text.split("::")` was both a source-text scan and
+   * wrong: it turned `R6:::R6Class` into `:R6Class`, and it silently missed every
+   * namespaced call whose `::` form differed from the bare name.
+   */
+  calleeName(fnNode) {
+    if (!fnNode) return "";
+    if (fnNode.type === "namespace_operator" || fnNode.type === "extract_operator") {
+      const rhs = fnNode.childForFieldName("rhs");
+      if (rhs) {
+        if (rhs.type === "identifier" || rhs.type === "dots") return this.unquoteIdentifier(rhs.text);
+        return this.unquoteIdentifier(rhs.text);
+      }
+      return "";
+    }
+    if (fnNode.type === "identifier") return this.unquoteIdentifier(fnNode.text);
+    if (this.isRName(fnNode.text)) return this.unquoteIdentifier(fnNode.text);
+    return "";
+  }
+  /**
+   * Is this text an R name? R's rule: a letter or a `.` not followed by a digit, then
+   * letters, digits, `.` and `_`; or a backtick-quoted name, inside which almost
+   * anything is legal. Letters beyond ASCII are accepted, since R source is frequently
+   * UTF-8 and a name is a name in any alphabet.
+   *
+   * Character codes rather than a regexp, to keep the analyzer free of pattern matching.
+   * This is the only place the analyzer inspects a node's TEXT to decide what it is -- the
+   * grammar's node types do not carry a "this is a name" flag -- and it is listed in the
+   * documentation's inventory of text operations.
+   */
+  isRName(text) {
+    if (text.length === 0) return false;
+    if (text.charCodeAt(0) === 96) {
+      return text.length >= 2 && text.charCodeAt(text.length - 1) === 96;
+    }
+    const isLetter = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 192 && c <= 591 || c >= 880 && c <= 8191;
+    const isDigit = (c) => c >= 48 && c <= 57;
+    const first = text.charCodeAt(0);
+    let i = 0;
+    if (first === 46) {
+      i = 1;
+      if (i < text.length && isDigit(text.charCodeAt(i))) return false;
+    } else if (!isLetter(first)) {
+      return false;
+    }
+    for (; i < text.length; i++) {
+      const c = text.charCodeAt(i);
+      if (isLetter(c) || isDigit(c) || c === 46 || c === 95) continue;
+      return false;
+    }
+    return true;
+  }
+  /**
+   * R identifiers may be backtick-quoted; the backticks are syntax, not part of
+   * the name. tree-sitter-r reports a quoted identifier as a plain `identifier`
+   * whose text still carries the backticks, so exactly one leading/trailing
+   * backtick pair is removed. Nothing else is inspected.
+   */
+  unquoteIdentifier(text) {
+    if (text.length >= 2 && text.charCodeAt(0) === 96 && text.charCodeAt(text.length - 1) === 96) {
+      return text.substring(1, text.length - 1);
+    }
+    return text;
+  }
+  /**
+   * S7 (rlang's object system) declarations, whose assigned name is a CALL:
+   *
+   *   `Foo        <- S7::new_class("Foo", parent = Bar, properties = list(...))`
+   *   `S7::method(print, class_foo) <- function(self, ...) ...`
+   *
+   * Neither has an identifier on the left, so both were previously invisible:
+   * no symbol, and calls inside the body attributed to a source string that was
+   * never a symbol.
+   */
+  handleS7Assignment(node, targetCall, value, symbols, relationships, metadata, insideFunction) {
+    const base = this.calleeName(targetCall.childForFieldName("function"));
+    if (insideFunction) return;
+    if (base === "method" || base === "S7_method") {
+      if (value.type !== "function_definition") return;
+      const tArgs = this.getArgumentsNode(targetCall);
+      const genericNode = this.firstPositionalValue(tArgs);
+      const classNode = this.secondPositionalValue(tArgs);
+      if (!genericNode) return;
+      const generic = this.nodeAsName(genericNode);
+      let owner;
+      if (classNode) {
+        owner = this.nodeAsName(classNode) || void 0;
+        if (!owner && classNode.type === "call" && this.calleeName(classNode.childForFieldName("function")) === "list") {
+          const listArgs = this.getArgumentsNode(classNode);
+          for (let i = 0; listArgs && i < listArgs.namedChildCount; i++) {
+            const entry = listArgs.namedChild(i);
+            if (entry?.type !== "argument") continue;
+            if (entry.childForFieldName("name")) continue;
+            const v = this.nodeAsName(entry.childForFieldName("value"));
+            if (v) {
+              owner = v;
+              break;
+            }
+          }
+        }
+      }
+      if (!generic) return;
+      this.pushIfUnique(metadata.patterns, "S7 Object System");
+      symbols.push({
+        name: generic,
+        kind: ASTEngine.SymbolKind.Method,
+        range: this.getRange(node),
+        ownerName: owner,
+        ownerKind: owner ? ASTEngine.SymbolKind.Class : void 0,
+        signature: this.extractSignature(value),
+        parameters: this.extractParameters(value),
+        docstring: this.extractDocstring(node),
+        metadata: {
+          rSpecific: true,
+          isS7Method: true,
+          s7Generic: generic,
+          s7Class: owner,
+          objectSystem: "S7"
+        }
+      });
+      if (owner) {
+        this.pushRel(relationships, owner, generic, ASTEngine.RelationshipType.Contains, 1, { rSpecific: true, relationshipSubType: "s7_method" }, genericNode);
+      }
+      return;
+    }
+    if (base === "new_class" || base === "new_base_class") {
+      const cArgs = this.getArgumentsNode(targetCall);
+      const declared = cArgs ? this.stringArgumentAt(cArgs, 0) : void 0;
+      const name = declared || (value.type === "identifier" ? this.unquoteIdentifier(value.text) : "");
+      if (!name) return;
+      this.pushIfUnique(metadata.patterns, "S7 Object System");
+      symbols.push({
+        name,
+        kind: ASTEngine.SymbolKind.Class,
+        range: this.getRange(node),
+        docstring: this.extractDocstring(node),
+        metadata: { rSpecific: true, type: "S7", isS7Class: true }
+      });
+      for (const parent of this.extractNamedArguments(targetCall, "parent")) {
+        this.pushRel(relationships, name, parent, ASTEngine.RelationshipType.Extends, 1, { rSpecific: true, relationshipSubType: "s7_parent" }, this.namedArgumentNode(targetCall, "parent", parent));
+      }
+      const propertyHolder = this.namedArgumentValue(targetCall, "properties");
+      if (propertyHolder && propertyHolder.type === "call" && this.calleeName(propertyHolder.childForFieldName("function")) === "list") {
+        const entries = this.getArgumentsNode(propertyHolder);
+        if (entries) {
+          for (let i = 0; i < entries.namedChildCount; i++) {
+            const entry = entries.namedChild(i);
+            if (entry?.type !== "argument") continue;
+            const propName = entry.childForFieldName("name");
+            if (!propName) continue;
+            symbols.push({
+              name: this.unquoteIdentifier(propName.text),
+              kind: ASTEngine.SymbolKind.Property,
+              range: this.getRange(propName),
+              ownerName: name,
+              ownerKind: ASTEngine.SymbolKind.Class,
+              docstring: "",
+              metadata: { rSpecific: true, isS7Property: true, objectSystem: "S7" }
+            });
+            this.pushRel(relationships, name, this.unquoteIdentifier(propName.text), ASTEngine.RelationshipType.Contains, 1, { rSpecific: true, relationshipSubType: "s7_property" }, propName);
+          }
+        }
+      }
+    }
+  }
+  /** An identifier or string node read as a name. */
+  nodeAsName(node) {
+    if (!node) return "";
+    if (node.type === "string") return this.stringNodeText(node);
+    if (node.type === "identifier" || node.type === "dots") return this.unquoteIdentifier(node.text);
+    return "";
+  }
+  /** The value of a named argument of a call, or null. */
+  /**
+   * True when the node sits inside a `local({ ... })` body.
+   *
+   * `local()` is the one construct in ordinary R that evaluates an expression in a
+   * NEW environment without introducing a `function_definition` node, so the
+   * function-ancestor test cannot see it. Assignments inside it are NOT file-level
+   * bindings: R's `local()` creates a child environment and nothing escapes.
+   *
+   * Found by the R oracle, not by reading: dplyr's test-across.R binds
+   * `_local_var` inside `local({ ... })` and the analyzer was publishing it as a
+   * global variable. A plain `{ ... }` block inside a call is deliberately NOT
+   * treated as a boundary, because R evaluates that in the CALLING frame and the
+   * binding really is global.
+   */
+  hasLocalBoundary(node) {
+    let current = node;
+    while (current) {
+      const parent = current.parent;
+      if (!parent) return false;
+      if (parent.type === "braced_expression" || parent.type === "parenthesized_expression") {
+        let owner = parent;
+        for (let hop = 0; hop < 3 && owner; hop++) {
+          const up = owner.parent;
+          if (!up) break;
+          if (up.type === "call") {
+            const fn = up.childForFieldName("function");
+            if (fn && this.calleeName(fn) === "local") return true;
+            break;
+          }
+          owner = up;
+        }
+      }
+      current = parent;
+    }
+    return false;
+  }
+  /**
+   * The line a symbol's NAME is written on.
+   *
+   * A declaration's range starts where the declaration starts, which for a
+   * multi-line `Cls <- R6Class(` is the line ABOVE the name, and for an S4 slot
+   * is the whole `setClass` call. M59.A7's convention is the line that NAMES the
+   * edge, so a `contains` edge is stamped with the name's own line, found by
+   * searching the symbol's own range for its name text. Falls back to the range's
+   * start when the name is synthesized (an S4 `validity` method has no literal
+   * token in the source).
+   */
+  /**
+   * Whether `at` is the start of the IDENTIFIER `name` in `segment`, rather than a place
+   * where those characters merely occur.
+   *
+   * R identifiers continue with letters, digits, `.` and `_`, so `theme` occurs inside
+   * `class_theme` and `sizes` inside `resize`. A substring search cannot tell those apart
+   * from the real thing, and the consequence is a relationship pointing at a line that
+   * does not name its target: `class_theme <- S7::new_class(` on line 219 matched
+   * `theme`, so `global exports theme` and `global contains theme` were attributed to 219
+   * while the class name is written on 220. Eight such edges in ggplot2's all-classes.R.
+   *
+   * A backtick-quoted name is a special case: inside backticks almost anything is legal,
+   * so only the closing backtick is excluded, and the backticks themselves are not part of
+   * the name.
+   */
+  isIdentifierOccurrence(segment, at, name) {
+    const isPart = (ch) => {
+      if (ch === void 0) return false;
+      const c = ch.charCodeAt(0);
+      return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c >= 48 && c <= 57 || c === 46 || c === 95;
+    };
+    const before = at > 0 ? segment[at - 1] : void 0;
+    if (before === "`") {
+      return segment[at + name.length] === "`";
+    }
+    if (isPart(before)) return false;
+    const after = segment[at + name.length];
+    return !isPart(after);
+  }
+  nameLineOf(symbol, content) {
+    const start = symbol.range.startIndex;
+    const end = symbol.range.endIndex;
+    if (typeof start !== "number" || typeof end !== "number" || end > content.length || end <= start) {
+      return symbol.range.startLine;
+    }
+    const segment = content.substring(start, end);
+    let at = -1;
+    for (let from = 0; from <= segment.length - symbol.name.length; from++) {
+      const i = segment.indexOf(symbol.name, from);
+      if (i === -1) break;
+      if (this.isIdentifierOccurrence(segment, i, symbol.name)) {
+        at = i;
+        break;
+      }
+      from = i;
+    }
+    if (at === -1) return symbol.range.startLine;
+    let line = symbol.range.startLine;
+    for (let i = 0; i < at; i++) if (segment.charCodeAt(i) === 10) line++;
+    return line;
+  }
+  /**
+   * The node that NAMES `wanted` inside a named argument's value, used to stamp a
+   * relationship's line. Looks in `c(...)`/`list(...)` element lists first, then
+   * in the argument's own value, so `inherit = c("A","B")`, `inherit = "A"` and
+   * `parent = Bar` all resolve to the node that actually spells the name.
+   */
+  namedArgumentNode(node, argName, wanted) {
+    const args = this.getArgumentsNode(node);
+    if (!args) return null;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (arg?.type !== "argument") continue;
+      if (arg.childForFieldName("name")?.text !== argName) continue;
+      const value = arg.childForFieldName("value");
+      if (!value) continue;
+      if (value.type === "call") {
+        const inner = this.getArgumentsNode(value);
+        if (inner) {
+          for (let j = 0; j < inner.namedChildCount; j++) {
+            const entry = inner.namedChild(j);
+            if (!entry) continue;
+            if (entry.type === "argument") {
+              const nm = entry.childForFieldName("name");
+              const v = entry.childForFieldName("value");
+              const text = nm?.text ?? (v ? this.baseClassNodeName(v) : "");
+              if (text === wanted) return nm ?? v ?? entry;
+            } else {
+              if (this.baseClassNodeName(entry) === wanted) return entry;
+            }
+          }
+        }
+        if (this.baseClassNodeName(value) === wanted) return value;
+        continue;
+      }
+      if (this.baseClassNodeName(value) === wanted) return value;
+    }
+    return null;
+  }
+  namedArgumentValue(node, argName) {
+    const args = this.getArgumentsNode(node);
+    if (!args) return null;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (arg?.type !== "argument") continue;
+      if (arg.childForFieldName("name")?.text === argName) return arg.childForFieldName("value");
+    }
+    return null;
+  }
+  /** The second positional argument value of a call. */
+  secondPositionalValue(args) {
+    if (!args) return null;
+    let seen = 0;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type === "comma") continue;
+      if (arg.type === "argument") {
+        if (arg.childForFieldName("name")) continue;
+        const v = arg.childForFieldName("value");
+        if (seen === 1) return v;
+        seen++;
+        continue;
+      }
+      if (seen === 1) return arg;
+      seen++;
+    }
+    return null;
+  }
+  isAllCapsName(name) {
+    if (!name || name.length < 2) return false;
+    let hasLetter = false;
+    for (let i = 0; i < name.length; i++) {
+      const c = name[i];
+      if (c >= "a" && c <= "z" || c >= "A" && c <= "Z") {
+        hasLetter = true;
+        if (c >= "a" && c <= "z") return false;
+      }
+    }
+    return hasLetter;
+  }
+  // ------------------------------------------------------------ R6 / R5 members
+  /**
+   * R6 members. Inside `public=`/`private=`/`active=` a named entry is either a
+   * METHOD (value is a `function_definition`) or a DATA MEMBER (any other value).
+   * Data members are declarations too: they are the class's public surface and
+   * are read as `self$name`, so omitting them hides the class API entirely.
+   *
+   * Only entries with a real `name` FIELD are members. The earlier
+   * `childForFieldName("name") || child(0)` fallback turned an unnamed list
+   * element holding a function into a Method whose "name" was the function's own
+   * source text — a phantom declaration invented from syntax.
+   */
+  extractR6Members(callNode, className, symbols, relationships, _doc) {
+    this.extractMemberLists(callNode, className, symbols, relationships, CLASS_MEMBER_LISTS, {
+      methodMeta: { isR6Method: true },
+      methodSubType: "r6_method",
+      system: "R6"
+    });
+  }
+  extractR5Members(callNode, className, symbols, relationships, _doc) {
+    this.extractMemberLists(callNode, className, symbols, relationships, R5_MEMBER_LISTS, {
+      methodMeta: { isR5Method: true },
+      methodSubType: "r5_method",
+      system: "R5"
+    });
+  }
+  extractMemberLists(callNode, className, symbols, relationships, listNames, opts) {
+    const argsNode = this.getArgumentsNode(callNode);
+    if (!argsNode) return;
+    for (let i = 0; i < argsNode.childCount; i++) {
+      const arg = argsNode.child(i);
+      if (!arg || arg.type !== "argument") continue;
+      const argNameNode = arg.childForFieldName("name");
+      if (!argNameNode) continue;
+      const listName = argNameNode.text;
+      if (!listNames.has(listName)) continue;
+      const listNode = arg.childForFieldName("value");
+      if (!listNode || listNode.type !== "call") continue;
+      if (this.calleeName(listNode.childForFieldName("function")) !== "list") continue;
+      const entries = this.getArgumentsNode(listNode);
+      if (!entries) continue;
+      for (let j = 0; j < entries.childCount; j++) {
+        const entry = entries.child(j);
+        if (!entry || entry.type !== "argument") continue;
+        const memberNameNode = entry.childForFieldName("name");
+        const memberValue = entry.childForFieldName("value");
+        if (!memberNameNode || !memberValue) continue;
+        const memberName = this.unquoteIdentifier(memberNameNode.text);
+        if (!memberName) continue;
+        const isMethod = memberValue.type === "function_definition" && !DATA_MEMBER_LISTS.has(listName);
+        if (isMethod) {
+          symbols.push({
+            name: memberName,
+            kind: ASTEngine.SymbolKind.Method,
+            range: this.getDeclarationRange(memberNameNode, memberValue),
+            signature: this.extractSignature(memberValue),
+            parameters: this.extractParameters(memberValue),
+            docstring: "",
+            ownerName: className,
+            ownerKind: ASTEngine.SymbolKind.Class,
+            metadata: {
+              rSpecific: true,
+              ...opts.methodMeta,
+              memberList: listName,
+              ownerClass: className,
+              objectSystem: opts.system
+            }
+          });
+        } else {
+          symbols.push({
+            name: memberName,
+            kind: ASTEngine.SymbolKind.Property,
+            range: this.getDeclarationRange(memberNameNode, memberValue),
+            ownerName: className,
+            ownerKind: ASTEngine.SymbolKind.Class,
+            docstring: "",
+            metadata: {
+              rSpecific: true,
+              isObjectSystemField: true,
+              memberList: listName,
+              ownerClass: className,
+              objectSystem: opts.system
+            }
+          });
+        }
+        this.pushRel(
+          relationships,
+          className,
+          memberName,
+          ASTEngine.RelationshipType.Contains,
+          1,
+          {
+            relationshipSubType: isMethod ? opts.methodSubType : `${opts.system.toLowerCase()}_field`,
+            visibility: listName,
+            memberKind: isMethod ? "method" : "field"
+          },
+          memberNameNode
+        );
+      }
+    }
+  }
+  // ----------------------------------------------------------------- parameters
+  getParametersNode(node) {
+    const byField = node.childForFieldName("parameters");
+    if (byField) return byField;
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.type === "parameters") return c;
+    }
+    return null;
+  }
+  /**
+   * A parameter's default lives in the grammar's `default` FIELD. The analyzer
+   * asked for `default_value`, which this grammar does not define, so the lookup
+   * was always null and the analyzer fell back to scanning the parameter's raw
+   * text for an `=`. Using the field removes the dead branch, removes the text
+   * scan, and additionally recovers the default EXPRESSION, which was being
+   * computed and then discarded.
+   *
+   * `...` arrives as a `parameter` whose `name` field is a `dots` node, so rest
+   * parameters are recognized by node type rather than by their text.
+   */
+  extractParameters(node) {
+    const params = [];
+    const parametersNode = this.getParametersNode(node);
+    if (parametersNode) {
+      for (let i = 0; i < parametersNode.childCount; i++) {
+        const p = parametersNode.child(i);
+        if (p && p.type === "parameter") {
+          const nameNode = p.childForFieldName("name");
+          if (!nameNode) continue;
+          const defaultValueNode = p.childForFieldName("default");
+          const isRest = nameNode.type === "dots";
+          const param = {
+            name: this.unquoteIdentifier(nameNode.text),
+            isOptional: !!defaultValueNode
+          };
+          if (defaultValueNode) param.defaultValue = defaultValueNode.text;
+          if (isRest) param.isRest = true;
+          params.push(param);
+        }
+      }
+    }
+    return params;
+  }
+  handleComment(node, metadata) {
+    if (node.text.startsWith("#'")) {
+      this.pushIfUnique(metadata.patterns, "Roxygen Documentation");
+    }
+  }
+  /**
+   * Roxygen tags live inside a single `comment` token — the grammar exposes no
+   * sub-structure for them — so a tag is recognised only at a tag position
+   * (start of line, after `#'` and optional spaces). A loose substring test also
+   * fired on prose such as "not @exported".
+   */
+  roxygenHasTag(doc, tag) {
+    let lineStart = 0;
+    while (lineStart <= doc.length) {
+      let lineEnd = doc.indexOf("\n", lineStart);
+      if (lineEnd === -1) lineEnd = doc.length;
+      const line = doc.substring(lineStart, lineEnd);
+      if (line.startsWith("#'")) {
+        let i = 2;
+        while (i < line.length && (line[i] === " " || line[i] === "	")) i++;
+        if (line.startsWith(tag, i)) {
+          const after = line.charAt(i + tag.length);
+          if (after === "" || after === " " || after === "	") return true;
+        }
+      }
+      lineStart = lineEnd + 1;
+    }
+    return false;
+  }
+  getArgumentsNode(node) {
+    const byField = node.childForFieldName("arguments");
+    if (byField) return byField;
+    for (let i = 0; i < node.childCount; i++) {
+      const c = node.child(i);
+      if (c && c.type === "arguments") return c;
+    }
+    return null;
+  }
+  /** Positional arguments of a call, in source order, `argument` nodes unwrapped. */
+  positionalArguments(args) {
+    const out = [];
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type === "comma") continue;
+      if (arg.type !== "argument") {
+        out.push(arg);
+        continue;
+      }
+      out.push(arg);
+    }
+    return out;
+  }
+  /** The first POSITIONAL (unnamed) argument value of a call, or null. */
+  firstPositionalValue(args) {
+    if (!args) return null;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type === "comma") continue;
+      if (arg.type === "argument") {
+        if (arg.childForFieldName("name")) continue;
+        return arg.childForFieldName("value");
+      }
+      return arg;
+    }
+    return null;
+  }
+  // ------------------------------------------------------------------ member reads
+  /**
+   * The `arguments` of a `subset2`, i.e. `x[[ ... ]]` -- not the same node as the
+   * `arguments` of a `call`. The grammar gives the field the same name in both, so
+   * reading it off the wrong node kind returns null and the count is 0 rather than
+   * wrong, which is the failure mode worth avoiding here.
+   */
+  subset2Arguments(node) {
+    if (node.type !== "subset2") return null;
+    return node.childForFieldName("arguments");
+  }
+  /**
+   * The NAME a `subset2` indexes by, when it indexes by a string literal:
+   * `df[["col"]]` -> `col`. Returns null for `df[[i]]` and `df[[get_col()]]`,
+   * because a computed index does not name a member and naming one anyway would be
+   * the fabrication this lane's ontology workstream warns about.
+   *
+   * Only `[[` is read, never `[`. In R the two are not interchangeable: `df[["col"]]`
+   * is a member lookup, while `df["col"]` on a plain list is a CHARACTER SUBSET that
+   * evaluates to NULL, and on a data.frame it is a column selection by a rule R
+   * documents separately (exact, then partial match). Publishing the string index of
+   * a `[` as a member name would put a `uses` edge on an expression R does not treat
+   * as a member read at all.
+   */
+  stringSubsetIndex(node) {
+    const args = this.subset2Arguments(node);
+    if (!args) return null;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type !== "argument") continue;
+      const value = arg.childForFieldName("value");
+      if (value && value.type === "string") {
+        const name = this.stringNodeText(value);
+        if (name) return name;
+      }
+    }
+    return null;
+  }
+  /**
+   * The MEMBER NAME an `extract_operator` reads, or null when the right side does
+   * not name one. `obj$member` and `obj@slot` name a member by construction; a
+   * computed right side (`obj[[which()]]` is a different node, but `obj$f()`-shaped
+   * and interpolated forms exist) does not, so no edge is emitted and the case is
+   * counted.
+   */
+  extractOperatorMember(node) {
+    if (node.type !== "extract_operator") return null;
+    const operator = node.childForFieldName("operator")?.text;
+    if (operator !== "$" && operator !== "@") return null;
+    const rhs = node.childForFieldName("rhs");
+    if (!rhs) return null;
+    if (rhs.type === "identifier") return this.unquoteIdentifier(rhs.text) || null;
+    if (rhs.type === "string") return this.stringNodeText(rhs) || null;
+    return null;
+  }
+  /**
+   * Is this node the `function` field of an enclosing `call`?
+   *
+   * Compared by RANGE and not by object identity: web-tree-sitter allocates a fresh
+   * JS wrapper on every accessor call, so `parent.childForFieldName("function") === n`
+   * is false for the very node it just returned. The walk that built this gate first
+   * compared identities and reported zero callee-position nodes out of 11,216 --
+   * a number that reads as a fact about R and is a bug in the gate.
+   *
+   * `pkg::obj$fn(...)` is the wrapped form the second clause exists for: the
+   * `namespace_operator` occupies the call's function field and the `extract_operator`
+   * is its `rhs`.
+   */
+  isCalleePosition(node) {
+    const parent = node.parent;
+    if (!parent) return false;
+    if (parent.type === "call") return this.sameNode(parent.childForFieldName("function"), node);
+    if (parent.type === "extract_operator" || parent.type === "namespace_operator") {
+      if (this.sameNode(parent.childForFieldName("rhs"), node)) return this.isCalleePosition(parent);
+    }
+    return false;
+  }
+  /**
+   * Is this member access the TARGET of an assignment, i.e. a write?
+   * `obj$field <- v` and `obj$field <<- v` store into the member; they do not read
+   * it. `x <- obj$field` reads. The two sides are read off the grammar's operator
+   * field through `assignmentSides`, so the rightward forms are handled by the same
+   * rule that already decides which side an assignment binds -- not by a second,
+   * possibly disagreeing, test.
+   */
+  isMemberWrite(node) {
+    const parent = node.parent;
+    if (!parent || parent.type !== "binary_operator") return false;
+    return this.sameNode(this.assignmentSides(parent).target, node);
+  }
+  /**
+   * A `uses` edge for one member read of a value.
+   *
+   * THE RULE, and why it is this rule: in R, `obj$member`, `obj@slot` and
+   * `df[["col"]]` all READ a named member of something. Reading a member is not
+   * calling anything, so it is not a `calls` edge, and it is not a package
+   * dependency, so it is not an `imports` edge. It is the same construct the Python
+   * and Julia lanes publish as `uses` (`python:1425` `isMemberRead`,
+   * `script/m14/oracles/julia-refs.ts` on `a.b`), and it is by a wide margin the
+   * largest thing this analyzer was not reading: measured over 1,890 real R files
+   * (`validation/m14/fixtures/r/probe-surfaces.ts`), the corpus holds 9,108
+   * `extract_operator` nodes of which **1,012 are the callee of a call** and
+   * **8,096 are not**. Before this method all 8,096 produced nothing.
+   *
+   * FOUR GATES, each of which exists because the alternative is a false edge:
+   *
+   *   1. not the callee of a call -- `obj$method()` is already a `calls` edge whose
+   *      target is `obj$method`. Publishing a second edge to `method` would be the
+   *      same fact under two labels, which is the `uses`/`references`/`calls`
+   *      confusion the workstream names as question 4.
+   *   2. not the target of an assignment -- `obj$field <- v` writes.
+   *   3. the member must be NAMEABLE -- a computed right side yields no edge, and is
+   *      counted rather than dropped.
+   *   4. an enclosing named symbol must exist -- the same attribution rule `calls`
+   *      uses, including the 0.7 closure case, so the two surfaces cannot disagree
+   *      about who owns a body. 55.6% of R's call sites are at file scope, so this
+   *      gate suppresses a large number and that number is reported in
+   *      `metadata.callAttribution.memberReadsUnresolvedScope` rather than lost.
+   *
+   * CONFIDENCE is the ATTRIBUTION's, not a constant, and that is the whole point of
+   * reading it from `enclosingAttribution` rather than writing 1.0: the member name
+   * is a certain parse fact, but the OWNER of a body reached through an anonymous
+   * function is inferred, so the edge is 0.7 there exactly as a `calls` edge in the
+   * same body is. A `uses` edge that reported 1.0 while the `calls` edge beside it
+   * reported 0.7 would be a confidence that measures the label rather than the
+   * evidence, and the honesty contract §4 ratio would then understate this lane's
+   * guesswork by exactly the closure cases. Every edge below 1.0 carries a
+   * `reasonCode` and a `reason`.
+   *
+   * The RECEIVER is recorded in metadata, not in the edge target, so the edge binds
+   * to a symbol with the member's own name -- which is what makes it joinable with
+   * the `property` symbols R6/R5/S4/S7 publish, and is the convention the Python and
+   * Julia lanes follow.
+   */
+  handleMemberRead(node, fnStack, relationships, ambiguity) {
+    const member = node.type === "extract_operator" ? this.extractOperatorMember(node) : this.stringSubsetIndex(node);
+    if (!member) {
+      if (node.type === "extract_operator") ambiguity.memberReadsWithComputedIndex++;
+      return;
+    }
+    if (this.isCalleePosition(node)) {
+      ambiguity.memberReadsSuppressedByCall++;
+      return;
+    }
+    if (this.isMemberWrite(node)) {
+      ambiguity.memberWrites++;
+      return;
+    }
+    const attribution = this.enclosingAttribution(fnStack);
+    if (!attribution) {
+      ambiguity.memberReadsUnresolvedScope++;
+      return;
+    }
+    const receiver = this.memberReadReceiver(node);
+    const inferred = attribution.subType !== "function";
+    this.pushRel(
+      relationships,
+      attribution.name,
+      member,
+      ASTEngine.RelationshipType.Uses,
+      attribution.confidence,
+      {
+        rSpecific: true,
+        relationshipSubType: "member_read",
+        memberAccessOperator: node.type === "extract_operator" ? node.childForFieldName("operator")?.text : "[[",
+        ...receiver ? { receiver } : {},
+        ...inferred ? { attributionSubType: attribution.subType, reasonCode: attribution.reason, reason: attribution.reason } : {}
+      },
+      this.memberNameNode(node)
+    );
+  }
+  /**
+   * The receiver of a member read, when it is itself a plain NAME, for metadata
+   * only. A receiver that is an expression (`pkg::obj$fn`, `get_obj()$field`) is
+   * omitted rather than interpolated: the edge target never carries source text, and
+   * a metadata field that quotes the input back is the same smell in a place where
+   * nobody is looking at it.
+   */
+  memberReadReceiver(node) {
+    const lhs = node.type === "extract_operator" ? node.childForFieldName("lhs") : node.childForFieldName("function");
+    if (!lhs) return null;
+    if (lhs.type === "identifier") return this.unquoteIdentifier(lhs.text) || null;
+    return null;
+  }
+  /** The node that WRITES the member name, which is where the edge's line comes from. */
+  memberNameNode(node) {
+    if (node.type === "extract_operator") {
+      const rhs = node.childForFieldName("rhs");
+      if (rhs && (rhs.type === "identifier" || rhs.type === "string")) return rhs;
+    }
+    const args = this.subset2Arguments(node);
+    if (args) {
+      for (let i = 0; i < args.namedChildCount; i++) {
+        const arg = args.namedChild(i);
+        if (!arg || arg.type !== "argument") continue;
+        const value = arg.childForFieldName("value");
+        if (value && value.type === "string") return value;
+      }
+    }
+    return node;
+  }
+  // ----------------------------------------------------------------------- call
+  handleCall(node, symbols, imports, exports, relationships, metadata, declaredTypes, ambiguity, fnStack) {
+    const fnNode = node.childForFieldName("function");
+    if (!fnNode) return;
+    const fnName = this.calleeName(fnNode);
+    const args = this.getArgumentsNode(node);
+    if (fnNode.type === "namespace_operator") {
+      const ns = fnNode.childForFieldName("lhs");
+      const op = fnNode.childForFieldName("operator")?.text;
+      if (ns && op && NAMESPACE_OPERATORS.has(op)) {
+        imports.push({
+          module: this.unquoteIdentifier(ns.text),
+          names: [],
+          range: this.getRange(fnNode),
+          isWildcard: true,
+          metadata: { rSpecific: true, accessOperator: op }
+        });
+        this.pushRel(relationships, "global", this.unquoteIdentifier(ns.text), ASTEngine.RelationshipType.Imports, 1, {
+          rSpecific: true,
+          relationshipSubType: "namespace_access",
+          accessOperator: op
+        }, ns);
+        this.pushRel(relationships, "global", this.unquoteIdentifier(ns.text), ASTEngine.RelationshipType.References, 1, {
+          rSpecific: true,
+          relationshipSubType: "namespace_access",
+          accessOperator: op
+        }, ns);
+      }
+    }
+    if (fnName === "UseMethod") {
+      this.pushIfUnique(metadata.patterns, "S3 Object System (Generics)");
+    }
+    if (APPLY_FAMILY.has(fnName)) this.pushIfUnique(metadata.patterns, "Apply Family");
+    if (DATA_FRAME_CONSTRUCTORS.has(fnName)) this.pushIfUnique(metadata.patterns, "Data Frames");
+    if (STATISTICAL_MODELS.has(fnName) || STATISTICAL_MODELS.has(fnNode.text)) {
+      if (metadata.statisticalFocus !== void 0) metadata.statisticalFocus += 30;
+    }
+    if (TIDYVERSE_NSE.has(fnName)) {
+      this.pushIfUnique(metadata.patterns, "Tidyverse Data Masking (NSE)");
+      if (metadata.dataManipulationIntensity !== void 0) metadata.dataManipulationIntensity += 10;
+    }
+    if (fnName === "NS") this.pushIfUnique(metadata.patterns, "Shiny Module Namespace (NS)");
+    if (ERROR_HANDLERS.has(fnName)) this.pushIfUnique(metadata.patterns, "Error Handling");
+    if (CLEANUP_HANDLERS.has(fnName)) this.pushIfUnique(metadata.patterns, "Cleanup Handlers");
+    if (NSE_CAPTURERS.has(fnName)) this.pushIfUnique(metadata.patterns, "Non-Standard Evaluation (NSE)");
+    const attribution = this.enclosingAttribution(fnStack);
+    if (attribution) {
+      const relMeta = { rSpecific: true };
+      if (attribution.subType !== "function") {
+        relMeta.relationshipSubType = attribution.subType;
+        if (attribution.reason) {
+          relMeta.reasonCode = attribution.reason;
+          relMeta.reason = attribution.reason;
+        }
+      }
+      const callTarget = this.callTargetName(fnNode, fnName);
+      if (!callTarget) ambiguity.callsToUnnameableCallee++;
+      else this.pushRel(relationships, attribution.name, callTarget, ASTEngine.RelationshipType.Calls, attribution.confidence, relMeta, this.callTargetNode(fnNode, callTarget));
+      if (attribution.confidence < 1) ambiguity.callsAttributedThroughClosure++;
+      const constructorName = this.constructorTarget(fnNode);
+      if (constructorName && declaredTypes.has(constructorName)) {
+        this.pushRel(relationships, attribution.name, constructorName, ASTEngine.RelationshipType.Instantiates, 0.9, { isRConstructor: true, reasonCode: "declared_class_constructor" }, fnNode);
+      }
+      if (fnName === "new") {
+        const cls = this.firstStringArgumentOf(node, 0);
+        if (cls && declaredTypes.has(cls)) {
+          this.pushRel(relationships, attribution.name, cls, ASTEngine.RelationshipType.Instantiates, 0.9, { isS4Constructor: true, reasonCode: "declared_class_constructor" }, fnNode);
+        }
+      }
+    } else {
+      ambiguity.callsUnresolvedScope++;
+    }
+    if (fnName === "library" || fnName === "require") {
+      this.handleLibraryCall(node, args, imports, relationships);
+      return;
+    }
+    if (fnName === "rm" && fnStack.length === 0) {
+      const removed = this.removeTopLevelBindings(node, args, symbols, relationships, metadata);
+      if (removed) {
+        if (metadata.ambiguity === void 0) metadata.ambiguity = {};
+        metadata.ambiguity.removedByTopLevelRm = (metadata.ambiguity.removedByTopLevelRm ?? 0) + removed;
+      }
+      return;
+    }
+    if (fnName === "sourceCpp") {
+      this.pushIfUnique(metadata.patterns, "Rcpp / C++ Integration");
+      this.handleSourceCall(node, args, imports, relationships, {
+        relationshipSubType: "rcpp_source",
+        language: "cpp",
+        crossLanguage: true
+      });
+      return;
+    }
+    if (fnName === "source") {
+      this.handleSourceCall(node, args, imports, relationships, { relationshipSubType: "r_source" });
+      return;
+    }
+    if (fnName === "setClass") {
+      this.pushIfUnique(metadata.patterns, "S4 Object System");
+      this.handleSetClass(node, args, symbols, exports, relationships, declaredTypes);
+      return;
+    }
+    if (fnName === "setRefClass") {
+      const parent = node.parent;
+      const isAssignmentValue = parent?.type === "binary_operator" && this.sameNode(this.assignmentSides(parent).value, node);
+      if (!isAssignmentValue && fnStack.length === 0 && !this.hasLocalBoundary(node)) {
+        const declared = this.firstStringArgumentOf(node, 0);
+        if (declared) {
+          this.declareR5Class(
+            node,
+            declared,
+            node,
+            symbols,
+            exports,
+            relationships,
+            declaredTypes,
+            this.extractDocstring(node),
+            metadata.patterns
+          );
+        }
+      }
+      return;
+    }
+    if (fnName === "setGeneric") {
+      this.handleSetGenericOrMethod(node, args, symbols, exports, relationships, ambiguity);
+      return;
+    }
+    if (fnName === "setMethod") {
+      this.handleSetGenericOrMethod(node, args, symbols, exports, relationships, ambiguity);
+      return;
+    }
+    if (fnName === "setValidity") {
+      this.handleSetValidity(node, args, symbols, relationships);
+      return;
+    }
+  }
+  /**
+   * `library(pkg)` / `require(pkg)` declare ONE dependency: the first POSITIONAL
+   * argument. Every other argument is an option — `warn.conflicts`, `quietly`,
+   * `character.only`, `pos`, `lib.loc`, `mask.ok`, `exclude`, `include.only`,
+   * `attach.required` — and the previous implementation turned each of those
+   * option NAMES into both an import and a `references` edge, publishing phantom
+   * packages. `library(dplyr, warn.conflicts = FALSE)` is the polite form and is
+   * everywhere in CRAN code.
+   *
+   * Confidence is 1.0 for a string literal (`library("dplyr")` names the package
+   * outright) and 0.8 for a bare identifier, which with `character.only = TRUE`
+   * may hold a computed package name.
+   */
+  handleLibraryCall(node, args, imports, relationships) {
+    if (!args) return;
+    let value = null;
+    for (let i = 0; i < args.namedChildCount && !value; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type === "comma") continue;
+      if (arg.type === "argument") {
+        const nameNode = arg.childForFieldName("name");
+        if (nameNode) {
+          if (nameNode.text === "package") value = arg.childForFieldName("value");
+          continue;
+        }
+        value = arg.childForFieldName("value");
+      } else {
+        value = arg;
+      }
+    }
+    if (!value) return;
+    let moduleName = "";
+    let confidence = 0.8;
+    if (value.type === "string") {
+      moduleName = this.stringNodeText(value);
+      confidence = 1;
+    } else if (value.type === "identifier") {
+      moduleName = this.unquoteIdentifier(value.text);
+    }
+    if (!moduleName) return;
+    imports.push({
+      module: moduleName,
+      names: [],
+      range: this.getRange(node),
+      isWildcard: true,
+      metadata: { rSpecific: true, declaredBy: "library" }
+    });
+    this.pushRel(
+      relationships,
+      "global",
+      moduleName,
+      ASTEngine.RelationshipType.References,
+      confidence,
+      {
+        rSpecific: true,
+        relationshipSubType: "library_dependency",
+        reasonCode: confidence < 1 ? "library_bare_identifier" : "library_string_literal"
+      },
+      value
+    );
+    this.pushRel(relationships, "global", moduleName, ASTEngine.RelationshipType.Imports, confidence, {
+      rSpecific: true,
+      relationshipSubType: "library_import",
+      reasonCode: confidence < 1 ? "library_bare_identifier" : "library_string_literal"
+    }, value);
+  }
+  /**
+   * `source("helpers.R")` / `sourceCpp("code.cpp")` declare a file dependency.
+   * The first argument is read as the first `argument` child of the `arguments`
+   * node; indexing `child(0)` instead returned the `(` token, so the guard never
+   * matched and these calls produced no dependency at all while still advertising
+   * the Rcpp pattern in metadata.
+   */
+  handleSourceCall(node, args, imports, relationships, meta) {
+    const value = this.firstPositionalValue(args);
+    if (!value || value.type !== "string") return;
+    const path = this.stringNodeText(value);
+    if (!path) return;
+    imports.push({
+      module: path,
+      names: [],
+      range: this.getRange(node),
+      isWildcard: true,
+      metadata: { rSpecific: true, ...meta }
+    });
+    this.pushRel(relationships, "global", path, ASTEngine.RelationshipType.References, 1, { ...meta, relationshipSubType: meta.relationshipSubType }, value);
+    this.pushRel(relationships, "global", path, ASTEngine.RelationshipType.Imports, 1, { ...meta, relationshipSubType: meta.relationshipSubType }, value);
+  }
+  handleSetClass(node, args, symbols, exports, relationships, declaredTypes) {
+    if (!args) return;
+    const className = this.firstStringArgumentOf(node, 0);
+    if (!className) return;
+    const baseClasses = this.extractNamedArguments(node, "contains");
+    const composesList = this.compositionClauseIsList(node, "contains");
+    const doc = this.extractDocstring(node);
+    symbols.push({
+      name: className,
+      kind: ASTEngine.SymbolKind.Class,
+      range: this.getRange(node),
+      docstring: doc,
+      metadata: { rSpecific: true, type: "S4", isS4Class: true, baseClasses }
+    });
+    declaredTypes.add(className);
+    const slotNames = /* @__PURE__ */ new Map();
+    for (const slot of this.extractSlotKeys(node)) {
+      if (!slotNames.has(slot.name)) slotNames.set(slot.name, slot);
+    }
+    for (const slotName of slotNames.values()) {
+      symbols.push({
+        name: slotName.name,
+        kind: ASTEngine.SymbolKind.Property,
+        range: slotName.range ?? this.getRange(node),
+        ownerName: className,
+        ownerKind: ASTEngine.SymbolKind.Class,
+        docstring: "",
+        metadata: { rSpecific: true, isS4Slot: true, declaredVia: slotName.via }
+      });
+    }
+    for (const bc of baseClasses) {
+      const type = composesList ? ASTEngine.RelationshipType.MixesIn : ASTEngine.RelationshipType.Extends;
+      const subType = composesList ? "s4_composes" : "s4_inherits";
+      this.pushRel(relationships, className, bc, type, 1, { relationshipSubType: subType }, this.namedArgumentNode(node, "contains", bc));
+    }
+    if (doc && this.roxygenHasTag(doc, "@export")) exports.push({ name: className, kind: ASTEngine.SymbolKind.Class });
+  }
+  handleSetGenericOrMethod(node, args, symbols, exports, relationships, ambiguity) {
+    if (!args) return;
+    const fnName = this.calleeName(node.childForFieldName("function"));
+    const methodName = this.firstStringArgumentOf(node, 0);
+    if (!methodName) return;
+    let ownerName;
+    if (fnName === "setMethod") {
+      ownerName = this.setMethodOwner(args);
+    }
+    const body = this.lastPositionalValue(args);
+    let parameters;
+    let signature;
+    if (body && body.type === "function_definition") {
+      parameters = this.extractParameters(body);
+      signature = this.extractSignature(body);
+    }
+    const doc = this.extractDocstring(node);
+    symbols.push({
+      name: methodName,
+      kind: fnName === "setMethod" ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function,
+      range: this.getRange(node),
+      ownerName,
+      ownerKind: ownerName ? ASTEngine.SymbolKind.Class : void 0,
+      signature,
+      parameters,
+      docstring: doc,
+      metadata: {
+        rSpecific: true,
+        type: fnName === "setGeneric" ? "S4_Generic" : "S4_Method",
+        isS4Generic: fnName === "setGeneric",
+        isS4Method: fnName === "setMethod"
+      }
+    });
+    if (doc && this.roxygenHasTag(doc, "@export"))
+      exports.push({
+        name: methodName,
+        kind: fnName === "setMethod" ? ASTEngine.SymbolKind.Method : ASTEngine.SymbolKind.Function
+      });
+    if (fnName === "setMethod" && ownerName) {
+      this.pushRel(relationships, ownerName, methodName, ASTEngine.RelationshipType.Contains, 1, { rSpecific: true, relationshipSubType: "s4_method" }, node);
+    }
+    void ambiguity;
+  }
+  /**
+   * `setValidity("Class", function(object) ...)` declares a class-level
+   * validator. It was not handled at all, so a validation rule attached to an
+   * S4 class was invisible.
+   */
+  handleSetValidity(node, args, symbols, relationships) {
+    if (!args) return;
+    const className = this.firstStringArgumentOf(node, 0);
+    if (!className) return;
+    const body = this.lastPositionalValue(args);
+    let parameters;
+    let signature;
+    if (body && body.type === "function_definition") {
+      parameters = this.extractParameters(body);
+      signature = this.extractSignature(body);
+    }
+    symbols.push({
+      name: "validity",
+      kind: ASTEngine.SymbolKind.Method,
+      range: this.getRange(node),
+      ownerName: className,
+      ownerKind: ASTEngine.SymbolKind.Class,
+      signature,
+      parameters,
+      docstring: this.extractDocstring(node),
+      metadata: { rSpecific: true, isS4Validity: true, ownerClass: className, objectSystem: "S4" }
+    });
+    this.pushRel(relationships, className, "validity", ASTEngine.RelationshipType.Contains, 1, { rSpecific: true, relationshipSubType: "s4_validity" }, node);
+  }
+  /** The class named by a `setMethod` second argument, string or `signature(...)`. */
+  setMethodOwner(args) {
+    let seen = 0;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type === "comma") continue;
+      if (arg.type === "argument") {
+        if (arg.childForFieldName("name")) continue;
+        const value = arg.childForFieldName("value");
+        if (!value) continue;
+        if (seen === 1) {
+          if (value.type === "string") return this.stringNodeText(value);
+          if (value.type === "call" && this.calleeName(value.childForFieldName("function")) === "signature") {
+            const inner = this.getArgumentsNode(value);
+            const first = this.firstPositionalValue(inner);
+            if (first && first.type === "string") return this.stringNodeText(first);
+          }
+          return void 0;
+        }
+        seen++;
+        continue;
+      }
+      if (seen === 1) {
+        if (arg.type === "string") return this.stringNodeText(arg);
+        return void 0;
+      }
+      seen++;
+    }
+    return void 0;
+  }
+  /**
+   * Attribute a call to the nearest enclosing symbol that the SYNTAX actually
+   * names, and say how sure we are.
+   *
+   * Resolution order for each enclosing `function_definition`, innermost first:
+   *   1. assigned to a name                  -> confidence 1.0
+   *   2. a named R6/R5 list member           -> confidence 1.0
+   *   3. the body of a `setGeneric`/`setMethod` -> confidence 1.0
+   *   4. any other closure                   -> attributed to the nearest
+   *      enclosing NAMED symbol, confidence 0.7, with a reason code; if there is
+   *      no enclosing symbol the call is counted unresolved rather than given an
+   *      invented source.
+   *
+   * Case 4 is the common case in idiomatic R: `lapply(x, function(v) f(v))`,
+   * `tryCatch(..., error = function(e) ...)`, `shiny::moduleServer(id, function(id)
+   * ...)`. The earlier implementation returned null for every one of them, so
+   * idiomatic functional R contributed no call edges at all.
+   */
+  enclosingAttribution(fnStack) {
+    for (let i = fnStack.length - 1; i >= 0; i--) {
+      const resolved = fnStack[i].attribution;
+      if (!resolved) continue;
+      if (i === fnStack.length - 1) return resolved;
+      return {
+        name: resolved.name,
+        confidence: 0.7,
+        subType: "closure_call",
+        reason: "call appears inside an anonymous function expression; attributed to the nearest enclosing named symbol"
+      };
+    }
+    return null;
+  }
+  /** The symbol a `function_definition` node is the body of, if the syntax names one. */
+  resolveFunctionOwner(fnDef) {
+    const parent = fnDef.parent;
+    if (!parent) return null;
+    if (parent.type === "binary_operator") {
+      const { target, value } = this.assignmentSides(parent);
+      if (target?.type === "identifier" && value && this.sameNode(value, fnDef)) {
+        return {
+          name: this.unquoteIdentifier(target.text),
+          confidence: 1,
+          subType: "function",
+          reason: ""
+        };
+      }
+      if (value && this.sameNode(value, fnDef)) {
+        const s7 = this.findOwningS7Method(fnDef);
+        if (s7) return { name: s7, confidence: 1, subType: "s7_method", reason: "" };
+      }
+      return null;
+    }
+    if (parent.type === "argument") {
+      const memberOwner = this.findOwningObjectSystem(fnDef);
+      if (memberOwner) {
+        return {
+          name: memberOwner.methodName,
+          confidence: 1,
+          subType: memberOwner.subType,
+          reason: ""
+        };
+      }
+      const s4 = this.findOwningS4Declaration(fnDef);
+      if (s4) {
+        return { name: s4, confidence: 1, subType: "s4_method", reason: "" };
+      }
+      return null;
+    }
+    return null;
+  }
+  /** If this function is the body of an `S7::method(...) <-` definition, name the generic. */
+  findOwningS7Method(fnDef) {
+    const parent = fnDef.parent;
+    if (!parent || parent.type !== "binary_operator") return null;
+    const { target, value } = this.assignmentSides(parent);
+    if (!value || !this.sameNode(value, fnDef)) return null;
+    if (!target || target.type !== "call") return null;
+    const base = this.calleeName(target.childForFieldName("function"));
+    if (base !== "method" && base !== "S7_method") return null;
+    const generic = this.firstPositionalValue(this.getArgumentsNode(target));
+    return generic ? this.nodeAsName(generic) || null : null;
+  }
+  /**
+   * If this function is a member of an R6Class/setRefClass list, name its class.
+   *
+   * The chain is: function_definition -> argument (the `go = function() ...`
+   * entry) -> arguments (of the `list(...)`) -> call (`list`) -> argument
+   * (`public = list(...)`) -> arguments (of `R6Class`) -> call (`R6Class`).
+   * The member-list NAME is on the argument wrapping the `list` call, not on the
+   * method's own argument.
+   */
+  findOwningObjectSystem(fnDef) {
+    const methodArg = fnDef.parent;
+    if (!methodArg || methodArg.type !== "argument") return null;
+    const methodName = methodArg.childForFieldName("name")?.text ?? "";
+    if (!methodName) return null;
+    const listArgs = methodArg.parent;
+    if (!listArgs || listArgs.type !== "arguments") return null;
+    const listCall = listArgs.parent;
+    if (!listCall || listCall.type !== "call") return null;
+    if (this.calleeName(listCall.childForFieldName("function")) !== "list") return null;
+    const memberArg = listCall.parent;
+    if (!memberArg || memberArg.type !== "argument") return null;
+    const listName = memberArg.childForFieldName("name")?.text ?? "";
+    if (!CLASS_MEMBER_LISTS.has(listName) && !R5_MEMBER_LISTS.has(listName)) return null;
+    const classArgs = memberArg.parent;
+    if (!classArgs || classArgs.type !== "arguments") return null;
+    const classCall = classArgs.parent;
+    if (!classCall || classCall.type !== "call") return null;
+    const base = this.calleeName(classCall.childForFieldName("function"));
+    if (base !== "R6Class" && base !== "setRefClass") return null;
+    return {
+      className: this.assignmentTargetForCall(classCall) ?? "",
+      methodName,
+      subType: base === "R6Class" ? "r6_method" : "r5_method"
+    };
+  }
+  /** If this function is the body of a setGeneric/setMethod, return the declared name. */
+  findOwningS4Declaration(fnDef) {
+    const parent = fnDef.parent;
+    if (!parent) return null;
+    let p = parent;
+    let depth = 0;
+    while (p && depth < 4) {
+      if (p.type === "call") {
+        const base = this.calleeName(p.childForFieldName("function"));
+        if (base === "setGeneric" || base === "setMethod") {
+          const args = this.getArgumentsNode(p);
+          const first = this.firstPositionalValue(args);
+          if (first && first.type === "string") return this.stringNodeText(first);
+        }
+        return null;
+      }
+      if (p.type === "function_definition") return null;
+      p = p.parent;
+      depth++;
+    }
+    return null;
+  }
+  /** The name a class-constructor call is assigned to, used to label R6 members. */
+  assignmentTargetForCall(callNode) {
+    const parent = callNode.parent;
+    if (parent && parent.type === "binary_operator") {
+      const target = this.assignmentTarget(parent);
+      if (target) return this.unquoteIdentifier(target.text);
+    }
+    return null;
+  }
+  /**
+   * The receiver of a constructor call, read from grammar FIELDS.
+   *   `Cls$new()`        -> extract_operator(lhs=Cls, operator=$, rhs=new)
+   *   `pkg::Cls$new()`   -> namespace_operator(rhs=extract_operator(...))
+   * The previous `text.indexOf("$new")` was a source-text scan that also fired on
+   * arguments and strings containing that sequence.
+   */
+  constructorTarget(fnNode) {
+    const candidate = fnNode.type === "namespace_operator" ? fnNode.childForFieldName("rhs") : fnNode;
+    if (!candidate) return null;
+    if (candidate.type !== "extract_operator") return null;
+    const op = candidate.childForFieldName("operator")?.text;
+    if (op !== "$" && op !== "@") return null;
+    const rhs = candidate.childForFieldName("rhs");
+    if (!rhs || rhs.type !== "identifier" || rhs.text !== "new") return null;
+    const lhs = candidate.childForFieldName("lhs");
+    if (!lhs || lhs.type !== "identifier") return null;
+    return this.unquoteIdentifier(lhs.text);
+  }
+  /**
+   * The name a `calls` edge should carry: the callee as written, so a reader can
+   * see `dplyr::filter`, `obj$method` and `Cls$new` rather than three different
+   * functions that all end in the same word. Falls back to the bare name when the
+   * function slot is not a simple callable form.
+   */
+  callTargetName(fnNode, bare) {
+    if (!bare) return "";
+    if (fnNode.type === "identifier") return bare;
+    if (fnNode.type === "namespace_operator" || fnNode.type === "extract_operator") {
+      const ns = fnNode.childForFieldName("lhs");
+      const op = fnNode.childForFieldName("operator")?.text;
+      const rhs = fnNode.childForFieldName("rhs");
+      if (ns && op && rhs) {
+        const receiver = this.calleeName(ns);
+        if (!receiver) return bare;
+        const rhsName = rhs.type === "identifier" ? this.unquoteIdentifier(rhs.text) : rhs.text;
+        return `${receiver}${op}${rhsName}`;
+      }
+      return bare;
+    }
+    return bare;
+  }
+  /**
+   * The node that WRITES the edge's target, which is the node the edge's `line_number`
+   * must come from.
+   *
+   * The rule is: **the line where the target's LAST name component is written.** For
+   * `pkg::fn` and `obj$method` on one line that is the same line either way, so the
+   * common case is unaffected. It matters when R splits a chain, which the promises
+   * package does routinely:
+   *
+   *     p$value <- p$value$          <- line 743: `value` is here
+   *       then(function(value) {     <- line 744: `then` is HERE
+   *
+   * The target is `value$then`, and the method name is what identifies the call and what
+   * a reader searches for. Preferring the rhs puts the edge on 744. Preferring the
+   * expression start put it on 743, a line that does not contain the string `then` at
+   * all -- and "the line where the expression happens to begin" is not a stable property
+   * of the call, it is an artifact of where the author pressed return.
+   */
+  callTargetNode(fnNode, _target) {
+    if (fnNode.type !== "namespace_operator" && fnNode.type !== "extract_operator") return fnNode;
+    const rhs = fnNode.childForFieldName("rhs");
+    if (rhs && rhs.type === "identifier") return rhs;
+    return fnNode;
+  }
+  stringArgumentAt(args, index) {
+    const n = this.stringArgumentNodeAt(args, index);
+    return n ? this.stringNodeText(n) : void 0;
+  }
+  /**
+   * The Nth positional STRING argument of a call, as the NODE rather than the text.
+   *
+   * The node matters because an edge's `line_number` is the line of the node that NAMES
+   * the target, and the name of an S7 class lives in a string that need not be on the
+   * same line as the call:
+   *
+   *     class_theme <- S7::new_class(        <- line 219
+   *       "theme", class_S3_gg,              <- line 220: this is where `theme` is named
+   *       ...
+   *
+   * Attributing the edge to the call put `class_theme references theme` on line 219, a
+   * line that does not contain the word `theme` anywhere. The R-positions oracle found 6
+   * such edges in ggplot2 alone. Passing the string node puts the edge on the line that
+   * actually names the class, which is the line a reader needs.
+   */
+  stringArgumentNodeAt(args, index) {
+    if (!args) return null;
+    let seen = 0;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type === "comma") continue;
+      if (arg.type === "argument") {
+        if (arg.childForFieldName("name")) continue;
+        const value = arg.childForFieldName("value");
+        if (!value) continue;
+        if (seen === index) return value.type === "string" ? value : null;
+        seen++;
+        continue;
+      }
+      if (seen === index) return arg.type === "string" ? arg : null;
+      seen++;
+    }
+    return null;
+  }
+  /** The Nth positional STRING argument of a call, unquoted. */
+  firstStringArgumentOf(node, index) {
+    return this.stringArgumentAt(this.getArgumentsNode(node), index);
+  }
+  /** The last positional argument value of a call (the function body, for setGeneric/setMethod). */
+  lastPositionalValue(args) {
+    if (!args) return null;
+    let last = null;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type === "comma") continue;
+      if (arg.type === "argument") {
+        if (arg.childForFieldName("name")) continue;
+        last = arg.childForFieldName("value");
+      } else {
+        last = arg;
+      }
+    }
+    return last;
+  }
+  /** The text of a `string` node: the grammar's `content` field, else the raw token. */
+  stringNodeText(value) {
+    const content = value.childForFieldName("content");
+    if (content) return content.text;
+    return this.unquoteString(value.text);
+  }
+  /**
+   * Slot names of an S4 class, each with the RANGE OF ITS OWN NAME NODE so a
+   * slot's symbol points at the slot rather than at the whole `setClass` call.
+   *
+   * Two shapes declare slots and both are in real use:
+   *   slots = c(a = "numeric")        the current idiom
+   *   representation(a = "numeric")   the original S4 idiom, still written by
+   *                                  R Core itself in Matrix
+   * Reading only the first left every `representation()` class with no members.
+   */
+  extractSlotKeys(node) {
+    const results = [];
+    const args = this.getArgumentsNode(node);
+    if (!args) return results;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (arg?.type !== "argument") continue;
+      const nameNode = arg.childForFieldName("name");
+      const value = arg.childForFieldName("value");
+      if (!value) continue;
+      const argName = nameNode?.text;
+      const callee = value.type === "call" ? this.calleeName(value.childForFieldName("function")) : "";
+      if (argName === "slots" && callee === "c") {
+        for (const slot of this.namedArgumentNameKeys(value, "slots")) results.push(slot);
+        continue;
+      }
+      if ((argName === "representation" || callee === "representation") && value.type === "call") {
+        for (const slot of this.namedArgumentNameKeys(value, "representation")) results.push(slot);
+      }
+    }
+    return results;
+  }
+  /** The names (with ranges) of the named arguments of a call. */
+  namedArgumentNameKeys(callNode, via) {
+    const results = [];
+    const args = this.getArgumentsNode(callNode);
+    if (!args) return results;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const entry = args.namedChild(i);
+      if (entry?.type !== "argument") continue;
+      const entryName = entry.childForFieldName("name");
+      if (entryName?.text) {
+        const name = this.unquoteString(this.unquoteIdentifier(entryName.text));
+        results.push({ name, range: this.getRange(entryName), via });
+      }
+    }
+    return results;
+  }
+  unquoteString(text) {
+    const trimmed = text.trim();
+    if (trimmed.length >= 2) {
+      const first = trimmed[0];
+      const last = trimmed[trimmed.length - 1];
+      if ((first === '"' || first === "'") && first === last) return trimmed.substring(1, trimmed.length - 1);
+    }
+    return trimmed;
+  }
+  extractSignature(node) {
+    const parameters = this.getParametersNode(node);
+    return parameters ? parameters.text : void 0;
+  }
+  extractDocstring(node) {
+    let prev = node.previousSibling;
+    const docsStack = [];
+    while (prev) {
+      if (prev.type === "comment") {
+        docsStack.push(prev.text);
+        prev = prev.previousSibling;
+      } else if (prev.type === "return") {
+        prev = prev.previousSibling;
+      } else {
+        break;
+      }
+    }
+    if (docsStack.length === 0) return void 0;
+    let combined = "";
+    for (let i = docsStack.length - 1; i >= 0; i--) {
+      combined += docsStack[i];
+      if (i > 0) combined += "\n";
+    }
+    return combined;
+  }
+  extractNamedArguments(node, argName) {
+    const results = [];
+    const args = this.getArgumentsNode(node);
+    if (!args) return results;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type !== "argument") continue;
+      const nameNode = arg.childForFieldName("name");
+      if (!nameNode || nameNode.text !== argName) continue;
+      const valNode = arg.childForFieldName("value");
+      if (!valNode) continue;
+      if (valNode.type === "call" && this.calleeName(valNode.childForFieldName("function")) === "c") {
+        const cArgs = this.getArgumentsNode(valNode);
+        if (cArgs) {
+          for (let j = 0; j < cArgs.namedChildCount; j++) {
+            const ca = cArgs.namedChild(j);
+            if (!ca || ca.type === "comma") continue;
+            if (ca.type === "argument") {
+              const v = ca.childForFieldName("value");
+              const text = v ? this.baseClassNodeName(v) : "";
+              if (text) results.push(text);
+            } else {
+              const text = this.baseClassNodeName(ca);
+              if (text) results.push(text);
+            }
+          }
+        }
+      } else {
+        const text = this.baseClassNodeName(valNode);
+        if (text) results.push(text);
+      }
+    }
+    return results;
+  }
+  /**
+   * Whether a class-construction argument is a LIST-shaped composition clause.
+   *
+   * `setClass(contains=)` and `setRefClass(contains=)` are R's composition clauses, and they
+   * come in two shapes that are not the same construct:
+   *
+   *   contains = "Base"                 ONE class — a single supertype; R's own `is()` and
+   *                                     `extends()` answer TRUE for it, so the relation is a
+   *                                     conformance edge (`extends`).
+   *   contains = c("A", "B")            SEVERAL classes — a member-set clause with no single
+   *                                     base. This is the shape the fleet's `mixes_in` names
+   *                                     ("no single base and the `with` list is not an
+   *                                     inheritance clause", `src/ast/types.ts:156-160`), the
+   *                                     same reading the Scala `extends A with B, C` clause
+   *                                     takes for its later positions.
+   *
+   * The count is taken from the VALUE node, not from the names that resolve: `c("A", pkg)` has
+   * two entries even though only one is nameable, and the clause is a list either way. `comma`
+   * is a named node type in this grammar, so the entries alternate argument/comma; commas are
+   * skipped or every two-element list would read as four.
+   *
+   * A single-base `contains=` is deliberately NOT relabelled: R says it is conformance, and
+   * moving it to `mixes_in` would publish a false edge. The conformance fact is carried as a
+   * stated caveat on the list-shaped branch rather than dropped — R's `contains=` also makes
+   * `is()` TRUE for the composed classes, and the fleet's label is the composition-clause
+   * reading, not a claim that no conformance exists.
+   */
+  compositionClauseIsList(node, argName) {
+    const args = this.getArgumentsNode(node);
+    if (!args) return false;
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg || arg.type !== "argument") continue;
+      if (arg.childForFieldName("name")?.text !== argName) continue;
+      const value = arg.childForFieldName("value");
+      if (!value || value.type !== "call") return false;
+      const callee = this.calleeName(value.childForFieldName("function"));
+      if (callee !== "c" && callee !== "list") return false;
+      const entries = this.getArgumentsNode(value);
+      if (!entries) return false;
+      let count = 0;
+      for (let j = 0; j < entries.namedChildCount; j++) {
+        const entry = entries.namedChild(j);
+        if (!entry || entry.type === "comma") continue;
+        if (entry.type === "argument" && !entry.childForFieldName("value")) continue;
+        count++;
+      }
+      return count > 1;
+    }
+    return false;
+  }
+  /**
+   * The class name a base-class ARGUMENT node carries, or "".
+   *
+   * R writes a base class three ways and this reads all three:
+   *
+   *   inherit = Parent            identifier      -> Parent
+   *   contains = "Parent"         string          -> Parent
+   *   inherit = pkg::Parent       namespace_operator
+   *
+   * The third was dropped. R6 documents it — `inherit` may name a class in another package,
+   * and R6's own test suite uses it: `R6/tests/manual/test-inheritance.R:126` writes
+   * `BC <- R6Class(inherit = R6testA::AC, ...)`, where `AC` is declared 9 lines above in the
+   * same file inside the `R6testA = {...}` argument. A census of every class-constructor call
+   * in the corpus (738 of them across 2,342 R files: `new_class` 283, `R6Class` 229,
+   * `setClass` 201, `new_base_class` 12, `setRefClass` 9) found exactly ONE qualified base
+   * class, so this is a 1-edge gap and is recorded as one rather than dressed up. It is a
+   * deterministic parse fact, so the edge it produces is a fact and not a heuristic.
+   *
+   * The qualifier is dropped and the BARE name kept: `pkg::Parent` names the class `Parent`,
+   * which is what `class(x)` returns and what dispatch keys on, and a symbol named
+   * `pkg::Parent` binds to nothing in any file.
+   */
+  baseClassNodeName(node) {
+    if (!node) return "";
+    if (node.type === "string") return this.stringNodeText(node);
+    if (node.type === "identifier") return this.unquoteIdentifier(node.text);
+    if (node.type === "namespace_operator") {
+      const rhs = node.childForFieldName("rhs");
+      return rhs ? this.unquoteIdentifier(rhs.text) : "";
+    }
+    return "";
+  }
+  /**
+   * The range of a member DECLARATION: from the declared name to the end of its value.
+   *
+   * A member is written `name = value`, and a range taken from `value` alone starts at
+   * the value. For an R6 or R5 method that means the range begins at the `function`
+   * keyword and so EXCLUDES the name the symbol is published under -- a range that does
+   * not contain the thing it names. The R-positions oracle found 833 of these across the
+   * pinned corpora (dplyr, shiny, testthat), every one a method, all of them off by the
+   * length of `name = `.
+   *
+   * Both nodes are required, so a member with no name is not representable here and the
+   * caller is forced to decide what it means rather than being handed a range that
+   * silently omits the name.
+   */
+  getDeclarationRange(nameNode, valueNode) {
+    const r = {
+      startLine: nameNode.startPosition.row + 1,
+      startColumn: nameNode.startPosition.column + 1,
+      endLine: valueNode.endPosition.row + 1,
+      endColumn: valueNode.endPosition.column + 1,
+      startIndex: nameNode.startIndex,
+      endIndex: valueNode.endIndex
+    };
+    const toBytes = this.byteOffsetOf;
+    if (toBytes) {
+      r.byteStart = toBytes(nameNode.startIndex);
+      r.byteEnd = toBytes(valueNode.endIndex);
+    }
+    return r;
+  }
+  /**
+   * The range of a node.
+   *
+   * `startIndex`/`endIndex` are whatever the parser reported -- UTF-16 code units, for
+   * web-tree-sitter -- and are passed through unchanged so nothing that already reads them
+   * moves. `byteStart`/`byteEnd` are the same positions in BYTES, added alongside, which is
+   * what a consumer slicing a Buffer needs. `byteOffset` is supplied by `analyze`, which is
+   * the only place that has the source text; a node range built outside an analyze call
+   * simply omits the byte fields rather than reporting a wrong one.
+   */
+  /**
+   * Is this `if` condition the literal FALSE, so the `then` branch never executes?
+   *
+   * Only the literals. A variable holding FALSE is not statically knowable, and R does not
+   * constant-fold, so guessing there would drop real declarations.
+   */
+  /**
+   * Remove the symbols a top-level `rm(...)` unbinds, and any relationship that named one
+   * as its source. Returns how many were removed, so the removal is countable rather than
+   * silent.
+   */
+  removeTopLevelBindings(node, args, symbols, relationships, metadata) {
+    if (!args) return 0;
+    const doomed = /* @__PURE__ */ new Set();
+    for (let i = 0; i < args.namedChildCount; i++) {
+      const arg = args.namedChild(i);
+      if (!arg) continue;
+      if (arg.childForFieldName("name")) continue;
+      const v = arg.childForFieldName("value") ?? (arg.type === "identifier" ? arg : null);
+      if (!v) continue;
+      const nm = v.type === "identifier" ? this.unquoteIdentifier(v.text) : v.type === "string" ? this.unquoteString(v.text) : null;
+      if (nm) doomed.add(nm);
+    }
+    if (doomed.size === 0) return 0;
+    const before = symbols.length;
+    for (let i = symbols.length - 1; i >= 0; i--) {
+      const s = symbols[i];
+      if (s.ownerName || !doomed.has(s.name)) continue;
+      symbols.splice(i, 1);
+    }
+    for (let i = relationships.length - 1; i >= 0; i--) {
+      const r = relationships[i];
+      if (doomed.has(String(r.source))) relationships.splice(i, 1);
+    }
+    void node;
+    void metadata;
+    return before - symbols.length;
+  }
+  isStaticallyFalseCondition(ifNode) {
+    const cond = ifNode.childForFieldName("condition");
+    if (!cond) return false;
+    if (cond.type === "false") return true;
+    if (cond.type !== "identifier") return false;
+    const t = this.unquoteIdentifier(cond.text);
+    return t === "F" || t === "FALSE" || t === "false";
+  }
+  getRange(node, byteOffset) {
+    const toBytes = byteOffset ?? this.byteOffsetOf;
+    const r = {
+      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
+    };
+    if (toBytes) {
+      r.byteStart = toBytes(node.startIndex);
+      r.byteEnd = toBytes(node.endIndex);
+    }
+    return r;
+  }
+};
+export {
+  RealRAnalyzer
+};