@suss/adapter-ruby 0.29.0 → 0.31.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 { hole as hole2, literalOf as literalOf3, piecesOf } from "@suss/values";
 
 // src/values/evaluator.ts
 import { nodeOfKey } from "@suss/resolution";
@@ -289,40 +336,56 @@ import { Evaluator, force, literalOf, text } from "@suss/values";
 // src/facts/resolve.ts
 import { constant, lit, rule, variable as v } from "@suss/datalog";
 import {
+  allocationSitesOf,
+  alsoSteps,
   askResolution,
+  askResolutionUnder,
+  INSTANCE_STEP,
   resolutionProgram,
+  resolutionUnderProgram,
   writtenValueOf as sharedWrittenValueOf,
+  writtenValueUnder as sharedWrittenValueUnder,
   VALUE_STEP
 } from "@suss/resolution";
-var RUBY_RULES = [
-  // `Loader.new` makes one of the class, which the shared rules already say
-  // about calling a class. Ruby writes it as a method read off the constant
-  // instead, so the read is what steps to the class here.
+var RUBY_RULES = alsoSteps([
+  // Making one of a class is a call of the class, which the shared rules
+  // already say. Ruby writes the callee as `new` read off the constant, so
+  // what this adds is that the callee is the class.
   rule(
-    "stepsTo",
-    [v("x"), v("cls"), VALUE_STEP],
+    "hop",
+    [v("x"), v("cls"), INSTANCE_STEP],
     [
       lit("readsProperty", v("x"), v("o"), constant("new")),
       lit("comesTo", v("o"), v("cls")),
       lit("objectValue", v("cls"))
     ]
   ),
-  // The shared `declared finder` step, for the same spelling: `Account.first`
-  // and `Account.where(x).first` write no arguments, so Ruby reads them as
-  // property reads and neither gets a `call` fact to hang that step on.
+  // The same spelling again, for the caller asking where a class was
+  // made. `callsNamed` reaches a callee written as the name itself, and
+  // Ruby writes `new` off the constant instead.
   rule(
-    "stepsTo",
-    [v("x"), v("cls"), VALUE_STEP],
+    "constructsNamed",
+    [v("r"), v("cls")],
     [
-      lit("readsProperty", v("x"), v("o"), v("m")),
-      lit("objectOf", v("o"), v("cls")),
-      lit("objectValue", v("cls")),
-      lit("libraryBase", v("cls"), v("n")),
-      lit("givesBackOne", v("n"), v("m"))
-    ],
-    "declared finder"
+      lit("binds", v("o"), v("cls")),
+      lit("readsProperty", v("c"), v("o"), constant("new")),
+      lit("call", v("r"), v("c"))
+    ]
+  ),
+  // `%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(
+      "hop",
+      [v("r"), v("o"), VALUE_STEP],
+      [
+        lit("call", v("r"), v("c")),
+        lit("readsProperty", v("c"), v("o"), constant(method))
+      ],
+      "hands back the receiver"
+    )
   )
-];
+]);
 var RUBY_PROGRAM = resolutionProgram(RUBY_RULES);
 function resolveValues(db, keys) {
   askResolution(db, keys, "wanted", RUBY_PROGRAM);
@@ -334,14 +397,122 @@ function writtenValueOf(db, key) {
   resolveValues(db, [key]);
   return sharedWrittenValueOf(db, key, (keys) => resolveValues(db, keys));
 }
+function writtenValueUnder(db, key, site) {
+  askResolutionUnder(db, [[key, site]], resolutionUnderProgram(RUBY_RULES));
+  return sharedWrittenValueUnder(db, key, site);
+}
+function constructionSites(db, classKey) {
+  askResolution(db, [classKey], "wantedSites", RUBY_PROGRAM);
+  return allocationSitesOf(db, classKey);
+}
 
 // src/facts/values.ts
 import { startsAtName, valueLeftByWrites } from "@suss/resolution";
 
+// src/paths/bareCalls.ts
+var PARAMETER_LIST_TYPES = [
+  "method_parameters",
+  "block_parameters",
+  "lambda_parameters",
+  "parameters"
+];
+function isFieldOf(parent, node, name) {
+  return field(parent, name)?.id === node.id;
+}
+function namedAt(parent, node) {
+  return isFieldOf(parent, node, "name");
+}
+function always() {
+  return true;
+}
+var SPELLS_A_NAME = {
+  call: (parent, node) => isFieldOf(parent, node, "method") || isFieldOf(parent, node, "receiver"),
+  method: namedAt,
+  singleton_method: namedAt,
+  assignment: (parent, node) => isFieldOf(parent, node, "left"),
+  operator_assignment: (parent, node) => isFieldOf(parent, node, "left"),
+  for: (parent, node) => isFieldOf(parent, node, "pattern"),
+  optional_parameter: namedAt,
+  splat_parameter: namedAt,
+  hash_splat_parameter: namedAt,
+  keyword_parameter: namedAt,
+  block_parameter: namedAt,
+  destructured_parameter: always,
+  left_assignment_list: always,
+  rest_assignment: always,
+  destructured_left_assignment: always,
+  exception_variable: always,
+  undef: always,
+  alias: always,
+  ...Object.fromEntries(PARAMETER_LIST_TYPES.map((type) => [type, always]))
+};
+function addNamesUnder(node, names) {
+  if (node === null) {
+    return;
+  }
+  if (node.type === "identifier") {
+    names.add(node.text);
+    return;
+  }
+  for (const child of bodyStatements(node)) {
+    addNamesUnder(child, names);
+  }
+}
+function parameterNames(node, names) {
+  for (const parameter of bodyStatements(node)) {
+    if (parameter.type === "identifier") {
+      names.add(parameter.text);
+      continue;
+    }
+    const declared = field(parameter, "name");
+    if (declared !== null && declared.type === "identifier") {
+      names.add(declared.text);
+      continue;
+    }
+    addNamesUnder(parameter, names);
+  }
+}
+function assignedNames(node, names) {
+  addNamesUnder(field(node, "left"), names);
+}
+var BINDS_A_NAME = {
+  assignment: assignedNames,
+  operator_assignment: assignedNames,
+  for: (node, names) => addNamesUnder(field(node, "pattern"), names),
+  exception_variable: (node, names) => addNamesUnder(node, names),
+  ...Object.fromEntries(
+    PARAMETER_LIST_TYPES.map((type) => [type, parameterNames])
+  )
+};
+function localNamesIn(definitionNode) {
+  const names = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    BINDS_A_NAME[node.type]?.(node, names);
+    for (const child of bodyStatements(node)) {
+      visit(child);
+    }
+  };
+  visit(definitionNode);
+  return names;
+}
+function spellsAName(node) {
+  const parent = node.parent;
+  if (parent === null) {
+    return true;
+  }
+  return SPELLS_A_NAME[parent.type]?.(parent, node) === true;
+}
+function isBareMethodCall(node, locals) {
+  if (node.type !== "identifier" || locals.has(node.text)) {
+    return false;
+  }
+  return !spellsAName(node);
+}
+
 // 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"
@@ -362,7 +533,7 @@ function parametersOf(owner) {
   const params = field(owner, "parameters");
   return params === null ? [] : bodyStatements(params);
 }
