@suss/adapter-ruby 0.30.0 → 0.31.0

package/dist/index.js

@@ -327,7 +327,7 @@ function autoloadDirectories(root) {
 
 // src/defineMethod.ts
 import { nodeOfKey as nodeOfKey2 } from "@suss/resolution";
-import { force as force2, hole as hole2, literalOf as literalOf2, piecesOf } from "@suss/values";
+import { hole as hole2, literalOf as literalOf3, piecesOf } from "@suss/values";
 
 // src/values/evaluator.ts
 import { nodeOfKey } from "@suss/resolution";
@@ -336,63 +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"
-  ),
-  // Ruby cannot refer to a method without running it, so
-  // `Settings.filters` is worth what the method returns. The shared
-  // rules hang that step on a `call` fact this spelling never gets.
-  rule(
-    "invokes",
-    [v("x"), v("f")],
-    [
-      lit("readsProperty", v("x"), v("o"), v("m")),
-      lit("comesTo", v("x"), v("f")),
-      lit("func", v("f"))
-    ],
-    "property read runs a method"
+      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(
-      "stepsTo",
-      [v("x"), v("o"), VALUE_STEP],
-      [lit("readsProperty", v("x"), v("o"), constant(method))],
+      "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);
@@ -404,10 +397,118 @@ 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_TYPES2 = /* @__PURE__ */ new Set(["block", "do_block"]);
@@ -432,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);
@@ -480,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)) {
@@ -494,6 +602,7 @@ var WRITE_READERS = {
   assignment: readAssignment,
   operator_assignment: readOperatorAssignment,
   for: readForVariable,
+  rescue: readRescueVariable,
   block: readBlockParameters,
   do_block: readBlockParameters
 };
@@ -539,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;
 }
@@ -561,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_TYPES2.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)) {
@@ -620,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,
@@ -665,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",
@@ -699,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") {
@@ -717,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,
@@ -754,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;
@@ -878,9 +1013,7 @@ function emitExpressionFacts(emitter, node) {
   emitDynamicDefinition(emitter, node, []);
   walkExpressions(node, emitter, (child, turns) => {
     emitDynamicDefinition(emitter, child, turns);
-    if (isPropertyRead(child)) {
-      emitPropertyRead(emitter, child);
-    } else if (child.type === "call") {
+    if (child.type === "call" || isBareCall(child, emitter.enclosing)) {
       emitCall(emitter, child);
     }
     if (ARRAY_TYPES.has(child.type)) {
@@ -936,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);
     }
   }
 }
@@ -1017,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));
     }
   });
@@ -1085,20 +1242,32 @@ 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));
@@ -1126,6 +1295,7 @@ function emitClassFacts(emitter, cls) {
   const within = {
     ...emitter,
     selfKey: classKey,
+    insideMethod: false,
     instanceWrites: collected
   };
   const statements = body === null ? [] : bodyStatementsRun(body, cls.type === "module", emitter.bodyBlocks);
@@ -1153,10 +1323,30 @@ function emitClassFacts(emitter, cls) {
       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);
@@ -1168,6 +1358,7 @@ function emitValueFacts(db, filePath, root, bodyBlocks = NO_BODY_BLOCKS) {
     filePath,
     enclosing: null,
     selfKey: null,
+    insideMethod: false,
     instanceWrites: null,
     bodyBlocks
   };
@@ -1248,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;
@@ -1765,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") {
@@ -2183,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 evaluatedValue(node, db, bindings) {
+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, 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));
@@ -2253,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) => {
@@ -2279,6 +2514,31 @@ function contextOver(db, nodes) {
   };
 }
 
