@suss/adapter-ruby 0.29.0 → 0.30.0

package/dist/index.js

@@ -63,7 +63,52 @@ var OWN_BODY_TYPES = /* @__PURE__ */ new Set([
   "singleton_class"
 ]);
 var NESTING_TYPES = /* @__PURE__ */ new Set(["class", "module"]);
+var INCLUDE_CALL = "include";
+var PREPEND_CALL = "prepend";
 var ARGUMENT_LIST_TYPE = "argument_list";
+var BLOCK_TYPES = /* @__PURE__ */ new Set(["block", "do_block"]);
+var NO_BODY_BLOCKS = /* @__PURE__ */ new Map();
+function isModuleBody(body) {
+  return body.parent?.type === "module";
+}
+function declaredBlockAt(statement, isModule, blocks) {
+  if (statement.type !== "call" || field(statement, "receiver") !== null) {
+    return null;
+  }
+  const method = field(statement, "method");
+  const kind = method === null ? void 0 : blocks.get(method.text);
+  if (kind === void 0 || kind.moduleOnly && !isModule) {
+    return null;
+  }
+  return field(statement, "block") === null ? null : kind;
+}
+function bodyStatementsRun(body, isModule, blocks) {
+  return bodyStatements(body).flatMap((statement) => {
+    if (declaredBlockAt(statement, isModule, blocks) === null) {
+      return [statement];
+    }
+    const block = field(statement, "block");
+    const inner = block === null ? null : field(block, "body");
+    return inner === null ? [] : bodyStatementsRun(inner, isModule, blocks);
+  });
+}
+function definedAtClassLevel(node, body, blocks) {
+  if (blocks.size === 0) {
+    return false;
+  }
+  const isModule = isModuleBody(body);
+  let current = node.parent;
+  while (current !== null && current.id !== body.id) {
+    const parent = current.parent;
+    if (BLOCK_TYPES.has(current.type) && parent !== null) {
+      if (declaredBlockAt(parent, isModule, blocks)?.definesClassMethods) {
+        return true;
+      }
+    }
+    current = parent;
+  }
+  return false;
+}
 function runStatements(body, blockConfigures = () => false) {
   const found = [];
   const readsItsChildren = (node) => {
@@ -99,10 +144,10 @@ function stringLiteralValue(node) {
 function symbolValue(node) {
   return node.type === "simple_symbol" ? node.text.slice(1) : null;
 }
-function instanceMethodsByName(body) {
+function instanceMethodsByName(body, blocks = NO_BODY_BLOCKS) {
   const methods = /* @__PURE__ */ new Map();
   for (const stmt of runStatements(body)) {
-    if (stmt.type !== "method") {
+    if (stmt.type !== "method" || definedAtClassLevel(stmt, body, blocks)) {
       continue;
     }
     const name = field(stmt, "name")?.text;
@@ -164,10 +209,11 @@ function instanceMethodVisibility(body) {
   }
   return visibility;
 }
-function singletonMethodsByName(body) {
+function singletonMethodsByName(body, blocks = NO_BODY_BLOCKS) {
   const methods = /* @__PURE__ */ new Map();
   for (const stmt of runStatements(body)) {
-    if (stmt.type !== "singleton_method") {
+    const classLevel = stmt.type === "method" && definedAtClassLevel(stmt, body, blocks);
+    if (stmt.type !== "singleton_method" && !classLevel) {
       continue;
     }
     const name = field(stmt, "name")?.text;
@@ -280,7 +326,8 @@ function autoloadDirectories(root) {
 }
 
 // src/defineMethod.ts
-import { force as force2, literalOf as literalOf2 } from "@suss/values";
+import { nodeOfKey as nodeOfKey2 } from "@suss/resolution";
+import { force as force2, hole as hole2, literalOf as literalOf2, piecesOf } from "@suss/values";
 
 // src/values/evaluator.ts
 import { nodeOfKey } from "@suss/resolution";
@@ -321,6 +368,29 @@ var RUBY_RULES = [
       lit("givesBackOne", v("n"), v("m"))
     ],
     "declared finder"
+  ),
+  // Ruby cannot refer to a method without running it, so
+  // `Settings.filters` is worth what the method returns. The shared
+  // rules hang that step on a `call` fact this spelling never gets.
+  rule(
+    "invokes",
+    [v("x"), v("f")],
+    [
+      lit("readsProperty", v("x"), v("o"), v("m")),
+      lit("comesTo", v("x"), v("f")),
+      lit("func", v("f"))
+    ],
+    "property read runs a method"
+  ),
+  // `%i[a b].freeze` is worth the list it was written as. The evaluator
+  // says the same in its row table, for a value it reads in one file.
+  ...["freeze", "dup"].map(
+    (method) => rule(
+      "stepsTo",
+      [v("x"), v("o"), VALUE_STEP],
+      [lit("readsProperty", v("x"), v("o"), constant(method))],
+      "hands back the receiver"
+    )
   )
 ];
 var RUBY_PROGRAM = resolutionProgram(RUBY_RULES);
@@ -340,8 +410,8 @@ import { startsAtName, valueLeftByWrites } from "@suss/resolution";
 
 // src/facts/locals.ts
 import { writesRunInOrder } from "@suss/resolution";
-var BLOCK_TYPES = /* @__PURE__ */ new Set(["block", "do_block"]);
-var LATER_BODY_TYPES = /* @__PURE__ */ new Set([...OWN_BODY_TYPES, ...BLOCK_TYPES]);
+var BLOCK_TYPES2 = /* @__PURE__ */ new Set(["block", "do_block"]);
+var LATER_BODY_TYPES = /* @__PURE__ */ new Set([...OWN_BODY_TYPES, ...BLOCK_TYPES2]);
 var RUBY_NAME_TYPES = /* @__PURE__ */ new Set([
   "identifier",
   "instance_variable"
@@ -494,7 +564,7 @@ function ownerOfName(node, name, enclosing) {
 function blockDeclaring(node, name) {
   let current = node.parent;
   while (current !== null) {
-    if (BLOCK_TYPES.has(current.type) && parameterNames(current).has(name)) {
+    if (BLOCK_TYPES2.has(current.type) && parameterNames(current).has(name)) {
       return current;
     }
     if (OWN_BODY_TYPES.has(current.type)) {
@@ -744,17 +814,70 @@ function emitHash(emitter, hash) {
     add(emitter, "holdsProperty", objectKey, keyText, valueKey(emitter, value));
   }
 }
-function walkExpressions(node, visit) {
+var BLOCK_TYPES3 = /* @__PURE__ */ new Set(["block", "do_block"]);
+var LOOP_METHODS = /* @__PURE__ */ new Set(["each", "each_with_index", "map"]);
+var DEFINE_METHOD_CALL = "define_method";
+function loopTurnAt(emitter, block) {
+  const call = block.parent;
+  if (call?.type !== "call") {
+    return null;
+  }
+  const receiver = field(call, "receiver");
+  const method = field(call, "method");
+  if (receiver === null || method === null || !LOOP_METHODS.has(method.text)) {
+    return null;
+  }
+  const parameters = field(block, "parameters");
+  const names = parameters === null ? [] : children(parameters).map((p) => p.text);
+  const element = names[0];
+  if (element === void 0) {
+    return null;
+  }
+  return {
+    element,
+    index: names[1] ?? "",
+    overKey: nodeId(emitter.filePath, receiver)
+  };
+}
+function emitDynamicDefinition(emitter, call, turns) {
+  if (emitter.selfKey === null || // A call inside a method runs when that method does, not at load time.
+  emitter.enclosing !== null || call.type !== "call" || field(call, "receiver") !== null || field(call, "method")?.text !== DEFINE_METHOD_CALL) {
+    return;
+  }
+  const args = field(call, "arguments");
+  const first = args === null ? void 0 : children(args)[0];
+  const nameKey2 = nodeId(emitter.filePath, first ?? call);
+  add(emitter, "definesMethodFrom", emitter.selfKey, nameKey2);
+  for (const turn of turns) {
+    add(
+      emitter,
+      "nameTurnsOn",
+      nameKey2,
+      turn.element,
+      turn.index,
+      turn.overKey
+    );
+  }
+}
+function walkExpressions(node, emitter, visit, turns = []) {
   for (const child of children(node)) {
     if (OWN_BODY_TYPES.has(child.type)) {
       continue;
     }
-    visit(child);
-    walkExpressions(child, visit);
+    visit(child, turns);
+    const opened = BLOCK_TYPES3.has(child.type) ? loopTurnAt(emitter, child) : null;
+    walkExpressions(
+      child,
+      emitter,
+      visit,
+      opened === null ? turns : [...turns, opened]
+    );
   }
 }
 function emitExpressionFacts(emitter, node) {
-  walkExpressions(node, (child) => {
+  emitDynamicDefinition(emitter, node, []);
+  walkExpressions(node, emitter, (child, turns) => {
+    emitDynamicDefinition(emitter, child, turns);
     if (isPropertyRead(child)) {
       emitPropertyRead(emitter, child);
     } else if (child.type === "call") {
@@ -843,7 +966,20 @@ function implicitReturn(body) {
     (child) => child.type !== "rescue" && child.type !== "ensure"
   );
   const last = statements[statements.length - 1];
-  return last === void 0 || last.type === "return" ? null : last;
+  if (last === void 0 || last.type === "return") {
+    return null;
+  }
+  return assignedValueOf(last) ?? last;
+}
+function assignedValueOf(node) {
+  if (!ASSIGNMENT_TYPES.has(node.type)) {
+    return null;
+  }
+  const operator = field(node, "operator")?.text;
+  if (node.type !== "assignment" && !WHOLE_VALUE_OPERATORS.has(operator ?? "")) {
+    return null;
+  }
+  return field(node, "right");
 }
 function emitMethodFacts(emitter, method) {
   const funcKey = nodeId(emitter.filePath, method);
@@ -873,7 +1009,7 @@ function emitMethodFacts(emitter, method) {
     }
   };
   recordNested(body);
-  walkExpressions(body, (child) => {
+  walkExpressions(body, inside, (child) => {
     if (child.type === "return") {
       const first = children(child)[0];
       const returned = first?.type === "argument_list" ? children(first)[0] : first;
@@ -963,23 +1099,37 @@ function emitCandidates(emitter, key, group) {
   }
 }
 var METHOD_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method"]);
+var CONSTANT_REF_TYPES = /* @__PURE__ */ new Set(["constant", "scope_resolution"]);
+function mixedInConstants(body, callName) {
+  return bareCallArgumentGroups(body, callName).flatMap((group) => [...group].reverse()).reverse().map(readThrough).filter((argument) => CONSTANT_REF_TYPES.has(argument.type));
+}
+function emitMixinFacts(emitter, classKey, body, callName) {
+  for (const mixin of mixedInConstants(body, callName)) {
+    add(emitter, "extends", classKey, valueKey(emitter, mixin));
+  }
+}
 function emitClassFacts(emitter, cls) {
   const classKey = nodeId(emitter.filePath, cls);
   add(emitter, "objectValue", classKey);
+  const body = field(cls, "body");
+  if (body !== null) {
+    emitMixinFacts(emitter, classKey, body, PREPEND_CALL);
+    emitMixinFacts(emitter, classKey, body, INCLUDE_CALL);
+  }
   const superclass = field(cls, "superclass");
   const base = superclass === null ? null : children(superclass)[0] ?? null;
   if (base !== null) {
     add(emitter, "extends", classKey, valueKey(emitter, base));
     add(emitter, "extendsNamed", classKey, base.text);
   }
-  const body = field(cls, "body");
   const collected = /* @__PURE__ */ new Map();
   const within = {
     ...emitter,
     selfKey: classKey,
     instanceWrites: collected
   };
-  for (const statement of body === null ? [] : children(body)) {
+  const statements = body === null ? [] : bodyStatementsRun(body, cls.type === "module", emitter.bodyBlocks);
+  for (const statement of statements) {
     if (statement.type === "assignment") {
       const left = field(statement, "left");
       const right = field(statement, "right");
@@ -1000,6 +1150,7 @@ function emitClassFacts(emitter, cls) {
       continue;
     }
     if (!METHOD_TYPES.has(statement.type)) {
+      emitExpressionFacts(within, statement);
       continue;
     }
     const funcKey = emitMethodFacts(within, statement);
@@ -1011,13 +1162,14 @@ function emitClassFacts(emitter, cls) {
   emitInstanceWrites(within, classKey, collected);
   return classKey;
 }
-function emitValueFacts(db, filePath, root) {
+function emitValueFacts(db, filePath, root, bodyBlocks = NO_BODY_BLOCKS) {
   const emitter = {
     db,
     filePath,
     enclosing: null,
     selfKey: null,
-    instanceWrites: null
+    instanceWrites: null,
+    bodyBlocks
   };
   const declaresName = (child, key) => {
     const name = field(child, "name");
@@ -1057,7 +1209,7 @@ var OWN_ROOT_TYPES = /* @__PURE__ */ new Set([
   "module",
   "singleton_class"
 ]);
-var BLOCK_TYPES2 = /* @__PURE__ */ new Set(["block", "do_block"]);
+var BLOCK_TYPES4 = /* @__PURE__ */ new Set(["block", "do_block"]);
 var METHOD_TYPES2 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
 var NAME_TYPES = /* @__PURE__ */ new Set([
   "identifier",
@@ -1566,7 +1718,7 @@ function isTailExpression(node) {
   if (owner.type === "block" && owner.parent?.type === "lambda") {
     return true;
   }
-  if (METHOD_TYPES2.has(owner.type) || BLOCK_TYPES2.has(owner.type)) {
+  if (METHOD_TYPES2.has(owner.type) || BLOCK_TYPES4.has(owner.type)) {
     return true;
   }
   if (owner.type === "when") {
@@ -1585,7 +1737,7 @@ function isRoot(node) {
   if (OWN_ROOT_TYPES.has(node.type)) {
     return true;
   }
-  return BLOCK_TYPES2.has(node.type) && node.parent?.type === "call";
+  return BLOCK_TYPES4.has(node.type) && node.parent?.type === "call";
 }
 function isPathStatement(node, parent) {
   if (node.type === "elsif") {
@@ -1639,7 +1791,7 @@ function functionOf(node) {
       body: bodyOf(block)
     };
   }
-  if (BLOCK_TYPES2.has(node.type)) {
+  if (BLOCK_TYPES4.has(node.type)) {
     return {
       parameters: parametersOf2(field(node, "parameters")),
       body: bodyOf(node)
@@ -2128,113 +2280,119 @@ function contextOver(db, nodes) {
 }
 
 // src/defineMethod.ts
-var DEFINE_METHOD_CALL = "define_method";
-var LOOP_METHODS = /* @__PURE__ */ new Set(["each", "each_with_index", "map"]);
-var BLOCK_TYPES3 = /* @__PURE__ */ new Set(["block", "do_block"]);
-var NOTHING = { names: /* @__PURE__ */ new Set(), unreadable: false };
-var byTree = /* @__PURE__ */ new WeakMap();
-function defineMethodNames(body) {
-  let perTree = byTree.get(body.tree);
-  if (perTree === void 0) {
-    perTree = /* @__PURE__ */ new Map();
-    byTree.set(body.tree, perTree);
-  }
-  const cached = perTree.get(body.id);
-  if (cached !== void 0) {
-    return cached;
-  }
-  const read = readNames(body);
-  perTree.set(body.id, read);
-  return read;
-}
-function readNames(body) {
-  const calls = bareCalls(body, DEFINE_METHOD_CALL);
-  if (calls.length === 0) {
-    return NOTHING;
+var NOTHING = {
+  names: /* @__PURE__ */ new Set(),
+  patterns: [],
+  unreadable: false
+};
+function couldBeDefined(defined, name) {
+  return defined.unreadable || defined.patterns.some((pattern) => pattern.test(name));
+}
+function definedNamesOf(dynamic, classKey) {
+  return dynamic?.get(classKey) ?? NOTHING;
+}
+function readDynamicNames(db, rootsByFile) {
+  const byClass = /* @__PURE__ */ new Map();
+  for (const [classKey, nameKey2] of db.facts("definesMethodFrom")) {
+    const key = String(classKey);
+    byClass.set(
+      key,
+      foldReading(
+        byClass.get(key) ?? NOTHING,
+        readOne(db, rootsByFile, String(nameKey2))
+      )
+    );
   }
-  const names = /* @__PURE__ */ new Set();
-  let unreadable = false;
-  for (const call of calls) {
-    const defined = namesDefinedBy(call);
-    if (defined === null) {
-      unreadable = true;
-      continue;
-    }
-    for (const name of defined) {
-      names.add(name);
+  for (const [classKey, reading] of byClass) {
+    for (const name of reading.names) {
+      db.add("declaresName", [classKey, name]);
     }
   }
-  return { names, unreadable };
+  return byClass;
 }
-function namesDefinedBy(call) {
-  const args = field(call, "arguments");
-  const first = args === null ? void 0 : bodyStatements(args)[0];
-  if (first === void 0) {
-    return null;
+function foldReading(soFar, reading) {
+  if (reading === null) {
+    return { ...soFar, unreadable: true };
   }
+  return {
+    names: /* @__PURE__ */ new Set([...soFar.names, ...reading.names]),
+    patterns: [...soFar.patterns, ...reading.patterns],
+    unreadable: soFar.unreadable
+  };
+}
+function readOne(db, rootsByFile, nameKey2) {
+  const node = nodeOfKey2(rootsByFile, nameKey2);
   const names = [];
-  for (const bindings of loopTurns(call)) {
-    const name = stringValueOf(
-      first,
-      void 0,
-      bindings.size === 0 ? void 0 : bindings
-    );
-    if (name === null) {
+  const patterns = [];
+  for (const bindings of loopTurns(db, rootsByFile, nameKey2)) {
+    const value = node === null ? hole2(nameKey2) : evaluatedValue(node, db, bindings.size === 0 ? void 0 : bindings);
+    const name = literalOf2(value);
+    if (name !== null) {
+      names.push(name);
+      continue;
+    }
+    const pattern = patternOf(value);
+    if (pattern === null) {
       return null;
     }
-    names.push(name);
+    patterns.push(pattern);
   }
-  return names;
+  return { names, patterns };
 }
-function loopTurns(call) {
-  let turns = [/* @__PURE__ */ new Map()];
-  for (const taken of blocksAround(call)) {
-    const perElement = elementBindings(taken);
-    if (perElement === null) {
+function patternOf(value) {
+  const pieces = piecesOf(value);
+  let source = "^";
+  let readSomething = false;
+  for (const piece of pieces) {
+    if (piece.kind === "hole") {
+      source += "[\\s\\S]*";
+      continue;
+    }
+    const options = piece.options.filter((option) => option.length > 0);
+    if (options.length === 0) {
       continue;
     }
+    readSomething = true;
+    source += `(?:${options.map(escapeForPattern).join("|")})`;
+  }
+  return readSomething ? new RegExp(`${source}$`) : null;
+}
+function escapeForPattern(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function loopTurns(db, rootsByFile, nameKey2) {
+  let turns = [/* @__PURE__ */ new Map()];
+  for (const over of listsBehind(db, rootsByFile, nameKey2)) {
     turns = turns.flatMap(
-      (base) => perElement.map((element) => new Map([...base, ...element]))
+      (base) => over.elements.map((value, position) => {
+        const binding = new Map([...base, [over.element, value]]);
+        if (over.index !== "") {
+          binding.set(over.index, String(position));
+        }
+        return binding;
+      })
     );
   }
   return turns;
 }
-function blocksAround(call) {
-  const blocks = [];
-  let current = call.parent;
-  while (current !== null && !OWN_BODY_TYPES.has(current.type)) {
-    const parent = current.parent;
-    if (BLOCK_TYPES3.has(current.type) && parent?.type === "call") {
-      blocks.unshift({ block: current, call: parent });
+function listsBehind(db, rootsByFile, nameKey2) {
+  const found = [];
+  for (const [, element, index, overKey] of db.lookup(
+    "nameTurnsOn",
+    0,
+    nameKey2
+  )) {
+    const elements = literalElementsOf(rootsByFile, String(overKey), db);
+    if (elements !== null) {
+      found.push({ element: String(element), index: String(index), elements });
     }
-    current = parent;
   }
-  return blocks;
+  return found;
 }
-function elementBindings(taken) {
-  const { block, call } = taken;
-  const receiver = field(call, "receiver");
-  const method = field(call, "method")?.text;
-  if (receiver === null || method === void 0 || !LOOP_METHODS.has(method)) {
-    return null;
-  }
-  const parameters = field(block, "parameters");
-  const [element, index] = parameters === null ? [] : bodyStatements(parameters).map((parameter) => parameter.text);
-  const elements = element === void 0 ? null : literalElementsOf(receiver);
-  if (element === void 0 || elements === null) {
-    return null;
-  }
-  return elements.map((value, position) => {
-    const binding = /* @__PURE__ */ new Map([[element, value]]);
-    if (index !== void 0) {
-      binding.set(index, String(position));
-    }
-    return binding;
-  });
-}
-function literalElementsOf(node) {
-  const value = evaluatedValue(node);
-  if (value.kind !== "sequence") {
+function literalElementsOf(rootsByFile, key, db) {
+  const node = nodeOfKey2(rootsByFile, key);
+  const value = node === null ? null : evaluatedValue(node, db);
+  if (value === null || value.kind !== "sequence") {
     return null;
   }
   const elements = [];
@@ -2374,8 +2532,6 @@ function graphqlTypeNameFromQualified(qualifiedName, convention) {
 }
 
 // src/ancestry.ts
-var INCLUDE_CALL = "include";
-var PREPEND_CALL = "prepend";
 async function reachDefinition(qualifiedName, lookup) {
   const filePath = resolveConstantFile(
     lookup.root,
@@ -2502,7 +2658,7 @@ function superclassCandidatesOf(blocks) {
   }
   return [];
 }
-function methodInAncestry(ancestry, name) {
+function methodInAncestry(ancestry, name, read = {}) {
   for (const entry of ancestry) {
     if (entry.type === "root") {
       return { type: "none" };
@@ -2514,7 +2670,7 @@ function methodInAncestry(ancestry, name) {
         cause: "unreadAncestor"
       };
     }
-    const found = definitionIn(entry.blocks, name);
+    const found = definitionIn(entry.blocks, name, read);
     if (found.method !== null && found.block !== null) {
       return { type: "found", method: found.method, block: found.block };
     }
@@ -2528,7 +2684,7 @@ function methodInAncestry(ancestry, name) {
   }
   return { type: "none" };
 }
-function definitionIn(blocks, name) {
+function definitionIn(blocks, name, read) {
   let method = null;
   let block = null;
   let definedDynamically = false;
@@ -2538,14 +2694,17 @@ function definitionIn(blocks, name) {
     if (body === null) {
       continue;
     }
-    const found = instanceMethodsByName(body).get(name);
+    const found = instanceMethodsByName(body, read.bodyBlocks).get(name);
     if (found !== void 0) {
       method = found;
       block = candidate;
     }
-    const defined = defineMethodNames(body);
+    const defined = definedNamesOf(
+      read.dynamicNames,
+      nodeId(candidate.file, candidate.info.node)
+    );
     definedDynamically ||= defined.names.has(name);
-    unreadableDefine ||= defined.unreadable;
+    unreadableDefine ||= couldBeDefined(defined, name);
   }
   return { method, block, definedDynamically, unreadableDefine };
 }
@@ -2959,7 +3118,7 @@ function lowerRubyBody(body, terminals, responseCalls = []) {
 
 // src/paths/effects.ts
 var RAISE_NAMES2 = /* @__PURE__ */ new Set(["raise", "fail"]);
-var BLOCK_TYPES4 = /* @__PURE__ */ new Set([
+var BLOCK_TYPES5 = /* @__PURE__ */ new Set([
   "body_statement",
   "then",
   "else",
@@ -3088,7 +3247,7 @@ function argsOf(call) {
 function enclosingStatement(call, body) {
   let current = call;
   while (current.parent !== null) {
-    if (BLOCK_TYPES4.has(current.parent.type) || current.parent.id === body.id) {
+    if (BLOCK_TYPES5.has(current.parent.type) || current.parent.id === body.id) {
       return current;
     }
     current = current.parent;
@@ -3837,7 +3996,7 @@ function isDefaultedAt(node) {
 }
 
 // src/filters.ts
-function controllerFilters(pattern, ancestry) {
+function controllerFilters(pattern, ancestry, read = {}) {
   const forms = pattern.filters ?? [];
   if (forms.length === 0) {
     return [];
@@ -3872,7 +4031,7 @@ function controllerFilters(pattern, ancestry) {
   }
   const resolved = [];
   for (const declaration of declared) {
-    const found = methodInAncestry(ancestry, declaration.methodName);
+    const found = methodInAncestry(ancestry, declaration.methodName, read);
     if (found.type !== "found") {
       continue;
     }
@@ -4076,28 +4235,98 @@ function modelPattern(constant2, file, options) {
     (candidate) => reachesBase(options.facts, classKey, candidate.baseClasses)
   );
 }
-function selectorOf(node) {
-  const picked = [];
-  const walk = (current) => {
-    const args = field(current, "arguments");
-    for (const argument of args === null ? [] : children3(args)) {
-      if (argument.type !== "pair") {
-        continue;
-      }
-      const key = field(argument, "key");
+function chainLinks(call) {
+  const links = [];
+  let current = call;
+  while (current !== null && current.type === "call") {
+    links.push(current);
+    current = receiverOf(current);
+  }
+  return links;
+}
+function kindOfCall(pattern, method) {
+  if (pattern.writes.includes(method)) {
+    return "write";
+  }
+  if (pattern.reads.includes(method)) {
+    return "read";
+  }
+  return void 0;
+}
+function someLibraryDefines(options, method) {
+  return options.patterns.some(
+    (pattern) => kindOfCall(pattern, method) !== void 0
+  );
+}
+function argumentsOf2(call) {
+  const args = field(call, "arguments");
+  return args === null ? [] : children3(args);
+}
+function isKeywordArgument(argument) {
+  return argument.type === "pair" || argument.type === "hash";
+}
+function bareName(node) {
+  return node.text.replace(/^:/, "").replace(/:$/, "");
+}
+function pairsIn(argument) {
+  if (argument.type === "pair") {
+    return [argument];
+  }
+  if (argument.type === "hash") {
+    return children3(argument).filter((child) => child.type === "pair");
+  }
+  return [];
+}
+function keywordKeys(call) {
+  const keys = [];
+  for (const argument of argumentsOf2(call)) {
+    for (const pair of pairsIn(argument)) {
+      const key = field(pair, "key");
       if (key !== null) {
-        picked.push(key.text.replace(/^:/, "").replace(/:$/, ""));
+        keys.push(bareName(key));
       }
     }
-    const receiver = receiverOf(current);
-    if (receiver !== null) {
-      walk(receiver);
+  }
+  return keys;
+}
+function hasPositionalArgument(call) {
+  return argumentsOf2(call).some((argument) => !isKeywordArgument(argument));
+}
+function columnsAskedFor(call, pattern) {
+  if (!(pattern.columnArguments ?? []).includes(methodOf(call))) {
+    return [];
+  }
+  return argumentsOf2(call).filter((argument) => argument.type === "simple_symbol").map(bareName);
+}
+function primaryKeySelector(call, pattern) {
+  const byPrimaryKey = pattern.byPrimaryKey;
+  if (byPrimaryKey === void 0) {
+    return [];
+  }
+  const picks = byPrimaryKey.methods.includes(methodOf(call)) && hasPositionalArgument(call);
+  return picks ? [byPrimaryKey.column] : [];
+}
+function selectorOf(call, pattern) {
+  const picked = [];
+  for (const link of chainLinks(call)) {
+    picked.push(...primaryKeySelector(link, pattern));
+    if (pattern.reads.includes(methodOf(link))) {
+      picked.push(...keywordKeys(link));
     }
-  };
-  walk(node);
+  }
   return [...new Set(picked)];
 }
-function storageEffect(call, container, pattern, kind, selector) {
+function fieldsOf(call, pattern, kind) {
+  if (kind === "write") {
+    return [...new Set(keywordKeys(call))];
+  }
+  return [
+    ...new Set(
+      chainLinks(call).flatMap((link) => columnsAskedFor(link, pattern))
+    )
+  ];
+}
+function storageEffect(call, container, pattern, kind, selector, fields) {
   const operation = methodOf(call);
   return {
     type: "interaction",
@@ -4111,35 +4340,12 @@ function storageEffect(call, container, pattern, kind, selector) {
     interaction: {
       class: "storage-access",
       kind,
-      fields: [],
+      fields,
       operation,
       ...selector.length > 0 ? { selector } : {}
     }
   };
 }
-function modelCallEffects(call, file, options) {
-  const constant2 = rootConstant(call);
-  if (constant2 === null) {
-    return [];
-  }
-  const pattern = modelPattern(constant2, file, options);
-  if (pattern === void 0) {
-    return [];
-  }
-  const kind = pattern.writes.includes(methodOf(call)) ? "write" : "read";
-  return [
-    storageEffect(
-      call,
-      constantName(constant2),
-      pattern,
-      kind,
-      selectorOf(call)
-    )
-  ];
-}
-function writeMethods(patterns) {
-  return new Set(patterns.flatMap((pattern) => pattern.writes));
-}
 function classSettledOn(facts, key) {
   askResolution2(facts, [key], "wanted", RUBY_PROGRAM);
   const objects = new Set(
@@ -4156,27 +4362,64 @@ function declaredName(facts, classKey) {
 function projectDeclares(facts, classKey, method) {
   return facts.lookup("wantedDeclaredName", 0, classKey).some((row) => String(row[1]) === method);
 }
-function instanceWriteEffects(call, file, options, enclosing) {
+function constantReceiver(constant2, file, facts) {
+  const classKey = classBehind(facts, file, constant2);
+  return classKey === void 0 ? void 0 : { classKey, container: constantName(constant2) };
+}
+function settledReceiver(receiver, file, facts, enclosing) {
+  const classKey = classSettledOn(facts, readKey(file, receiver, enclosing));
+  if (classKey === void 0) {
+    return void 0;
+  }
+  const container = declaredName(facts, classKey);
+  return container === void 0 ? void 0 : { classKey, container };
+}
+function receiverClass(call, file, options, enclosing) {
+  const constant2 = rootConstant(call);
+  if (constant2 !== null) {
+    return constantReceiver(constant2, file, options.facts);
+  }
   const receiver = receiverOf(call);
-  const method = methodOf(call);
-  if (receiver === null || !writeMethods(options.patterns).has(method)) {
-    return [];
+  if (receiver === null) {
+    return void 0;
   }
-  const classKey = classSettledOn(
-    options.facts,
-    readKey(file, receiver, enclosing)
-  );
-  if (classKey === void 0) {
+  return settledReceiver(receiver, file, options.facts, enclosing);
+}
+function libraryCallIn(call, options) {
+  return chainLinks(call).find(
+    (link) => someLibraryDefines(options, methodOf(link))
+  ) ?? null;
+}
+function modelCallEffects(call, file, options, enclosing) {
+  const worked = libraryCallIn(call, options);
+  if (worked === null) {
     return [];
   }
-  const pattern = options.patterns.find(
-    (candidate) => candidate.writes.includes(method) && reachesBase(options.facts, classKey, candidate.baseClasses)
-  );
-  if (pattern === void 0 || projectDeclares(options.facts, classKey, method)) {
+  const method = methodOf(worked);
+  const target = receiverClass(worked, file, options, enclosing);
+  if (target === void 0) {
     return [];
   }
-  const container = declaredName(options.facts, classKey);
-  return container === void 0 ? [] : [storageEffect(call, container, pattern, "write", [])];
+  for (const pattern of options.patterns) {
+    const kind = kindOfCall(pattern, method);
+    if (kind === void 0 || !reachesBase(options.facts, target.classKey, pattern.baseClasses)) {
+      continue;
+    }
+    if (projectDeclares(options.facts, target.classKey, method)) {
+      return [];
+    }
+    return [
+      storageEffect(
+        worked,
+        target.container,
+        pattern,
+        kind,
+        selectorOf(worked, pattern),
+        fieldsOf(worked, pattern, kind)
+      )
+    ];
+  }
+  return [];
 }
 function isLoader(node, loader) {
   if (node === null) {
@@ -4214,7 +4457,7 @@ function loaderCallEffects(call, file, options) {
       const pattern = modelPattern(argument, file, options);
       if (pattern !== void 0) {
         effects.push(
-          storageEffect(call, constantName(argument), pattern, "read", [])
+          storageEffect(call, constantName(argument), pattern, "read", [], [])
         );
       }
     }
@@ -4222,22 +4465,21 @@ function loaderCallEffects(call, file, options) {
   return effects;
 }
 function effectsOfCall(call, file, options, enclosing) {
-  const onModel = modelCallEffects(call, file, options);
-  if (onModel.length > 0) {
-    return onModel;
-  }
-  const onInstance = rootConstant(call) === null ? instanceWriteEffects(call, file, options, enclosing) : [];
-  return onInstance.length > 0 ? onInstance : loaderCallEffects(call, file, options);
+  const onModel = modelCallEffects(call, file, options, enclosing);
+  return onModel.length > 0 ? onModel : loaderCallEffects(call, file, options);
 }
 function storageClaims(call, file, options, enclosing = null) {
   return options.patterns.length > 0 && effectsOfCall(call, file, options, enclosing).length > 0;
 }
 function receiverKeysToAsk(chains, file, options, enclosing) {
-  const writes = writeMethods(options.patterns);
   const keys = [];
   for (const call of chains) {
-    const receiver = receiverOf(call);
-    if (receiver !== null && writes.has(methodOf(call)) && rootConstant(call) === null) {
+    const worked = libraryCallIn(call, options);
+    if (worked === null || rootConstant(worked) !== null) {
+      continue;
+    }
+    const receiver = receiverOf(worked);
+    if (receiver !== null) {
       keys.push(readKey(file, receiver, enclosing));
     }
   }
@@ -4334,11 +4576,17 @@ function createFileCache(parse, readFile) {
     }
   };
 }
-function fieldReadContext(pattern, cache, fileBlocks, bodyRead) {
+function fieldReadContext(pattern, cache, fileBlocks, bodyRead, facts) {
   return {
     pattern,
     cache,
     bodyRead,
+    facts,
+    read: {
+      facts,
+      bodyBlocks: bodyRead.bodyBlocks,
+      dynamicNames: bodyRead.dynamicNames
+    },
     lookup: {
       root: pattern.root,
       pathConvention: pattern.pathConvention,
@@ -4421,7 +4669,13 @@ async function graphqlObjectFieldUnits(pattern, pack, info, ownBlocks, fileBlock
   if (info.bodyNode === null || pattern.baseClassNames.includes(info.qualifiedName)) {
     return [];
   }
-  const ctx = fieldReadContext(pattern, options.cache, fileBlocks, options);
+  const ctx = fieldReadContext(
+    pattern,
+    options.cache,
+    fileBlocks,
+    options,
+    options.facts
+  );
   const ancestry = await ancestryOf(info.qualifiedName, ownBlocks, ctx.lookup);
   if (!reachesConfiguredBase(ancestry, info.qualifiedName, pattern.baseClassNames)) {
     return [];
@@ -4469,7 +4723,11 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
   ])) {
     return [];
   }
-  const filters = controllerFilters(pattern, ancestry);
+  const filters = controllerFilters(pattern, ancestry, {
+    facts: options.facts,
+    bodyBlocks: options.bodyBlocks,
+    dynamicNames: options.dynamicNames
+  });
   const units = [];
   for (const filter of filters) {
     const displayPath = options.displayPathOf?.(filter.file) ?? filter.file;
@@ -4514,7 +4772,10 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
     });
   };
   const own = /* @__PURE__ */ new Set();
-  for (const [actionName, method, block] of publicInstanceMethods(ownBlocks)) {
+  for (const [actionName, method, block] of publicInstanceMethods(
+    ownBlocks,
+    options.bodyBlocks
+  )) {
     own.add(actionName);
     emitAction(actionName, method, block);
   }
@@ -4524,7 +4785,8 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
       continue;
     }
     for (const [actionName, method, block] of publicInstanceMethods(
-      entry.blocks
+      entry.blocks,
+      options.bodyBlocks
     )) {
       if (seen.has(actionName)) {
         continue;
@@ -4538,14 +4800,17 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
   }
   return units;
 }
-function publicInstanceMethods(blocks) {
+function publicInstanceMethods(blocks, bodyBlocks) {
   const found = [];
   for (const block of blocks) {
     if (block.info.bodyNode === null) {
       continue;
     }
     const visibility = instanceMethodVisibility(block.info.bodyNode);
-    for (const [name, method] of instanceMethodsByName(block.info.bodyNode)) {
+    for (const [name, method] of instanceMethodsByName(
+      block.info.bodyNode,
+      bodyBlocks
+    )) {
       if ((visibility.get(name) ?? "public") === "public") {
         found.push([name, method, block]);
       }
@@ -4808,7 +5073,7 @@ async function readFieldShape(symbol, callArgs, scope, ctx, ancestry, range) {
   return {
     contract: literalContract(callArgs, scope, ctx),
     body: bodyFromLookup(
-      methodInAncestry(ancestry, symbol),
+      methodInAncestry(ancestry, symbol, ctx.read),
       range,
       "This field",
       NO_METHOD_BEHIND_IT,
@@ -4853,7 +5118,7 @@ async function readWiredClass(ref, scope, ctx) {
   return {
     contract: readClassContract(ancestry, ctx.pattern),
     body: bodyFromLookup(
-      methodInAncestry(ancestry, ctx.pattern.resolverMethodName),
+      methodInAncestry(ancestry, ctx.pattern.resolverMethodName, ctx.read),
       range,
       `This field's ${targetQualifiedName}`,
       methodNotSettled(
@@ -5025,6 +5290,202 @@ function buildFieldUnit(pack, typeName, decl, filePath) {
   };
 }
 
+// src/inflect.ts
+var SINGULAR_RULES = [
+  [/s$/i, ""],
+  [/(ss)$/i, "$1"],
+  [/(n)ews$/i, "$1ews"],
+  [/([ti])a$/i, "$1um"],
+  [
+    /((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i,
+    "$1sis"
+  ],
+  [/(^analy)(sis|ses)$/i, "$1sis"],
+  [/([^f])ves$/i, "$1fe"],
+  [/(hive)s$/i, "$1"],
+  [/(tive)s$/i, "$1"],
+  [/([lr])ves$/i, "$1f"],
+  [/([^aeiouy]|qu)ies$/i, "$1y"],
+  [/(s)eries$/i, "$1eries"],
+  [/(m)ovies$/i, "$1ovie"],
+  [/(x|ch|ss|sh)es$/i, "$1"],
+  [/^(m|l)ice$/i, "$1ouse"],
+  [/(bus)(es)?$/i, "$1"],
+  [/(o)es$/i, "$1"],
+  [/(shoe)s$/i, "$1"],
+  [/(cris|test)(is|es)$/i, "$1is"],
+  [/^(a)x[ie]s$/i, "$1xis"],
+  [/(octop|vir)(us|i)$/i, "$1us"],
+  [/(alias|status)(es)?$/i, "$1"],
+  [/^(ox)en/i, "$1"],
+  [/(vert|ind)ices$/i, "$1ex"],
+  [/(matr)ices$/i, "$1ix"],
+  [/(quiz)zes$/i, "$1"],
+  [/(database)s$/i, "$1"],
+  // The words ActiveSupport calls irregular. It declares them after the
+  // rules above, which is what puts them ahead in the search.
+  [/(p)erson$/i, "$1erson"],
+  [/(p)eople$/i, "$1erson"],
+  [/(m)an$/i, "$1an"],
+  [/(m)en$/i, "$1an"],
+  [/(c)hild$/i, "$1hild"],
+  [/(c)hildren$/i, "$1hild"],
+  [/(s)ex$/i, "$1ex"],
+  [/(s)exes$/i, "$1ex"],
+  [/(m)ove$/i, "$1ove"],
+  [/(m)oves$/i, "$1ove"],
+  [/(z)ombie$/i, "$1ombie"],
+  [/(z)ombies$/i, "$1ombie"]
+];
+var UNCOUNTABLE = /* @__PURE__ */ new Set([
+  "equipment",
+  "information",
+  "rice",
+  "money",
+  "species",
+  "series",
+  "fish",
+  "sheep",
+  "jeans",
+  "police"
+]);
+function singularize(word, project) {
+  if (UNCOUNTABLE.has(word.toLowerCase()) || (project?.uncountable ?? []).some(
+    (uncountable) => uncountable.toLowerCase() === word.toLowerCase()
+  )) {
+    return word;
+  }
+  const own = projectSingular(word, project);
+  if (own !== null) {
+    return own;
+  }
+  for (let at = SINGULAR_RULES.length - 1; at >= 0; at--) {
+    const [pattern, replacement] = SINGULAR_RULES[at];
+    if (pattern.test(word)) {
+      return word.replace(pattern, replacement);
+    }
+  }
+  return word;
+}
+function projectSingular(word, project) {
+  const irregular = [...project?.irregular ?? []].reverse();
+  for (const [plural, singular] of irregular) {
+    if (plural.toLowerCase() === word.toLowerCase()) {
+      return matchingCase(word, singular);
+    }
+  }
+  const rules = [...project?.singular ?? []].reverse();
+  for (const [rule3, replacement] of rules) {
+    const applied = applyRule(word, rule3, replacement);
+    if (applied !== null) {
+      return applied;
+    }
+  }
+  return null;
+}
+function applyRule(word, rule3, replacement) {
+  const written = /^\/(.*)\/([a-z]*)$/s.exec(rule3);
+  if (written === null) {
+    return word.includes(rule3) ? word.replace(rule3, replacement) : null;
+  }
+  const flags = (written[2] ?? "").replace("m", "s").replace(/[^is]/g, "");
+  const pattern = new RegExp(written[1] ?? "", flags);
+  return pattern.test(word) ? word.replace(pattern, replacement.replace(/\\(\d)/g, "$$$1")) : null;
+}
+function matchingCase(word, replacement) {
+  const first = word[0];
+  if (first === void 0 || first !== first.toUpperCase()) {
+    return replacement;
+  }
+  return replacement.charAt(0).toUpperCase() + replacement.slice(1);
+}
+function camelize(word, acronyms = []) {
+  return word.split("_").map((part) => capitalize(part, acronyms)).join("");
+}
+function capitalize(part, acronyms) {
+  if (part === "") {
+    return "";
+  }
+  const acronym = acronyms.find(
+    (known) => known.toLowerCase() === part.toLowerCase()
+  );
+  return acronym ?? part[0]?.toUpperCase() + part.slice(1);
+}
+function associationTargetName(name, plural, project) {
+  return camelize(
+    plural ? singularize(name, project) : name,
+    project?.acronyms ?? []
+  );
+}
+
+// src/facts/associations.ts
+function declaredName2(argument) {
+  if (argument === void 0) {
+    return null;
+  }
+  if (argument.type === "simple_symbol") {
+    return argument.text.slice(1);
+  }
+  return stringLiteralValue(argument);
+}
+function targetReference(key, written, nesting) {
+  if (written.startsWith("::")) {
+    return { key, written: written.slice(2), nesting: [] };
+  }
+  return { key, written, nesting };
+}
+function targetName(call, calls, name, plural, inflections) {
+  const override = readCallArgs(field(call, "arguments")).keyword[calls.classNameKeyword];
+  if (override === void 0) {
+    return associationTargetName(name, plural, inflections);
+  }
+  return stringLiteralValue(override);
+}
+function associationsDeclaredIn(cls, classKey, nesting, calls, inflections) {
+  const body = field(cls, "body");
+  if (body === null || calls.length === 0) {
+    return [];
+  }
+  const found = [];
+  for (const statement of runStatements(body)) {
+    if (statement.type !== "call" || field(statement, "receiver") !== null) {
+      continue;
+    }
+    const method = field(statement, "method")?.text ?? "";
+    for (const declaration of calls) {
+      const plural = declaration.plural.includes(method);
+      if (!plural && !declaration.singular.includes(method)) {
+        continue;
+      }
+      const positional = readCallArgs(field(statement, "arguments")).positional;
+      const name = declaredName2(positional[0]);
+      if (name === null) {
+        continue;
+      }
+      const written = targetName(
+        statement,
+        declaration,
+        name,
+        plural,
+        inflections
+      );
+      if (written === null) {
+        continue;
+      }
+      found.push({
+        classKey,
+        name,
+        target: targetReference(
+          `${classKey}#association:${name}`,
+          written,
+          nesting
+        )
+      });
+    }
+  }
+  return found;
+}
+
 // src/facts/constants.ts
 function children4(node) {
   return node.namedChildren.filter((child) => child !== null);
@@ -5059,20 +5520,32 @@ function isDeclaration(node, parent) {
   }
   return parent.type === "scope_resolution";
 }
-function collectFileConstants(filePath, root) {
+function collectFileConstants(filePath, root, associationCalls = [], inflections) {
   const definitions = [];
   const references = [];
+  const associations = [];
   const walk = (node, parent, nesting) => {
     if (NESTING_TYPES.has(node.type)) {
       const name = field(node, "name");
       const written = name === null ? null : writtenName(name);
       if (written !== null) {
+        const classKey = nodeId(filePath, node);
         definitions.push({
           qualifiedName: qualify(nesting, written),
-          key: nodeId(filePath, node),
+          key: classKey,
           kind: "declaration"
         });
         const inside = [...nesting, ...written.split("::")];
+        for (const declared of associationsDeclaredIn(
+          node,
+          classKey,
+          inside,
+          associationCalls,
+          inflections
+        )) {
+          associations.push(declared);
+          references.push(declared.target);
+        }
         for (const child of children4(node)) {
           walk(child, node, inside);
         }
@@ -5104,7 +5577,7 @@ function collectFileConstants(filePath, root) {
     }
   };
   walk(root, null, []);
-  return { filePath, definitions, references };
+  return { filePath, definitions, references, associations };
 }
 function emitConstantBindings(db, perFile) {
   const byName = /* @__PURE__ */ new Map();
@@ -5128,6 +5601,13 @@ function emitConstantBindings(db, perFile) {
     return found.length === 1 ? found[0].key : null;
   };
   for (const file of files) {
+    for (const declared of file.associations) {
+      db.add("declaresAssociation", [
+        declared.classKey,
+        declared.name,
+        declared.target.key
+      ]);
+    }
     for (const reference of file.references) {
       for (let depth = reference.nesting.length; depth >= 0; depth--) {
         const candidate = qualify(
@@ -5289,6 +5769,35 @@ function requiredRelativePath(node) {
   return positional[0] === void 0 ? null : stringLiteralValue(positional[0]);
 }
 
+// src/pack.ts
+function inflectionsIn(packs) {
+  const pooled = {
+    acronyms: [],
+    irregular: [],
+    uncountable: [],
+    singular: []
+  };
+  for (const pack of packs) {
+    pooled.acronyms?.push(...pack.inflections?.acronyms ?? []);
+    pooled.irregular?.push(...pack.inflections?.irregular ?? []);
+    pooled.uncountable?.push(...pack.inflections?.uncountable ?? []);
+    pooled.singular?.push(...pack.inflections?.singular ?? []);
+  }
+  return pooled;
+}
+function bodyBlocksIn(packs) {
+  const pooled = /* @__PURE__ */ new Map();
+  for (const pack of packs) {
+    for (const declared of pack.bodyBlocks ?? []) {
+      pooled.set(declared.name, {
+        moduleOnly: declared.moduleOnly ?? false,
+        definesClassMethods: declared.definesClassMethods ?? false
+      });
+    }
+  }
+  return pooled;
+}
+
 // src/reach/closure.ts
 import {
   functionCallBinding,
@@ -5466,7 +5975,11 @@ function methodOnAncestryOf(qualifiedName, methodName, ctx) {
   if (ancestry === void 0) {
     return stop("outsideRun");
   }
-  const found = methodInAncestry(ancestry, methodName);
+  const found = methodInAncestry(ancestry, methodName, {
+    facts: ctx.facts,
+    bodyBlocks: ctx.bodyBlocks,
+    dynamicNames: ctx.dynamicNames
+  });
   if (found.type === "found") {
     return followed(reachedMethod(found.method, found.block, methodName));
   }
@@ -5495,7 +6008,10 @@ function singletonMethodOn(qualifiedName, methodName, ctx) {
     if (block.info.bodyNode === null) {
       continue;
     }
-    const found = singletonMethodsByName(block.info.bodyNode).get(methodName);
+    const found = singletonMethodsByName(
+      block.info.bodyNode,
+      ctx.bodyBlocks
+    ).get(methodName);
     if (found !== void 0) {
       return followed(reachedMethod(found, block, methodName));
     }
@@ -5849,7 +6365,7 @@ function parameterName(param) {
 
 // src/reach/context.ts
 var METHOD_TYPES4 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
-async function buildReachContext(files, facts) {
+async function buildReachContext(files, facts, bodyBlocks = NO_BODY_BLOCKS, dynamicNames = /* @__PURE__ */ new Map()) {
   const blocksByQualifiedName = /* @__PURE__ */ new Map();
   const classes = [];
   const classNames = /* @__PURE__ */ new Map();
@@ -5923,7 +6439,9 @@ async function buildReachContext(files, facts) {
     topLevelMethods,
     facts,
     classNames,
-    definitions
+    definitions,
+    bodyBlocks,
+    dynamicNames
   };
 }
 function namedChildren(node) {
@@ -5969,6 +6487,13 @@ function inheritedMethodsIn(packs) {
   }
   return found;
 }
+function associationCallsIn(packs) {
+  return packs.flatMap(
+    (pack) => (pack.storage ?? []).flatMap(
+      (pattern) => pattern.associations === void 0 ? [] : [pattern.associations]
+    )
+  );
+}
 function emitStorageFacts(db, packs) {
   for (const pack of packs) {
     for (const pattern of pack.storage ?? []) {
@@ -6023,6 +6548,9 @@ async function extractRubyProject(options) {
   );
   const parsed = [];
   const definitions = /* @__PURE__ */ new Map();
+  const associationCalls = associationCallsIn(options.packs);
+  const bodyBlocks = bodyBlocksIn(options.packs);
+  const inflections = inflectionsIn(options.packs);
   for (const file of options.files) {
     await timer.timeAsync("parse", async () => {
       const root = await cache.get(file);
@@ -6030,14 +6558,16 @@ async function extractRubyProject(options) {
         return;
       }
       parsed.push({ file, root });
-      emitValueFacts(db, file, root);
+      emitValueFacts(db, file, root, bodyBlocks);
       for (const [key, method] of methodDefinitionsIn(file, root)) {
         definitions.set(key, method);
       }
-      constants.push(collectFileConstants(file, root));
+      constants.push(
+        collectFileConstants(file, root, associationCalls, inflections)
+      );
     });
   }
-  timer.time("discover", () => {
+  const dynamicNames = timer.time("discover", () => {
     emitConstantBindings(db, constants);
     const known = new Set(parsed.map(({ file }) => file));
     for (const { file, root } of parsed) {
@@ -6045,6 +6575,10 @@ async function extractRubyProject(options) {
     }
     bindEvaluator(db, { files: parsed, definitions });
     emitStorageFacts(db, options.packs);
+    return readDynamicNames(
+      db,
+      new Map(parsed.map(({ file, root }) => [file, root]))
+    );
   });
   const storagePatterns = options.packs.flatMap((pack) => pack.storage ?? []);
   const loaderPatterns = options.packs.flatMap((pack) => pack.loaders ?? []);
@@ -6052,7 +6586,7 @@ async function extractRubyProject(options) {
   const inheritedMethods = inheritedMethodsIn(options.packs);
   const reachContext = await timer.timeAsync(
     "discover",
-    () => buildReachContext(parsed, db)
+    () => buildReachContext(parsed, db, bodyBlocks, dynamicNames)
   );
   const displayPathOf = (file) => options.workspaceRoot !== void 0 ? path4.relative(options.workspaceRoot, file) : file;
   const seeds = [];
@@ -6072,6 +6606,8 @@ async function extractRubyProject(options) {
         cache,
         ...storage === void 0 ? {} : { storage },
         inheritedMethods,
+        bodyBlocks,
+        dynamicNames,
         displayPathOf,
         facts: db,
         onReachSeed: (raw, seed) => seedByRaw.set(raw, seed)
@@ -6143,7 +6679,9 @@ async function extractRubyProject(options) {
       context: reachContext,
       displayPathOf,
       ...storage === void 0 ? {} : { storage },
-      inheritedMethods
+      inheritedMethods,
+      bodyBlocks,
+      dynamicNames
     })
   );
   for (const entry of found) {