-function parameterNames(owner) {
+function parameterNames2(owner) {
   const names = /* @__PURE__ */ new Set();
   for (const param of parametersOf(owner)) {
     const name = paramNameOf(param);
@@ -410,6 +581,13 @@ function readForVariable(node) {
   }
   return targetsOf(pattern).map((target) => writeOf(target, null, node, false));
 }
+function readRescueVariable(node) {
+  const variable = field(node, "variable");
+  if (variable === null) {
+    return [];
+  }
+  return bodyStatements(variable).flatMap(targetsOf).map((target) => writeOf(target, null, node, false));
+}
 function readBlockParameters(node) {
   const found = [];
   for (const param of parametersOf(node)) {
@@ -424,6 +602,7 @@ var WRITE_READERS = {
   assignment: readAssignment,
   operator_assignment: readOperatorAssignment,
   for: readForVariable,
+  rescue: readRescueVariable,
   block: readBlockParameters,
   do_block: readBlockParameters
 };
@@ -469,7 +648,7 @@ function namesOfMethod(method) {
   if (remembered !== void 0) {
     return remembered;
   }
-  const names = scopeNames(parameterNames(method), field(method, "body"));
+  const names = scopeNames(parameterNames2(method), field(method, "body"));
   cache.byMethod.set(method, names);
   return names;
 }
@@ -491,10 +670,17 @@ function ownerOfName(node, name, enclosing) {
   }
   return enclosing !== null && names.locals.has(name) ? enclosing : null;
 }
+function isLocalName(node, name, enclosing) {
+  const names = enclosing === null ? namesOfFile(node.tree) : namesOfMethod(enclosing);
+  if (names.blockParams.has(name) && blockDeclaring(node, name) !== null) {
+    return true;
+  }
+  return names.locals.has(name);
+}
 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) && parameterNames2(current).has(name)) {
       return current;
     }
     if (OWN_BODY_TYPES.has(current.type)) {
@@ -550,6 +736,17 @@ function collectWrites(method, body) {
   }
   return [...groups.values()];
 }
+function instanceWritesRunInOrder(body, name, targets) {
+  return writesRunInOrder(
+    body,
+    name,
+    targets.map((target) => ({
+      at: target,
+      direct: target.parent?.parent?.id === body.id
+    })),
+    nameReads(new Set(targets.map((target) => target.id)))
+  );
+}
 function orderedWrite(write, scope) {
   return {
     at: write.at,
@@ -595,12 +792,28 @@ function readKey(filePath, written, enclosing) {
   if (node.type !== "identifier" && node.type !== "constant") {
     return nodeId(filePath, node);
   }
-  const parent = node.parent;
-  if (parent !== null && parent.type === "call" && field(parent, "method")?.id === node.id && field(parent, "receiver") !== null) {
-    return isPropertyRead(parent) ? nodeId(filePath, parent) : nodeId(filePath, node);
+  if (isMethodOfReceiver(node) || isBareCall(node, enclosing)) {
+    return nodeId(filePath, node);
   }
   return nameKey(filePath, node, enclosing);
 }
+function isMethodOfReceiver(node) {
+  const parent = node.parent;
+  return parent !== null && parent.type === "call" && field(parent, "method")?.id === node.id && field(parent, "receiver") !== null;
+}
+function isReceiverOfCall(node) {
+  const parent = node.parent;
+  return parent !== null && parent.type === "call" && field(parent, "receiver")?.id === node.id;
+}
+function isBareCall(node, enclosing) {
+  if (node.type !== "identifier") {
+    return false;
+  }
+  if (spellsAName(node) && !isReceiverOfCall(node)) {
+    return false;
+  }
+  return !isLocalName(node, node.text, enclosing);
+}
 var WRITTEN_VALUE_TYPES = /* @__PURE__ */ new Set([
   "string",
   "integer",
@@ -629,11 +842,7 @@ function add(emitter, relation, ...tuple) {
   emitter.db.add(relation, tuple);
 }
 function valueKey(emitter, written) {
-  const value = readThrough(written);
-  if (value.type !== "identifier" && value.type !== "constant") {
-    return nodeId(emitter.filePath, value);
-  }
-  return nameKey(emitter.filePath, value, emitter.enclosing);
+  return readKey(emitter.filePath, written, emitter.enclosing);
 }
 function pairKeyText(key) {
   if (key.type === "hash_key_symbol") {
@@ -647,35 +856,29 @@ function pairKeyText(key) {
   }
   return null;
 }
-function isPropertyRead(node) {
-  return node.type === "call" && field(node, "receiver") !== null && field(node, "arguments") === null && children(node).every(
-    (child) => child.type !== "do_block" && child.type !== "block"
-  );
-}
-function emitPropertyRead(emitter, node) {
-  const receiver = field(node, "receiver");
-  const method = field(node, "method");
-  if (receiver === null || method === null) {
-    return;
+function calleeKeyOf(filePath, node, enclosing) {
+  if (isBareCall(node, enclosing)) {
+    return nameKey(filePath, node, enclosing);
   }
-  add(
-    emitter,
-    "readsProperty",
-    nodeId(emitter.filePath, node),
-    valueKey(emitter, receiver),
-    method.text
-  );
+  const method = node.type === "call" ? field(node, "method") : null;
+  if (method === null) {
+    return null;
+  }
+  return field(node, "receiver") === null ? nameKey(filePath, method, enclosing) : nodeId(filePath, method);
 }
 function emitCall(emitter, call) {
   add(emitter, "writtenValue", nodeId(emitter.filePath, call));
-  const method = field(call, "method");
-  if (method === null) {
+  const method = call.type === "identifier" ? call : field(call, "method");
+  const calleeKey = calleeKeyOf(emitter.filePath, call, emitter.enclosing);
+  if (method === null || calleeKey === null) {
     return;
   }
   const receiver = field(call, "receiver");
   const callKey = nodeId(emitter.filePath, call);
-  const calleeKey = receiver === null ? valueKey(emitter, method) : nodeId(emitter.filePath, method);
   add(emitter, "call", callKey, calleeKey);
+  if (!emitter.insideMethod) {
+    add(emitter, "callOutsideMethod", callKey);
+  }
   if (receiver !== null) {
     add(
       emitter,
@@ -684,6 +887,8 @@ function emitCall(emitter, call) {
       valueKey(emitter, receiver),
       method.text
     );
+  } else if (emitter.selfKey !== null) {
+    add(emitter, "readsProperty", calleeKey, emitter.selfKey, method.text);
   }
   const args = field(call, "arguments");
   let position = 0;
@@ -744,20 +949,71 @@ 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) => {
-    if (isPropertyRead(child)) {
-      emitPropertyRead(emitter, child);
-    } else if (child.type === "call") {
+  emitDynamicDefinition(emitter, node, []);
+  walkExpressions(node, emitter, (child, turns) => {
+    emitDynamicDefinition(emitter, child, turns);
+    if (child.type === "call" || isBareCall(child, emitter.enclosing)) {
       emitCall(emitter, child);
     }
     if (ARRAY_TYPES.has(child.type)) {
@@ -813,28 +1069,52 @@ function collectInstanceWrite(emitter, node) {
   const operator = field(node, "operator")?.text;
   const value = node.type === "assignment" || WHOLE_VALUE_OPERATORS.has(operator ?? "") ? right : null;
   const written = collector.get(left.text) ?? [];
-  written.push(
-    describeWrite(emitter, {
+  written.push({
+    write: describeWrite(emitter, {
       name: left.text,
       target: left,
       value,
       at: node,
       fromParameter: false
-    })
-  );
+    }),
+    target: left
+  });
   collector.set(left.text, written);
 }
+function settledWrites(writes, ordered) {
+  const described = writes.map((written) => written.write);
+  const settled = valueLeftByWrites(described, ordered);
+  if (settled !== null) {
+    return [settled];
+  }
+  const left = [];
+  for (const write of described) {
+    if (write.value !== null && !write.narrowsName) {
+      left.push(write.value);
+    }
+  }
+  return left;
+}
 function emitInstanceWrites(emitter, classKey, collected) {
   for (const [name, writes] of collected) {
-    const settled = valueLeftByWrites(writes, false);
-    if (settled !== null) {
-      add(emitter, "holdsProperty", classKey, name, settled);
+    for (const value of settledWrites(writes, false)) {
+      add(emitter, "holdsProperty", classKey, name, value);
+    }
+  }
+}
+function emitInstanceStores(emitter, funcKey, body, collected) {
+  for (const [name, writes] of collected) {
+    const deciding = writes.filter((written) => !written.write.narrowsName);
+    if (deciding.length === 0) {
       continue;
     }
-    for (const write of writes) {
-      if (write.value !== null && !write.narrowsName) {
-        add(emitter, "holdsProperty", classKey, name, write.value);
-      }
+    const ordered = instanceWritesRunInOrder(
+      body,
+      name,
+      deciding.map((written) => written.target)
+    );
+    for (const value of settledWrites(deciding, ordered)) {
+      add(emitter, "storesProperty", funcKey, name, value);
     }
   }
 }
@@ -843,7 +1123,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 +1166,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;
@@ -881,7 +1174,7 @@ function emitMethodFacts(emitter, method) {
         add(inside, "returnsValue", funcKey, valueKey(inside, returned));
       }
     }
-    if (child.type === "call") {
+    if (child.type === "call" || isBareCall(child, method)) {
       add(inside, "bodyCalls", funcKey, nodeId(inside.filePath, child));
     }
   });
@@ -949,37 +1242,64 @@ function emitScopeWrites(emitter, method, body) {
   }
 }
 function emitCandidates(emitter, key, group) {
+  let unstated = false;
+  let stated = 0;
   for (const write of group.writes) {
     if (write.value === null) {
       add(emitter, "writesUnstated", key);
+      unstated = true;
       continue;
     }
     if (write.fromParameter) {
+      unstated = true;
       continue;
     }
     if (!describeWrite(emitter, write).narrowsName) {
       add(emitter, "mayHold", key, valueKey(emitter, write.value));
+      stated += 1;
     }
   }
+  if (!unstated && stated > 0) {
+    add(emitter, "writesAllStated", key);
+  }
 }
 var METHOD_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method"]);
+var INITIALIZE_METHOD = "initialize";
+function receiverKeyOf(filePath, method, classKey) {
+  return method.type === "singleton_method" ? classKey : `${nodeId(filePath, method)}#self`;
+}
+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,
+    insideMethod: false,
     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,24 +1320,47 @@ function emitClassFacts(emitter, cls) {
       continue;
     }
     if (!METHOD_TYPES.has(statement.type)) {
+      emitExpressionFacts(within, statement);
       continue;
     }
-    const funcKey = emitMethodFacts(within, statement);
+    const stored = /* @__PURE__ */ new Map();
+    const receiverKey = receiverKeyOf(emitter.filePath, statement, classKey);
+    if (receiverKey !== classKey) {
+      add(emitter, "instanceOf", receiverKey, classKey);
+    }
+    const funcKey = emitMethodFacts(
+      {
+        ...within,
+        selfKey: receiverKey,
+        insideMethod: receiverKey !== classKey,
+        instanceWrites: stored
+      },
+      statement
+    );
     const name = field(statement, "name");
     if (name !== null) {
       add(emitter, "holdsProperty", classKey, name.text, funcKey);
+      if (name.text === INITIALIZE_METHOD) {
+        add(emitter, "initializes", classKey, funcKey);
+      }
+    }
+    const methodBody = field(statement, "body");
+    if (methodBody !== null) {
+      emitInstanceStores(within, funcKey, methodBody, stored);
     }
   }
   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
+    insideMethod: false,
+    instanceWrites: null,
+    bodyBlocks
   };
   const declaresName = (child, key) => {
     const name = field(child, "name");
@@ -1057,7 +1400,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",
@@ -1096,7 +1439,7 @@ function rubyLowering(options) {
     statement: statementOf,
     siteOf,
     functionOf,
-    writtenTo: (node) => context === null ? null : context.writtenTo(node),
+    writtenTo: (node, site) => context === null ? null : context.writtenTo(node, site),
     callable: (node) => {
       if (!isInlinableCall(node)) {
         return null;
@@ -1566,7 +1909,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 +1928,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") {
@@ -1613,17 +1956,32 @@ function siteOf(node) {
     current = parent;
   }
 }
+var BARE_SPLAT_TYPES = /* @__PURE__ */ new Set(["splat_parameter", "hash_splat_parameter"]);
 function parametersOf2(parameters) {
   if (parameters === null) {
     return [];
   }
-  return named(parameters).flatMap((parameter) => {
+  const declared = [];
+  let position = 0;
+  for (const parameter of named(parameters)) {
+    if (BARE_SPLAT_TYPES.has(parameter.type) && field(parameter, "name") === null) {
+      continue;
+    }
     if (parameter.type === "identifier") {
-      return [{ name: parameter.text, default: null }];
+      declared.push({ name: parameter.text, default: null, position });
+    } else {
+      const name = field(parameter, "name");
+      if (name !== null) {
+        declared.push({
+          name: name.text,
+          default: field(parameter, "value"),
+          position
+        });
+      }
     }
-    const name = field(parameter, "name");
-    return name === null ? [] : [{ name: name.text, default: field(parameter, "value") }];
-  });
+    position += 1;
+  }
+  return declared;
 }
 function functionOf(node) {
   if (node.type === "program") {
@@ -1639,7 +1997,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)
@@ -2031,25 +2389,56 @@ var rubyRows = [
 
 // src/values/evaluator.ts
 var evaluators = /* @__PURE__ */ new WeakMap();
+var contexts = /* @__PURE__ */ new WeakMap();
 var withoutFacts = /* @__PURE__ */ new WeakMap();
+var filesByTree = /* @__PURE__ */ new WeakMap();
 var METHOD_TYPES3 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
 function bindEvaluator(db, nodes) {
-  evaluators.set(
-    db,
-    new Evaluator(
-      rubyLowering({ context: contextOver(db, nodes), rows: rubyRows })
-    )
-  );
+  for (const entry of nodes.files) {
+    filesByTree.set(entry.root.tree, entry.file);
+  }
+  const context = contextOver(db, nodes);
+  contexts.set(db, context);
+  evaluators.set(db, new Evaluator(rubyLowering({ context, rows: rubyRows })));
+}
+function writtenNodeOf(node, db, site) {
+  const context = db === void 0 ? void 0 : contexts.get(db);
+  return context === void 0 ? null : context.writtenTo(node, site);
 }
-function evaluatedValue(node, db, bindings) {
+function evaluatedValue(node, db, bindings, site) {
   const evaluator = evaluatorFor(node, db);
   if (bindings === void 0) {
-    return force(evaluator.evaluate(node));
+    return force(
+      site === void 0 ? evaluator.evaluate(node) : evaluator.evaluate(node, { site })
+    );
   }
   const supplied = new Map(
     [...bindings].map(([name, value]) => [name, text(value)])
   );
-  return force(evaluator.evaluate(node, { bindings: supplied }));
+  return force(
+    evaluator.evaluate(node, {
+      bindings: supplied,
+      ...site === void 0 ? {} : { site }
+    })
+  );
+}
+function constructionSitesOf(node, db) {
+  const cls = enclosingClass(node);
+  const file = cls === null ? void 0 : filesByTree.get(cls.tree);
+  if (db === void 0 || cls === null || file === void 0) {
+    return [];
+  }
+  return constructionSites(db, nodeId(file, cls));
+}
+function enclosingClass(node) {
+  let current = node.parent;
+  while (current !== null) {
+    if (current.type === "class") {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
 }
 function stringValueOf(node, db, bindings) {
   return literalOf(evaluatedValue(node, db, bindings));
@@ -2101,15 +2490,13 @@ function contextOver(db, nodes) {
   }
   const fileOf = (node) => filesByRoot.get(node.tree.rootNode.id)?.file ?? null;
   return {
-    writtenTo: (node) => {
+    writtenTo: (node, site) => {
       const file = fileOf(node);
       if (file === null) {
         return null;
       }
-      const answer = writtenValueOf(
-        db,
-        readKey(file, node, enclosingMethod(node))
-      );
+      const key = readKey(file, node, enclosingMethod(node));
+      const answer = site === void 0 ? writtenValueOf(db, key) : writtenValueUnder(db, key, site);
       return answer === null ? null : nodeOfKey(rootsByFile, answer);
     },
     callable: (call) => {
@@ -2127,125 +2514,141 @@ 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;
+// src/values/literals.ts
+import { force as force2, literalOf as literalOf2 } from "@suss/values";
+function literalElementsIn(value) {
+  if (value.kind !== "sequence") {
+    return null;
   }
-  const names = /* @__PURE__ */ new Set();
-  let unreadable = false;
-  for (const call of calls) {
-    const defined = namesDefinedBy(call);
-    if (defined === null) {
-      unreadable = true;
-      continue;
+  const elements = [];
+  for (const item of value.items) {
+    const literal = literalOf2(force2(item.value));
+    if (literal === null) {
+      return null;
     }
-    for (const name of defined) {
-      names.add(name);
+    elements.push(literal);
+  }
+  return elements;
+}
+function literalElementsOf(node, db) {
+  return literalElementsIn(evaluatedValue(node, db));
+}
+function namesOf(node, db) {
+  const value = evaluatedValue(node, db);
+  const single = literalOf2(value);
+  return single === null ? literalElementsIn(value) : [single];
+}
+
+// src/defineMethod.ts
+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))
+      )
+    );
+  }
+  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 = literalOf3(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;
     }
-    turns = turns.flatMap(
-      (base) => perElement.map((element) => new Map([...base, ...element]))
-    );
-  }
-  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 });
+    const options = piece.options.filter((option) => option.length > 0);
+    if (options.length === 0) {
+      continue;
     }
-    current = parent;
+    readSomething = true;
+    source += `(?:${options.map(escapeForPattern).join("|")})`;
   }
-  return blocks;
+  return readSomething ? new RegExp(`${source}$`) : null;
 }
-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 escapeForPattern(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function literalElementsOf(node) {
-  const value = evaluatedValue(node);
-  if (value.kind !== "sequence") {
-    return null;
+function loopTurns(db, rootsByFile, nameKey2) {
+  let turns = [/* @__PURE__ */ new Map()];
+  for (const over of listsBehind(db, rootsByFile, nameKey2)) {
+    turns = turns.flatMap(
+      (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;
+      })
+    );
   }
-  const elements = [];
-  for (const item of value.items) {
-    const literal = literalOf2(force2(item.value));
-    if (literal === null) {
-      return null;
+  return turns;
+}
+function listsBehind(db, rootsByFile, nameKey2) {
+  const found = [];
+  for (const [, element, index, overKey] of db.lookup(
+    "nameTurnsOn",
+    0,
+    nameKey2
+  )) {
+    const node = nodeOfKey2(rootsByFile, String(overKey));
+    const elements = node === null ? null : literalElementsOf(node, db);
+    if (elements !== null) {
+      found.push({ element: String(element), index: String(index), elements });
     }
-    elements.push(literal);
   }
-  return elements;
+  return found;
 }
 
 // src/scope.ts
@@ -2374,8 +2777,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 +2903,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 +2915,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 +2929,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 +2939,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 };
 }
@@ -2577,108 +2981,12 @@ import {
 import { absentReading as absentReading2, unreadableReading as unreadableReading2 } from "@suss/extractor";
 
 // src/clientCalls.ts
-import { namesNothing, restBinding } from "@suss/behavioral-ir";
+import { hasNameHole, namesNothing, restBinding } from "@suss/behavioral-ir";
 import { pathOf } from "@suss/values";
 
 // src/paths/effects.ts
 import { enumerateOrDegrade, sharedGatingConditions } from "@suss/extractor";
-
-// src/paths/bareCalls.ts
-var PARAMETER_LIST_TYPES = [
-  "method_parameters",
-  "block_parameters",
-  "lambda_parameters",
-  "parameters"
-];
-function isFieldOf(parent, node, name) {
-  return field(parent, name)?.id === node.id;
-}
-function namedAt(parent, node) {
-  return isFieldOf(parent, node, "name");
-}
-function always() {
-  return true;
-}
-var SPELLS_A_NAME = {
-  call: (parent, node) => isFieldOf(parent, node, "method") || isFieldOf(parent, node, "receiver"),
-  method: namedAt,
-  singleton_method: namedAt,
-  assignment: (parent, node) => isFieldOf(parent, node, "left"),
-  operator_assignment: (parent, node) => isFieldOf(parent, node, "left"),
-  for: (parent, node) => isFieldOf(parent, node, "pattern"),
-  optional_parameter: namedAt,
-  splat_parameter: namedAt,
-  hash_splat_parameter: namedAt,
-  keyword_parameter: namedAt,
-  block_parameter: namedAt,
-  destructured_parameter: always,
-  left_assignment_list: always,
-  rest_assignment: always,
-  destructured_left_assignment: always,
-  exception_variable: always,
-  undef: always,
-  alias: always,
-  ...Object.fromEntries(PARAMETER_LIST_TYPES.map((type) => [type, always]))
-};
-function addNamesUnder(node, names) {
-  if (node === null) {
-    return;
-  }
-  if (node.type === "identifier") {
-    names.add(node.text);
-    return;
-  }
-  for (const child of bodyStatements(node)) {
-    addNamesUnder(child, names);
-  }
-}
-function parameterNames2(node, names) {
-  for (const parameter of bodyStatements(node)) {
-    if (parameter.type === "identifier") {
-      names.add(parameter.text);
-      continue;
-    }
-    const declared = field(parameter, "name");
-    if (declared !== null && declared.type === "identifier") {
-      names.add(declared.text);
-      continue;
-    }
-    addNamesUnder(parameter, names);
-  }
-}
-function assignedNames(node, names) {
-  addNamesUnder(field(node, "left"), names);
-}
-var BINDS_A_NAME = {
-  assignment: assignedNames,
-  operator_assignment: assignedNames,
-  for: (node, names) => addNamesUnder(field(node, "pattern"), names),
-  exception_variable: (node, names) => addNamesUnder(node, names),
-  ...Object.fromEntries(
-    PARAMETER_LIST_TYPES.map((type) => [type, parameterNames2])
-  )
-};
-function localNamesIn(definitionNode) {
-  const names = /* @__PURE__ */ new Set();
-  const visit = (node) => {
-    BINDS_A_NAME[node.type]?.(node, names);
-    for (const child of bodyStatements(node)) {
-      visit(child);
-    }
-  };
-  visit(definitionNode);
-  return names;
-}
-function isBareMethodCall(node, locals) {
-  if (node.type !== "identifier" || locals.has(node.text)) {
-    return false;
-  }
-  const parent = node.parent;
-  if (parent === null) {
-    return false;
-  }
-  return SPELLS_A_NAME[parent.type]?.(parent, node) !== true;
-}
+import { constantOf, literalOf as literalOf4 } from "@suss/values";
 
 // src/paths/lowering.ts
 var RAISE_NAMES = /* @__PURE__ */ new Set(["raise", "fail"]);
@@ -2959,30 +3267,28 @@ 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",
-  "do_block",
-  "block"
-]);
-var LITERAL_ARGS = {
-  string: (node) => ({
-    kind: "string",
-    value: node.text.replace(/^["']|["']$/g, "")
-  }),
-  integer: (node) => {
-    const value = Number.parseInt(node.text, 10);
-    return Number.isNaN(value) ? null : { kind: "number", value };
-  },
-  float: (node) => {
-    const value = Number.parseFloat(node.text);
-    return Number.isNaN(value) ? null : { kind: "number", value };
-  },
-  true: () => ({ kind: "boolean", value: true }),
-  false: () => ({ kind: "boolean", value: false }),
-  simple_symbol: (node) => ({ kind: "string", value: node.text.slice(1) })
-};
+  "else",
+  "do_block",
+  "block"
+]);
+function literalArgOf(node, facts) {
+  const value = evaluatedValue(node, facts);
+  const text2 = literalOf4(value);
+  if (text2 !== null) {
+    return { kind: "string", value: text2 };
+  }
+  const constant2 = constantOf(value);
+  if (typeof constant2 === "number") {
+    return { kind: "number", value: constant2 };
+  }
+  if (typeof constant2 === "boolean") {
+    return { kind: "boolean", value: constant2 };
+  }
+  return null;
+}
 function children2(node) {
   return node.namedChildren.filter((child) => child !== null);
 }
@@ -3066,36 +3372,40 @@ function calleeText(call) {
   }
   return receiver === null ? method : `${receiver.text}.${method}`;
 }
-function argOf(node) {
-  const literal = LITERAL_ARGS[node.type]?.(node);
-  if (literal !== null && literal !== void 0) {
+function argOf(node, facts) {
+  const literal = literalArgOf(node, facts);
+  if (literal !== null) {
     return literal;
   }
   if (node.type === "call" && !isArglessReceiverCall(node)) {
-    return { kind: "call", callee: calleeText(node), args: argsOf(node) };
+    return {
+      kind: "call",
+      callee: calleeText(node),
+      args: argsOf(node, facts)
+    };
   }
   return { kind: "identifier", name: node.text };
 }
-function argsOf(call) {
+function argsOf(call, facts) {
   const args = field(call, "arguments");
   if (args === null) {
     return [];
   }
   return children2(args).map(
-    (child) => child.type === "pair" ? argOf(field(child, "value") ?? child) : argOf(child)
+    (child) => child.type === "pair" ? argOf(field(child, "value") ?? child, facts) : argOf(child, facts)
   );
 }
 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;
   }
   return current;
 }
-function invocationEffects(definitionNode, inherited = NO_INHERITED_METHODS, keepsArglessCall = NO_ARGLESS_CALLS) {
+function invocationEffects(definitionNode, inherited = NO_INHERITED_METHODS, keepsArglessCall = NO_ARGLESS_CALLS, facts) {
   const body = field(definitionNode, "body");
   if (body === null) {
     return [];
@@ -3135,7 +3445,7 @@ function invocationEffects(definitionNode, inherited = NO_INHERITED_METHODS, kee
     return {
       type: "invocation",
       callee: calleeText(call),
-      args: argsOf(call),
+      args: argsOf(call, facts),
       async: false,
       ...conditions.length > 0 ? { preconditions: conditions } : {}
     };
@@ -3150,7 +3460,7 @@ import {
   unreadableReading,
   writtenReading
 } from "@suss/extractor";
-import { constantOf, literalOf as literalOf4 } from "@suss/values";
+import { constantOf as constantOf2, literalOf as literalOf6 } from "@suss/values";
 
 // src/paths/predicates.ts
 var OPERATORS = {
@@ -3219,7 +3529,7 @@ function binaryOf(node) {
   return opaqueOf(node);
 }
 function valueRefOf(node) {
-  const literal = literalOf3(node);
+  const literal = literalOf5(node);
   if (literal !== null) {
     return literal;
   }
@@ -3232,7 +3542,7 @@ function valueRefOf(node) {
   }
   return { type: "unresolved", sourceText: node.text };
 }
-function literalOf3(node) {
+function literalOf5(node) {
   if (node.type === "integer") {
     const value = Number.parseInt(node.text, 10);
     return Number.isNaN(value) ? null : { type: "literal", value };
@@ -3275,13 +3585,13 @@ function statusArgumentOf(call, declaration) {
   }
   return args.positional[declaration.statusArgument] ?? null;
 }
-function statusNumberOf(node, names) {
-  const value = evaluatedValue(node);
-  const constant2 = constantOf(value);
+function statusNumberOf(node, names, facts) {
+  const value = evaluatedValue(node, facts);
+  const constant2 = constantOf2(value);
   if (typeof constant2 === "number") {
     return constant2;
   }
-  const name = literalOf4(value);
+  const name = literalOf6(value);
   return name === null ? null : names[name] ?? null;
 }
 function declarationsByName(declarations) {
@@ -3325,12 +3635,12 @@ function collectReturns(node, found) {
   }
   return found;
 }
-function readingOfCall(call, declaration, names) {
+function readingOfCall(call, declaration, names, facts) {
   const argument = statusArgumentOf(call, declaration);
   if (argument === null) {
     return declaration.defaultStatusCode === void 0 ? absentReading : writtenReading(declaration.defaultStatusCode, rangeOf(call));
   }
-  const status = statusNumberOf(argument, names);
+  const status = statusNumberOf(argument, names, facts);
   if (status === null) {
     return unreadableReading(
       "This response writes a status that does not settle on a number here, so this outcome claims none",
@@ -3474,7 +3784,7 @@ function responseBranches(method, pattern, effects, extraEffects, options = {})
   const outcomes = [];
   for (const terminal of terminals) {
     const declaration = declarationOf(terminal, byName, locals);
-    const reading = declaration === void 0 ? absentReading : readingOfCall(terminal, declaration, statusNames);
+    const reading = declaration === void 0 ? absentReading : readingOfCall(terminal, declaration, statusNames, options.facts);
     for (const path7 of enumerated.byTerminal.get(terminal) ?? []) {
       outcomes.push({
         conditions: path7.map(conditionOf),
@@ -3508,11 +3818,9 @@ function clientCallUnits(root, pack, pattern, options) {
       continue;
     }
     for (const call of callsUnder(method)) {
-      const request = requestCall(call, method, root, pattern, options);
-      if (request === null) {
-        continue;
+      for (const request of requestCalls(call, pattern, options)) {
+        units.push(clientUnit(method, name, request, pattern, pack, options));
       }
-      units.push(clientUnit(method, name, request, pattern, pack, options));
     }
   }
   return units;
@@ -3541,36 +3849,60 @@ function callsUnder(node, found = []) {
   }
   return found;
 }
-function requestCall(call, method, root, pattern, options) {
+function requestCalls(call, pattern, options) {
   const receiver = field(call, "receiver");
   const called = field(call, "method")?.text;
-  if (receiver === null || called === void 0) {
-    return null;
+  if (receiver === null || called === void 0 || !isLibraryReceiver(receiver, pattern, options)) {
+    return [];
   }
-  const prefix = receiverPrefix(receiver, method, root, pattern, options);
-  if (prefix === null) {
-    return null;
+  const read = (site) => requestCall(
+    call,
+    called,
+    receiverPrefix(receiver, pattern, options, site),
+    pattern,
+    options,
+    site
+  );
+  const plain = read();
+  if (plain !== null && !hasNameHole(plain.path)) {
+    return [plain];
+  }
+  const byBoundary = /* @__PURE__ */ new Map();
+  for (const site of constructionSitesOf(call, options.facts)) {
+    const stated = read(site);
+    if (stated !== null) {
+      byBoundary.set(`${stated.method} ${stated.path}`, stated);
+    }
   }
+  if (byBoundary.size > 0) {
+    return [...byBoundary.values()];
+  }
+  return plain === null ? [] : [plain];
+}
+function requestCall(call, called, prefix, pattern, options, site) {
   const args = readCallArgs(field(call, "arguments"));
   const verb = pattern.verbMethodNames[called];
   if (verb !== void 0) {
-    const path8 = urlIn(args, pattern, options);
+    const path8 = urlIn(args, pattern, options, site);
     return path8 === null ? null : { method: verb, path: prefix + path8 };
   }
   const sent = pattern.requestObject;
   if (sent === void 0 || sent.attribute !== called) {
     return null;
   }
-  const built = requestBuilt(args.positional[0], method, sent);
+  const built = requestBuilt(args.positional[0], sent, options, site);
   if (built === null) {
     return null;
   }
-  const path7 = pathAt(built.url, options);
+  const path7 = pathAt(built.url, options, site);
   return path7 === null ? null : { method: built.method, path: prefix + path7 };
 }
-function requestBuilt(argument, method, sent) {
-  const written = argument === void 0 ? null : assignedCall(argument, method) ?? argument;
-  if (written === null || written.type !== "call") {
+function requestBuilt(argument, sent, options, site) {
+  if (argument === void 0) {
+    return null;
+  }
+  const written = writtenNodeOf(argument, options.facts, site) ?? argument;
+  if (written.type !== "call") {
     return null;
   }
   const requestClass = field(written, "receiver")?.text;
@@ -3581,28 +3913,18 @@ function requestBuilt(argument, method, sent) {
   const args = readCallArgs(field(written, "arguments"));
   return { method: verb, url: args.positional[sent.urlPosition] };
 }
-function assignedCall(node, method) {
-  if (node.type !== "identifier") {
-    return null;
-  }
-  const value = assignedValue(node.text, method);
-  return value !== null && value.type === "call" ? value : null;
+function isLibraryReceiver(receiver, pattern, options) {
+  return namesConstant(receiver, pattern.constantName) || builderCallBehind(receiver, pattern, options.facts) !== null;
 }
-function receiverPrefix(receiver, method, root, pattern, options) {
-  if (namesConstant(receiver, pattern.constantName)) {
-    return "";
-  }
-  if (receiver.type !== "identifier") {
-    return null;
-  }
-  const built = builtBy(receiver.text, method, root, pattern);
+function receiverPrefix(receiver, pattern, options, site) {
+  const built = builderCallBehind(receiver, pattern, options.facts);
   if (built === null) {
-    return null;
+    return "";
   }
   const args = readCallArgs(field(built, "arguments"));
   const keyword = pattern.builderUrlKeyword;
   const base = (keyword === void 0 ? void 0 : args.keyword[keyword]) ?? args.positional[0];
-  const path7 = base === void 0 ? null : pathOf(evaluatedValue(base, options.facts));
+  const path7 = base === void 0 ? null : pathOf(evaluatedValue(base, options.facts, void 0, site));
   return path7 === void 0 || path7 === null ? "" : trimmed(path7);
 }
 function trimmed(path7) {
@@ -3614,61 +3936,28 @@ function namesConstant(receiver, constantName2) {
   }
   return receiver.type === "scope_resolution" && compoundName(receiver) === constantName2;
 }
-function builtBy(name, method, root, pattern) {
+function builderCallBehind(receiver, pattern, facts) {
   const builders = pattern.receiverBuilders ?? [];
   if (builders.length === 0) {
     return null;
   }
-  const value = assignedValue(name, method) ?? valueMethodNamedReturns(name, root);
-  if (value === null || value.type !== "call" || !builders.includes(field(value, "method")?.text ?? "")) {
-    return null;
-  }
-  const receiver = field(value, "receiver");
-  return receiver !== null && namesConstant(receiver, pattern.constantName) ? value : null;
-}
-function valueMethodNamedReturns(name, root) {
-  const defined = methodDefinitions(root).find(
-    (candidate) => field(candidate, "name")?.text === name
-  );
-  if (defined === void 0) {
-    return null;
-  }
-  const body = field(defined, "body");
-  const statements = body === null ? [] : body.namedChildren;
-  const last = statements[statements.length - 1];
-  if (last === void 0) {
-    return null;
-  }
-  if (last.type === "operator_assignment" || last.type === "assignment") {
-    return field(last, "right");
-  }
-  return last.type === "return" ? last.namedChildren[0] ?? null : last;
-}
-function assignedValue(name, method) {
-  const body = field(method, "body");
-  if (body === null) {
+  const written = writtenNodeOf(receiver, facts);
+  if (written === null || written.type !== "call" || !builders.includes(field(written, "method")?.text ?? "")) {
     return null;
   }
-  for (const statement of runStatements(body)) {
-    if (statement.type !== "assignment") {
-      continue;
-    }
-    if (field(statement, "left")?.text === name) {
-      return field(statement, "right");
-    }
-  }
-  return null;
+  const constant2 = field(written, "receiver");
+  return constant2 !== null && namesConstant(constant2, pattern.constantName) ? written : null;
 }
-function urlIn(args, pattern, options) {
+function urlIn(args, pattern, options, site) {
   const keyword = pattern.url.keyword;
   const written = (keyword === void 0 ? void 0 : args.keyword[keyword]) ?? args.positional[pattern.url.position];
-  return pathAt(written, options);
+  return pathAt(written, options, site);
 }
-function pathAt(written, options) {
+function pathAt(written, options, site) {
   if (written === void 0) {
     return null;
   }
-  const path7 = pathOf(evaluatedValue(written, options.facts));
+  const path7 = pathOf(evaluatedValue(written, options.facts, void 0, site));
   return path7 === void 0 || namesNothing(path7) ? null : path7;
 }
 function clientUnit(method, name, request, pattern, pack, options) {
@@ -3691,15 +3980,15 @@ function clientUnit(method, name, request, pattern, pack, options) {
       recognition: pack.name
     }),
     parameters: [],
-    branches: callerBranches(method, range),
+    branches: callerBranches(method, range, options.facts),
     ...responseAccessors(pattern),
     bodyContent: "statements",
     dependencyCalls: [],
     declaredContract: null
   };
 }
-function callerBranches(method, range) {
-  const effects = invocationEffects(method);
+function callerBranches(method, range, facts) {
+  const effects = invocationEffects(method, void 0, void 0, facts);
   return returnPathBranches(method, effects) ?? [returnBranch(range, effects)];
 }
 function responseAccessors(pattern) {
@@ -3837,7 +4126,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 [];
@@ -3857,7 +4146,7 @@ function controllerFilters(pattern, ancestry) {
     }
     const form = byName.get(called);
     if (form !== void 0) {
-      for (const declaration of declarationsOf(statement, form)) {
+      for (const declaration of declarationsOf(statement, form, read.facts)) {
         declared = [
           ...declared.filter((earlier) => !sameFilter(earlier, declaration)),
           declaration
@@ -3867,12 +4156,12 @@ function controllerFilters(pattern, ancestry) {
     }
     const skipped = skipNames.get(called);
     if (skipped !== void 0) {
-      declared = applySkips(declared, skipsOf(statement, skipped));
+      declared = applySkips(declared, skipsOf(statement, skipped, read.facts));
     }
   }
   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;
     }
@@ -3904,14 +4193,14 @@ function filterReference(filter, displayPath) {
     ...filter.filter.onThrow === true ? { onThrow: true } : {}
   };
 }
-function filterUnit(filter, pattern, displayPath, body) {
+function filterUnit(filter, pattern, displayPath, body, facts) {
   const range = rangeOf(filter.method);
   const branches = responseBranches(
     filter.method,
     pattern,
     body.effects ?? [],
     body.extraEffects,
-    { fallthrough: "handOn" }
+    { fallthrough: "handOn", facts }
   );
   return {
     identity: {
@@ -3959,30 +4248,30 @@ function calledName(statement) {
   }
   return field(statement, "method")?.text ?? null;
 }
-function declarationsOf(statement, filter) {
+function declarationsOf(statement, filter, facts) {
   const args = readCallArgs(field(statement, "arguments"));
   const keywords = filter.actionKeywords;
-  const only = keywords === void 0 ? null : namesUnder(args.keyword[keywords.include]);
-  const except = keywords === void 0 ? null : namesUnder(args.keyword[keywords.exclude]);
-  return methodNamesOf(args, filter).map((methodName) => ({
+  const only = keywords === void 0 ? null : actionsUnder(args.keyword[keywords.include], facts);
+  const except = keywords === void 0 ? null : actionsUnder(args.keyword[keywords.exclude], facts);
+  return methodNamesOf(args, filter, facts).map((methodName) => ({
     filter,
     methodName,
     only,
     except: except ?? /* @__PURE__ */ new Set()
   }));
 }
-function methodNamesOf(args, filter) {
+function methodNamesOf(args, filter, facts) {
   if (filter.methodFrom === "withKeyword") {
     const named2 = args.keyword.with;
-    const value = named2 === void 0 ? null : symbolValue(named2);
+    const value = named2 === void 0 ? null : stringValueOf(named2, facts);
     return value === null ? [] : [value];
   }
-  return args.positional.map((arg) => symbolValue(arg)).filter((name) => name !== null);
+  return args.positional.map((arg) => stringValueOf(arg, facts)).filter((name) => name !== null);
 }
-function skipsOf(statement, filterName) {
+function skipsOf(statement, filterName, facts) {
   const args = readCallArgs(field(statement, "arguments"));
-  const actions = namesUnder(args.keyword.only);
-  return args.positional.map((arg) => symbolValue(arg)).filter((name) => name !== null).map((methodName) => ({ filterName, methodName, actions }));
+  const actions = actionsUnder(args.keyword.only, facts);
+  return args.positional.map((arg) => stringValueOf(arg, facts)).filter((name) => name !== null).map((methodName) => ({ filterName, methodName, actions }));
 }
 function sameFilter(one, other) {
   return one.filter.name === other.filter.name && one.methodName === other.methodName;
@@ -4006,26 +4295,12 @@ function applySkips(declared, skips) {
   }
   return left;
 }
-function namesUnder(node) {
+function actionsUnder(node, facts) {
   if (node === void 0) {
     return null;
   }
-  const single = symbolValue(node);
-  if (single !== null) {
-    return /* @__PURE__ */ new Set([single]);
-  }
-  if (node.type !== "array" && node.type !== "symbol_array") {
-    return null;
-  }
-  const names = /* @__PURE__ */ new Set();
-  for (const child of bodyStatements(node)) {
-    const bare = child.type === "bare_symbol" ? child.text : null;
-    const name = symbolValue(child) ?? bare;
-    if (name !== null) {
-      names.add(name);
-    }
-  }
-  return names;
+  const found = namesOf(node, facts);
+  return found === null ? null : new Set(found);
 }
 
 // src/storage.ts
@@ -4076,28 +4351,95 @@ 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");
-      if (key !== null) {
-        picked.push(key.text.replace(/^:/, "").replace(/:$/, ""));
-      }
+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 recordFieldsOf(argument, facts) {
+  const value = evaluatedValue(argument, facts);
+  return value.kind === "record" ? [...value.fields.keys()] : [];
+}
+function keywordKeys(call, facts) {
+  const keys = [];
+  for (const argument of argumentsOf2(call)) {
+    if (argument.type !== "pair") {
+      keys.push(...recordFieldsOf(argument, facts));
+      continue;
     }
-    const receiver = receiverOf(current);
-    if (receiver !== null) {
-      walk(receiver);
+    const key = field(argument, "key");
+    const name = key === null ? null : keyNameOf(key);
+    if (name !== null) {
+      keys.push(name);
     }
-  };
-  walk(node);
+  }
+  return keys;
+}
+function keyNameOf(key) {
+  return hashKeySymbolName(key) ?? symbolValue(key) ?? stringLiteralValue(key);
+}
+function hasPositionalArgument(call, facts) {
+  return argumentsOf2(call).some(
+    (argument) => argument.type !== "pair" && recordFieldsOf(argument, facts).length === 0
+  );
+}
+function columnsAskedFor(call, pattern, facts) {
+  if (!(pattern.columnArguments ?? []).includes(methodOf(call))) {
+    return [];
+  }
+  return argumentsOf2(call).map((argument) => stringValueOf(argument, facts)).filter((column) => column !== null);
+}
+function primaryKeySelector(call, pattern, facts) {
+  const byPrimaryKey = pattern.byPrimaryKey;
+  if (byPrimaryKey === void 0) {
+    return [];
+  }
+  const picks = byPrimaryKey.methods.includes(methodOf(call)) && hasPositionalArgument(call, facts);
+  return picks ? [byPrimaryKey.column] : [];
+}
+function selectorOf(call, pattern, facts) {
+  const picked = [];
+  for (const link of chainLinks(call)) {
+    picked.push(...primaryKeySelector(link, pattern, facts));
+    if (pattern.reads.includes(methodOf(link))) {
+      picked.push(...keywordKeys(link, facts));
+    }
+  }
   return [...new Set(picked)];
 }
-function storageEffect(call, container, pattern, kind, selector) {
+function fieldsOf(call, pattern, kind, facts) {
+  if (kind === "write") {
+    return [...new Set(keywordKeys(call, facts))];
+  }
+  return [
+    ...new Set(
+      chainLinks(call).flatMap((link) => columnsAskedFor(link, pattern, facts))
+    )
+  ];
+}
+function storageEffect(call, container, pattern, kind, selector, fields) {
   const operation = methodOf(call);
   return {
     type: "interaction",
@@ -4111,35 +4453,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 +4475,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, options.facts),
+        fieldsOf(worked, pattern, kind, options.facts)
+      )
+    ];
+  }
+  return [];
 }
 function isLoader(node, loader) {
   if (node === null) {
@@ -4214,7 +4570,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 +4578,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 +4689,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 +4782,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 +4836,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;
@@ -4477,7 +4848,8 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
       filter,
       pattern,
       displayPath,
-      bodyOfMethod(filter.method, filter.file, options)
+      bodyOfMethod(filter.method, filter.file, options),
+      options.facts
     );
     units.push(raw);
     options.onReachSeed?.(raw, {
@@ -4514,7 +4886,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 +4899,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 +4914,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]);
       }
@@ -4561,7 +4940,8 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
     method,
     pattern,
     body.effects ?? [],
-    body.extraEffects
+    body.extraEffects,
+    { facts: bodyRead.facts }
   );
   return {
     identity: {
@@ -4691,7 +5071,8 @@ function bodyOfMethod(method, file, bodyRead = {}) {
   const effects = invocationEffects(
     method,
     bodyRead.inheritedMethods,
-    EVERY_ARGLESS_CALL
+    EVERY_ARGLESS_CALL,
+    bodyRead.facts
   );
   const storage = bodyRead.storage;
   const extra = [
@@ -4808,7 +5189,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 +5234,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 +5406,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 +5636,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 +5693,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 +5717,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(
@@ -5214,6 +5810,7 @@ function parseWith(language, source) {
 import fs3 from "fs";
 import path4 from "path";
 import {
+  boundaryKey,
   disambiguateSummaryIds,
   linkCallsToSummaries,
   placeArgTargets as placeArgTargets2,
@@ -5234,6 +5831,7 @@ import {
   runDigest,
   stampModuleImports
 } from "@suss/extractor";
+import { addPackWords } from "@suss/resolution";
 
 // src/diagnostics.ts
 import {
@@ -5289,6 +5887,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 +6093,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 +6126,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 +6483,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 +6557,9 @@ async function buildReachContext(files, facts) {
     topLevelMethods,
     facts,
     classNames,
-    definitions
+    definitions,
+    bodyBlocks,
+    dynamicNames
   };
 }
 function namedChildren(node) {
@@ -5969,20 +6605,48 @@ function inheritedMethodsIn(packs) {
   }
   return found;
 }
-function emitStorageFacts(db, packs) {
-  for (const pack of packs) {
-    for (const pattern of pack.storage ?? []) {
-      for (const base of pattern.baseClasses) {
-        for (const method of pattern.givesBack) {
-          db.add("givesBackOne", [base, method]);
-        }
-      }
-    }
-  }
+function associationCallsIn(packs) {
+  return packs.flatMap(
+    (pack) => (pack.storage ?? []).flatMap(
+      (pattern) => pattern.associations === void 0 ? [] : [pattern.associations]
+    )
+  );
+}
+function packWordsOf(packs) {
+  return {
+    givesBackOne: packs.flatMap(
+      (pack) => (pack.storage ?? []).flatMap(
+        (pattern) => pattern.baseClasses.flatMap(
+          (base) => pattern.givesBack.map((method) => ({ base, method }))
+        )
+      )
+    )
+  };
+}
+function factsForFile(options) {
+  const db = new Database2();
+  const bodyBlocks = bodyBlocksIn(options.packs);
+  emitValueFacts(db, options.file, options.root, bodyBlocks);
+  emitConstantBindings(db, [
+    collectFileConstants(
+      options.file,
+      options.root,
+      associationCallsIn(options.packs),
+      inflectionsIn(options.packs)
+    )
+  ]);
+  emitRequireFacts(db, options.file, options.root, /* @__PURE__ */ new Set([options.file]));
+  bindEvaluator(db, {
+    files: [{ file: options.file, root: options.root }],
+    definitions: new Map(methodDefinitionsIn(options.file, options.root))
+  });
+  addPackWords(db, packWordsOf(options.packs));
+  return db;
 }
 function alreadyDiscovered(seen, raw) {
   const reported = raw.identity.exportPath?.join(".") ?? raw.identity.name;
-  const key = `${raw.identity.file}::${reported}::${raw.identity.range.start}`;
+  const boundary = raw.boundaryBinding === null ? "" : boundaryKey(raw.boundaryBinding) ?? "";
+  const key = `${raw.identity.file}::${reported}::${raw.identity.range.start}::${boundary}`;
   if (seen.has(key)) {
     return true;
   }
@@ -6023,6 +6687,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,21 +6697,27 @@ 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) {
       emitRequireFacts(db, file, root, known);
     }
     bindEvaluator(db, { files: parsed, definitions });
-    emitStorageFacts(db, options.packs);
+    addPackWords(db, packWordsOf(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 +6725,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 +6745,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 +6818,9 @@ async function extractRubyProject(options) {
       context: reachContext,
       displayPathOf,
       ...storage === void 0 ? {} : { storage },
-      inheritedMethods
+      inheritedMethods,
+      bodyBlocks,
+      dynamicNames
     })
   );
   for (const entry of found) {
@@ -6309,6 +6986,10 @@ function displayNameOf(node) {
 function width(node) {
   return node.endIndex - node.startIndex;
 }
+function askedKey(value) {
+  const enclosing = enclosingMethod2(value.node);
+  return calleeKeyOf(value.file, value.node, enclosing) ?? readKey(value.file, value.node, enclosing);
+}
 var RubyWhySession = class {
   root;
   db = new Database3();
@@ -6384,7 +7065,7 @@ var RubyWhySession = class {
     return explainResolvedKey({
       db: this.db,
       rules: WITNESS_RULES,
-      key: readKey(value.file, value.node, enclosingMethod2(value.node)),
+      key: askedKey(value),
       locate: (key) => this.locate(key),
       displayPath: (key) => this.displayPath(key),
       ...options
@@ -6501,6 +7182,7 @@ export {
   emitValueFacts,
   evaluatedValue,
   extractRubyProject,
+  factsForFile,
   field,
   findRubyFiles,
   graphqlTypeNameFromQualified,