+// src/values/literals.ts
+import { force as force2, literalOf as literalOf2 } from "@suss/values";
+function literalElementsIn(value) {
+  if (value.kind !== "sequence") {
+    return null;
+  }
+  const elements = [];
+  for (const item of value.items) {
+    const literal = literalOf2(force2(item.value));
+    if (literal === null) {
+      return null;
+    }
+    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(),
@@ -2326,7 +2586,7 @@ function readOne(db, rootsByFile, nameKey2) {
   const patterns = [];
   for (const bindings of loopTurns(db, rootsByFile, nameKey2)) {
     const value = node === null ? hole2(nameKey2) : evaluatedValue(node, db, bindings.size === 0 ? void 0 : bindings);
-    const name = literalOf2(value);
+    const name = literalOf3(value);
     if (name !== null) {
       names.push(name);
       continue;
@@ -2382,29 +2642,14 @@ function listsBehind(db, rootsByFile, nameKey2) {
     0,
     nameKey2
   )) {
-    const elements = literalElementsOf(rootsByFile, String(overKey), db);
+    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 });
     }
   }
   return found;
 }
-function literalElementsOf(rootsByFile, key, db) {
-  const node = nodeOfKey2(rootsByFile, key);
-  const value = node === null ? null : evaluatedValue(node, db);
-  if (value === null || value.kind !== "sequence") {
-    return null;
-  }
-  const elements = [];
-  for (const item of value.items) {
-    const literal = literalOf2(force2(item.value));
-    if (literal === null) {
-      return null;
-    }
-    elements.push(literal);
-  }
-  return elements;
-}
 
 // src/scope.ts
 function qualifyConstantRef(node, nesting) {
@@ -2736,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"]);
@@ -3125,23 +3274,21 @@ var BLOCK_TYPES5 = /* @__PURE__ */ new Set([
   "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) })
-};
+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);
 }
@@ -3225,23 +3372,27 @@ 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) {
@@ -3254,7 +3405,7 @@ function enclosingStatement(call, body) {
   }
   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 [];
@@ -3294,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 } : {}
     };
@@ -3309,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 = {
@@ -3378,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;
   }
