@suss/adapter-python 0.26.0 → 0.28.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) {
@@ -93,6 +98,25 @@ function children(node) {
 function bodyStatements(body) {
   return children(body);
 }
+function nestedStatements(stmt) {
+  const found = [];
+  for (const child of children(stmt)) {
+    if (child.type === "block") {
+      for (const inner of children(child)) {
+        if (inner.type.endsWith("_clause")) {
+          found.push(...nestedStatements(inner));
+          continue;
+        }
+        found.push(inner);
+      }
+      continue;
+    }
+    if (child.type.endsWith("_clause")) {
+      found.push(...nestedStatements(child));
+    }
+  }
+  return found;
+}
 function stripDecorators(node) {
   if (node.type !== "decorated_definition") {
     return { definition: node, decorators: [] };
@@ -453,8 +477,36 @@ function resolveNonlocal(scope, name) {
 }
 
 // src/annotations.ts
-function createAnnotationContext(scopeFor) {
-  return { scopeFor, definitions: /* @__PURE__ */ new Map() };
+function createAnnotationContext(scopeFor, importedDefinition = null) {
+  return {
+    scopeMaps: [scopeFor],
+    definitions: /* @__PURE__ */ new Map(),
+    importedDefinition,
+    expanding: /* @__PURE__ */ new Set()
+  };
+}
+function scopeOfNode(ctx, node) {
+  for (const scopeFor of ctx.scopeMaps) {
+    const scope = scopeFor.get(node.id);
+    if (scope !== void 0) {
+      return scope;
+    }
+  }
+  return void 0;
+}
+function aliasValueOf(name, scope, ctx) {
+  const binding = resolveName(scope, name);
+  if (binding?.kind === "assignment") {
+    return binding.value === null ? null : { node: binding.value, scope };
+  }
+  if (binding?.kind !== "import" && binding?.kind !== "importFrom") {
+    return null;
+  }
+  const imported = ctx.importedDefinition?.(scope, name) ?? null;
+  if (imported === null || imported.node.type === "class_definition") {
+    return null;
+  }
+  return { node: imported.node, scope: imported.moduleScope };
 }
 function collectedDefinitions(ctx) {
   const out = {};
@@ -497,6 +549,7 @@ var EXPRESSION_SHAPERS = {
   identifier: (node, scope, ctx) => shapeFromName(node.text, scope, ctx),
   none: () => ({ type: "null" }),
   generic_type: shapeFromGenericType,
+  subscript: shapeFromSubscript,
   binary_operator: shapeFromBinaryOperator
 };
 function shapeFromExpression(node, scope, ctx) {
@@ -518,8 +571,46 @@ function shapeFromName(name, scope, ctx) {
   if (binding?.kind === "classDef") {
     return recordShapeRef(name, binding.node, ctx);
   }
+  if (binding?.kind === "import" || binding?.kind === "importFrom") {
+    const imported = ctx.importedDefinition?.(scope, name) ?? null;
+    if (imported?.node.type === "class_definition") {
+      if (!ctx.scopeMaps.includes(imported.scopeFor)) {
+        ctx.scopeMaps.push(imported.scopeFor);
+      }
+      return recordShapeRef(name, imported.node, ctx);
+    }
+  }
+  const alias = aliasValueOf(name, scope, ctx);
+  if (alias !== null) {
+    return shapeFromAliasValue(name, alias, ctx);
+  }
   return { type: "ref", name };
 }
+function shapeFromAliasValue(name, alias, ctx) {
+  if (ctx.expanding.has(alias.node.id)) {
+    return { type: "ref", name };
+  }
+  ctx.expanding.add(alias.node.id);
+  try {
+    return shapeFromExpression(alias.node, alias.scope, ctx);
+  } finally {
+    ctx.expanding.delete(alias.node.id);
+  }
+}
+function shapeFromSubscript(node, scope, ctx) {
+  const base = field(node, "value");
+  const args = fields(node, "subscript");
+  const baseName = base?.type === "identifier" ? base.text : null;
+  if (baseName === "Annotated") {
+    const first = args[0];
+    return first === void 0 ? { type: "unknown" } : shapeFromExpression(first, scope, ctx);
+  }
+  return shapeFromGeneric(
+    baseName,
+    node.text,
+    args.map((arg) => shapeFromExpression(arg, scope, ctx))
+  );
+}
 function genericTypeArgs(node) {
   const typeParameter = node.namedChildren.find(
     (child) => child !== null && child.type === "type_parameter"
@@ -530,14 +621,20 @@ function genericTypeArgs(node) {
 }
 function shapeFromGenericType(node, scope, ctx) {
   const base = node.namedChild(0);
-  const args = genericTypeArgs(node);
-  const shapeOf = (arg) => arg !== void 0 ? annotationToShape(arg, scope, ctx) : { type: "unknown" };
   const baseName = base?.type === "identifier" ? base.text : null;
+  return shapeFromGeneric(
+    baseName,
+    node.text,
+    genericTypeArgs(node).map((arg) => annotationToShape(arg, scope, ctx))
+  );
+}
+function shapeFromGeneric(baseName, text2, args) {
+  const shapeOf = (arg) => arg ?? { type: "unknown" };
   if (baseName === "Optional") {
     return { type: "union", variants: [shapeOf(args[0]), { type: "null" }] };
   }
   if (baseName === "Union") {
-    return { type: "union", variants: args.map((arg) => shapeOf(arg)) };
+    return { type: "union", variants: args };
   }
   if (baseName !== null && LIST_NAMES.has(baseName)) {
     return { type: "array", items: shapeOf(args[0]) };
@@ -548,7 +645,7 @@ function shapeFromGenericType(node, scope, ctx) {
   if (baseName !== null && TUPLE_SET_NAMES.has(baseName)) {
     return { type: "array", items: shapeOf(args[0]) };
   }
-  return { type: "ref", name: baseName ?? node.text };
+  return { type: "ref", name: baseName ?? text2 };
 }
 function shapeFromBinaryOperator(node, scope, ctx) {
   const operator = field(node, "operator");
@@ -573,7 +670,7 @@ function recordShapeRef(name, classNode, ctx) {
   }
   ctx.definitions.set(key, null);
   const bodyNode = field(classNode, "body");
-  const classScope = ctx.scopeFor.get(classNode.id);
+  const classScope = scopeOfNode(ctx, classNode);
   ctx.definitions.set(
     key,
     bodyNode !== null && classScope !== void 0 ? recordShapeOf(bodyNode, classScope, ctx) : { type: "record", properties: {} }
@@ -1316,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);
@@ -1335,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
@@ -1354,44 +1451,30 @@ 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, 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();
   if (valueKeys.length === 0) {
     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);
@@ -1438,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}`;
 }
@@ -1448,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",
@@ -1489,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 = [];
@@ -1506,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") {
@@ -1554,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);
@@ -1648,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;
@@ -1671,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];
@@ -1699,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, right)
-    );
-    return;
-  }
-  if (receiver === null || left.type !== "attribute") {
+  if (left === null || right === null || left.type !== "attribute") {
     return;
   }
   const object = field(left, "object");
@@ -1737,20 +1831,13 @@ 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;
+function assignedValue(right) {
+  if (right.type !== "subscript") {
+    return right;
   }
-  add(
-    emitter,
-    "exportsAs",
-    emitter.filePath,
-    left.text,
-    valueKey(emitter, right)
-  );
+  const outer = field(right, "value");
+  const first = fields(right, "subscript")[0];
+  return outer?.text === "Annotated" && first !== void 0 ? first : right;
 }
 function declaredBy(statement) {
   if (statement.type === "decorated_definition") {
@@ -1794,40 +1881,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);
 }
 
@@ -1940,7 +2348,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),
@@ -2204,7 +2612,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);
 }
@@ -3274,9 +3682,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;
 }
@@ -3347,11 +3759,15 @@ var WALK_DESCENTS = {
       scan,
       visit
     );
-  }
+  },
+  if_statement: descendInPlace,
+  try_statement: descendInPlace,
+  while_statement: descendInPlace,
+  with_statement: descendInPlace,
+  match_statement: descendInPlace
 };
-function nestedStatements(stmt) {
-  const body = field(stmt, "body");
-  return body === null ? [] : bodyStatements(body);
+function descendInPlace(stmt, position, scan, visit) {
+  walkStatements(nestedStatements(stmt), position, scan, visit);
 }
 function walkStatements(statements, position, scan, visit) {
   for (const stmt of statements) {
@@ -3363,11 +3779,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") {
@@ -3404,7 +3820,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;
@@ -4432,7 +4848,7 @@ function rawSqlEffects(calls, options) {
         binding: storageBinding({
           recognition: `python-${pattern.module}`,
           storageSystem: pattern.storageSystem,
-          scope: pattern.module,
+          scope: "default",
           container: access.table
         }),
         callee: field(call, "function")?.text ?? "",
@@ -4576,16 +4992,23 @@ function typeNameOf(annotation) {
   if (quoted !== null) {
     return quoted;
   }
+  if (annotation.type === "binary_operator") {
+    const named = [field(annotation, "left"), field(annotation, "right")].find(
+      (side) => side !== null && side.type !== "none"
+    );
+    return named === void 0 || named === null ? null : typeNameOf(named);
+  }
   if (annotation.type === "generic_type") {
     const outer = annotation.namedChildren[0];
     const first = genericTypeArgs(annotation)[0];
     if ((outer?.text === "Annotated" || outer?.text === "Optional") && first !== void 0) {
       return typeNameOf(first);
     }
+    return outer?.type === "identifier" ? outer.text : null;
   }
   return null;
 }
-function typeGivenBy(statement, name) {
+function typeGivenBy(statement, name, options) {
   if (statement.type === "assignment") {
     if (field(statement, "left")?.text !== name) {
       return null;
@@ -4595,8 +5018,7 @@ function typeGivenBy(statement, name) {
       return typeNameOf(annotation);
     }
     const right = field(statement, "right");
-    const callee = right?.type === "call" ? field(right, "function") : null;
-    return callee?.type === "identifier" ? callee.text : null;
+    return right?.type === "call" ? builtType(right, options) : null;
   }
   if (statement.type === "as_pattern") {
     const alias = field(statement, "alias");
@@ -4606,7 +5028,34 @@ function typeGivenBy(statement, name) {
   }
   return null;
 }
-function declaredTypeName(name, from) {
+function builtType(call, options) {
+  const root = rootOf(call);
+  const callee = field(root, "function");
+  if (callee?.type === "identifier") {
+    return isClassName(callee.text) ? callee.text : resolvedReturnType(options, callee);
+  }
+  const object = callee?.type === "attribute" ? field(callee, "object") : null;
+  if (object?.type === "identifier" && isClassName(object.text)) {
+    return object.text;
+  }
+  const args = field(root, "arguments");
+  const first = (args === null ? [] : children(args))[0];
+  if (first?.type === "identifier" && isClassName(first.text)) {
+    return first.text;
+  }
+  return callee === null ? null : resolvedReturnType(options, callee);
+}
+function resolvedReturnType(options, callee) {
+  const settled = settledCallee(options, callee);
+  return settled === void 0 ? null : returnTypeName(options.definitionAt(settled));
+}
+function settledCallee(options, callee) {
+  const key = readKey(options.filePath, callee, enclosingFunction(callee));
+  resolveCalls(options.facts, [key]);
+  const resolved = options.facts.facts("wantedResolves").filter((row) => String(row[0]) === key).map((row) => String(row[1]));
+  return resolved.length === 1 ? resolved[0] : void 0;
+}
+function declaredTypeName(name, from, options) {
   const fn = enclosingFunction(from);
   if (fn === null) {
     return null;
@@ -4619,7 +5068,7 @@ function declaredTypeName(name, from) {
     }
   }
   const visit = (node) => {
-    const given = typeGivenBy(node, name);
+    const given = typeGivenBy(node, name, options);
     if (given !== null) {
       return given;
     }
@@ -4648,16 +5097,27 @@ function typedReceiverPattern(options, chain) {
   if (receiver === null) {
     return void 0;
   }
-  const typeName = declaredTypeName(receiver, chain.root);
+  const typeName = declaredTypeName(receiver, chain.root, options);
   if (typeName === null) {
     return void 0;
   }
-  const from = options.facts.facts("pyImportedName").find((row) => String(row[0]) === `${options.filePath}#${typeName}`);
-  if (from === void 0) {
-    return void 0;
+  const typeKey = `${options.filePath}#${typeName}`;
+  const imported = options.facts.facts("pyImportedName").find((row) => String(row[0]) === typeKey);
+  const direct = imported === void 0 ? void 0 : queryTypePattern(options, String(imported[1]), String(imported[2]));
+  if (direct !== void 0) {
+    return direct;
+  }
+  for (const origin of originsOf(options.facts, typeKey)) {
+    const pattern = queryTypePattern(options, origin.module, origin.name);
+    if (pattern !== void 0) {
+      return pattern;
+    }
   }
+  return void 0;
+}
+function queryTypePattern(options, module, name) {
   return options.patterns.find(
-    (pattern) => String(from[1]) === pattern.module && pattern.queryTypes.includes(String(from[2]))
+    (pattern) => module === pattern.module && pattern.queryTypes.includes(name)
   );
 }
 function fieldsOf(chain, valueMethods) {
@@ -4703,16 +5163,80 @@ function keywordNames(call) {
       }
     }
   }
-  return picked;
+  return picked;
+}
+function selectorOf(chain, valueMethods) {
+  return [
+    ...new Set(
+      laterCalls(chain).filter((call) => !valueMethods.includes(methodNameOf(call))).flatMap(keywordNames)
+    )
+  ];
+}
+var TABLE_METHODS = ["select_from", "join"];
+function modelOf(chain, options) {
+  const fromRoot = modelArgument(chain.root, chain.root, options);
+  if (fromRoot !== null) {
+    return fromRoot;
+  }
+  for (const call of laterCalls(chain)) {
+    if (TABLE_METHODS.includes(methodNameOf(call))) {
+      const named = modelArgument(call, chain.root, options);
+      if (named !== null) {
+        return named;
+      }
+    }
+  }
+  return isClassName(chain.subject) ? chain.subject : null;
+}
+function modelArgument(call, from, options) {
+  const args = field(call, "arguments");
+  const first = (args === null ? [] : children(args)).find(
+    (argument) => argument.type !== "keyword_argument"
+  );
+  return first === void 0 ? null : modelNamed(first, from, options);
+}
+function modelNamed(node, from, options) {
+  if (node.type === "identifier") {
+    if (isClassName(node.text)) {
+      return node.text;
+    }
+    const declared = declaredTypeName(node.text, from, options);
+    return declared === null ? null : classBehind(declared, options);
+  }
+  if (node.type === "attribute") {
+    const property = field(node, "attribute");
+    if (property !== null && isClassName(property.text)) {
+      return property.text;
+    }
+    const object = field(node, "object");
+    return object === null ? null : modelNamed(object, from, options);
+  }
+  if (node.type === "call") {
+    const callee = field(node, "function");
+    const built = callee === null ? null : modelNamed(callee, from, options);
+    return built ?? modelArgument(node, from, options);
+  }
+  return null;
 }
-function selectorOf(chain, valueMethods) {
-  return [
-    ...new Set(
-      laterCalls(chain).filter((call) => !valueMethods.includes(methodNameOf(call))).flatMap(keywordNames)
-    )
-  ];
+function classBehind(typeName, options) {
+  const key = `${options.filePath}#${typeName}`;
+  originsOf(options.facts, key);
+  const reached = new Set(
+    options.facts.facts("wantedComesTo").filter((row) => String(row[0]) === key).map((row) => String(row[1]))
+  );
+  const classes = new Set(
+    options.facts.facts("objectValue").map((row) => String(row[0])).filter((value) => reached.has(value))
+  );
+  const exported = options.facts.facts("exportsAs").find((row) => classes.has(String(row[2])));
+  if (exported !== void 0) {
+    return String(exported[1]);
+  }
+  return isClassName(typeName) ? typeName : null;
 }
-function effectFor(pattern, chain, operation) {
+function isClassName(name) {
+  return /^[A-Z][A-Za-z0-9_]*$/.test(name) && name !== name.toUpperCase();
+}
+function effectFor(pattern, chain, operation, options) {
   const valueMethods = pattern.valueMethods ?? [];
   const picked = selectorOf(chain, valueMethods);
   return {
@@ -4720,8 +5244,8 @@ function effectFor(pattern, chain, operation) {
     binding: storageBinding2({
       recognition: "python-storage",
       storageSystem: pattern.storageSystem,
-      scope: pattern.module,
-      container: chain.subject
+      scope: "default",
+      container: modelOf(chain, options)
     }),
     callee: chain.last.text,
     interaction: {
@@ -4738,23 +5262,14 @@ function fileOf(key) {
   return at === -1 ? key : key.slice(0, at);
 }
 function returnTypeName(node) {
-  if (node === void 0) {
-    return null;
-  }
-  const annotation = field(node, "return_type");
-  if (annotation === null) {
-    return null;
-  }
-  return annotation.type === "subscript" ? field(annotation, "value")?.text ?? null : annotation.text;
+  const annotation = node === void 0 ? null : field(node, "return_type");
+  return annotation === null ? null : typeNameOf(annotation);
 }
 function storageCallees(calls, filePath, couldMatch) {
   return chainsIn(calls).filter((chain) => couldMatch.has(methodName(chain.root))).map((chain) => field(chain.root, "function")).filter((callee) => callee !== null).map((callee) => readKey(filePath, callee, enclosingFunction(callee)));
 }
 function resolvedMethodPattern(options, callee) {
-  const resolved = options.facts.facts("wantedResolves").filter(
-    (row) => String(row[0]) === readKey(options.filePath, callee, enclosingFunction(callee))
-  ).map((row) => String(row[1]));
-  const settled = resolved.length === 1 ? resolved[0] : void 0;
+  const settled = settledCallee(options, callee);
   if (settled === void 0) {
     return void 0;
   }
@@ -4781,14 +5296,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) {
@@ -4831,7 +5341,7 @@ function storageCallIds(calls, options) {
 }
 function storageEffects(calls, options) {
   return matchedChains(calls, options).flatMap(
-    ({ chain, pattern, operation }) => operation === null ? [] : [effectFor(pattern, chain, operation)]
+    ({ chain, pattern, operation }) => operation === null ? [] : [effectFor(pattern, chain, operation, options)]
   );
 }
 
@@ -5127,6 +5637,7 @@ function classRouteUnits(pattern, pack, classification, classNode, module, optio
               pattern
             ),
             storage: options.storage,
+            importedDefinition: options.importedDefinition,
             wrappers: wrappersAround(
               pattern,
               pack,
@@ -5456,7 +5967,10 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
   if (functionName === void 0) {
     return [];
   }
-  const ctx = createAnnotationContext(module.scopeFor);
+  const ctx = createAnnotationContext(
+    module.scopeFor,
+    options.importedDefinition ?? null
+  );
   return readRoutePaths(
     pattern,
     readPathArgument(classification, options),
@@ -5495,6 +6009,7 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
         ),
         definitionsCtx: ctx,
         storage: options.storage,
+        importedDefinition: options.importedDefinition,
         wrappers: wrappersAround(
           pattern,
           pack,
@@ -5592,7 +6107,10 @@ function buildRouteUnit(options) {
     storage: storageLookup
   } = options;
   const template = valueToReadFurtherFrom(routePath);
-  const ctx = definitionsCtx ?? createAnnotationContext(module.scopeFor);
+  const ctx = definitionsCtx ?? createAnnotationContext(
+    module.scopeFor,
+    options.importedDefinition ?? null
+  );
   const parameters = readParameters(
     definitionNode,
     enclosingScope,
@@ -5673,7 +6191,7 @@ function buildRouteUnit(options) {
     declaredContract: null,
     readings: [
       routePath,
-      ...unreadRoleReadings(parameters, rangeOf(definitionNode)),
+      ...template === null ? unreadRoleReadings(parameters, rangeOf(definitionNode)) : [],
       ...responseShape.passedOver
     ],
     ...collectedDefinitions(ctx) !== null ? { definitions: collectedDefinitions(ctx) } : {},
@@ -5768,7 +6286,7 @@ function readParameter(param, scope, ctx, pathParamNames, requestBodyFromAnnotat
   }
   const { name, typeNode } = info;
   const shape = typeNode !== null ? annotationToShape(typeNode, scope, ctx) : null;
-  const role = isInjectedParameter(param, injectedCallees) ? null : roleOf(name, shape, pathParamNames, requestBodyFromAnnotatedClass);
+  const role = isInjectedParameter(param, injectedCallees, scope, ctx) ? null : roleOf(name, shape, pathParamNames, requestBodyFromAnnotatedClass);
   return {
     name,
     position,
@@ -5802,7 +6320,7 @@ function calleeName2(call) {
   }
   return null;
 }
-function isInjectedParameter(param, injectedCallees) {
+function isInjectedParameter(param, injectedCallees, scope, ctx) {
   if (injectedCallees.size === 0) {
     return false;
   }
@@ -5816,25 +6334,33 @@ function isInjectedParameter(param, injectedCallees) {
   if (callsAnInjector(field(param, "value"))) {
     return true;
   }
-  const containsInjectorCall = (node, depth) => {
+  const followed = /* @__PURE__ */ new Set();
+  const containsInjectorCall = (node, nodeScope, depth) => {
     if (node === null || depth > MAX_ANNOTATION_DEPTH) {
       return false;
     }
     if (callsAnInjector(node)) {
       return true;
     }
+    if (node.type === "identifier" && !followed.has(node.id)) {
+      followed.add(node.id);
+      const alias = aliasValueOf(node.text, nodeScope, ctx);
+      if (alias !== null && containsInjectorCall(alias.node, alias.scope, 0)) {
+        return true;
+      }
+    }
     return node.namedChildren.some(
-      (child) => containsInjectorCall(child, depth + 1)
+      (child) => containsInjectorCall(child, nodeScope, depth + 1)
     );
   };
-  return containsInjectorCall(field(param, "type"), 0);
+  return containsInjectorCall(field(param, "type"), scope, 0);
 }
 
 // src/facts/why.ts
 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) {
@@ -5852,7 +6378,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
@@ -5868,16 +6394,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) {
@@ -5985,6 +6511,58 @@ function buildPythonExtractionReport(args) {
   });
 }
 
+// src/importedDefinitions.ts
+function importedDefinitionLookup(db, files) {
+  const fileOfModuleScope = /* @__PURE__ */ new Map();
+  const byFile = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    fileOfModuleScope.set(file.module.moduleScope.node.id, file.file);
+    byFile.set(file.file, file);
+  }
+  const found = /* @__PURE__ */ new Map();
+  return (scope, name) => {
+    const fromFile = fileOfModuleScope.get(moduleScopeOf(scope).node.id);
+    if (fromFile === void 0) {
+      return null;
+    }
+    const key = `${fromFile}#${name}`;
+    const known = found.get(key);
+    if (known !== void 0) {
+      return known;
+    }
+    const definition = definitionAmong(originsOf(db, key), byFile);
+    found.set(key, definition);
+    return definition;
+  };
+}
+function definitionAmong(origins, byFile) {
+  for (const origin of origins) {
+    const file = byFile.get(origin.module);
+    const binding = file?.module.moduleScope.bindings.get(origin.name);
+    if (file === void 0 || binding === void 0) {
+      continue;
+    }
+    const node = definedNodeOf(binding);
+    if (node !== null) {
+      return {
+        node,
+        moduleScope: file.module.moduleScope,
+        scopeFor: file.module.scopeFor
+      };
+    }
+  }
+  return null;
+}
+function definedNodeOf(binding) {
+  if (binding.kind === "classDef") {
+    return binding.node;
+  }
+  if (binding.kind === "assignment") {
+    return binding.value;
+  }
+  return null;
+}
+
 // src/reach/closure.ts
 import {
   functionCallBinding,
@@ -5996,7 +6574,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,
@@ -6004,248 +6582,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" };
+function assignedElsewhere(facts, nameKey2) {
+  return writtenSourcesOf(facts, nameKey2).some(
+    (source) => !facts.has("func", [source])
+  );
+}
+function readThrough(node) {
+  if (node?.type !== "parenthesized_expression") {
+    return node;
   }
-  return { kind: "stopped", reason: "noDeclaration" };
+  return readThrough(children(node)[0] ?? null);
 }
-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);
-  },
-  // `Service().run()` runs a method on whatever the constructor built.
-  call: (node, site, ctx) => {
-    const callee = field(node, "function");
-    if (callee === null) {
-      return stop("noDeclaration");
-    }
-    const built = resolveExpression(callee, site, ctx);
-    return built.kind === "class" ? built : stop("noDeclaration");
-  },
-  parenthesized_expression: (node, site, ctx) => {
-    const inner = node.namedChildren[0];
-    return inner === null || inner === void 0 ? stop("noDeclaration") : resolveExpression(inner, site, ctx);
+function spellingFor(call, site, ctx) {
+  const callee = readThrough(field(call, "function"));
+  if (callee === null) {
+    return { kind: "stopped", reason: "noDeclaration" };
   }
-};
-function resolveExpression(node, site, ctx) {
-  const resolver = EXPRESSION_RESOLVERS[node.type];
-  return resolver === void 0 ? stop("noDeclaration") : resolver(node, site, ctx);
+  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 };
-}
-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);
+  const target = functionAt(key, ctx);
+  return target === null ? NO_DECLARATION : { kind: "followed", target };
 }
-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");
-    const built = callee === null ? stop("unsettledValue") : aliasedValue(callee, file, scope, ctx, visited);
-    return built.kind === "class" ? built : stop("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;
+  }
+  const object = field(callee, "object");
+  const attribute = field(callee, "attribute");
+  if (object === null || attribute === null) {
+    return null;
   }
-  if (base.kind === "class") {
-    return memberOfClass(base.file, base.node, name, ctx);
+  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;
   }
-  if (base.kind === "stop") {
-    return base;
+  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);
+    }
   }
-  return stop("noDeclaration");
+  if (found.size > 1) {
+    return { kind: "stopped", reason: "multipleSources" };
+  }
+  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;
+  }
+  const object = field(node, "object");
+  const attribute = field(node, "attribute");
+  if (object === null || attribute === null) {
+    return null;
   }
-  return resolveBinding(binding, file, classScope, ctx, /* @__PURE__ */ new Set());
+  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 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;
   }
-  return found[0] ?? stop("noDeclaration");
+  const file = ctx.filesByPath.get(resolution.file);
+  return file === void 0 ? null : { kind: "module", file };
 }
 
 // src/reach/closure.ts
@@ -6260,7 +6817,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();
@@ -6282,21 +6841,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);
@@ -6362,7 +6926,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();
@@ -6371,12 +6946,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;
@@ -6385,9 +6960,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) {
@@ -6407,13 +6981,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)
@@ -6422,8 +6992,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}`;
@@ -6446,32 +7015,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,
@@ -6481,6 +7027,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) {
@@ -6492,40 +7050,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);
@@ -6538,10 +7062,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");
@@ -6692,6 +7212,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;
@@ -6738,20 +7270,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));
         }
@@ -6893,12 +7417,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),
@@ -7226,9 +7746,11 @@ async function extractPythonProject(options) {
       packs: options.packs,
       roots: options.roots,
       facts: needsValues ? db : void 0,
+      definitions,
       storageFor
     })
   );
+  const importedDefinition = importedDefinitionLookup(db, bound);
   const discovered = /* @__PURE__ */ new Map();
   for (const boundFile of bound) {
     const { file, root, module: moduleBinding } = boundFile;
@@ -7242,6 +7764,7 @@ async function extractPythonProject(options) {
         routerIndex,
         gapHandling,
         wrappers: wrapperIndex,
+        importedDefinition,
         ...needsValues ? { facts: db } : {},
         ...storage === void 0 ? {} : { storage }
       })
@@ -7307,7 +7830,9 @@ async function extractPythonProject(options) {
       files: bound,
       roots: options.roots,
       gapHandling,
-      storageFor
+      storageFor,
+      facts: db,
+      definitions
     })
   );
   for (const [key, owners] of summariesBySeed) {
@@ -7569,7 +8094,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),
@@ -7699,6 +8224,7 @@ export {
   emitValueFacts,
   extractPythonProject,
   findPythonFiles,
+  nameKeyIn,
   nodeId,
   objectReturnedBy,
   parsePython,