@suss/adapter-python 0.27.0 → 0.29.0

package/dist/index.js

@@ -24,6 +24,11 @@ function isType(node, ...types) {
 function isFunction(node) {
   return node.type === "function_definition" || node.type === "lambda";
 }
+var LATER_BODY_TYPES = /* @__PURE__ */ new Set([
+  "function_definition",
+  "lambda",
+  "class_definition"
+]);
 function enclosingFunction(node) {
   let current = node.parent;
   while (current !== null) {
@@ -1408,14 +1413,14 @@ function invocationEffects(definitionNode) {
   if (calls.length === 0) {
     return [];
   }
-  const statementOf2 = /* @__PURE__ */ new Map();
+  const statementOf3 = /* @__PURE__ */ new Map();
   const statements = [];
   for (const call of calls) {
     const statement = enclosingStatement(call, body);
     if (statement === null) {
       continue;
     }
-    statementOf2.set(call.id, statement);
+    statementOf3.set(call.id, statement);
     statements.push(statement);
   }
   const lowered = lowerPythonBody(body, statements);
@@ -1427,7 +1432,7 @@ function invocationEffects(definitionNode) {
     statements
   );
   return calls.map((call) => {
-    const statement = statementOf2.get(call.id);
+    const statement = statementOf3.get(call.id);
     const conditions = sharedGatingConditions(
       statement === void 0 ? void 0 : enumerated.byTerminal.get(statement),
       predicateOf
@@ -1446,40 +1451,22 @@ function invocationEffects(definitionNode) {
 import { mountPathsOf } from "@suss/resolution";
 
 // src/facts/resolve.ts
-import { deriveOnDemand, evaluate } from "@suss/datalog";
 import {
-  ANSWER_RELATIONS,
+  askResolution,
   placeholderValues,
-  RESOLUTION_QUESTIONS,
-  RESOLUTION_RULES,
   writtenValueOf as sharedWrittenValueOf,
   singleAnswers
 } from "@suss/resolution";
-var RESOLUTION_PROGRAM = deriveOnDemand(
-  [...RESOLUTION_RULES, ...RESOLUTION_QUESTIONS],
-  ANSWER_RELATIONS
-);
 function resolveCalls(db, callKeys) {
-  const asked = new Set(db.facts("wanted").map((row) => String(row[0])));
-  const fresh = callKeys.filter((key) => !asked.has(key));
-  if (fresh.length === 0) {
-    return;
-  }
-  for (const callKey of fresh) {
-    db.add("wanted", [callKey]);
-  }
-  evaluate(db, RESOLUTION_PROGRAM.rules);
+  askResolution(db, callKeys);
 }
 function writtenValueOf(db, key) {
   resolveCalls(db, [key]);
   return sharedWrittenValueOf(db, key, (keys) => resolveCalls(db, keys));
 }
-function originsOf(db, nameKey) {
-  if (!db.facts("wantedOrigin").some((row) => String(row[0]) === nameKey)) {
-    db.add("wantedOrigin", [nameKey]);
-    evaluate(db, RESOLUTION_PROGRAM.rules);
-  }
-  return db.facts("wantedComesFrom").filter((row) => String(row[0]) === nameKey).map((row) => ({ module: String(row[1]), name: String(row[2]) }));
+function originsOf(db, nameKey2) {
+  askResolution(db, [nameKey2], "wantedOrigin");
+  return db.facts("wantedComesFrom").filter((row) => String(row[0]) === nameKey2).map((row) => ({ module: String(row[1]), name: String(row[2]) }));
 }
 function subjectConstructions(db, valueKeys) {
   const found = /* @__PURE__ */ new Map();
@@ -1487,10 +1474,7 @@ function subjectConstructions(db, valueKeys) {
     return found;
   }
   const askSubjects = (keys) => {
-    for (const key of keys) {
-      db.add("wantedSubject", [key]);
-    }
-    evaluate(db, RESOLUTION_PROGRAM.rules);
+    askResolution(db, keys, "wantedSubject");
   };
   askSubjects(valueKeys);
   const placeholders = placeholderValues(db);
@@ -1537,6 +1521,11 @@ function objectReturnedBy(db, callKey) {
 }
 
 // src/facts/values.ts
+import {
+  startsAtName,
+  valueLeftByWrites,
+  writesRunInOrder
+} from "@suss/resolution";
 function nodeId(filePath, node) {
   return `${filePath}:${node.startIndex}-${node.endIndex}`;
 }
@@ -1547,10 +1536,10 @@ function readKey(filePath, node, enclosing) {
   if (node.type !== "identifier") {
     return nodeId(filePath, node);
   }
-  if (enclosing !== null && parameterNames(enclosing).has(node.text)) {
-    return `${nodeId(filePath, enclosing)}#${node.text}`;
-  }
-  return nameId(filePath, node.text);
+  return nameKeyIn(filePath, enclosing, node.text);
+}
+function nameKeyIn(filePath, enclosing, name) {
+  return nameKey(filePath, scopeChainOf(filePath, enclosing), name);
 }
 var WRITTEN_VALUE_TYPES = /* @__PURE__ */ new Set([
   "string",
@@ -1588,9 +1577,6 @@ function parameterName2(param) {
   }
   return children(param).find((child) => child.type === "identifier") ?? null;
 }
-function parameterList(fn) {
-  return parameterShapes(fn).map((parameter) => parameter.name);
-}
 function parameterShapes(fn) {
   const params = field(fn, "parameters");
   const declared = [];
@@ -1605,24 +1591,52 @@ function parameterShapes(fn) {
   }
   return declared;
 }
-function parameterNames(fn) {
-  return new Set(parameterList(fn));
+function boundParameterNames(fn) {
+  const params = field(fn, "parameters");
+  const names = [];
+  for (const param of params === null ? [] : children(params)) {
+    const name = parameterName2(param);
+    if (name !== null) {
+      names.push(name.text);
+    }
+  }
+  return names;
 }
 function add(emitter, relation, ...tuple) {
   emitter.db.add(relation, tuple);
 }
+function nameKey(filePath, scope, name) {
+  for (let current = scope; current !== null; current = current.parent) {
+    if (current.globals.has(name)) {
+      return nameId(filePath, name);
+    }
+    if (current.locals.has(name)) {
+      return `${current.funcKey}#${name}`;
+    }
+  }
+  return nameId(filePath, name);
+}
+function scopeChainOf(filePath, fn) {
+  if (fn === null) {
+    return null;
+  }
+  const reading = scopeReadingOf(fn);
+  return {
+    funcKey: nodeId(filePath, fn),
+    locals: reading.locals,
+    globals: reading.globals,
+    parent: scopeChainOf(filePath, enclosingFunction(fn))
+  };
+}
 function emitCall(emitter, call) {
   add(emitter, "writtenValue", nodeId(emitter.filePath, call));
   const callee = field(call, "function");
-  if (callee === null) {
+  const args = field(call, "arguments");
+  if (callee === null || args === null) {
     return;
   }
   const callKey = nodeId(emitter.filePath, call);
   add(emitter, "call", callKey, valueKey(emitter, callee));
-  const args = field(call, "arguments");
-  if (args === null) {
-    return;
-  }
   let position = 0;
   for (const argument of children(args)) {
     if (argument.type === "keyword_argument") {
@@ -1653,11 +1667,7 @@ function valueKey(emitter, value) {
   if (value.type !== "identifier") {
     return nodeId(emitter.filePath, value);
   }
-  const enclosing = emitter.enclosing;
-  if (enclosing !== null && enclosing.params.has(value.text)) {
-    return `${enclosing.funcKey}#${value.text}`;
-  }
-  return nameId(emitter.filePath, value.text);
+  return nameKey(emitter.filePath, emitter.enclosing, value.text);
 }
 function emitSequence(emitter, sequence) {
   const objectKey = nodeId(emitter.filePath, sequence);
@@ -1747,7 +1757,6 @@ function emitFunctionFacts(emitter, fn, classKey) {
   const funcKey = nodeId(emitter.filePath, fn);
   add(emitter, "func", funcKey);
   const params = field(fn, "parameters");
-  const declared = parameterNames(fn);
   let position = classKey === void 0 ? 0 : -1;
   let byPosition = true;
   let receiver = null;
@@ -1770,24 +1779,22 @@ function emitFunctionFacts(emitter, fn, classKey) {
     }
     position += 1;
   }
+  const reading = scopeReadingOf(fn);
   const inside = {
     ...emitter,
-    enclosing: { funcKey, params: declared }
+    enclosing: {
+      funcKey,
+      locals: reading.locals,
+      globals: reading.globals,
+      parent: emitter.enclosing
+    }
   };
+  emitScopeWrites(inside, reading, false);
   const body = field(fn, "body");
   if (body === null) {
     return funcKey;
   }
-  const recordNested = (node) => {
-    for (const child of children(node)) {
-      if (isFunction(child)) {
-        add(emitter, "containsFn", funcKey, nodeId(emitter.filePath, child));
-        continue;
-      }
-      recordNested(child);
-    }
-  };
-  recordNested(body);
+  emitNestedDefinitions(inside, body);
   walkExpressions(inside, body, (child) => {
     if (child.type === "return_statement") {
       const returned = child.namedChildren[0];
@@ -1798,29 +1805,17 @@ function emitFunctionFacts(emitter, fn, classKey) {
     if (child.type === "call") {
       add(inside, "bodyCalls", funcKey, nodeId(inside.filePath, child));
     }
-    if (child.type === "assignment") {
-      emitBinding(inside, child, receiver);
+    if (child.type === "assignment" && receiver !== null) {
+      emitReceiverProperty(inside, child, receiver);
     }
     emitExpressionFact(inside, child);
   });
   return funcKey;
 }
-function emitBinding(emitter, assignment2, receiver) {
+function emitReceiverProperty(emitter, assignment2, receiver) {
   const left = field(assignment2, "left");
   const right = field(assignment2, "right");
-  if (left === null || right === null) {
-    return;
-  }
-  if (left.type === "identifier") {
-    add(
-      emitter,
-      "binds",
-      nameId(emitter.filePath, left.text),
-      valueKey(emitter, assignedValue(right))
-    );
-    return;
-  }
-  if (receiver === null || left.type !== "attribute") {
+  if (left === null || right === null || left.type !== "attribute") {
     return;
   }
   const object = field(left, "object");
@@ -1836,21 +1831,6 @@ function emitBinding(emitter, assignment2, receiver) {
     valueKey(emitter, right)
   );
 }
-function emitAssignment(emitter, assignment2) {
-  emitBinding(emitter, assignment2, null);
-  const left = field(assignment2, "left");
-  const right = field(assignment2, "right");
-  if (left === null || right === null || left.type !== "identifier") {
-    return;
-  }
-  add(
-    emitter,
-    "exportsAs",
-    emitter.filePath,
-    left.text,
-    valueKey(emitter, assignedValue(right))
-  );
-}
 function assignedValue(right) {
   if (right.type !== "subscript") {
     return right;
@@ -1877,12 +1857,19 @@ function declaredMemberKey(emitter, member, classKey) {
   }
   return null;
 }
+function writtenBaseName(base) {
+  return base.type === "identifier" || base.type === "attribute" ? base.text : null;
+}
 function emitClassFacts(emitter, cls) {
   const classKey = nodeId(emitter.filePath, cls);
   add(emitter, "objectValue", classKey);
   const bases = field(cls, "superclasses");
   for (const base of bases === null ? [] : children(bases)) {
     add(emitter, "extends", classKey, valueKey(emitter, base));
+    const written = writtenBaseName(base);
+    if (written !== null) {
+      add(emitter, "extendsNamed", classKey, written);
+    }
   }
   const body = field(cls, "body");
   for (const statement of body === null ? [] : children(body)) {
@@ -1901,40 +1888,361 @@ function emitClassFacts(emitter, cls) {
       }
       continue;
     }
-    const memberKey = declaredMemberKey(emitter, member, classKey);
+    const memberKey2 = declaredMemberKey(emitter, member, classKey);
     const name = field(member, "name");
-    if (memberKey !== null && name !== null) {
-      add(emitter, "holdsProperty", classKey, name.text, memberKey);
+    if (memberKey2 !== null && name !== null) {
+      add(emitter, "holdsProperty", classKey, name.text, memberKey2);
     }
   }
   return classKey;
 }
-function emitValueFacts(db, filePath, root) {
-  const emitter = { db, filePath, enclosing: null };
-  const declaresName = (child, key) => {
-    const name = field(child, "name");
-    if (name === null) {
+function emitNestedDefinitions(emitter, node) {
+  for (const child of children(node)) {
+    if (isFunction(child)) {
+      emitFunctionFacts(emitter, child);
+      if (emitter.enclosing !== null) {
+        add(
+          emitter,
+          "containsFn",
+          emitter.enclosing.funcKey,
+          nodeId(emitter.filePath, child)
+        );
+      }
+      continue;
+    }
+    if (child.type === "class_definition") {
+      emitClassFacts(emitter, child);
+      continue;
+    }
+    emitNestedDefinitions(emitter, child);
+  }
+}
+var readingsByTree = /* @__PURE__ */ new WeakMap();
+function scopeReadingOf(fn) {
+  const tree = fn.tree;
+  let byNode = readingsByTree.get(tree);
+  if (byNode === void 0) {
+    byNode = /* @__PURE__ */ new Map();
+    readingsByTree.set(tree, byNode);
+  }
+  const remembered = byNode.get(fn.id);
+  if (remembered !== void 0) {
+    return remembered;
+  }
+  const body = field(fn, "body");
+  const reading = readScope(
+    body !== null && body.type === "block" ? body : null,
+    boundParameterNames(fn)
+  );
+  byNode.set(fn.id, reading);
+  return reading;
+}
+var TARGET_PATTERN_TYPES = /* @__PURE__ */ new Set([
+  "pattern_list",
+  "tuple_pattern",
+  "list_pattern"
+]);
+function targetNames(target, found = []) {
+  if (target.type === "identifier") {
+    found.push(target);
+    return found;
+  }
+  if (TARGET_PATTERN_TYPES.has(target.type)) {
+    for (const child of children(target)) {
+      targetNames(child, found);
+    }
+  }
+  return found;
+}
+function readAssignment(node, sink) {
+  const left = field(node, "left");
+  const right = field(node, "right");
+  if (left === null) {
+    return;
+  }
+  const written = right === null ? null : assignedValue(right);
+  const names = targetNames(left);
+  for (const name of names) {
+    sink.record(name.text, {
+      // An unpacked target takes one piece of the value, and which piece
+      // is not something the assignment says.
+      value: names.length === 1 ? written : null,
+      given: null,
+      at: node,
+      direct: isDirectStatement(node, sink.bodyOwner)
+    });
+  }
+}
+function readAugmentedAssignment(node, sink) {
+  const left = field(node, "left");
+  if (left === null || left.type !== "identifier") {
+    return;
+  }
+  sink.record(left.text, {
+    value: null,
+    given: null,
+    at: node,
+    direct: isDirectStatement(node, sink.bodyOwner)
+  });
+}
+function readIterationTarget(node, sink) {
+  const left = field(node, "left");
+  if (left === null) {
+    return;
+  }
+  for (const name of targetNames(left)) {
+    sink.record(name.text, {
+      value: null,
+      given: null,
+      at: node,
+      direct: false
+    });
+  }
+}
+function identifierOf(node) {
+  if (node.type === "identifier") {
+    return node;
+  }
+  return children(node).find((child) => child.type === "identifier") ?? null;
+}
+function readAsPattern(node, sink) {
+  const target = field(node, "alias") ?? children(node)[1];
+  const name = target === void 0 ? null : identifierOf(target);
+  if (name === null) {
+    return;
+  }
+  sink.record(name.text, {
+    value: null,
+    given: null,
+    at: node,
+    direct: false
+  });
+}
+function readWalrus(node, sink) {
+  const name = field(node, "name");
+  if (name === null || name.type !== "identifier") {
+    return;
+  }
+  sink.record(name.text, {
+    value: field(node, "value"),
+    given: null,
+    at: node,
+    direct: false
+  });
+}
+function readGlobalStatement(node, sink) {
+  for (const child of children(node)) {
+    if (child.type === "identifier") {
+      sink.globals.add(child.text);
+    }
+  }
+}
+function readNonlocalStatement(node, sink) {
+  for (const child of children(node)) {
+    if (child.type === "identifier") {
+      sink.nonlocals.add(child.text);
+    }
+  }
+}
+var WRITE_READERS = {
+  assignment: readAssignment,
+  augmented_assignment: readAugmentedAssignment,
+  for_statement: readIterationTarget,
+  for_in_clause: readIterationTarget,
+  as_pattern: readAsPattern,
+  named_expression: readWalrus,
+  global_statement: readGlobalStatement,
+  nonlocal_statement: readNonlocalStatement
+};
+function readScope(bodyOwner, parameterNames) {
+  const writes = /* @__PURE__ */ new Map();
+  const globals = /* @__PURE__ */ new Set();
+  const nonlocals = /* @__PURE__ */ new Set();
+  const record = (name, write) => {
+    const existing = writes.get(name);
+    if (existing === void 0) {
+      writes.set(name, [write]);
       return;
     }
-    add(emitter, "binds", nameId(filePath, name.text), key);
-    add(emitter, "exportsAs", filePath, name.text, key);
+    existing.push(write);
   };
-  const walk = (node) => {
-    for (const child of children(node)) {
-      if (child.type === "class_definition") {
-        declaresName(child, emitClassFacts(emitter, child));
-        continue;
-      }
-      if (isFunction(child)) {
-        declaresName(child, emitFunctionFacts(emitter, child));
-      }
-      if (child.type === "assignment") {
-        emitAssignment(emitter, child);
+  const sink = { bodyOwner, globals, nonlocals, record };
+  const visit = (node) => {
+    if (isFunction(node) || node.type === "class_definition") {
+      const name = field(node, "name");
+      if (name !== null) {
+        record(name.text, {
+          value: node,
+          given: null,
+          at: node,
+          direct: isDirectStatement(node, bodyOwner)
+        });
       }
-      walk(child);
+      return;
+    }
+    WRITE_READERS[node.type]?.(node, sink);
+    for (const child of children(node)) {
+      visit(child);
     }
   };
-  walk(root);
+  for (const statement of bodyOwner === null ? [] : children(bodyOwner)) {
+    visit(statement);
+  }
+  const locals = new Set(writes.keys());
+  for (const name of [...globals, ...nonlocals]) {
+    locals.delete(name);
+  }
+  for (const name of parameterNames) {
+    locals.add(name);
+    addParameterWrite(writes.get(name), name);
+  }
+  return { bodyOwner, writes, locals, globals };
+}
+function addParameterWrite(later, name) {
+  const first = later?.[0];
+  if (later === void 0 || first === void 0) {
+    return;
+  }
+  later.unshift({ value: null, given: name, at: first.at, direct: false });
+}
+function statementOf(node) {
+  let current = node;
+  while (current !== null) {
+    const parent = current.parent;
+    if (parent === null) {
+      return null;
+    }
+    if (parent.type === "block" || parent.type === "module") {
+      return current;
+    }
+    current = parent;
+  }
+  return null;
+}
+function isDirectStatement(node, bodyOwner) {
+  if (bodyOwner === null) {
+    return false;
+  }
+  const statement = statementOf(node);
+  return statement !== null && statement.parent?.id === bodyOwner.id;
+}
+var UNREAD_PARENTS = /* @__PURE__ */ new Set([
+  "as_pattern_target",
+  "global_statement",
+  "nonlocal_statement",
+  "pattern_list",
+  "tuple_pattern",
+  "list_pattern",
+  "dotted_name"
+]);
+var UNREAD_FIELDS = {
+  assignment: "left",
+  augmented_assignment: "left",
+  for_statement: "left",
+  for_in_clause: "left",
+  named_expression: "name",
+  function_definition: "name",
+  class_definition: "name",
+  attribute: "attribute",
+  keyword_argument: "name"
+};
+function isNameRead(name) {
+  const parent = name.parent;
+  if (parent === null) {
+    return true;
+  }
+  if (UNREAD_PARENTS.has(parent.type)) {
+    return false;
+  }
+  const fieldName = UNREAD_FIELDS[parent.type];
+  return fieldName === void 0 || field(parent, fieldName)?.id !== name.id;
+}
+var READ_FIRST = {
+  call: "function",
+  attribute: "object"
+};
+function readFirst(node) {
+  if (node.type === "parenthesized_expression") {
+    return children(node)[0] ?? null;
+  }
+  const fieldName = READ_FIRST[node.type];
+  return fieldName === void 0 ? null : field(node, fieldName);
+}
+var NAME_READS = {
+  nameTypes: /* @__PURE__ */ new Set(["identifier"]),
+  laterBodies: LATER_BODY_TYPES,
+  childrenOf: children,
+  isRead: isNameRead,
+  readFirst
+};
+var CONSTRUCTION_TYPES = /* @__PURE__ */ new Set([
+  "call",
+  "list",
+  "dictionary",
+  "set",
+  "tuple",
+  "list_comprehension",
+  "dictionary_comprehension",
+  "set_comprehension",
+  "generator_expression"
+]);
+function describeWrite(emitter, write, name) {
+  if (write.value === null) {
+    return {
+      value: write.given,
+      placeholder: false,
+      construction: null,
+      narrowsName: false
+    };
+  }
+  return {
+    value: valueKey(emitter, write.value),
+    placeholder: write.value.type === "none",
+    construction: CONSTRUCTION_TYPES.has(write.value.type) ? write.value.text.replace(/\s+/g, " ").trim() : null,
+    narrowsName: write.value.type === "call" && startsAtName(write.value, name, NAME_READS)
+  };
+}
+function settledValue(emitter, reading, name, writes) {
+  const only = writes.length === 1 ? writes[0] : void 0;
+  if (only !== void 0) {
+    return only.value === null ? only.given : valueKey(emitter, only.value);
+  }
+  return valueLeftByWrites(
+    writes.map((write) => describeWrite(emitter, write, name)),
+    writesRunInOrder(reading.bodyOwner, name, writes, NAME_READS)
+  );
+}
+function emitScopeWrites(emitter, reading, atModule) {
+  for (const [name, writes] of reading.writes) {
+    const settled = settledValue(emitter, reading, name, writes);
+    const key = nameKey(emitter.filePath, emitter.enclosing, name);
+    if (settled === null) {
+      emitCandidates(emitter, key, name, writes);
+      continue;
+    }
+    add(emitter, writes.length === 1 ? "binds" : "endsHolding", key, settled);
+    if (atModule) {
+      add(emitter, "exportsAs", emitter.filePath, name, settled);
+    }
+  }
+}
+function emitCandidates(emitter, key, name, writes) {
+  for (const write of writes) {
+    if (write.value === null) {
+      if (write.given === null) {
+        add(emitter, "writesUnstated", key);
+      }
+      continue;
+    }
+    if (!describeWrite(emitter, write, name).narrowsName) {
+      add(emitter, "mayHold", key, valueKey(emitter, write.value));
+    }
+  }
+}
+function emitValueFacts(db, filePath, root) {
+  const emitter = { db, filePath, enclosing: null };
+  emitNestedDefinitions(emitter, root);
+  emitScopeWrites(emitter, readScope(root, []), true);
   emitExpressionFacts(emitter, root);
 }
 
@@ -2047,7 +2355,7 @@ function pythonLowering(options) {
   return {
     idOf: (node) => node.id,
     expression: (node) => expressionOf(node, originOf2),
-    statement: statementOf,
+    statement: statementOf2,
     siteOf,
     functionOf,
     writtenTo: (node) => context === null ? null : context.writtenTo(node),
@@ -2311,7 +2619,7 @@ var STATEMENT_TYPES = {
     body: blockStatements2(field(node, "body"))
   })
 };
-function statementOf(node) {
+function statementOf2(node) {
   const lower = STATEMENT_TYPES[node.type];
   return lower === void 0 ? { kind: "opaque" } : lower(node);
 }
@@ -3381,9 +3689,13 @@ function constructionThroughFacts(name, scope, scan) {
   if (binding.kind !== "assignment" && binding.kind !== "importFrom") {
     return null;
   }
-  const nameKey = `${scan.bound.file}#${name}`;
-  const constructionKey2 = subjectConstructions(facts, [nameKey]).get(
-    nameKey
+  const nameKey2 = nameKeyIn(
+    scan.bound.file,
+    scope.kind === "function" ? scope.node : enclosingFunction(scope.node),
+    name
+  );
+  const constructionKey2 = subjectConstructions(facts, [nameKey2]).get(
+    nameKey2
   )?.constructionKey;
   return constructionKey2 === void 0 ? null : scan.index.byValueKey.get(constructionKey2) ?? null;
 }
@@ -3474,11 +3786,11 @@ function walkStatements(statements, position, scan, visit) {
     visit(stmt, position, scan);
   }
 }
-function targetNames(node) {
+function targetNames2(node) {
   if (node.type === "identifier") {
     return [node.text];
   }
-  return bodyStatements(node).flatMap(targetNames);
+  return bodyStatements(node).flatMap(targetNames2);
 }
 function sequenceElementNames(node) {
   if (node === null || node.type !== "list" && node.type !== "tuple") {
@@ -3515,7 +3827,7 @@ function loopBindingsOf(stmt, position, scan) {
     });
     return bindings;
   }
-  for (const name of targetNames(left)) {
+  for (const name of targetNames2(left)) {
     bindings.set(name, { kind: "unenumerable", location });
   }
   return bindings;
@@ -4991,14 +5303,9 @@ function matchedChains(calls, options) {
   if (chains.length === 0) {
     return [];
   }
-  const alreadyAsked = new Set(
-    options.facts.facts("wanted").map((row) => String(row[0]))
-  );
   resolveCalls(
     options.facts,
-    storageCallees(calls, options.filePath, options.couldMatch).filter(
-      (key) => !alreadyAsked.has(key)
-    )
+    storageCallees(calls, options.filePath, options.couldMatch)
   );
   const matched = [];
   for (const chain of chains) {
@@ -6060,7 +6367,7 @@ function isInjectedParameter(param, injectedCallees, scope, ctx) {
 import fs4 from "fs";
 import path4 from "path";
 import { Database as Database3 } from "@suss/datalog";
-import { explainResolvedKey, RESOLUTION_RULES as RESOLUTION_RULES2 } from "@suss/resolution";
+import { explainResolvedKey, RESOLUTION_RULES } from "@suss/resolution";
 
 // src/facts.ts
 function unitKey(filePath, range, name) {
@@ -6078,7 +6385,7 @@ function emitModuleImportFacts(db, filePath, module, resolverOptions) {
       if (binding.kind !== "import" && binding.kind !== "importFrom") {
         continue;
       }
-      const nameKey = `${filePath}#${localName}`;
+      const nameKey2 = `${filePath}#${localName}`;
       const moduleText = importedModuleText(
         binding.module,
         binding.relativeLevel
@@ -6094,16 +6401,16 @@ function emitModuleImportFacts(db, filePath, module, resolverOptions) {
         resolution.status === "resolved" ? "resolved" : resolution.reason
       ]);
       const importedName = binding.kind === "import" ? binding.localName : binding.importedName;
-      db.add("pyImportedName", [nameKey, moduleText, importedName]);
+      db.add("pyImportedName", [nameKey2, moduleText, importedName]);
       if (scope.kind === "module") {
-        db.add("exportsAs", [filePath, localName, nameKey]);
+        db.add("exportsAs", [filePath, localName, nameKey2]);
       }
       if (resolution.status === "resolved") {
         db.add("pyImportResolved", [filePath, moduleText, resolution.file]);
-        db.add("imports", [nameKey, resolution.file, importedName]);
+        db.add("imports", [nameKey2, resolution.file, importedName]);
         continue;
       }
-      db.add("imports", [nameKey, moduleText, importedName]);
+      db.add("imports", [nameKey2, moduleText, importedName]);
     }
   }
   for (const openModule of module.openImports) {
@@ -6274,7 +6581,7 @@ import {
   unfollowedCallGap,
   worthRecording
 } from "@suss/behavioral-ir";
-import { Database, evaluate as evaluate2, lit, rule, variable as v } from "@suss/datalog";
+import { Database, evaluate, lit, rule, variable as v } from "@suss/datalog";
 import {
   assembleSummary,
   SKIP_CHILDREN as SKIP_CHILDREN2,
@@ -6282,251 +6589,227 @@ import {
 } from "@suss/extractor";
 
 // src/reach/resolveCallee.ts
-var stop = (reason) => ({ kind: "stop", reason });
-var MODULE_STOP = {
-  ambiguous: "multipleSources",
-  outsideRoots: "outsideRun"
+import {
+  calleeOutcomeOf,
+  calleeOutcomes,
+  writtenSourcesOf
+} from "@suss/resolution";
+var STOP_FOR = {
+  severalSources: "multipleSources",
+  outsideRun: "outsideRun",
+  unsettled: "unsettledValue",
+  undeclared: "noDeclaration"
 };
-function resolveCallee2(call, site, ctx) {
-  const callee = field(call, "function");
-  if (callee === null) {
-    return { kind: "stopped", reason: "noDeclaration" };
+var NO_DECLARATION = {
+  kind: "stopped",
+  reason: "noDeclaration"
+};
+function calleeSpellings(calls, ctx) {
+  const spellingOf = /* @__PURE__ */ new Map();
+  const keys = /* @__PURE__ */ new Set();
+  for (const { call, site } of calls) {
+    const spelling = spellingFor(call, site, ctx);
+    spellingOf.set(call.id, spelling);
+    if (spelling.kind === "key") {
+      keys.add(spelling.key);
+    }
   }
-  return asCallee(resolveExpression(callee, site, ctx), ctx);
+  return { spellingOf, outcomes: calleeOutcomes(ctx.facts, [...keys]) };
 }
-function resolveNamedFunctionArgument(name, site, ctx) {
-  if (site.rebound.has(name)) {
-    return null;
+function resolveCallee2(call, site, ctx, read) {
+  const spelling = read?.spellingOf.get(call.id) ?? spellingFor(call, site, ctx);
+  if (spelling.kind === "stopped") {
+    return spelling;
   }
-  const binding = resolveName(site.scope, name);
-  if (binding !== null && binding.kind === "assignment") {
+  const outcome = read?.outcomes.get(spelling.key) ?? calleeOutcomeOf(ctx.facts, spelling.key);
+  return asCallee(outcome, site.owner, ctx);
+}
+function functionNamed(nameKey2, ctx) {
+  if (assignedElsewhere(ctx.facts, nameKey2)) {
     return null;
   }
-  const resolved = binding === null ? throughOpenImports(site.file, name, ctx, /* @__PURE__ */ new Set()) : resolveBinding(binding, site.file, site.scope, ctx, /* @__PURE__ */ new Set());
-  return resolved.kind === "function" ? resolved.target : null;
+  const outcome = calleeOutcomeOf(ctx.facts, nameKey2);
+  return outcome.kind === "function" ? functionAt(outcome.key, ctx) : null;
 }
-function asCallee(resolved, ctx) {
-  if (resolved.kind === "function") {
-    return { kind: "followed", target: resolved.target };
-  }
-  if (resolved.kind === "class") {
-    return asCallee(
-      memberOfClass(resolved.file, resolved.node, "__init__", ctx),
-      ctx
-    );
-  }
-  if (resolved.kind === "stop") {
-    return { kind: "stopped", reason: resolved.reason };
-  }
-  if (resolved.kind === "package") {
-    return { kind: "stopped", reason: "outsideRun" };
-  }
-  return { kind: "stopped", reason: "noDeclaration" };
+function assignedElsewhere(facts, nameKey2) {
+  return writtenSourcesOf(facts, nameKey2).some(
+    (source) => !facts.has("func", [source])
+  );
 }
-var EXPRESSION_RESOLVERS = {
-  identifier: (node, site, ctx) => resolveIdentifier(node.text, site, ctx),
-  attribute: (node, site, ctx) => {
-    const object = field(node, "object");
-    const attribute = field(node, "attribute");
-    if (object === null || attribute === null) {
-      return stop("noDeclaration");
-    }
-    return memberOf(resolveExpression(object, site, ctx), attribute.text, ctx);
-  },
-  call: (node, site, ctx) => {
-    const callee = field(node, "function");
-    return callee === null ? stop("noDeclaration") : instanceBuiltBy(resolveExpression(callee, site, ctx), "noDeclaration");
-  },
-  parenthesized_expression: (node, site, ctx) => {
-    const inner = node.namedChildren[0];
-    return inner === null || inner === void 0 ? stop("noDeclaration") : resolveExpression(inner, site, ctx);
+function readThrough(node) {
+  if (node?.type !== "parenthesized_expression") {
+    return node;
   }
-};
-function resolveExpression(node, site, ctx) {
-  const resolver = EXPRESSION_RESOLVERS[node.type];
-  return resolver === void 0 ? stop("noDeclaration") : resolver(node, site, ctx);
+  return readThrough(children(node)[0] ?? null);
 }
-function instanceBuiltBy(built, otherwise) {
-  if (built.kind === "class" || built.kind === "stop") {
-    return built;
+function spellingFor(call, site, ctx) {
+  const callee = readThrough(field(call, "function"));
+  if (callee === null) {
+    return { kind: "stopped", reason: "noDeclaration" };
   }
-  return built.kind === "package" ? stop("outsideRun") : stop(otherwise);
+  return throughModules(callee, site, ctx) ?? {
+    kind: "key",
+    key: readKey(site.file.file, callee, enclosingFunction(callee))
+  };
 }
-function resolveIdentifier(name, site, ctx) {
-  if (site.rebound.has(name)) {
-    return stop("unsettledValue");
+function asCallee(outcome, owner, ctx) {
+  if (outcome.kind === "function") {
+    return functionCallee(outcome.key, ctx);
   }
-  if (isReceiver(name, site.scope)) {
-    return receiverClass(site);
+  if (outcome.kind === "object") {
+    return constructorOf(outcome.key, ctx);
   }
-  const binding = resolveName(site.scope, name);
-  if (binding === null) {
-    return throughOpenImports(site.file, name, ctx, /* @__PURE__ */ new Set());
+  if (outcome.kind === "callerSupplied") {
+    return outcome.key.startsWith(`${owner}#`) ? { kind: "stopped", reason: "callerSupplied" } : { kind: "stopped", reason: "unsettledValue" };
   }
-  return resolveBinding(binding, site.file, site.scope, ctx, /* @__PURE__ */ new Set());
-}
-function isReceiver(name, scope) {
-  return (name === "self" || name === "cls") && scope.kind === "function" && scope.parent?.kind === "class";
+  return {
+    kind: "stopped",
+    reason: STOP_FOR[outcome.kind] ?? "noDeclaration"
+  };
 }
-function receiverClass(site) {
-  const classScope = site.scope.parent;
-  if (classScope === null || classScope === void 0) {
-    return stop("noDeclaration");
+function functionCallee(key, ctx) {
+  if (ctx.definitions.get(key)?.type === "lambda") {
+    return { kind: "stopped", reason: "unsettledValue" };
   }
-  return { kind: "class", file: site.file, node: classScope.node };
+  const target = functionAt(key, ctx);
+  return target === null ? NO_DECLARATION : { kind: "followed", target };
 }
-var BINDING_RESOLVERS = {
-  functionDef: (binding, file) => ({
-    kind: "function",
-    target: reachedFunction(file, binding.node)
-  }),
-  classDef: (binding, file) => ({ kind: "class", file, node: binding.node }),
-  parameter: () => stop("callerSupplied"),
-  // `import a.b.c` binds `a`, and `import a.b.c as m` binds `m` to `a.b.c`.
-  import: (binding, file, _scope, ctx) => moduleNamed(
-    file,
-    binding.localName === binding.module.split(".")[0] ? binding.localName : binding.module,
-    0,
-    ctx
-  ),
-  importFrom: (binding, file, _scope, ctx, visited) => memberOf(
-    moduleNamed(file, binding.module, binding.relativeLevel, ctx),
-    binding.importedName,
-    ctx,
-    visited
-  ),
-  // `run = load` is an alias worth one hop; anything else is a value.
-  assignment: (binding, file, scope, ctx, visited) => aliasedValue(binding.value, file, scope, ctx, visited),
-  global: () => stop("unsettledValue"),
-  nonlocal: () => stop("unsettledValue")
-};
-function resolveBinding(binding, file, scope, ctx, visited) {
-  const resolver = BINDING_RESOLVERS[binding.kind];
-  return resolver(binding, file, scope, ctx, visited);
-}
-function aliasedValue(value, file, scope, ctx, visited) {
-  if (value === null) {
-    return stop("unsettledValue");
-  }
-  if (value.type === "identifier") {
-    const binding = resolveName(scope, value.text);
-    if (binding === null || binding.kind === "assignment") {
-      return stop("unsettledValue");
-    }
-    return resolveBinding(binding, file, scope, ctx, visited);
-  }
-  if (value.type === "call") {
-    const callee = field(value, "function");
-    return callee === null ? stop("unsettledValue") : instanceBuiltBy(
-      aliasedValue(callee, file, scope, ctx, visited),
-      "unsettledValue"
-    );
+function constructorOf(classKey, ctx) {
+  const declared = ctx.facts.lookup("holdsProperty", 0, classKey).find((row) => String(row[1]) === "__init__");
+  if (declared === void 0) {
+    return NO_DECLARATION;
   }
-  if (value.type === "attribute") {
-    const object = field(value, "object");
-    const attribute = field(value, "attribute");
-    if (object === null || attribute === null) {
-      return stop("unsettledValue");
-    }
-    return memberOf(
-      aliasedValue(object, file, scope, ctx, visited),
-      attribute.text,
-      ctx
-    );
-  }
-  return stop("unsettledValue");
+  return functionCallee(String(declared[2]), ctx);
 }
-function reachedFunction(file, node, owner) {
+function functionAt(key, ctx) {
+  const node = ctx.definitions.get(key);
+  const file = ctx.filesByPath.get(key.slice(0, key.lastIndexOf(":")));
+  if (node === void 0 || file === void 0) {
+    return null;
+  }
   const name = field(node, "name")?.text ?? "<anon>";
-  const ownerName = owner === void 0 ? null : field(owner, "name")?.text;
+  const owner = ownerClassOf(node);
+  const ownerName = owner === null ? void 0 : field(owner, "name")?.text;
   return {
     file,
     node,
     name,
-    exportPath: ownerName === null || ownerName === void 0 ? [name] : [ownerName, name]
+    exportPath: ownerName === void 0 ? [name] : [ownerName, name]
   };
 }
-function moduleNamed(from, module, relativeLevel, ctx) {
-  const resolution = resolveModule(
-    from.file,
-    { module, relativeLevel },
-    { roots: ctx.roots }
-  );
-  if (resolution.status !== "resolved") {
-    return resolution.reason === "external" ? { kind: "package", dotted: module, relativeLevel, from } : stop(MODULE_STOP[resolution.reason]);
+function ownerClassOf(node) {
+  for (let up = node.parent; up !== null; up = up.parent) {
+    if (isFunction(up)) {
+      return null;
+    }
+    if (up.type === "class_definition") {
+      return up;
+    }
   }
-  const file = ctx.filesByPath.get(resolution.file);
-  return file === void 0 ? stop("outsideRun") : { kind: "module", file };
+  return null;
 }
-function memberOf(base, name, ctx, visited = /* @__PURE__ */ new Set()) {
-  if (base.kind === "module") {
-    return memberOfModule(base.file, name, ctx, visited);
+function throughModules(callee, site, ctx) {
+  if (callee.type === "identifier") {
+    return resolveName(site.scope, callee.text) === null ? openImportMember(site.file, callee.text, ctx, /* @__PURE__ */ new Set()) : null;
   }
-  if (base.kind === "package") {
-    return moduleNamed(
-      base.from,
-      base.dotted === "" ? name : `${base.dotted}.${name}`,
-      base.relativeLevel,
-      ctx
-    );
+  if (callee.type !== "attribute") {
+    return null;
   }
-  if (base.kind === "class") {
-    return memberOfClass(base.file, base.node, name, ctx);
+  const object = field(callee, "object");
+  const attribute = field(callee, "attribute");
+  if (object === null || attribute === null) {
+    return null;
   }
-  if (base.kind === "stop") {
-    return base;
+  const base = moduleAt(object, site, ctx);
+  return base === null ? null : memberKey(base, attribute.text, ctx);
+}
+function openImportMember(file, name, ctx, visited) {
+  if (visited.has(file.file)) {
+    return null;
+  }
+  visited.add(file.file);
+  const found = /* @__PURE__ */ new Set();
+  for (const spec of file.module.openImports) {
+    const dots = spec.length - spec.replace(/^\.+/, "").length;
+    const opened = moduleNamed(file, spec.slice(dots), dots, ctx);
+    if (opened === null || opened.kind !== "module") {
+      continue;
+    }
+    const member = opened.file.module.moduleScope.bindings.has(name) ? { kind: "key", key: `${opened.file.file}#${name}` } : openImportMember(opened.file, name, ctx, visited);
+    if (member?.kind === "key") {
+      found.add(member.key);
+    }
+  }
+  if (found.size > 1) {
+    return { kind: "stopped", reason: "multipleSources" };
   }
-  return stop("noDeclaration");
+  const only = [...found][0];
+  return only === void 0 ? null : { kind: "key", key: only };
 }
-function memberOfClass(file, classNode, name, ctx) {
-  const classScope = file.module.scopeFor.get(classNode.id);
-  const binding = classScope?.bindings.get(name);
-  if (binding === void 0) {
-    return stop("noDeclaration");
+function moduleAt(node, site, ctx) {
+  if (node.type === "identifier") {
+    return importedModule(node.text, site, ctx);
   }
-  if (binding.kind === "functionDef") {
-    return {
-      kind: "function",
-      target: reachedFunction(file, binding.node, classNode)
-    };
+  if (node.type !== "attribute") {
+    return null;
   }
-  return resolveBinding(binding, file, classScope, ctx, /* @__PURE__ */ new Set());
+  const object = field(node, "object");
+  const attribute = field(node, "attribute");
+  if (object === null || attribute === null) {
+    return null;
+  }
+  const base = moduleAt(object, site, ctx);
+  return base === null ? null : submoduleOf(base, attribute.text, ctx);
 }
-function memberOfModule(file, name, ctx, visited) {
-  const key = `${file.file}#${name}`;
-  if (visited.has(key)) {
-    return stop("unsettledValue");
+function importedModule(name, site, ctx) {
+  const binding = resolveName(site.scope, name);
+  if (binding?.kind === "import") {
+    const head = binding.module.split(".")[0];
+    const dotted = binding.localName === head ? binding.localName : binding.module;
+    return moduleNamed(site.file, dotted, 0, ctx);
   }
-  visited.add(key);
-  const binding = file.module.moduleScope.bindings.get(name);
-  if (binding !== void 0) {
-    return resolveBinding(binding, file, file.module.moduleScope, ctx, visited);
+  if (binding?.kind !== "importFrom") {
+    return null;
   }
-  if (file.file.endsWith("__init__.py")) {
-    const submodule = moduleNamed(file, name, 1, ctx);
-    if (submodule.kind === "module") {
-      return submodule;
-    }
+  const from = moduleNamed(
+    site.file,
+    binding.module,
+    binding.relativeLevel,
+    ctx
+  );
+  return from === null ? null : submoduleOf(from, binding.importedName, ctx);
+}
+function submoduleOf(base, name, ctx) {
+  if (base.kind === "package") {
+    return moduleNamed(
+      base.from,
+      base.dotted === "" ? name : `${base.dotted}.${name}`,
+      base.relativeLevel,
+      ctx
+    );
   }
-  return throughOpenImports(file, name, ctx, visited);
+  return base.file.file.endsWith("__init__.py") ? moduleNamed(base.file, name, 1, ctx) : null;
 }
-function throughOpenImports(file, name, ctx, visited) {
-  const found = [];
-  for (const spec of file.module.openImports) {
-    const dots = spec.length - spec.replace(/^\.+/, "").length;
-    const opened = moduleNamed(file, spec.slice(dots), dots, ctx);
-    if (opened.kind !== "module") {
-      continue;
-    }
-    const member = memberOfModule(opened.file, name, ctx, visited);
-    if (member.kind !== "stop") {
-      found.push(member);
-    }
+function memberKey(base, name, ctx) {
+  if (base.kind === "package") {
+    return null;
   }
-  if (found.length > 1) {
-    return stop("multipleSources");
+  if (base.file.module.moduleScope.bindings.has(name)) {
+    return { kind: "key", key: `${base.file.file}#${name}` };
   }
-  return found[0] ?? stop("noDeclaration");
+  return openImportMember(base.file, name, ctx, /* @__PURE__ */ new Set());
+}
+function moduleNamed(from, module, relativeLevel, ctx) {
+  const resolution = resolveModule(
+    from.file,
+    { module, relativeLevel },
+    { roots: ctx.roots }
+  );
+  if (resolution.status !== "resolved") {
+    return resolution.reason === "external" ? { kind: "package", dotted: module, relativeLevel, from } : null;
+  }
+  const file = ctx.filesByPath.get(resolution.file);
+  return file === void 0 ? null : { kind: "module", file };
 }
 
 // src/reach/closure.ts
@@ -6541,7 +6824,9 @@ var REACHABLE_RULES = [
 function reachedFunctions(seeds, options) {
   const ctx = {
     filesByPath: new Map(options.files.map((file) => [file.file, file])),
-    roots: options.roots
+    roots: options.roots,
+    facts: options.facts,
+    definitions: options.definitions
   };
   const db = new Database();
   const functionByKey = /* @__PURE__ */ new Map();
@@ -6563,21 +6848,26 @@ function reachedFunctions(seeds, options) {
     db.add("entry", [seed.key]);
   }
   for (; ; ) {
-    evaluate2(db, REACHABLE_RULES);
+    evaluate(db, REACHABLE_RULES);
     const frontier = db.facts("reachable").map(([key]) => String(key)).filter((key) => !scanned.has(key));
     if (frontier.length === 0) {
       break;
     }
-    for (const key of frontier) {
+    const bodies = frontier.flatMap((key) => {
       scanned.add(key);
       const source = functionByKey.get(key);
-      if (source === void 0) {
-        continue;
-      }
+      return source === void 0 ? [] : [{ key, source, ...bodyOf(source) }];
+    });
+    const spellings = calleeSpellings(
+      bodies.flatMap((body) => body.written),
+      ctx
+    );
+    for (const { key, source, body, written } of bodies) {
       const scan = scanBody(
         source,
         ctx,
-        recognizedCallIds(source.node, options.storageFor(source.file))
+        recognizedCallIds(source.node, options.storageFor(source.file)),
+        { body, written, spellings }
       );
       if (scan.stops.length > 0) {
         stopsByKey.set(key, scan.stops);
@@ -6643,7 +6933,18 @@ var EMPTY_SCAN = {
   parameterCalls: [],
   passedPositions: /* @__PURE__ */ new Set()
 };
-function scanBody(source, ctx, recognized) {
+function bodyOf(source) {
+  const { file, node } = source;
+  const body = field(node, "body");
+  if (body === null) {
+    return { body, written: [] };
+  }
+  return {
+    body,
+    written: callsWritten(file, body, scopeAt2(file, node), keyOf(source))
+  };
+}
+function scanBody(source, ctx, recognized, read) {
   const followed = [];
   const stops = [];
   const placements = new TargetPlacements();
@@ -6652,12 +6953,12 @@ function scanBody(source, ctx, recognized) {
   const seen = /* @__PURE__ */ new Set();
   const parameterCallsSeen = /* @__PURE__ */ new Set();
   const { file, node } = source;
-  const body = field(node, "body");
-  if (body === null) {
+  const { written, spellings } = read;
+  if (read.body === null) {
     return EMPTY_SCAN;
   }
   const ownParameters = callParameterNames(node, source.exportPath.length > 1);
-  const recordPassedArgs = (call, callee, calleeKey, where) => {
+  const recordPassedArgs = (call, callee, calleeKey) => {
     const args = field(call, "arguments");
     if (args === null) {
       return;
@@ -6666,9 +6967,8 @@ function scanBody(source, ctx, recognized) {
       if (arg === null || arg.type !== "identifier") {
         return;
       }
-      const resolved = resolveNamedFunctionArgument(
-        arg.text,
-        { file, scope: where.scope, rebound: where.rebound },
+      const resolved = functionNamed(
+        readKey(file.file, arg, enclosingFunction(arg)),
         ctx
       );
       if (resolved === null) {
@@ -6688,13 +6988,9 @@ function scanBody(source, ctx, recognized) {
       }
     });
   };
-  const record = (call, where) => {
+  const record = (call, site) => {
     const callee = calleeText(call);
-    const outcome = resolveCallee2(
-      call,
-      { file, scope: where.scope, rebound: where.rebound },
-      ctx
-    );
+    const outcome = resolveCallee2(call, site, ctx, spellings);
     const placed = outcome.kind === "followed" ? {
       file: outcome.target.file.displayPath,
       span: spanOf(outcome.target.node)
@@ -6703,8 +6999,7 @@ function scanBody(source, ctx, recognized) {
     recordPassedArgs(
       call,
       callee,
-      outcome.kind === "followed" ? keyOf(outcome.target) : null,
-      where
+      outcome.kind === "followed" ? keyOf(outcome.target) : null
     );
     if (outcome.kind === "stopped") {
       const stopKey = `${outcome.reason}:${callee}`;
@@ -6727,32 +7022,9 @@ function scanBody(source, ctx, recognized) {
       followed.push(outcome.target);
     }
   };
-  walkDescendants3(
-    body,
-    { scope: scopeAt2(file, node), rebound: reboundNames(body) },
-    {
-      at: (child, where) => {
-        if (child.type === "call") {
-          record(child, where);
-        }
-      },
-      into: (child, where) => {
-        if (child.type === "function_definition") {
-          return SKIP_CHILDREN2;
-        }
-        if (child.type === "lambda") {
-          return {
-            scope: where.scope,
-            rebound: /* @__PURE__ */ new Set([...where.rebound, ...lambdaParameters(child)])
-          };
-        }
-        return {
-          scope: file.module.scopeFor.get(child.id) ?? where.scope,
-          rebound: where.rebound
-        };
-      }
-    }
-  );
+  for (const { call, site } of written) {
+    record(call, site);
+  }
   return {
     followed,
     stops,
@@ -6762,6 +7034,18 @@ function scanBody(source, ctx, recognized) {
     passedPositions
   };
 }
+function callsWritten(file, body, outer, owner) {
+  const found = [];
+  walkDescendants3(body, outer, {
+    at: (child, scope) => {
+      if (child.type === "call") {
+        found.push({ call: child, site: { file, scope, owner } });
+      }
+    },
+    into: (child, scope) => child.type === "function_definition" ? SKIP_CHILDREN2 : file.module.scopeFor.get(child.id) ?? scope
+  });
+  return found;
+}
 function scopeAt2(file, node) {
   let current = node;
   while (current !== null) {
@@ -6773,40 +7057,6 @@ function scopeAt2(file, node) {
   }
   return file.module.moduleScope;
 }
-var REBINDING_FIELDS = {
-  assignment: "left",
-  augmented_assignment: "left",
-  named_expression: "name",
-  for_statement: "left",
-  for_in_clause: "left",
-  as_pattern: "alias"
-};
-function reboundNames(body) {
-  const names = /* @__PURE__ */ new Set();
-  walkDescendants3(body, null, {
-    at: (node) => {
-      const target = REBINDING_FIELDS[node.type];
-      if (target === void 0 || boundByBinder(node, body)) {
-        return;
-      }
-      const written = field(node, target);
-      if (written !== null) {
-        for (const name of identifiersUnder(written)) {
-          names.add(name);
-        }
-      }
-    },
-    into: (node) => node.type === "function_definition" ? SKIP_CHILDREN2 : null
-  });
-  return names;
-}
-function boundByBinder(node, body) {
-  if (node.type !== "assignment") {
-    return false;
-  }
-  const statement = node.parent;
-  return field(node, "left")?.type === "identifier" && statement?.type === "expression_statement" && statement.parent?.id === body.id;
-}
 function identifiersUnder(node, found = []) {
   if (node.type === "identifier") {
     found.push(node.text);
@@ -6819,10 +7069,6 @@ function identifiersUnder(node, found = []) {
   }
   return found;
 }
-function lambdaParameters(lambda) {
-  const parameters = field(lambda, "parameters");
-  return parameters === null ? [] : identifiersUnder(parameters);
-}
 function libraryUnit(target, options) {
   const { file, node, name, exportPath } = target;
   const body = field(node, "body");
@@ -6973,6 +7219,18 @@ var PythonWrapperIndex = class {
   ownRoutes = /* @__PURE__ */ new Map();
   unitsByKey = /* @__PURE__ */ new Map();
   unitsByFile = /* @__PURE__ */ new Map();
+  /** The project function a module-level name in this file refers to, or null for anything else. */
+  functionCalled(file, name) {
+    if (this.options.facts === void 0) {
+      return null;
+    }
+    return functionNamed(nameKeyIn(file, null, name), {
+      filesByPath: this.filesByPath,
+      roots: this.options.roots,
+      facts: this.options.facts,
+      definitions: this.options.definitions
+    });
+  }
   register(covers, target, declared) {
     const registered = this.registered(target, declared);
     const table = covers.kind === "everyRoute" ? this.everyRoute : this.ownRoutes;
@@ -7019,20 +7277,12 @@ var PythonWrapperIndex = class {
       if (declared.form.type !== "dependency") {
         continue;
       }
-      const site = {
-        file,
-        scope: query.module.moduleScope,
-        rebound: /* @__PURE__ */ new Set()
-      };
       const targets = [
         ...decoratorDependencies(query.classification, declared.form),
         ...parameterDependencies(query.definitionNode, declared.form)
       ];
       for (const name of targets) {
-        const target = resolveNamedFunctionArgument(name, site, {
-          filesByPath: this.filesByPath,
-          roots: this.options.roots
-        });
+        const target = this.functionCalled(file.file, name);
         if (target !== null) {
           found.push(this.registered(target, declared));
         }
@@ -7174,12 +7424,8 @@ function registerConstructorDependencies(file, declared, form, index) {
     if (listed === void 0) {
       continue;
     }
-    const site = { file, scope, rebound: /* @__PURE__ */ new Set() };
     for (const name of dependencyNamesIn(listed.node, form)) {
-      const target = resolveNamedFunctionArgument(name, site, {
-        filesByPath: index.filesByPath,
-        roots: index.options.roots
-      });
+      const target = index.functionCalled(file.file, name);
       if (target !== null) {
         index.register(
           coverageOf(match, file, declared.pack),
@@ -7419,6 +7665,31 @@ function reportUnresolvedProjectModules(options, db) {
     }
   }
 }
+function emitModelQueryFacts(db, packs) {
+  for (const pack of packs) {
+    for (const model of pack.models ?? []) {
+      for (const base of model.baseNames) {
+        for (const method of model.givesBack) {
+          db.add("givesBackOne", [base, method]);
+        }
+        for (const entry of model.entryMethods) {
+          db.add("givesBackOneOfArgument", [
+            base,
+            entry.method,
+            String(entry.argument)
+          ]);
+        }
+      }
+      for (const entry of model.entryFunctions) {
+        db.add("givesBackOneOfImport", [
+          entry.module,
+          entry.name,
+          String(entry.argument)
+        ]);
+      }
+    }
+  }
+}
 async function extractPythonProject(options) {
   const timer = options.onTiming !== void 0 ? createTimer() : noopTimer();
   const cacheDir = adapterStamp.declineWhenRunFromSource(
@@ -7466,8 +7737,9 @@ async function extractPythonProject(options) {
   );
   const storagePatterns = options.packs.flatMap((pack) => pack.storage ?? []);
   const rawSqlPatterns = options.packs.flatMap((pack) => pack.rawSql ?? []);
+  const modelQueries = options.packs.flatMap((pack) => pack.models ?? []);
   const discovers = options.packs.some((pack) => pack.discovery.length > 0);
-  const needsValues = discovers || mountsRouters || storagePatterns.length > 0;
+  const needsValues = discovers || mountsRouters || storagePatterns.length > 0 || modelQueries.length > 0;
   const definitions = /* @__PURE__ */ new Map();
   timer.time("discover", () => {
     for (const { file, root, module: moduleBinding } of bound) {
@@ -7480,6 +7752,7 @@ async function extractPythonProject(options) {
     if (needsValues) {
       bindEvaluator(db, { files: bound, definitions });
     }
+    emitModelQueryFacts(db, options.packs);
   });
   reportUnresolvedProjectModules(options, db);
   const couldMatch = timer.time(
@@ -7507,6 +7780,7 @@ async function extractPythonProject(options) {
       packs: options.packs,
       roots: options.roots,
       facts: needsValues ? db : void 0,
+      definitions,
       storageFor
     })
   );
@@ -7590,7 +7864,9 @@ async function extractPythonProject(options) {
       files: bound,
       roots: options.roots,
       gapHandling,
-      storageFor
+      storageFor,
+      facts: db,
+      definitions
     })
   );
   for (const [key, owners] of summariesBySeed) {
@@ -7852,7 +8128,7 @@ var PythonWhySession = class {
   explain(value, options = {}) {
     return explainResolvedKey({
       db: this.db,
-      rules: RESOLUTION_RULES2,
+      rules: RESOLUTION_RULES,
       key: readKey(value.file, value.node, enclosingFunction(value.node)),
       locate: (key) => this.locate(key),
       displayPath: (key) => this.displayPath(key),
@@ -7982,6 +8258,7 @@ export {
   emitValueFacts,
   extractPythonProject,
   findPythonFiles,
+  nameKeyIn,
   nodeId,
   objectReturnedBy,
   parsePython,