@@ -3391,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 };
@@ -3434,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) {
@@ -3484,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",
@@ -3633,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),
@@ -3667,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;
@@ -3700,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;
@@ -3740,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) {
@@ -3773,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 ?? "")) {
+  const written = writtenNodeOf(receiver, facts);
+  if (written === null || written.type !== "call" || !builders.includes(field(written, "method")?.text ?? "")) {
     return null;
   }
-  const receiver = field(value, "receiver");
-  return receiver !== null && namesConstant(receiver, pattern.constantName) ? value : null;
+  const constant2 = field(written, "receiver");
+  return constant2 !== null && namesConstant(constant2, pattern.constantName) ? written : 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) {
-    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;
-}
-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) {
@@ -3850,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) {
@@ -4016,7 +4146,7 @@ function controllerFilters(pattern, ancestry, read = {}) {
     }
     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
@@ -4026,7 +4156,7 @@ function controllerFilters(pattern, ancestry, read = {}) {
     }
     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 = [];
@@ -4063,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: {
@@ -4118,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;
@@ -4165,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
@@ -4262,67 +4378,64 @@ function argumentsOf2(call) {
   const args = field(call, "arguments");
   return args === null ? [] : children3(args);
 }
-function isKeywordArgument(argument) {
-  return argument.type === "pair" || argument.type === "hash";
-}
-function bareName(node) {
-  return node.text.replace(/^:/, "").replace(/:$/, "");
-}
-function pairsIn(argument) {
-  if (argument.type === "pair") {
-    return [argument];
-  }
-  if (argument.type === "hash") {
-    return children3(argument).filter((child) => child.type === "pair");
-  }
-  return [];
+function recordFieldsOf(argument, facts) {
+  const value = evaluatedValue(argument, facts);
+  return value.kind === "record" ? [...value.fields.keys()] : [];
 }
-function keywordKeys(call) {
+function keywordKeys(call, facts) {
   const keys = [];
   for (const argument of argumentsOf2(call)) {
-    for (const pair of pairsIn(argument)) {
-      const key = field(pair, "key");
-      if (key !== null) {
-        keys.push(bareName(key));
-      }
+    if (argument.type !== "pair") {
+      keys.push(...recordFieldsOf(argument, facts));
+      continue;
+    }
+    const key = field(argument, "key");
+    const name = key === null ? null : keyNameOf(key);
+    if (name !== null) {
+      keys.push(name);
     }
   }
   return keys;
 }
-function hasPositionalArgument(call) {
-  return argumentsOf2(call).some((argument) => !isKeywordArgument(argument));
+function keyNameOf(key) {
+  return hashKeySymbolName(key) ?? symbolValue(key) ?? stringLiteralValue(key);
 }
-function columnsAskedFor(call, pattern) {
+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).filter((argument) => argument.type === "simple_symbol").map(bareName);
+  return argumentsOf2(call).map((argument) => stringValueOf(argument, facts)).filter((column) => column !== null);
 }
-function primaryKeySelector(call, pattern) {
+function primaryKeySelector(call, pattern, facts) {
   const byPrimaryKey = pattern.byPrimaryKey;
   if (byPrimaryKey === void 0) {
     return [];
   }
-  const picks = byPrimaryKey.methods.includes(methodOf(call)) && hasPositionalArgument(call);
+  const picks = byPrimaryKey.methods.includes(methodOf(call)) && hasPositionalArgument(call, facts);
   return picks ? [byPrimaryKey.column] : [];
 }
-function selectorOf(call, pattern) {
+function selectorOf(call, pattern, facts) {
   const picked = [];
   for (const link of chainLinks(call)) {
-    picked.push(...primaryKeySelector(link, pattern));
+    picked.push(...primaryKeySelector(link, pattern, facts));
     if (pattern.reads.includes(methodOf(link))) {
-      picked.push(...keywordKeys(link));
+      picked.push(...keywordKeys(link, facts));
     }
   }
   return [...new Set(picked)];
 }
-function fieldsOf(call, pattern, kind) {
+function fieldsOf(call, pattern, kind, facts) {
   if (kind === "write") {
-    return [...new Set(keywordKeys(call))];
+    return [...new Set(keywordKeys(call, facts))];
   }
   return [
     ...new Set(
-      chainLinks(call).flatMap((link) => columnsAskedFor(link, pattern))
+      chainLinks(call).flatMap((link) => columnsAskedFor(link, pattern, facts))
     )
   ];
 }
@@ -4414,8 +4527,8 @@ function modelCallEffects(call, file, options, enclosing) {
         target.container,
         pattern,
         kind,
-        selectorOf(worked, pattern),
-        fieldsOf(worked, pattern, kind)
+        selectorOf(worked, pattern, options.facts),
+        fieldsOf(worked, pattern, kind, options.facts)
       )
     ];
   }
@@ -4735,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, {
@@ -4826,7 +4940,8 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
     method,
     pattern,
     body.effects ?? [],
-    body.extraEffects
+    body.extraEffects,
+    { facts: bodyRead.facts }
   );
   return {
     identity: {
@@ -4956,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 = [
@@ -5694,6 +5810,7 @@ function parseWith(language, source) {
 import fs3 from "fs";
 import path4 from "path";
 import {
+  boundaryKey,
   disambiguateSummaryIds,
   linkCallsToSummaries,
   placeArgTargets as placeArgTargets2,
@@ -5714,6 +5831,7 @@ import {
   runDigest,
   stampModuleImports
 } from "@suss/extractor";
+import { addPackWords } from "@suss/resolution";
 
 // src/diagnostics.ts
 import {
@@ -6494,20 +6612,41 @@ function associationCallsIn(packs) {
     )
   );
 }
-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 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;
   }
@@ -6574,7 +6713,7 @@ async function extractRubyProject(options) {
       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]))
@@ -6847,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();
@@ -6922,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
@@ -7039,6 +7182,7 @@ export {
   emitValueFacts,
   evaluatedValue,
   extractRubyProject,
+  factsForFile,
   field,
   findRubyFiles,
   graphqlTypeNameFromQualified,