@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-ruby-analyzer-X2KTLVBH.js

@@ -0,0 +1,2429 @@
+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-ruby-analyzer.ts
+function isAsciiWhitespace(code) {
+  return code === 32 || code === 9 || code === 10 || code === 13 || code === 12 || code === 11;
+}
+var FILE_SCOPE_OWNER = "Global";
+function rubyReopenIdentity(rawName, enclosingOwner) {
+  const sepIdx = rawName.lastIndexOf("::");
+  if (sepIdx < 0) return { name: rawName, owner: enclosingOwner };
+  const name = rawName.substring(sepIdx + 2);
+  const scopeOwner = rawName.substring(0, sepIdx);
+  if (scopeOwner.length === 0) return { name, owner: enclosingOwner };
+  return { name, owner: enclosingOwner ? `${enclosingOwner}::${scopeOwner}` : scopeOwner };
+}
+function rubyFileUnitName(filePath) {
+  if (!filePath) return FILE_SCOPE_OWNER;
+  let end = filePath.length;
+  while (end > 0) {
+    const c = filePath.charCodeAt(end - 1);
+    if (c === 47 || c === 92) break;
+    end--;
+  }
+  const tail = filePath.substring(end);
+  if (tail.length === 0) return FILE_SCOPE_OWNER;
+  const dot = tail.lastIndexOf(".");
+  let stem = dot > 0 ? tail.substring(0, dot) : tail;
+  if (stem.indexOf(".") >= 0) {
+    let out = "";
+    for (let i = 0; i < stem.length; i++) out += stem[i] === "." ? "_" : stem[i];
+    stem = out;
+  }
+  return stem.length > 0 ? stem : FILE_SCOPE_OWNER;
+}
+var RAILS_FRAMEWORK = "Ruby on Rails";
+var VARIABLE_RECEIVER_TYPES = /* @__PURE__ */ new Set(["instance_variable", "class_variable", "global_variable"]);
+function isRubyVisibilityDirectiveName(name) {
+  return name === "private" || name === "protected" || name === "public";
+}
+var BARE_CALL_SKIP_PARENTS = /* @__PURE__ */ new Set([
+  // `call` — the METHOD NAME of a call node is part of the call, not a bare
+  // read: `Mutex.new` must not also read as a bare `new`. The pinned grammar
+  // folds every call shape — paren'd (`foo(1)`), paren-less command (`foo 1`),
+  // and command-with-block (`foo 1 do ... end`) — into `call` nodes, and
+  // `command` / `command_call` are not node types it can produce. This set USED
+  // to carry those two as "grammar-version drift" insurance, which cost two
+  // dead branches (a skip entry that can never match, and a `type ===` arm
+  // that can never fire) and made the file cite a grammar audit as proof of a
+  // claim the audit could not see.
+  //
+  // Removing the two dead entries is a one-token edit with a real failure mode
+  // and the rack-wave fixture caught it immediately: the same edit dropped
+  // `call` itself, and every constructor call in a default argument
+  // (`def initialize(app, mutex = Mutex.new)`) began reading its `new` as a
+  // bare call as well — `calls initialize->new`, a fabricated edge the RB-A
+  // fixture has forbidden since the rack wave. A cleanup of two provably dead
+  // strings was never a safe place to be casual about the live one beside them.
+  "call",
+  // NOTE: `method`/`singleton_method` are deliberately ABSENT — an endless
+  // `def label = name` body is a DIRECT identifier child of the def node,
+  // and only the FIRST named child is the def name (second review: the set
+  // form suppressed endless-body reads on both sides). The def-name check
+  // lives inline at the identifier branch (positional).
+  // `def size=(v)` parses the NAME as a `setter` node wrapping the plain
+  // identifier — without this the nested `size` leaked as a bare call
+  // (master-review 2026-09; oracle already carried `setter`).
+  "setter",
+  // Keyword `alias new_name old_name` (any scope): its identifiers are
+  // method-name DECLARATIONS, never expression calls. Class-level alias
+  // gets the RB-E alias_method contract in the main loop; alias inside a
+  // method body is a runtime-definition (SyntaxError in practice) and must
+  // emit nothing, not two junk calls (master-review 2026-09).
+  "alias",
+  // NOT present: `pair` — a hash/argument pair's VALUE is a real expression
+  // (`{ x: helper }`, `foo(k: helper)`); only colon-form KEYS are
+  // non-expression, and those are hash_key_symbol/simple_symbol nodes, never
+  // identifiers. Rocket-form keys (`key => v`) also evaluate. pair was
+  // suppressing genuine value-position method calls on both sides — a
+  // shared blind spot F5 cannot see (master-review 2026-09, RUBD12).
+  "method_parameters",
+  "parameters",
+  "block_parameters",
+  "lambda_parameters",
+  "block_parameters",
+  "class",
+  "module",
+  "singleton_class"
+]);
+var RUBY_BUILTINS = /* @__PURE__ */ new Set([
+  // Kernel / top-level
+  "puts",
+  "print",
+  "p",
+  "pp",
+  "p$",
+  "print_flush",
+  "putc",
+  "raise",
+  "fail",
+  "exit",
+  "exit!",
+  "abort",
+  "warn",
+  "gets",
+  "readline",
+  "readlines",
+  "rand",
+  "srand",
+  "sleep",
+  "loop",
+  "require",
+  "require_relative",
+  "load",
+  "autoload",
+  "eval",
+  "binding",
+  "local_variables",
+  "global_variables",
+  "global_variable_get",
+  "global_variable_set",
+  "caller",
+  "caller_locations",
+  "trace_var",
+  "untrace_var",
+  "method",
+  "public_method",
+  "private_method",
+  "protected_method",
+  "instance_method",
+  "public_instance_method",
+  "private_instance_method",
+  "respond_to",
+  "respond_to?",
+  "class",
+  "superclass",
+  "Object",
+  "Kernel",
+  "BasicObject",
+  "NilClass",
+  "TrueClass",
+  "FalseClass",
+  "Integer",
+  "Float",
+  "String",
+  "Array",
+  "Hash",
+  "Symbol",
+  "Regexp",
+  "Range",
+  "IO",
+  "File",
+  "Dir",
+  "Process",
+  "Signal",
+  "GC",
+  "ObjectSpace",
+  "Marshal",
+  "Thread",
+  "Fiber",
+  "Random",
+  "SecureRandom",
+  "Time",
+  "Date",
+  "DateTime",
+  "Math",
+  "Comparable",
+  "Enumerable",
+  "Errno",
+  // Ruby dunders / special methods
+  "super",
+  "method_missing",
+  "respond_to_missing?",
+  "initialize_copy",
+  "initialize_dup",
+  "initialize_clone",
+  "send",
+  "__send__",
+  "freeze",
+  "frozen?",
+  "dup",
+  "clone",
+  "taint",
+  "untaint",
+  "trust",
+  "untrust",
+  "hash",
+  "eql?",
+  "equal?",
+  "object_id",
+  "instance_of?",
+  "kind_of?",
+  "is_a?",
+  "nil?",
+  "instance_variable_defined?",
+  "instance_variables",
+  "instance_variable_get",
+  "instance_variable_set",
+  "class_variables",
+  "class_variable_defined?",
+  "class_variable_get",
+  "class_variable_set",
+  "const_defined?",
+  "const_get",
+  "const_set",
+  "const_defined?",
+  "method_defined?",
+  "private_method_defined?",
+  "protected_method_defined?",
+  "singleton_method",
+  "define_singleton_method",
+  "to_s",
+  "to_i",
+  "to_f",
+  "to_a",
+  "to_h",
+  "to_proc",
+  "inspect",
+  "display",
+  "extend",
+  "include",
+  "prepend",
+  // Rails macros (emit properties, not call edges)
+  "has_many",
+  "belongs_to",
+  "has_one",
+  "has_and_belongs_to_many",
+  "scope",
+  "default_scope",
+  "validates",
+  "validate",
+  "validates_with",
+  "validates_each",
+  "before_action",
+  "after_action",
+  "before_filter",
+  "after_filter",
+  "before_validation",
+  "after_validation",
+  "before_save",
+  "after_save",
+  "before_create",
+  "after_create",
+  "before_update",
+  "after_update",
+  "before_destroy",
+  "after_destroy",
+  "before_commit",
+  "after_commit",
+  "after_rollback",
+  "attr_reader",
+  "attr_writer",
+  "attr_accessor",
+  "alias_method",
+  "remove_method",
+  "undef_method",
+  "delegate",
+  "delegate_missing_to",
+  "event",
+  "transition",
+  "state_machine",
+  "module_function",
+  "using",
+  // Module-level visibility MODIFIER METHODS. `private_constant :X` is not a
+  // keyword in this grammar — it is an ordinary `call` on Module — and it was
+  // missing from this list, so it published `calls <owner> -> private_constant`:
+  // an edge whose target is a stdlib method no project declares, which is the same
+  // shape as every other entry above and the reason they are here. Found by the
+  // oracle-agreement suite, whose negative case asserts the modifier is not a
+  // call: the oracle suppressed it (it lists both names among its visibility
+  // modifiers) and the analyzer did not, and the analyzer is the side whose
+  // suppression list IS the contract — `RUBY_BUILTINS` is a list of things the
+  // payload does not carry as call targets, not a judgement about Ruby.
+  //
+  // The DECLARATION side is not lost: `private_constant`'s effect on the export
+  // surface is read by `collectPrivateConstants`. So the pair is the same shape as
+  // `attr_reader` (declares a member, no call edge) and `module_function`
+  // (declares, no call edge). Measured on the corpus: 142 `private_constant` and
+  // 2 `public_constant` sites.
+  "private_constant",
+  "public_constant",
+  "ruby2_keywords",
+  "no_touching"
+]);
+function isRubyInstanceVariableWrite(node) {
+  const parent = node.parent;
+  if (!parent) return false;
+  if (parent.type === "assignment" || parent.type === "operator_assignment") {
+    const left = parent.childForFieldName("left");
+    if (!left || left.id !== node.id) return false;
+    return left.type !== "call" && left.type !== "element_reference";
+  }
+  if (parent.type === "left_assignment_list") {
+    const grand = parent.parent;
+    if (!grand || grand.type !== "assignment" && grand.type !== "operator_assignment") return false;
+    const left = grand.childForFieldName("left");
+    if (!left || left.id !== parent.id) return false;
+    const _nc1 = parent.namedChildCount;
+    for (let i = 0; i < _nc1; i++) {
+      const c = parent.namedChild(i);
+      if (c && c.id === node.id) return c.type !== "call" && c.type !== "element_reference";
+    }
+  }
+  return false;
+}
+function isRubyStaticSuperclassName(text) {
+  if (!text) return false;
+  const t = text.trim();
+  const isConstChar = (c) => {
+    const code = c.charCodeAt(0);
+    return code >= 65 && code <= 90;
+  };
+  const isNameChar = (c) => {
+    const code = c.charCodeAt(0);
+    return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57 || c === "_";
+  };
+  let i = 0;
+  const readConst = () => {
+    if (i >= t.length || !isConstChar(t[i])) return false;
+    i++;
+    while (i < t.length && isNameChar(t[i])) i++;
+    return true;
+  };
+  if (t.startsWith("::")) i = 2;
+  if (!readConst()) return false;
+  while (i < t.length) {
+    while (i < t.length && (t[i] === " " || t[i] === "	")) i++;
+    if (i >= t.length) break;
+    if (t[i] !== ":") return false;
+    if (t[i + 1] !== ":") return false;
+    i += 2;
+    while (i < t.length && (t[i] === " " || t[i] === "	")) i++;
+    if (!readConst()) return false;
+  }
+  return true;
+}
+function isRubyIdentifierShaped(name) {
+  if (!name) return false;
+  const isAlpha = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 95 || c === 36;
+  const isDigit = (c) => c >= 48 && c <= 57;
+  if (!isAlpha(name.charCodeAt(0))) return false;
+  for (let i = 1; i < name.length; i++) {
+    const c = name.charCodeAt(i);
+    if (!isAlpha(c) && !isDigit(c)) return false;
+  }
+  return true;
+}
+var RAILS_MACRO_METHODS = /* @__PURE__ */ new Set([
+  "has_many",
+  "belongs_to",
+  "has_one",
+  "has_and_belongs_to_many",
+  "scope",
+  "default_scope",
+  "validates",
+  "validate",
+  "validates_with",
+  "validates_each",
+  "attr_reader",
+  "attr_writer",
+  "attr_accessor",
+  "alias_method",
+  "remove_method",
+  "undef_method",
+  "delegate",
+  "delegate_missing_to",
+  "event",
+  "transition",
+  "before_action",
+  "after_action",
+  "before_validation",
+  "after_validation",
+  "before_save",
+  "after_save",
+  "before_create",
+  "after_create",
+  "before_update",
+  "after_update",
+  "before_destroy",
+  "after_destroy",
+  "before_commit",
+  "after_commit",
+  "after_rollback",
+  "define_method",
+  "module_function"
+]);
+var RealRubyAnalyzer = class {
+  analyze(rootNode, content, filePath, context) {
+    const symbols = [];
+    const imports = [];
+    const exports = [];
+    const relationships = [];
+    const metadata = {
+      detectedFrameworks: [],
+      frameworkPatterns: [],
+      cyclomaticComplexity: 1,
+      linesOfCode: 0
+    };
+    if (!rootNode) return { symbols, imports, errors: [] };
+    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: `Syntax ${n.type} detected.`,
+            range: this.nodeToRange(n),
+            severity: "warning"
+          });
+        }
+        for (let i = n.namedChildCount - 1; i >= 0; i--) {
+          const child = n.namedChild(i);
+          if (child) errStack.push(child);
+        }
+      }
+    }
+    let loc = 1;
+    for (let i = 0; i < content.length; i++) {
+      if (content[i] === "\n") loc++;
+    }
+    metadata.linesOfCode = loc;
+    const visibilityOverrides = /* @__PURE__ */ new Map();
+    const stack = [{
+      node: rootNode,
+      owner: void 0,
+      ownerKind: void 0,
+      visibility: "public",
+      isSingleton: false,
+      inSingletonClass: false
+    }];
+    while (stack.length > 0) {
+      const frame = stack.pop();
+      const { node, owner, ownerKind, visibility, isSingleton, anonBinding, inSingletonClass } = frame;
+      const type = node.type;
+      if (type === "class") {
+        const nameNode = node.childForFieldName("name");
+        if (!nameNode) continue;
+        const rawName = nameNode.text;
+        const { name, owner: effOwner } = rubyReopenIdentity(rawName, owner);
+        const sepIdx = rawName.lastIndexOf("::");
+        const superClass = this.extractSuperclass(node);
+        const isRailsModel = this.isRailsModelName(superClass);
+        const isRailsController = this.isRailsControllerName(superClass);
+        if (isRailsModel || isRailsController) {
+          this.recordFramework(metadata, RAILS_FRAMEWORK);
+        }
+        const sym = {
+          name,
+          kind: ASTEngine.SymbolKind.Class,
+          range: this.nodeToRange(node),
+          ownerName: effOwner,
+          metadata: {
+            superClass,
+            isRailsModel,
+            isRailsController,
+            // A class declared inside a `class << obj` body lands on that object's
+            // SINGLETON, so no consumer can reach it by name. The module branch
+            // below carries the same marker for the same reason, and the export
+            // pass reads it for both.
+            ...inSingletonClass ? { declaredInSingletonClass: true } : {},
+            // Full declaration path for reopen spellings (`Rake::NameSpace`)
+            // so consumers that want the lexical path can recover it even
+            // though the identity is leaf+owner (php-family precedent).
+            ...sepIdx >= 0 ? { fqn: rawName } : {}
+          }
+        };
+        symbols.push(sym);
+        if (superClass && this.isStaticSuperclassName(superClass)) {
+          const leaf = this.leafName(superClass);
+          relationships.push({
+            source: name,
+            target: leaf,
+            type: ASTEngine.RelationshipType.Extends,
+            confidence: 1,
+            // #825: the base type's own node, NOT the `superclass` node — that
+            // one starts at `<`, so a wrapped `class X <\n  Base` would stamp the
+            // edge one line above the type it names (measured, not assumed).
+            line_number: this.nodeLine(this.superclassTargetNode(node)),
+            metadata: {}
+          });
+        }
+        const body = this.findChild(node, "body_statement");
+        if (body) {
+          const bodyFrames = [];
+          let bodyVisibility = "public";
+          const _nc2 = body.namedChildCount;
+          for (let i = 0; i < _nc2; i++) {
+            const child = body.namedChild(i);
+            if (!child) continue;
+            bodyFrames.push({
+              node: child,
+              owner: name,
+              ownerKind: "class",
+              visibility: bodyVisibility,
+              isSingleton: false,
+              // A named class declared inside an anonymous block is a REAL
+              // class with a real name, so the anonymous binding does not
+              // carry into it.
+              anonBinding: void 0,
+              // Nor does a singleton-class scope: `class << obj; class K; end;
+              // end` declares K in the file, not on obj's singleton.
+              inSingletonClass: false
+            });
+            if (this.isNoArgumentVisibilityMarker(child)) {
+              bodyVisibility = child.text;
+            }
+          }
+          for (let i = bodyFrames.length - 1; i >= 0; i--) stack.push(bodyFrames[i]);
+        }
+        const superNode = this.findChild(node, "superclass");
+        if (superNode) {
+          const _nc3 = superNode.namedChildCount;
+          for (let i = 0; i < _nc3; i++) {
+            const sc = superNode.namedChild(i);
+            if (sc && sc.type === "call") {
+              stack.push({ node: sc, owner, ownerKind, visibility, isSingleton: false, inSingletonClass });
+            }
+          }
+        }
+        continue;
+      }
+      if (type === "module") {
+        const nameNode = node.childForFieldName("name");
+        if (!nameNode) continue;
+        const rawName = nameNode.text;
+        const { name, owner: effOwner } = rubyReopenIdentity(rawName, owner);
+        const sepIdx = rawName.lastIndexOf("::");
+        const sym = {
+          name,
+          kind: ASTEngine.SymbolKind.Module,
+          range: this.nodeToRange(node),
+          ownerName: effOwner,
+          metadata: {
+            ...sepIdx >= 0 ? { fqn: rawName } : {},
+            // A module declared inside a `class << obj` body lands on that object's
+            // singleton; the class branch above carries the same marker for the
+            // same reason.
+            ...inSingletonClass ? { declaredInSingletonClass: true } : {}
+          }
+        };
+        symbols.push(sym);
+        const body = this.findChild(node, "body_statement");
+        if (body) {
+          const bodyFrames = [];
+          let bodyVisibility = "public";
+          const _nc4 = body.namedChildCount;
+          for (let i = 0; i < _nc4; i++) {
+            const child = body.namedChild(i);
+            if (!child) continue;
+            bodyFrames.push({
+              node: child,
+              owner: name,
+              ownerKind: "module",
+              visibility: bodyVisibility,
+              isSingleton: false,
+              anonBinding: void 0,
+              inSingletonClass: false
+            });
+            if (this.isNoArgumentVisibilityMarker(child)) {
+              bodyVisibility = child.text;
+            }
+          }
+          for (let i = bodyFrames.length - 1; i >= 0; i--) stack.push(bodyFrames[i]);
+        }
+        continue;
+      }
+      if (type === "method") {
+        const nameNode = node.childForFieldName("name");
+        if (!nameNode) continue;
+        const name = nameNode.text;
+        const params = this.extractParameters(node);
+        const isTopLevel = !owner;
+        const sym = {
+          name,
+          kind: isTopLevel ? ASTEngine.SymbolKind.Function : ASTEngine.SymbolKind.Method,
+          range: this.nodeToRange(node),
+          ownerName: owner,
+          parameters: params,
+          visibility,
+          isStatic: isSingleton || void 0,
+          // Per-symbol cyclomatic complexity (managed-OO family contract —
+          // csharp #264 wave precedent). Mirrors the file-level counter's
+          // node set (if/unless/while/until/case/rescue/elsif), scoped to
+          // this method's subtree; base 1.
+          complexity: this.calculateNodeComplexity(node),
+          metadata: {
+            ...isSingleton ? { isSingleton: true } : {},
+            // Declares that `ownerName` is the LEXICAL owner, not the class
+            // this method actually belongs to: the method is defined in the
+            // block of an anonymous dynamic class bound to `anonBinding`.
+            ...anonBinding ? { anonymousScopeBinding: anonBinding } : {},
+            // ...and that the method belongs to ONE object's singleton, which is
+            // not the same statement: `ownerName` can be right while the method
+            // is still unreachable by any name from outside.
+            ...inSingletonClass ? { declaredInSingletonClass: true } : {}
+          }
+        };
+        symbols.push(sym);
+        const enclosingMethod = name;
+        const locals = new Set((params ?? []).map((p) => p.name));
+        for (const bound of this.extractParamDefaultBindings(node)) locals.add(bound);
+        this.walkMethodBody(
+          node,
+          this.findChild(node, "body_statement"),
+          symbols,
+          relationships,
+          imports,
+          metadata,
+          owner,
+          ownerKind,
+          enclosingMethod,
+          visibilityOverrides,
+          new Set(locals)
+        );
+        this.walkParamDefaults(
+          node,
+          symbols,
+          relationships,
+          imports,
+          metadata,
+          owner,
+          ownerKind,
+          enclosingMethod,
+          visibilityOverrides,
+          new Set(locals)
+        );
+        continue;
+      }
+      if (type === "singleton_class") {
+        const body = this.findChild(node, "body_statement");
+        if (body) {
+          const bodyFrames = [];
+          let bodyVisibility = "public";
+          const _nc5 = body.namedChildCount;
+          for (let i = 0; i < _nc5; i++) {
+            const child = body.namedChild(i);
+            if (!child) continue;
+            bodyFrames.push({
+              node: child,
+              owner,
+              ownerKind: "class",
+              visibility: bodyVisibility,
+              isSingleton: true,
+              anonBinding: void 0,
+              inSingletonClass: true
+            });
+            if (this.isNoArgumentVisibilityMarker(child)) bodyVisibility = child.text;
+          }
+          for (let i = bodyFrames.length - 1; i >= 0; i--) stack.push(bodyFrames[i]);
+        }
+        continue;
+      }
+      if (type === "singleton_method") {
+        const nameNode = node.childForFieldName("name");
+        if (!nameNode) continue;
+        const name = nameNode.text;
+        const params = this.extractParameters(node);
+        const isTopLevel = !owner;
+        const sym = {
+          name,
+          kind: isTopLevel ? ASTEngine.SymbolKind.Function : ASTEngine.SymbolKind.Method,
+          range: this.nodeToRange(node),
+          ownerName: owner,
+          parameters: params,
+          visibility,
+          isStatic: true,
+          // Per-symbol cyclomatic complexity (managed-OO family contract —
+          // csharp #264 wave precedent). Same node set as the file-level
+          // counter, scoped to this method's subtree; base 1.
+          complexity: this.calculateNodeComplexity(node),
+          metadata: {
+            isSingleton: true,
+            ...anonBinding ? { anonymousScopeBinding: anonBinding } : {},
+            ...inSingletonClass ? { declaredInSingletonClass: true } : {}
+          }
+        };
+        symbols.push(sym);
+        const locals = new Set((params ?? []).map((p) => p.name));
+        for (const bound of this.extractParamDefaultBindings(node)) locals.add(bound);
+        this.walkMethodBody(
+          node,
+          this.findChild(node, "body_statement"),
+          symbols,
+          relationships,
+          imports,
+          metadata,
+          owner,
+          ownerKind,
+          name,
+          visibilityOverrides,
+          new Set(locals)
+        );
+        const _nc6 = node.namedChildCount;
+        for (let i = 0; i < _nc6; i++) {
+          const c = node.namedChild(i);
+          if (!c || c.type !== "instance_variable") continue;
+          const nm = node.childForFieldName("name");
+          if (nm && c.id === nm.id) continue;
+          const p0 = node.namedChild(0);
+          if (p0 && c.id === p0.id && node.childForFieldName("name") == null) continue;
+          relationships.push({
+            source: name,
+            target: c.text,
+            type: ASTEngine.RelationshipType.Uses,
+            confidence: 0.9,
+            // #825: the member-read node names the edge.
+            line_number: this.nodeLine(c),
+            metadata: { memberRead: true }
+          });
+        }
+        this.walkParamDefaults(
+          node,
+          symbols,
+          relationships,
+          imports,
+          metadata,
+          owner,
+          ownerKind,
+          name,
+          visibilityOverrides,
+          new Set(locals)
+        );
+        continue;
+      }
+      if (type === "alias") {
+        const names = [];
+        const nameNodes = [];
+        let oldName;
+        for (let i = 0; i < node.namedChildCount && names.length < 2; i++) {
+          const c = node.namedChild(i);
+          if (!c) continue;
+          if (c.type === "identifier") {
+            names.push(c.text);
+            nameNodes.push(c);
+          } else if (c.type === "simple_symbol") {
+            const n = this.rubyNameFromLiteral(c);
+            if (n !== void 0 && n.length > 0) {
+              names.push(n);
+              nameNodes.push(c);
+            }
+          } else if (names.length === 1 && oldName === void 0) {
+            oldName = c.text;
+          }
+        }
+        if (names.length >= 1) {
+          relationships.push({
+            source: owner || FILE_SCOPE_OWNER,
+            target: names[0],
+            type: ASTEngine.RelationshipType.Calls,
+            confidence: 0.9,
+            line_number: this.nodeLine(nameNodes[0]),
+            metadata: { aliasedTo: names[1] ?? oldName ?? "", keywordAlias: true }
+          });
+        }
+        continue;
+      }
+      if (type === "identifier" && isRubyVisibilityDirectiveName(node.text)) {
+        continue;
+      }
+      if (type === "call") {
+        this.processCall(
+          node,
+          symbols,
+          relationships,
+          imports,
+          metadata,
+          owner,
+          void 0,
+          visibilityOverrides,
+          anonBinding
+        );
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) stack.push({ node: child, owner, ownerKind, visibility, isSingleton: false, anonBinding, inSingletonClass });
+        }
+        continue;
+      }
+      if (type === "program") {
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) stack.push({ node: child, owner, ownerKind, visibility, isSingleton: false, inSingletonClass });
+        }
+        continue;
+      }
+      if (type === "assignment" && (owner || this.isDynamicClassFactoryRhs(node))) {
+        const left = node.childForFieldName("left");
+        let factoryOwner;
+        let anonBindingForFrames = anonBinding;
+        if (left) {
+          const leftType = left.type;
+          if (leftType === "constant") {
+            const right = node.childForFieldName("right");
+            const factoryKind = right ? this.dynamicClassFactoryKind(right) : null;
+            if (factoryKind) {
+              symbols.push({
+                name: left.text,
+                kind: factoryKind === "Module" ? ASTEngine.SymbolKind.Module : ASTEngine.SymbolKind.Class,
+                range: this.nodeToRange(node),
+                ownerName: owner,
+                visibility,
+                metadata: { definedBy: factoryKind === "Module" ? "Module.new" : "classFactory" }
+              });
+              factoryOwner = left.text;
+              const factoryBaseNode = this.factorySuperclassNode(right);
+              const factoryBase = factoryBaseNode ? factoryBaseNode.text.trim() : void 0;
+              if (factoryBase && this.isStaticSuperclassName(factoryBase)) {
+                relationships.push({
+                  source: left.text,
+                  target: this.leafName(factoryBase),
+                  type: ASTEngine.RelationshipType.Extends,
+                  confidence: 1,
+                  // #825: the base type's own node names the edge, which is the
+                  // first argument of the factory call.
+                  line_number: this.nodeLine(factoryBaseNode),
+                  metadata: {
+                    // Both ends are WRITTEN — the constant on the left and the
+                    // constant in the call — so this is structural evidence with
+                    // no inferred name, unlike `instantiates`'
+                    // `resolvedTarget: "enclosing-class"`. What the edge ASSERTS is
+                    // `Class.new`'s documented meaning, which is Ruby rather than
+                    // this file, and there is no `superclass` clause on the line
+                    // for a reader to check; the mechanism is recorded so that is
+                    // visible rather than implied.
+                    definedBy: "Class.new"
+                  }
+                });
+              }
+            } else if (owner) {
+              symbols.push({
+                name: left.text,
+                kind: ASTEngine.SymbolKind.Constant,
+                range: this.nodeToRange(node),
+                ownerName: owner,
+                visibility,
+                metadata: { variableType: "constant" }
+              });
+            }
+          } else if (leftType === "identifier") {
+            const right = node.childForFieldName("right");
+            if (right && this.dynamicClassFactoryKind(right)) {
+              anonBindingForFrames = left.text;
+            }
+          }
+        }
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) stack.push({ node: child, owner: factoryOwner ?? owner, ownerKind, visibility, isSingleton: false, anonBinding: anonBindingForFrames, inSingletonClass });
+        }
+        continue;
+      }
+      if (type === "instance_variable") {
+        if (!isRubyInstanceVariableWrite(node)) {
+          relationships.push({
+            source: owner || FILE_SCOPE_OWNER,
+            target: node.text,
+            type: ASTEngine.RelationshipType.Uses,
+            confidence: 0.9,
+            // #825: the read node names the edge (top-level/DSL member read).
+            line_number: this.nodeLine(node),
+            metadata: { memberRead: true }
+          });
+        }
+      }
+      {
+        const childFrames = [];
+        for (let i = node.namedChildCount - 1; i >= 0; i--) {
+          const child = node.namedChild(i);
+          if (child) childFrames.push({ node: child, owner, ownerKind, visibility, isSingleton: false, anonBinding, inSingletonClass });
+        }
+        for (const cf of childFrames) stack.push(cf);
+      }
+    }
+    for (const symbol of symbols) {
+      if (!symbol.ownerName) continue;
+      const override = visibilityOverrides.get(`${symbol.ownerName}\0${symbol.name}`);
+      if (override) symbol.visibility = override;
+    }
+    const privateConstants = content.indexOf("private_constant") >= 0 ? this.collectPrivateConstants(rootNode) : /* @__PURE__ */ new Map();
+    const fileUnit = rubyFileUnitName(filePath);
+    const exportedNames = /* @__PURE__ */ new Set();
+    let exportDuplicate = 0;
+    let exportPrivateConstant = 0;
+    let exportUnnameable = 0;
+    let exportMainSingleton = 0;
+    let exportSingletonMember = 0;
+    for (const s of symbols) {
+      if (s.ownerName) continue;
+      if (s.kind !== ASTEngine.SymbolKind.Class && s.kind !== ASTEngine.SymbolKind.Module && s.kind !== ASTEngine.SymbolKind.Constant && s.kind !== ASTEngine.SymbolKind.Function) continue;
+      const name = String(s.name ?? "");
+      if (name.length === 0 || name.trim().length === 0 || name.indexOf("#{") >= 0) {
+        exportUnnameable++;
+        continue;
+      }
+      if (s.isStatic) {
+        exportMainSingleton++;
+        continue;
+      }
+      if (s.metadata?.declaredInSingletonClass === true) {
+        exportSingletonMember++;
+        continue;
+      }
+      const hidden = privateConstants.get(FILE_SCOPE_OWNER);
+      if (hidden?.has(name)) {
+        exportPrivateConstant++;
+        continue;
+      }
+      if (exportedNames.has(name)) {
+        exportDuplicate++;
+        continue;
+      }
+      exportedNames.add(name);
+      exports.push({
+        name,
+        type: "export_surface",
+        kind: s.kind,
+        range: s.range,
+        metadata: { unit: fileUnit, unitKind: "file", definedBy: s.metadata?.definedBy }
+      });
+      relationships.push({
+        source: fileUnit,
+        target: name,
+        type: ASTEngine.RelationshipType.Exports,
+        confidence: 1,
+        line_number: s.range?.startLine,
+        metadata: {
+          // The unit name comes from the PATH, not from a declaration in the
+          // file. Declared, so a consumer can tell an inferred unit from a
+          // written one — the same convention `instantiates` uses.
+          resolvedTarget: "file-unit",
+          exportKind: s.kind
+        }
+      });
+    }
+    metadata.exportsExcluded = {
+      duplicateReopen: exportDuplicate,
+      privateConstant: exportPrivateConstant,
+      unnameable: exportUnnameable,
+      mainSingleton: exportMainSingleton,
+      singletonMember: exportSingletonMember,
+      // Owned symbols are refused by RULE (the exports-family ruling), not by a
+      // filter that could drift, so this is a constant rather than a count. It is
+      // stated here so a reader does not have to infer it from the absence of a
+      // number.
+      memberByContains: "owned symbols are containment, not importable units"
+    };
+    const baseByClass = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (s.kind === ASTEngine.SymbolKind.Class && s.metadata?.superClass) {
+        const superText = String(s.metadata.superClass);
+        if (this.isStaticSuperclassName(superText)) {
+          baseByClass.set(s.name, this.leafName(superText));
+        }
+      }
+    }
+    const methodsByOwner = /* @__PURE__ */ new Map();
+    for (const s of symbols) {
+      if (s.kind !== ASTEngine.SymbolKind.Method || !s.ownerName) continue;
+      let names = methodsByOwner.get(s.ownerName);
+      if (!names) {
+        names = /* @__PURE__ */ new Set();
+        methodsByOwner.set(s.ownerName, names);
+      }
+      names.add(s.name);
+    }
+    for (const s of symbols) {
+      if (s.kind !== ASTEngine.SymbolKind.Method || !s.ownerName) continue;
+      const base = baseByClass.get(s.ownerName);
+      if (!base) continue;
+      const inFileMethods = base === s.ownerName ? void 0 : methodsByOwner.get(base);
+      const baseMethods = inFileMethods ?? context?.overrideCompanion?.get(base);
+      if (baseMethods?.has(s.name)) {
+        relationships.push({
+          source: `${s.ownerName}.${s.name}`,
+          target: `${base}.${s.name}`,
+          type: ASTEngine.RelationshipType.Overrides,
+          confidence: 0.95,
+          // #825: a symbol-named edge carries the SYMBOL's own declaration line,
+          // so the edge moves with its symbol.
+          line_number: s.range?.startLine,
+          metadata: { isOverride: true }
+        });
+      } else if (!inFileMethods && !context?.overrideCompanion?.get(base)) {
+        relationships.push({
+          source: `${s.ownerName}.${s.name}`,
+          target: `${base}.${s.name}`,
+          type: ASTEngine.RelationshipType.Overrides,
+          confidence: 0.5,
+          line_number: s.range?.startLine,
+          metadata: {
+            isOverride: true,
+            reasonCode: "first-parent-guess",
+            // THE REASON, ROUTED WHERE THE ARBITER READS IT.
+            //
+            // The lane has stated why since M37.10 — `reasonCode: "first-parent-guess"` — and the
+            // incoming gate never saw it: its declared-cause channel reads `baseBeyondRunScope`
+            // (`script/m14/incoming-rule.ts:274`), so `causeOK` is 0 fleet-wide and the residual
+            // reads as an unstated hole. The claim is the TRUE half of what this branch already
+            // knows: the base is not declared in this file AND the companion index gave no opinion
+            // (it is never populated in production, M37.10), so the run could not look. It is a
+            // claim about the RUN, not about the project, which is why the arbiter reads it only
+            // where the target names nothing and why it can never raise `resolved`.
+            //
+            // Three conditions, each of them the arbiter's own (`classifyEdge`):
+            //   · the value must be IDENTIFIER-SHAPED and must BE the target's owner, or the
+            //     claim is REFUTED (`causeFAIL`, counted against the lane, clause 4);
+            //   · `base === s.ownerName` is the leaf-collapse self-collision guard's case
+            //     (`class Rake::TestCase < Test::Unit::TestCase`): the run DID reach that
+            //     spelling — it is the class's own leaf — so "beyond this run's reach" would be
+            //     the wrong statement and that edge stays silent;
+            //   · it is MUTUALLY EXCLUSIVE with every external marker, by the arbiter's rule.
+            ...base !== s.ownerName && isRubyIdentifierShaped(base) ? { baseBeyondRunScope: base } : {}
+          }
+        });
+      }
+    }
+    for (const s of symbols) {
+      const _owner = s.ownerName;
+      if (_owner) {
+        relationships.push({
+          source: _owner,
+          target: s.name,
+          type: ASTEngine.RelationshipType.Contains,
+          confidence: 1,
+          line_number: s.range?.startLine,
+          metadata: {}
+        });
+      }
+    }
+    const containsPairs = /* @__PURE__ */ new Set();
+    for (const r of relationships) {
+      if (r.type === ASTEngine.RelationshipType.Contains) containsPairs.add(`${r.source}\0${r.target}`);
+    }
+    let exportDuplicateOfContains = 0;
+    for (const r of relationships) {
+      if (r.type === ASTEngine.RelationshipType.Exports && containsPairs.has(`${r.source}\0${r.target}`)) {
+        exportDuplicateOfContains++;
+      }
+    }
+    metadata.exportsOverlappingContains = exportDuplicateOfContains;
+    const indexFacts = this.applyProjectIndexFacts(relationships, context);
+    if (indexFacts !== void 0) metadata.projectIndex = indexFacts;
+    this.classifyEvidenceTier(relationships);
+    return {
+      symbols,
+      imports,
+      relationships,
+      exports,
+      metadata,
+      errors: metadata.errors || []
+    };
+  }
+  /**
+   * Walk a method's body: the body_statement when present, else (endless
+   * `def f = expr`) every direct child except the name and parameter nodes.
+   * Endless bodies are real executable code in the method's scope with its
+   * params bound — skipping them dropped all calls/reads inside.
+   */
+  walkMethodBody(node, body, symbols, relationships, imports, metadata, owner, ownerKind, enclosingMethod, visibilityOverrides, locals) {
+    if (body) {
+      this.walkBody(
+        body,
+        symbols,
+        relationships,
+        imports,
+        metadata,
+        owner,
+        ownerKind,
+        enclosingMethod,
+        visibilityOverrides,
+        locals
+      );
+      return;
+    }
+    const _nc7 = node.namedChildCount;
+    for (let i = 0; i < _nc7; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "method_parameters" || c.type === "block_parameters") continue;
+      const fld = node.childForFieldName?.("name");
+      if (fld && c.id === fld.id) continue;
+      if (c.type === "identifier" && i === 0) {
+        continue;
+      }
+      this.walkBody(
+        c,
+        symbols,
+        relationships,
+        imports,
+        metadata,
+        owner,
+        ownerKind,
+        enclosingMethod,
+        visibilityOverrides,
+        new Set(locals)
+      );
+    }
+  }
+  // ========================================================================
+  // BODY WALKER — processes statements inside a method/function body
+  // Handles: calls, require/require_relative, include/extend/prepend,
+  //          attr_*, define_method, alias_method, etc.
+  // ========================================================================
+  walkBody(node, symbols, relationships, imports, metadata, owner, ownerKind, enclosingMethod, visibilityOverrides, locals = /* @__PURE__ */ new Set()) {
+    const localNames = new Set(locals);
+    const scanStack = [node];
+    while (scanStack.length > 0) {
+      const sn = scanStack.pop();
+      if (sn.type === "unary") {
+        const op = sn.childCount > 0 ? sn.child(0) : null;
+        if (op && !op.isNamed && op.type === "defined?") continue;
+      }
+      if (sn.type === "assignment" || sn.type === "operator_assignment") {
+        const left = sn.childForFieldName("left") ?? sn.namedChild(0);
+        if (left) {
+          if (left.type === "identifier") {
+            localNames.add(left.text);
+          }
+          const _nc8 = left.namedChildCount;
+          for (let i = 0; i < _nc8; i++) {
+            const c = left.namedChild(i);
+            if (c?.type === "identifier") localNames.add(c.text);
+          }
+        }
+      }
+      if (sn.type === "method_parameters") {
+        const inner = [sn];
+        while (inner.length > 0) {
+          const q = inner.pop();
+          if (q.type === "identifier") localNames.add(q.text);
+          for (let j = 0; j < q.namedChildCount; j++) {
+            const d = q.namedChild(j);
+            if (d) inner.push(d);
+          }
+        }
+      }
+      if (sn.type === "block_parameters" || sn.type === "lambda_parameters") {
+        const _nc9 = sn.namedChildCount;
+        for (let i = 0; i < _nc9; i++) {
+          const c = sn.namedChild(i);
+          if (!c) continue;
+          if (c.type === "identifier") {
+            localNames.add(c.text);
+          } else if (c.type === "destructured_parameter") {
+            const inner = [c];
+            while (inner.length > 0) {
+              const q = inner.pop();
+              if (q.type === "identifier") localNames.add(q.text);
+              for (let j = 0; j < q.namedChildCount; j++) {
+                const d = q.namedChild(j);
+                if (d) inner.push(d);
+              }
+            }
+          } else {
+            const inner = [c];
+            while (inner.length > 0) {
+              const q = inner.pop();
+              if (q.type === "identifier") localNames.add(q.text);
+              for (let j = 0; j < q.namedChildCount; j++) {
+                const d = q.namedChild(j);
+                if (d) inner.push(d);
+              }
+            }
+          }
+        }
+      }
+      if (sn.type === "exception_variable") {
+        const _nc10 = sn.namedChildCount;
+        for (let i = 0; i < _nc10; i++) {
+          const c = sn.namedChild(i);
+          if (c?.type === "identifier") localNames.add(c.text);
+        }
+      }
+      if (sn.type === "array_pattern" || sn.type === "find_pattern" || sn.type === "as_pattern") {
+        const _nc11 = sn.namedChildCount;
+        for (let i = 0; i < _nc11; i++) {
+          const c = sn.namedChild(i);
+          if (!c) continue;
+          if (c.type === "identifier") {
+            localNames.add(c.text);
+          } else if (c.type === "splat_parameter") {
+            const nm = c.childForFieldName("name") ?? c.namedChild(0);
+            if (nm?.type === "identifier") localNames.add(nm.text);
+          }
+        }
+      } else if (sn.type === "keyword_pattern") {
+        const _nc12 = sn.namedChildCount;
+        for (let i = 0; i < _nc12; i++) {
+          const c = sn.namedChild(i);
+          if (!c) continue;
+          if (c.type === "identifier") localNames.add(c.text);
+          else if (c.type === "hash_key_symbol") localNames.add(this.stripSymbolColon(c.text));
+        }
+      } else if (sn.type === "in_clause") {
+        const first = sn.namedChild(0);
+        if (first?.type === "identifier") localNames.add(first.text);
+      }
+      for (let i = sn.namedChildCount - 1; i >= 0; i--) {
+        const child = sn.namedChild(i);
+        if (child) scanStack.push(child);
+      }
+    }
+    const anonRanges = [];
+    {
+      const scan = [node];
+      while (scan.length > 0) {
+        const c = scan.pop();
+        if (c.type === "assignment") {
+          const left = c.childForFieldName("left");
+          const right = c.childForFieldName("right");
+          if (left && left.type === "identifier" && right && this.dynamicClassFactoryKind(right)) {
+            anonRanges.push({ lo: right.startIndex, hi: right.endIndex, binding: left.text });
+          }
+        }
+        for (let j = 0; j < c.namedChildCount; j++) {
+          const d = c.namedChild(j);
+          if (d) scan.push(d);
+        }
+      }
+    }
+    anonRanges.sort((a, b) => a.hi - a.lo - (b.hi - b.lo));
+    const anonBindingAt = (startIndex) => {
+      for (const r of anonRanges) {
+        if (startIndex >= r.lo && startIndex <= r.hi) return r.binding;
+      }
+      return void 0;
+    };
+    const stack = [node];
+    while (stack.length > 0) {
+      const n = stack.pop();
+      const type = n.type;
+      if (type === "unary") {
+        const op = n.childCount > 0 ? n.child(0) : null;
+        if (op && !op.isNamed && op.type === "defined?") continue;
+      }
+      if (type === "call") {
+        this.processCall(
+          n,
+          symbols,
+          relationships,
+          imports,
+          metadata,
+          owner,
+          enclosingMethod,
+          visibilityOverrides,
+          anonBindingAt(n.startIndex)
+        );
+      }
+      if (type === "identifier") {
+        const parentType = n.parent?.type;
+        const nameField = parentType === "method" || parentType === "singleton_method" ? n.parent?.childForFieldName?.("name") ?? null : null;
+        const isDefName = nameField ? nameField.id === n.id : (parentType === "method" || parentType === "singleton_method") && n.parent.namedChild(0)?.id === n.id;
+        if (isDefName) continue;
+        if (!BARE_CALL_SKIP_PARENTS.has(parentType) && !localNames.has(n.text)) {
+          this.pushBareCall(n.text, n, owner, enclosingMethod, relationships);
+        }
+      }
+      if (type === "instance_variable") {
+        if (!isRubyInstanceVariableWrite(n)) {
+          const src = enclosingMethod || owner || FILE_SCOPE_OWNER;
+          relationships.push({
+            source: src,
+            target: n.text,
+            type: ASTEngine.RelationshipType.Uses,
+            confidence: 0.9,
+            line_number: this.nodeLine(n),
+            metadata: { memberRead: true }
+          });
+        }
+      }
+      if (type === "if" || type === "unless" || type === "while" || type === "until" || type === "case" || type === "rescue" || type === "elsif" || type === "if_modifier" || type === "unless_modifier" || type === "while_modifier" || type === "until_modifier" || type === "rescue_modifier") {
+        if (metadata.cyclomaticComplexity !== void 0) {
+          metadata.cyclomaticComplexity++;
+        }
+      }
+      if (type === "class_variable" || type === "global_variable") {
+        metadata.classAndGlobalVarsSkipped = (metadata.classAndGlobalVarsSkipped ?? 0) + 1;
+      }
+      if (type === "undef") continue;
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+  }
+  /**
+   * Names a method's PARAMETER DEFAULTS assign, which are locals of the method
+   * scope because Ruby evaluates a default expression in that scope.
+   *
+   * `def all(all_queries: (seen = true))` binds `seen`; a later
+   * `return nil if seen` reads a local, not a method. walkBody's pre-scan only
+   * ever saw the BODY subtree, so these names were unbound and every read of
+   * one became a fabricated bare call — measured on rails in
+   * activerecord/lib/active_record/scoping/named.rb:23, where the analyzer
+   * published `calls all -> all_queries_not_set` for a name the signature on
+   * line 22 itself binds.
+   *
+   * Only ASSIGNMENT targets are collected, and only from the VALUE position of
+   * an `optional_parameter` / `keyword_parameter` — a bare call in a default
+   * (`def f(lock = Mutex.new)`) is a real call and must stay one, so the value
+   * is scanned for what it BINDS and the call walk is left to walkParamDefaults.
+   * The left-hand side forms mirror the body pre-scan's: a plain identifier, and
+   * the identifiers under a `left_assignment_list` (tree-sitter-ruby has no
+   * `multiple_assignment` node, so `a, b = 1, 2` is one assignment whose left
+   * is a list).
+   */
+  extractParamDefaultBindings(node) {
+    const names = /* @__PURE__ */ new Set();
+    const paramsNode = this.findChild(node, "method_parameters") || this.findChild(node, "parameters");
+    if (!paramsNode) return names;
+    const _nc13 = paramsNode.namedChildCount;
+    for (let i = 0; i < _nc13; i++) {
+      const pc = paramsNode.namedChild(i);
+      if (!pc) continue;
+      if (pc.type !== "optional_parameter" && pc.type !== "keyword_parameter") continue;
+      if (pc.namedChildCount < 2) continue;
+      const stack = [];
+      for (let j = 1; j < pc.namedChildCount; j++) {
+        const c = pc.namedChild(j);
+        if (c) stack.push(c);
+      }
+      while (stack.length > 0) {
+        const n = stack.pop();
+        if (n.type === "assignment" || n.type === "operator_assignment") {
+          const left = n.childForFieldName("left") ?? n.namedChild(0);
+          if (left) {
+            if (left.type === "identifier") {
+              names.add(left.text);
+            } else {
+              for (let j = 0; j < left.namedChildCount; j++) {
+                const s = left.namedChild(j);
+                if (s && s.type === "identifier") names.add(s.text);
+              }
+            }
+          }
+        }
+        if (n.type === "do_block" || n.type === "block") continue;
+        for (let j = 0; j < n.namedChildCount; j++) {
+          const c = n.namedChild(j);
+          if (c) stack.push(c);
+        }
+      }
+    }
+    return names;
+  }
+  /**
+   * Walk the default-argument VALUE expressions of a method's parameters
+   * (`optional_parameter` `x = v`, `keyword_parameter` `k: v`) in the method's
+   * own scope. Ruby evaluates these at call time, so their calls, member
+   * reads and instantiations belong to the method — only the body was walked
+   * before, silently dropping `def f(app, lock = Lock.new)`-style call sites
+   * (RB-B, rack wave: mutex = Mutex.new, params = Rack::Utils.default_query_parser,
+   * app = @app). Mirrors the oracle truth, which walks parameter values.
+   */
+  walkParamDefaults(node, symbols, relationships, imports, metadata, owner, ownerKind, enclosingMethod, visibilityOverrides, locals) {
+    const paramsNode = this.findChild(node, "method_parameters") || this.findChild(node, "parameters");
+    if (!paramsNode) return;
+    const _nc14 = paramsNode.namedChildCount;
+    for (let i = 0; i < _nc14; i++) {
+      const pc = paramsNode.namedChild(i);
+      if (!pc) continue;
+      if (pc.type === "optional_parameter" || pc.type === "keyword_parameter") {
+        if (pc.namedChildCount >= 2) {
+          const value = pc.namedChild(pc.namedChildCount - 1);
+          if (value) {
+            this.walkBody(
+              value,
+              symbols,
+              relationships,
+              imports,
+              metadata,
+              owner,
+              ownerKind,
+              enclosingMethod,
+              visibilityOverrides,
+              locals
+            );
+          }
+        }
+      }
+    }
+  }
+  // ========================================================================
+  // LOAD FACTS — one `require`-family site, THREE surfaces
+  // ========================================================================
+  /**
+   * Everything a receiverless `require` / `require_relative` / `load` /
+   * `autoload` of a literal path states. One function because the four call
+   * sites this replaces were four copies of the same three pushes, and the
+   * `references`/`imports` PAIR is exactly the kind of thing that must not be
+   * half-applied: an earlier round of this file already lost a fix to a branch
+   * that claimed a rule "already existed" above the code that implemented it.
+   *
+   *   1. `ImportInfo` — the brain_import row. Reaches the file-dependency engine.
+   *   2. `references` — "this file mentions this path". Source is the declared
+   *      file-scope owner. Pinned by three committed fixtures; unchanged.
+   *   3. `imports` — "this file DEPENDS ON this path". The same target, a second
+   *      label, and the reason is not cosmetic:
+   *
+   *        - it is the label the dependency surfaces and `bb_graph`/`bb_impact`/
+   *          `bb_migrate` read. A graph query that narrows to `imports` sees
+   *          nothing for ruby today, so "ruby has no file dependencies" is
+   *          answerable from the graph and it is false.
+   *        - `metadata.fileLevel` is what makes the SOURCE bind to the importing
+   *          FILE: `parallel-indexer.ts` binds `source_external` to the
+   *          project-relative path when the source names no symbol and the edge
+   *          declares `fileLevel`. The `references` edge does not declare it, so
+   *          its source stays the scope sentinel and no surface can answer "what
+   *          does this file require".
+   *
+   *      bash emits the same pair for `source` (`isSourceImport` +
+   *      `isSourceDependency` on the same normalized path), so this is the family
+   *      precedent and not a ruby invention.
+   *
+   * The TARGET is the bare require path, not the `<path>:<item>` form the
+   * js/python/dart lanes use. That is a property of the language, not a choice:
+   * `require "json/parser"` names a FILE and Ruby has no syntax for requiring one
+   * member of it, so there is no item to write after a colon. The consequence is
+   * measured and declared: `import-resolution.ts` only considers `imports` rows
+   * whose target contains a `:`, so these rows reach the graph and the dependency
+   * engine but NOT that resolver. Inventing a `:*` suffix would buy admission to
+   * a pass that then refuses `*` by design ("namespace-star-no-single-target") —
+   * bytes and a target string that is not a path, for nothing.
+   */
+  pushLoadFacts(node, arg, cleanText, methodName, relationships, imports) {
+    if (cleanText.length === 0) return;
+    imports.push({
+      module: cleanText,
+      names: [],
+      range: this.nodeToRange(node),
+      isWildcard: true,
+      metadata: { requireMethod: methodName }
+    });
+    relationships.push({
+      // GAD2 twin (groovy wave, standing rule): the require edge's
+      // source used a hardcoded "root" while calls/uses/instan-
+      // tiates at the same top level use "Global" — two sentinels
+      // for one role in one file. Unified on "Global" (the pinned
+      // convention; no fixture ever pinned "root") — and now unified
+      // through FILE_SCOPE_OWNER, which is what made the SECOND
+      // divergent spelling ("unknown", four sites: alias,
+      // alias_method, mixin, association) visible at all.
+      source: FILE_SCOPE_OWNER,
+      target: cleanText,
+      type: ASTEngine.RelationshipType.References,
+      confidence: 0.9,
+      // #825: the required path's string node names the edge.
+      line_number: this.nodeLine(arg),
+      metadata: { requireMethod: methodName }
+    });
+    relationships.push({
+      source: FILE_SCOPE_OWNER,
+      target: cleanText,
+      type: ASTEngine.RelationshipType.Imports,
+      confidence: 1,
+      line_number: this.nodeLine(arg),
+      metadata: {
+        requireMethod: methodName,
+        // The importer is the FILE, not a scope — see the note above.
+        fileLevel: true,
+        // HOW the path is resolved, which is decidable per method and is the
+        // only classification that is a fact rather than a guess:
+        // `require_relative` is relative to the requiring file by definition, so
+        // its target is a path in the project; a bare `require` is resolved
+        // against `$LOAD_PATH`, which can name a gem OR a project file, so its
+        // target's location is unknown. `is_external` is therefore NOT set:
+        // parallel-indexer reads it to keep external packages out of internal
+        // resolution, and asserting `false` for a load-path require would be a
+        // claim this file cannot make.
+        resolution: methodName === "require_relative" ? "file-relative" : "load-path"
+      }
+    });
+  }
+  // ========================================================================
+  // CALL PROCESSOR — resolves a single `call` node
+  // ========================================================================
+  processCall(node, symbols, relationships, imports, metadata, owner, enclosingMethod, visibilityOverrides, anonBinding) {
+    const methodNode = node.childForFieldName("method");
+    if (!methodNode) return;
+    const methodName = methodNode.text;
+    if (!methodName) return;
+    let receiver;
+    let receiverLeaf;
+    let receiverNode = null;
+    let hasExpressionReceiver = false;
+    const _nc15 = node.namedChildCount;
+    for (let i = 0; i < _nc15; i++) {
+      const child = node.namedChild(i);
+      if (child && child.id === methodNode.id) break;
+      if (!child) continue;
+      if (child.type === "identifier" || child.type === "constant" || child.type === "scope_resolution") {
+        receiver = child.text;
+        receiverLeaf = this.leafName(child.text);
+        receiverNode = child;
+      } else if (VARIABLE_RECEIVER_TYPES.has(child.type)) {
+        receiver = child.text;
+        receiverNode = child;
+      } else if (child.type === "self") {
+      } else {
+        hasExpressionReceiver = true;
+      }
+    }
+    if (methodName === "private" || methodName === "protected" || methodName === "public") {
+      const args = this.findChild(node, "argument_list");
+      if (args && owner && args.namedChildCount > 0) {
+        const _nc16 = args.namedChildCount;
+        for (let i = 0; i < _nc16; i++) {
+          const arg = args.namedChild(i);
+          if (!arg || arg.type !== "simple_symbol") continue;
+          const targetName = this.stripSymbolColon(arg.text);
+          visibilityOverrides.set(`${owner}\0${targetName}`, methodName);
+        }
+      }
+      return;
+    }
+    if ((methodName === "require" || methodName === "require_relative" || methodName === "load") && !receiver && receiverNode === null && !hasExpressionReceiver) {
+      const args = this.findChild(node, "argument_list");
+      if (args) {
+        for (let i = 0; i < args.childCount; i++) {
+          const arg = args.child(i);
+          if (arg && arg.type === "string") {
+            const cleanText = this.stripQuotes(arg.text);
+            if (cleanText.indexOf("#{") >= 0) continue;
+            this.pushLoadFacts(node, arg, cleanText, methodName, relationships, imports);
+          }
+        }
+      }
+      return;
+    }
+    if (methodName === "autoload" && !receiver && receiverNode === null && !hasExpressionReceiver) {
+      const args = this.findChild(node, "argument_list");
+      if (args) {
+        for (let i = 0; i < args.childCount; i++) {
+          const arg = args.child(i);
+          if (arg && arg.type === "string") {
+            const cleanText = this.stripQuotes(arg.text);
+            if (cleanText.indexOf("#{") >= 0) continue;
+            this.pushLoadFacts(node, arg, cleanText, methodName, relationships, imports);
+          }
+        }
+      }
+      return;
+    }
+    if (methodName === "include" || methodName === "extend" || methodName === "prepend") {
+      const relType = ASTEngine.RelationshipType.MixesIn;
+      const args = this.findChild(node, "argument_list");
+      const selfKind = this.mixinSelfKind(node);
+      const hasExplicitReceiver = receiver !== void 0 || hasExpressionReceiver;
+      if (selfKind === "instance" || selfKind === "top" || hasExplicitReceiver) {
+        return;
+      }
+      if (!owner) {
+        return;
+      }
+      if (args) {
+        const _nc17 = args.namedChildCount;
+        for (let i = 0; i < _nc17; i++) {
+          const arg = args.namedChild(i);
+          if (arg && (arg.type === "constant" || arg.type === "scope_resolution")) {
+            const target = this.leafName(arg.text);
+            relationships.push({
+              source: owner || FILE_SCOPE_OWNER,
+              target,
+              type: relType,
+              confidence: 1,
+              // #825: the mixin CONSTANT's node names the edge.
+              line_number: this.nodeLine(arg),
+              metadata: { mixinType: methodName }
+            });
+          }
+        }
+      }
+      return;
+    }
+    if (methodName === "attr_reader" || methodName === "attr_writer" || methodName === "attr_accessor") {
+      const args = this.findChild(node, "argument_list");
+      if (args) {
+        const _nc18 = args.namedChildCount;
+        for (let i = 0; i < _nc18; i++) {
+          const arg = args.namedChild(i);
+          if (arg && (arg.type === "simple_symbol" || arg.type === "string")) {
+            const propName = this.rubyNameFromLiteral(arg);
+            if (propName === void 0 || propName.length === 0) continue;
+            symbols.push({
+              name: propName,
+              kind: ASTEngine.SymbolKind.Property,
+              range: this.nodeToRange(arg),
+              ownerName: owner,
+              visibility: "public",
+              metadata: { accessorType: methodName }
+            });
+          }
+        }
+      }
+      return;
+    }
+    if (methodName === "define_method") {
+      const args = this.findChild(node, "argument_list");
+      const nameArg = args && args.namedChildCount > 0 ? args.namedChild(0) : null;
+      if (nameArg && (nameArg.type === "simple_symbol" || nameArg.type === "string")) {
+        const name = this.rubyNameFromLiteral(nameArg);
+        if (name !== void 0 && name.length > 0 && name.indexOf("#{") < 0) {
+          symbols.push({
+            name,
+            kind: ASTEngine.SymbolKind.Method,
+            range: this.nodeToRange(nameArg),
+            ownerName: owner,
+            visibility: "public",
+            metadata: { isDynamicMethod: true }
+          });
+        }
+      }
+      return;
+    }
+    if (methodName === "alias_method") {
+      const args = this.findChild(node, "argument_list");
+      if (args) {
+        const names = [];
+        const argNodes = [];
+        for (let i = 0; i < args.namedChildCount && names.length < 2; i++) {
+          const arg = args.namedChild(i);
+          if (arg && arg.type === "simple_symbol") {
+            const n = this.rubyNameFromLiteral(arg);
+            if (n === void 0 || n.length === 0) continue;
+            names.push(n);
+            argNodes.push(arg);
+          }
+        }
+        if (names.length === 2) {
+          relationships.push({
+            source: owner || FILE_SCOPE_OWNER,
+            target: names[0],
+            type: ASTEngine.RelationshipType.Calls,
+            confidence: 0.9,
+            // #825: the `:new_name` argument's node names the edge.
+            line_number: this.nodeLine(argNodes[0]),
+            metadata: { aliasedTo: names[1] }
+          });
+        }
+      }
+      return;
+    }
+    if (methodName === "redirect_to" || methodName === "render" || methodName === "before_action" || methodName === "after_action") {
+      this.recordFramework(metadata, RAILS_FRAMEWORK);
+    }
+    if (methodName === "before_action" || methodName === "after_action") {
+      this.recordFramework(metadata, RAILS_FRAMEWORK, "Callbacks");
+    }
+    if (RAILS_MACRO_METHODS.has(methodName)) {
+      if (["has_many", "belongs_to", "has_one", "has_and_belongs_to_many"].includes(methodName)) {
+        const args = this.findChild(node, "argument_list");
+        if (args) {
+          const _nc20 = args.namedChildCount;
+          for (let i = 0; i < _nc20; i++) {
+            const arg = args.namedChild(i);
+            if (arg && (arg.type === "simple_symbol" || arg.type === "string")) {
+              const name = this.rubyNameFromLiteral(arg);
+              if (name === void 0 || name.length === 0) continue;
+              const anonMd = anonBinding ? { anonymousScopeBinding: anonBinding } : {};
+              symbols.push({
+                name,
+                kind: ASTEngine.SymbolKind.Property,
+                range: this.nodeToRange(arg),
+                ownerName: owner,
+                visibility: "public",
+                metadata: { associationType: methodName, ...anonMd }
+              });
+              relationships.push({
+                source: owner || FILE_SCOPE_OWNER,
+                target: name,
+                type: ASTEngine.RelationshipType.Uses,
+                confidence: 0.8,
+                // #825: the association's own argument node names the edge.
+                line_number: this.nodeLine(arg),
+                metadata: { activerecordMacro: methodName, ...anonMd }
+              });
+            }
+          }
+        }
+      } else if (methodName === "scope" || methodName === "default_scope") {
+        const args = this.findChild(node, "argument_list");
+        if (args && args.namedChildCount > 0) {
+          const firstArg = args.namedChild(0);
+          if (firstArg && firstArg.type === "simple_symbol") {
+            const scopeName = this.rubyNameFromLiteral(firstArg);
+            if (scopeName === void 0 || scopeName.length === 0) return;
+            symbols.push({
+              name: scopeName,
+              kind: ASTEngine.SymbolKind.Method,
+              range: this.nodeToRange(firstArg),
+              ownerName: owner,
+              visibility: "public",
+              metadata: { scopeType: methodName }
+            });
+          }
+        }
+      }
+      return;
+    }
+    if (RUBY_BUILTINS.has(methodName)) return;
+    if (methodName === "class" && receiver === "self") return;
+    const source = enclosingMethod || owner || FILE_SCOPE_OWNER;
+    if (methodName === "new") {
+      if (hasExpressionReceiver) return;
+      const target = receiverLeaf || (!receiver ? owner : void 0);
+      const firstChar = target?.charCodeAt(0) ?? 0;
+      if (target && (!receiverLeaf || firstChar >= 65 && firstChar <= 90)) {
+        relationships.push({
+          source,
+          target,
+          fromSymbol: source,
+          toSymbol: target,
+          type: ASTEngine.RelationshipType.Instantiates,
+          // #825: the constructed TYPE names the edge — its receiver node when
+          // there is one, else the call node itself (bare `new`).
+          line_number: this.nodeLine(receiverNode ?? node),
+          confidence: 0.9,
+          // When no receiver supplied the name, the target is the ENCLOSING
+          // class: Ruby's `self.new`, `self.class.new` and a receiverless `new`
+          // all construct the class they appear in. The line is the call site
+          // (correct), but the class name is IMPLIED rather than written there,
+          // so the inference is declared instead of left to look like a written
+          // name. The M59 oracle reads this marker to classify the claim as
+          // structurally uncheckable-by-token rather than as a failed claim.
+          metadata: receiverLeaf ? {} : { resolvedTarget: "enclosing-class" }
+        });
+        return;
+      }
+      if (!receiver && !owner) return;
+    }
+    const qualified = receiver ? `${receiver}.${methodName}` : methodName;
+    relationships.push({
+      source,
+      target: methodName,
+      fromSymbol: source,
+      toSymbol: qualified,
+      type: ASTEngine.RelationshipType.Calls,
+      confidence: 0.9,
+      // #825: the METHOD field's node, never the call node — a call node starts
+      // at its receiver, which is the line ABOVE the callee in `a.b.c` chains.
+      line_number: this.nodeLine(methodNode),
+      metadata: {}
+    });
+  }
+  /**
+   * Emit a calls relationship for a bare identifier used as a method call
+   * (tree-sitter-ruby parses `foo` with no receiver/args as an identifier).
+   * Mirrors processCall's regular-call tail: builtins are skipped and the
+   * same confidence/metadata shape is used so the graph stays consistent.
+   */
+  pushBareCall(name, nameNode, owner, enclosingMethod, relationships) {
+    if (RUBY_BUILTINS.has(name)) return;
+    if (name === "self" || name === "nil" || name === "true" || name === "false") return;
+    if (isRubyVisibilityDirectiveName(name)) return;
+    const firstChar = name.charCodeAt(0);
+    if (firstChar >= 65 && firstChar <= 90) return;
+    if (name.startsWith("__") && name.endsWith("__")) return;
+    const source = enclosingMethod || owner || FILE_SCOPE_OWNER;
+    relationships.push({
+      source,
+      target: name,
+      fromSymbol: source,
+      toSymbol: name,
+      type: ASTEngine.RelationshipType.Calls,
+      confidence: 0.9,
+      // #825: the identifier's own node names the bare call.
+      line_number: this.nodeLine(nameNode),
+      metadata: { bareCall: true }
+    });
+  }
+  // ========================================================================
+  // HELPERS
+  // ========================================================================
+  /**
+   * True when an `assignment` node's RHS is a dynamic class/module factory
+   * call (`Struct.new`, `Data.define`, `Class.new`, `Module.new`, possibly
+   * with blocks/args). Used to admit top-level factory assignments that
+   * the owner-gated constant rule would otherwise skip.
+   */
+  isDynamicClassFactoryRhs(node) {
+    const _nc21 = node.namedChildCount;
+    for (let i = 0; i < _nc21; i++) {
+      const c = node.namedChild(i);
+      if (!c) continue;
+      if (c.type === "call") {
+        if (this.dynamicClassFactoryKind(c)) return true;
+      }
+    }
+    return false;
+  }
+  /**
+  * The NAME a `simple_symbol` or `string` literal declares, or `undefined` when
+  * the analyzer cannot state it.
+  *
+  * ## Why this exists
+  *
+  * `stripQuotes` removes the OUTER quotes and stops there, so a Ruby escape inside
+  * the literal survives into the published name. Ruby's
+  * `define_method("test_safe_load_marshal String \"hello\" ivar")` defines a method
+  * whose name is `test_safe_load_marshal String "hello" ivar` — with a plain quote,
+  * no backslash — and the analyzer published the name with the backslash still in
+  * it. That name matches no method in the program, and it propagated: the symbol
+  * carried it, `contains` carried it, and `overrides` carried it again as
+  * `TestCase.<that name>`. Measured by the full-corpus R7 sweep: 19 distinct
+  * escaped names, 14 `contains` edges and 14 `overrides` edges with a quote in a
+  * target, every one in test/rubygems/test_gem_safe_marshal.rb — generated
+  * round-trip test methods, so the names are real but the escapes were not
+  * resolved.
+  *
+  * ## The escape set, and why it is closed
+  *
+  * The corpus says which escapes occur, and the inventory is four pairs:
+  *
+  *   \"  56      \\  21      \x  21      \u  1
+  *
+  * `\"`, `\\` and the single-character control escapes resolve to text a name can
+  * carry, so they are resolved here and the name is published correct. `\x` and
+  * `\u` are NOT resolved, and that is a decision rather than an omission: `\x61`
+  * is the BYTE 0x61 and `\u{3042}` is a non-ASCII character, so resolving them
+  * would publish a name built from raw bytes or a non-Latin script — a string that
+  * no consumer can bind and that the parallel-indexer's own name filters would
+  * then treat as garbage. A name this analyzer cannot state is not published,
+  * which is the same doctrine the `#{…}` template refusal above applies and the
+  * reason that refusal exists.
+  *
+  * So the rule is: resolve the escapes that yield a name, refuse the name when it
+  * carries an escape that does not. `\q` — an escape Ruby does not define at all
+  * — takes the same path, and returns `undefined` rather than passing the backslash
+  * through.
+  *
+  * ## Character scan, no pattern
+  *
+  * The escapes are matched by character code against a switch, and the scan walks
+  * the string once. A table keyed on a substring would be a lookup dressed as a
+  * parse; this reads the backslash, then the character it escapes, and decides on
+  * those two codes.
+  */
+  rubyNameFromLiteral(node) {
+    const raw = node.text;
+    let s = raw;
+    if (node.type === "string") {
+      s = this.stripQuotes(raw);
+    } else {
+      s = this.stripSymbolColon(raw);
+    }
+    if (s.indexOf("\\") < 0) return s;
+    let out = "";
+    for (let i = 0; i < s.length; i++) {
+      const c = s.charCodeAt(i);
+      if (c !== 92) {
+        out += s[i];
+        continue;
+      }
+      if (i + 1 >= s.length) return void 0;
+      const e = s[i + 1];
+      if (e === "\\" || e === '"' || e === "'" || e === "#") {
+        out += e;
+        i++;
+        continue;
+      }
+      if (e === "a") {
+        out += "\x07";
+        i++;
+        continue;
+      }
+      if (e === "b") {
+        out += "\b";
+        i++;
+        continue;
+      }
+      if (e === "e") {
+        out += "\x1B";
+        i++;
+        continue;
+      }
+      if (e === "f") {
+        out += "\f";
+        i++;
+        continue;
+      }
+      if (e === "n") {
+        out += "\n";
+        i++;
+        continue;
+      }
+      if (e === "r") {
+        out += "\r";
+        i++;
+        continue;
+      }
+      if (e === "s") {
+        out += " ";
+        i++;
+        continue;
+      }
+      if (e === "t") {
+        out += "	";
+        i++;
+        continue;
+      }
+      if (e === "v") {
+        out += "\v";
+        i++;
+        continue;
+      }
+      if (e === "0") {
+        out += "\0";
+        i++;
+        continue;
+      }
+      return void 0;
+    }
+    return out;
+  }
+  /**
+     * The node that NAMES the base of a `K = Class.new(Base)` factory, or null.
+     *
+     * Only `Class.new` counts, and only when the base is the FIRST argument and is
+     * written as a constant or a scope path. `Struct.new(:a, :b)` and
+     * `Data.define(:a, :b)` take member names there, not a superclass — neither
+     * class has a superclass parameter — so recognising them as a base would
+     * fabricate an `extends` edge against a symbol name. `Module.new` takes no
+     * argument at all, which the method check below also rules out.
+     *
+     * The RHS may wrap the call (`Class.new(Base) { … }.new`, which
+     * `dynamicClassFactoryKind` already recurses through), so the search for the
+     * `Class.new` head repeats the same bounded walk rather than assuming the call
+     * sits at the top. The recursion is bounded by the grammar: the inner node it
+     * recurses into must itself be a `.new` call whose own receiver is a constant.
+     */
+  factorySuperclassNode(rhs) {
+    if (!rhs) return null;
+    let callNode = rhs.type === "call" ? rhs : null;
+    if (!callNode) {
+      for (let i = 0; i < rhs.namedChildCount; i++) {
+        const c = rhs.namedChild(i);
+        if (c && c.type === "call") {
+          callNode = c;
+          break;
+        }
+      }
+    }
+    if (!callNode) return null;
+    const methodNode = callNode.childForFieldName("method");
+    if (!methodNode || methodNode.text !== "new") return null;
+    let receiver;
+    for (let i = 0; i < callNode.namedChildCount; i++) {
+      const c = callNode.namedChild(i);
+      if (!c) continue;
+      if (c.id === methodNode.id) break;
+      if (c.type === "constant" || c.type === "scope_resolution") {
+        receiver = c.text;
+        continue;
+      }
+      if (c.type === "call") return this.factorySuperclassNode(c);
+      return null;
+    }
+    if (receiver !== "Class") return null;
+    const args = this.findChild(callNode, "argument_list");
+    if (!args || args.namedChildCount === 0) return null;
+    const first = args.namedChild(0);
+    if (!first) return null;
+    if (first.type !== "constant" && first.type !== "scope_resolution") return null;
+    return first;
+  }
+  /**
+   * If `node` is a `X.new`/`X.define` call on a class-factory receiver,
+   * return "Class" (Struct/Data/Class) or "Module" (Module.new); else null.
+   * Receiver must be the bare constant (RHS of the assignment may wrap in
+   * blocks — only the call head matters).
+   */
+  dynamicClassFactoryKind(node) {
+    let callNode = node.type === "call" ? node : null;
+    if (!callNode) {
+      const _nc22 = node.namedChildCount;
+      for (let i = 0; i < _nc22; i++) {
+        const c = node.namedChild(i);
+        if (c && c.type === "call") {
+          callNode = c;
+          break;
+        }
+      }
+    }
+    if (!callNode) return null;
+    const methodNode = callNode.childForFieldName("method");
+    if (!methodNode) return null;
+    let methodName = methodNode.text;
+    let receiver;
+    const _nc23 = callNode.namedChildCount;
+    for (let i = 0; i < _nc23; i++) {
+      const child = callNode.namedChild(i);
+      if (child && child.id === methodNode.id) break;
+      if (!child) continue;
+      if (child.type === "constant" || child.type === "scope_resolution") {
+        receiver = child.text;
+      } else if (!receiver && child.type === "call" && (methodName === "new" || methodName === "define")) {
+        const inner = this.dynamicClassFactoryKind(child);
+        if (inner) return inner;
+      }
+    }
+    if (!receiver) return null;
+    if (methodName !== "new" && methodName !== "define") return null;
+    const leaf = receiver.split("::").filter(Boolean).pop() ?? receiver;
+    if (leaf === "Module" && methodName === "new") return "Module";
+    if ((leaf === "Struct" || leaf === "Data" || leaf === "Class") && (methodName === "new" || methodName === "define")) return "Class";
+    return null;
+  }
+  /**
+     * The constants a scope removes from its public surface with
+     * `private_constant :A, :B`, keyed by the OWNER NAME THE SYMBOL TABLE USES.
+     *
+     * Ruby's constant visibility has its own keyword and the method family does not,
+     * so the lexical `visibility` this file tracks for methods says nothing about a
+     * constant — a `private_constant :VERSION` member would otherwise be published
+     * as part of the export surface, which is precisely the members the language
+     * declares unexported. Measured on the corpus: 142 sites in 73 files.
+     *
+     * It is collected in its own walk rather than in `processCall` because it needs
+     * the ENCLOSING SCOPE, and threading a map through `walkBody` /
+     * `walkMethodBody` / `walkParamDefaults` / `processCall` — eight signatures and
+     * eight call sites — to carry one set is a large diff in a hot file for a small
+     * fact. The scope rule it needs is the same one the main walk uses, so it calls
+     * `rubyReopenIdentity` rather than restating it: a second copy of the reopen
+     * rule is exactly how the two existing copies came to disagree.
+     *
+     * Keyed by the same owner string the export pass reads off `ownerName`, and
+     * missing a scope costs a wrong edge, so the walk descends into every node type
+     * rather than only the ones a declaration can sit under.
+     */
+  collectPrivateConstants(root) {
+    const out = /* @__PURE__ */ new Map();
+    const stack = [{ node: root, owner: void 0 }];
+    while (stack.length > 0) {
+      const { node, owner } = stack.pop();
+      const type = node.type;
+      let nextOwner = owner;
+      if (type === "class" || type === "module" || type === "singleton_class") {
+        const nameNode = node.childForFieldName("name");
+        if (nameNode) nextOwner = rubyReopenIdentity(nameNode.text, owner).name;
+        if (type === "singleton_class") nextOwner = owner;
+      } else if (type === "call") {
+        const methodNode = node.childForFieldName("method");
+        if (methodNode?.text === "private_constant") {
+          const args = this.findChild(node, "argument_list");
+          if (args) {
+            const key = owner ?? FILE_SCOPE_OWNER;
+            let set = out.get(key);
+            if (!set) {
+              set = /* @__PURE__ */ new Set();
+              out.set(key, set);
+            }
+            for (let i = 0; i < args.namedChildCount; i++) {
+              const arg = args.namedChild(i);
+              if (!arg) continue;
+              if (arg.type === "simple_symbol" || arg.type === "string") {
+                const n = this.rubyNameFromLiteral(arg);
+                if (n !== void 0 && n.length > 0) set.add(n);
+              }
+            }
+          }
+        }
+      }
+      for (let i = node.namedChildCount - 1; i >= 0; i--) {
+        const child = node.namedChild(i);
+        if (child) stack.push({ node: child, owner: nextOwner });
+      }
+    }
+    return out;
+  }
+  /**
+   * Extract superclass from class node — pure char scan, no regex
+   */
+  /**
+   * The node that NAMES the base type of a `class X < Base` declaration: the
+   * first named child of the `superclass` node, i.e. `Base` as written. The
+   * `superclass` node itself begins at the `<` token, which sits on the previous
+   * line whenever the base is wrapped — so it is the wrong anchor for a line.
+   */
+  superclassTargetNode(node) {
+    const superNode = this.findChild(node, "superclass");
+    if (!superNode || superNode.namedChildCount === 0) return null;
+    return superNode.namedChild(0);
+  }
+  extractSuperclass(node) {
+    const superNode = this.findChild(node, "superclass");
+    if (!superNode) return void 0;
+    const target = this.superclassTargetNode(node);
+    if (target?.text) return target.text.trim();
+    const rawText = superNode.text;
+    let i = rawText.charCodeAt(0) === 60 ? 1 : 0;
+    while (i < rawText.length && isAsciiWhitespace(rawText.charCodeAt(i))) i++;
+    const text = rawText.substring(i).trim();
+    return text.length > 0 ? text : void 0;
+  }
+  /** Extract parameters from method node */
+  extractParameters(node) {
+    const params = this.findChild(node, "method_parameters") || this.findChild(node, "parameters");
+    if (!params) return void 0;
+    const result = [];
+    const _nc24 = params.namedChildCount;
+    for (let i = 0; i < _nc24; i++) {
+      const child = params.namedChild(i);
+      if (!child) continue;
+      const childType = child.type;
+      if (childType === "identifier") {
+        result.push({ name: child.text });
+      } else if (childType === "optional_parameter") {
+        const name = child.childForFieldName("name");
+        if (name) result.push({ name: name.text });
+      } else if (childType === "keyword_parameter" || childType === "keyword_rest") {
+        const name = child.childForFieldName("name");
+        if (name) result.push({ name: name.text });
+      } else if (childType === "splat_parameter" || childType === "hash_splat_parameter") {
+        const name = child.childForFieldName("name");
+        if (name) result.push({ name: name.text });
+      } else if (childType === "block_parameter") {
+        const name = child.childForFieldName("name") ?? child.namedChild(0);
+        if (name && name.type === "identifier") result.push({ name: name.text });
+      } else if (childType === "destructured_parameter") {
+        for (let j = 0; j < child.namedChildCount; j++) {
+          const sub = child.namedChild(j);
+          if (sub && sub.type === "identifier") {
+            result.push({ name: sub.text });
+          }
+        }
+      }
+    }
+    return result.length > 0 ? result : void 0;
+  }
+  /** Return true for a bare visibility directive that affects following methods. */
+  isNoArgumentVisibilityMarker(node) {
+    if (node.type === "identifier") {
+      return node.text === "private" || node.text === "protected" || node.text === "public";
+    }
+    if (node.type !== "call") return false;
+    const method = node.childForFieldName("method");
+    if (!method || method.text !== "private" && method.text !== "protected" && method.text !== "public") return false;
+    const args = this.findChild(node, "argument_list");
+    return !args || args.namedChildCount === 0;
+  }
+  /** Per-symbol cyclomatic complexity (managed-OO family contract —
+   * csharp #264 wave precedent). Mirrors the file-level counter's node set
+   * (if/unless/while/until/case/rescue/elsif PLUS the postfix *modifier
+   * forms), scoped to one method/function subtree; base 1.
+   *
+   * Postfix conditionals MUST count: `return false if amount <= 0` is a
+   * genuine branch — semantically identical to the block form, and the most
+   * idiomatic Ruby. tree-sitter-ruby emits a DISTINCT node type
+   * (if_modifier/unless_modifier/while_modifier/until_modifier/
+   * rescue_modifier) for postfix forms; before this fix the analyzer counted
+   * only the block forms, under-reporting every modifier-heavy method
+   * (verified: fixture authorize has 2 if_modifier + 1 while = complexity 4,
+   * previously pinned at the wrong value 2). */
+  calculateNodeComplexity(node) {
+    if (!node) return 1;
+    let complexity = 1;
+    const stack = [node];
+    let guard = 0;
+    while (stack.length > 0 && guard++ < 2e5) {
+      const n = stack.pop();
+      if (n.type === "if" || n.type === "unless" || n.type === "while" || n.type === "until" || n.type === "case" || n.type === "rescue" || n.type === "elsif" || n.type === "if_modifier" || n.type === "unless_modifier" || n.type === "while_modifier" || n.type === "until_modifier" || n.type === "rescue_modifier") {
+        complexity++;
+      }
+      for (let i = n.namedChildCount - 1; i >= 0; i--) {
+        const child = n.namedChild(i);
+        if (child) stack.push(child);
+      }
+    }
+    return complexity;
+  }
+  /**
+   * Evidence-tier classification — same rules as the swift/dart/csharp/objc
+   * family (see swift wave #266 for the full rationale).
+   */
+  /**
+   * PROJECT INDEX CONSUMPTION (task-22 phase 2) — facts, never fabrications.
+   *
+   * Behind `BB_RUBY_INDEX_CONSUME=1` ONLY, and FAIL-CLOSED: no context, no index, or `index.complete`
+   * not strictly true ⇒ touches nothing and the file's output is byte-identical to the pre-index run.
+   * What it does, in the pre-committed shape of the phase-1 sizing (4,611-row bound):
+   *   · overrides — VERIFY the first-parent guess: base type declared AND the base declares the member
+   *     (`typeKinds` + `typeMembers`, NOT counts) ⇒ `metadata.projectIndexVerified`/`ownerEvidence`,
+   *     confidence raised to structural; otherwise DECLINED with a reason (the 102 none-base rows stay
+   *     declared causes, they are not overwritten).
+   *   · instantiates/extends/mixes_in — a static constant path that the index declares gets
+   *     `metadata.projectIndexDeclared` (module existence is all mixes_in needs; typeBases is not read).
+   *   · calls — NOT TOUCHED. Name-only binding would bind decoys (the ruby D4 lesson); ruby has no
+   *     static receiver typing, so the index may not manufacture a call binding.
+   * Declined rows are COUNTED BY REASON in `metadata.projectIndex.declined`, never merged into a result.
+   */
+  applyProjectIndexFacts(relationships, context) {
+    if (process.env.BB_RUBY_INDEX_CONSUME !== "1") return void 0;
+    const index = context?.projectIndex;
+    if (!index || index.complete !== true) return void 0;
+    const leafOf = (name) => {
+      const at = name.lastIndexOf("::");
+      return at >= 0 ? name.slice(at + 2) : name;
+    };
+    const hasType = (name) => index.typeKinds.has(name) || index.typeKinds.has(leafOf(name));
+    const membersOf = (name) => index.typeMembers.get(name) ?? index.typeMembers.get(leafOf(name));
+    let verifiedOverrides = 0;
+    let declaredTargets = 0;
+    const declined = {};
+    const decline = (reason) => {
+      declined[reason] = (declined[reason] ?? 0) + 1;
+    };
+    for (const r of relationships) {
+      const type = String(r.type ?? "");
+      const md = r.metadata ??= {};
+      if (type === "overrides") {
+        const target = String(r.target ?? "");
+        const dot = target.lastIndexOf(".");
+        if (dot <= 0) {
+          decline("overrideTargetUnnameable");
+          continue;
+        }
+        const base = target.slice(0, dot);
+        const method = target.slice(dot + 1);
+        if (!hasType(base)) {
+          decline("baseNotDeclared");
+          continue;
+        }
+        const members = membersOf(base);
+        if (!members || !members.has(method)) {
+          decline("memberNotOnBase");
+          continue;
+        }
+        md.projectIndexVerified = true;
+        md.ownerEvidence = "projectIndex";
+        r.confidence = Math.max(r.confidence ?? 0, 0.95);
+        verifiedOverrides++;
+      } else if (type === "instantiates" || type === "extends" || type === "mixes_in") {
+        if (!hasType(String(r.target ?? ""))) {
+          decline(`${type}:typeNotDeclared`);
+          continue;
+        }
+        md.projectIndexDeclared = true;
+        declaredTargets++;
+      }
+    }
+    return {
+      complete: true,
+      verifiedOverrides,
+      declaredTargets,
+      callsUntouched: true,
+      declined
+    };
+  }
+  classifyEvidenceTier(relationships) {
+    for (const r of relationships) {
+      const type = r.type ?? r.relationshipType ?? "";
+      const md = r.metadata ?? {};
+      if (type === "contains") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (type === "imports" || type === "references") {
+        md.evidenceClass = "import_based";
+        continue;
+      }
+      if (type === "exports") {
+        md.evidenceClass = "structural";
+        continue;
+      }
+      if (type === "calls" || type === "uses") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.85 ? "usage_contextual" : "inferred";
+        continue;
+      }
+      if (type === "instantiates" || type === "extends" || type === "implements" || type === "mixes_in") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.9 ? "structural" : "inferred";
+        continue;
+      }
+      if (type === "overrides") {
+        md.evidenceClass = (r.confidence ?? 0) >= 0.9 ? "structural" : "inferred";
+        continue;
+      }
+      md.evidenceClass = "usage_contextual";
+    }
+  }
+  /**
+   * THE STATIC SELF-TYPE AT A CALL SITE — ruby's analogue of dart's "declared return type".
+   *
+   * `include`, `extend` and `prepend` are Module's methods, so a call with one of those names
+   * composes a mixin into the ENCLOSING CLASS only if `self` IS that class at that point. The
+   * static self-type is a NODE-TYPE question, never a name question:
+   *
+   *   · a class / module / `class << self` body   → "class"     (`self` IS the class)
+   *   · a `Class.new { }` / `Module.new { }` block → "class"     (the block is class_eval'd, so
+   *     `self` is the NEW class whatever encloses it lexically — and the enclosing call is the
+   *     block's PARENT, because the block node's own first child is the first statement of its body)
+   *   · a `singleton_method` node (`def self.x`, `def x.y`) → "class"  (`self` IS the class)
+   *   · a plain `method` node (`def x`)            → "instance"  (`self` IS an INSTANCE)
+   *   · nothing enclosing it                        → "top"       (`self` IS `main`)
+   *
+   * ⇒ MEASURED over the whole admitted population (989 files): of the 543 published `mixes_in` rows,
+   * 416 sit where `self` is the class, 29 in a singleton method, 18 in a plain instance method, and
+   * 80 at the file's top level. **⇒ THE LAST TWO CLASSES ARE IMPOSTORS: 127 rows, 23.4 %.** The 80
+   * top-level rows are RSpec's example-group `include` — the same NAME, a different construct.
+   */
+  mixinSelfKind(node) {
+    let cur = node.parent ?? null;
+    while (cur) {
+      if (cur.type === "method") return "instance";
+      if (cur.type === "singleton_method") return "singleton";
+      if (cur.type === "class" || cur.type === "module" || cur.type === "singleton_class") return "class";
+      if (cur.type === "do_block" || cur.type === "block") {
+        const p = cur.parent;
+        if (p && p.type === "call") {
+          const recv = p.childForFieldName?.("receiver");
+          const meth = p.childForFieldName?.("method");
+          const rt = recv ? recv.text : "";
+          const mt = meth ? meth.text : "";
+          if ((rt === "Class" || rt === "Module") && mt === "new") return "class";
+        }
+      }
+      cur = cur.parent ?? null;
+    }
+    return "top";
+  }
+  findChild(node, type) {
+    const _nc25 = node.namedChildCount;
+    for (let i = 0; i < _nc25; i++) {
+      const child = node.namedChild(i);
+      if (child && child.type === type) return child;
+    }
+    return null;
+  }
+  /** Strip leading ': ' from symbol text — pure char scan */
+  /**
+   * Record a detected framework EXACTLY ONCE, and publish the primary pick (#749).
+   *
+   * Both accumulators are arrays published into the graph, and every caller runs once
+   * per class and once per call, so a bare `.push` published one entry per trigger hit:
+   * measured, `["Ruby on Rails", "Ruby on Rails", …]` five times on a five-model file
+   * and three times on `rack/test.rb`. `metadata.framework` — the contract's
+   * deterministic primary pick — was published for nothing at all, so every file that
+   * DID detect Rails read as framework-less downstream.
+   */
+  recordFramework(metadata, name, pattern) {
+    const detected = metadata.detectedFrameworks ??= [];
+    if (!detected.includes(name)) detected.push(name);
+    metadata.framework ??= name;
+    if (!pattern) return;
+    const patterns = metadata.frameworkPatterns ??= [];
+    if (!patterns.some((p) => p.framework === name)) patterns.push({ framework: name, patterns: [pattern] });
+  }
+  stripSymbolColon(text) {
+    let start = 0;
+    while (start < text.length && text[start] === ":") start++;
+    return start < text.length ? text.substring(start) : text;
+  }
+  /** Strip surrounding quotes — pure char scan */
+  stripQuotes(text) {
+    if (text.length >= 2) {
+      const first = text.charCodeAt(0);
+      const last = text.charCodeAt(text.length - 1);
+      if (first === 34 && last === 34 || first === 39 && last === 39) {
+        return text.substring(1, text.length - 1);
+      }
+    }
+    return text;
+  }
+  /** Extract the leaf name from a possibly-qualified name like A::B */
+  leafName(name) {
+    const idx = name.lastIndexOf("::");
+    return idx >= 0 ? name.substring(idx + 2) : name;
+  }
+  isStaticSuperclassName(text) {
+    return isRubyStaticSuperclassName(text);
+  }
+  isRailsModelName(superClass) {
+    if (!superClass) return false;
+    const leaf = this.leafName(superClass);
+    return leaf === "Base" && superClass.includes("ActiveRecord") || leaf === "ApplicationRecord";
+  }
+  isRailsControllerName(superClass) {
+    if (!superClass) return false;
+    const leaf = this.leafName(superClass);
+    return leaf === "Base" && superClass.includes("ActionController") || leaf === "ApplicationController";
+  }
+  /**
+   * M59.A7 (#825): the 1-based line of the node that NAMES an edge's target.
+   *
+   * The contract is the family's, not this file's: a relationship's `line_number`
+   * is the line where the TARGET is written — the callee for a call, the read for
+   * a member use, the constructed type for an instantiation, the symbol's own
+   * declaration for contains/overrides. It is checked independently by
+   * script/m59/oracle-callsite.ts, which re-derives every edge from the tree and
+   * requires the target token to appear on the claimed line.
+   *
+   * Two shapes are traps and both were measured on the python lane first:
+   *   * a call's node starts at its RECEIVER, so `items.strip.upper` stamped the
+   *     whole call on the `items` line — hence the method field's node below,
+   *     which in this grammar IS the leaf that names the callee;
+   *   * `undefined` is a first-class answer. A node that does not exist (a dynamic
+   *     mixin, a computed callee) contributes NO line rather than a fabricated 0,
+   *     which is the rule `0 means unknown and unknown must be absent` (#820/#821)
+   *     applied to this field.
+   */
+  nodeLine(node) {
+    if (!node) return void 0;
+    return node.startPosition.row + 1;
+  }
+  nodeToRange(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column + 1,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column + 1,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+};
+export {
+  RAILS_MACRO_METHODS,
+  RUBY_BUILTINS,
+  RealRubyAnalyzer,
+  isRubyIdentifierShaped,
+  isRubyInstanceVariableWrite,
+  isRubyStaticSuperclassName
+};