@suss/adapter-python 0.25.0 → 0.27.0

package/dist/index.cjs

@@ -159,6 +159,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: [] };
@@ -519,8 +538,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 = {};
@@ -563,6 +610,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) {
@@ -584,8 +632,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"
@@ -596,14 +682,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]) };
@@ -614,7 +706,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");
@@ -639,7 +731,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: {} }
@@ -1431,6 +1523,13 @@ function writtenValueOf(db, key) {
   resolveCalls(db, [key]);
   return (0, import_resolution.writtenValueOf)(db, key, (keys) => resolveCalls(db, keys));
 }
+function originsOf(db, nameKey) {
+  if (!db.facts("wantedOrigin").some((row) => String(row[0]) === nameKey)) {
+    db.add("wantedOrigin", [nameKey]);
+    (0, import_datalog.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 subjectConstructions(db, valueKeys) {
   const found = /* @__PURE__ */ new Map();
   if (valueKeys.length === 0) {
@@ -1766,7 +1865,7 @@ function emitBinding(emitter, assignment2, receiver) {
       emitter,
       "binds",
       nameId(emitter.filePath, left.text),
-      valueKey(emitter, right)
+      valueKey(emitter, assignedValue(right))
     );
     return;
   }
@@ -1798,9 +1897,17 @@ function emitAssignment(emitter, assignment2) {
     "exportsAs",
     emitter.filePath,
     left.text,
-    valueKey(emitter, right)
+    valueKey(emitter, assignedValue(right))
   );
 }
+function assignedValue(right) {
+  if (right.type !== "subscript") {
+    return 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") {
     return field(statement, "definition") ?? statement;
@@ -3375,11 +3482,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) {
@@ -4460,7 +4571,7 @@ function rawSqlEffects(calls, options) {
         binding: (0, import_ir_core.storageBinding)({
           recognition: `python-${pattern.module}`,
           storageSystem: pattern.storageSystem,
-          scope: pattern.module,
+          scope: "default",
           container: access.table
         }),
         callee: field(call, "function")?.text ?? "",
@@ -4604,16 +4715,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;
@@ -4623,8 +4741,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");
@@ -4634,7 +4751,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;
@@ -4647,7 +4791,7 @@ function declaredTypeName(name, from) {
     }
   }
   const visit = (node) => {
-    const given = typeGivenBy(node, name);
+    const given = typeGivenBy(node, name, options);
     if (given !== null) {
       return given;
     }
@@ -4676,16 +4820,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, module2, name) {
   return options.patterns.find(
-    (pattern) => String(from[1]) === pattern.module && pattern.queryTypes.includes(String(from[2]))
+    (pattern) => module2 === pattern.module && pattern.queryTypes.includes(name)
   );
 }
 function fieldsOf(chain, valueMethods) {
@@ -4740,7 +4895,71 @@ function selectorOf(chain, valueMethods) {
     )
   ];
 }
-function effectFor(pattern, chain, operation) {
+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 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 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 {
@@ -4748,8 +4967,8 @@ function effectFor(pattern, chain, operation) {
     binding: (0, import_ir_core2.storageBinding)({
       recognition: "python-storage",
       storageSystem: pattern.storageSystem,
-      scope: pattern.module,
-      container: chain.subject
+      scope: "default",
+      container: modelOf(chain, options)
     }),
     callee: chain.last.text,
     interaction: {
@@ -4766,23 +4985,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;
   }
@@ -4859,7 +5069,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)]
   );
 }
 
@@ -5155,6 +5365,7 @@ function classRouteUnits(pattern, pack, classification, classNode, module2, opti
               pattern
             ),
             storage: options.storage,
+            importedDefinition: options.importedDefinition,
             wrappers: wrappersAround(
               pattern,
               pack,
@@ -5484,7 +5695,10 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
   if (functionName === void 0) {
     return [];
   }
-  const ctx = createAnnotationContext(module2.scopeFor);
+  const ctx = createAnnotationContext(
+    module2.scopeFor,
+    options.importedDefinition ?? null
+  );
   return readRoutePaths(
     pattern,
     readPathArgument(classification, options),
@@ -5523,6 +5737,7 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
         ),
         definitionsCtx: ctx,
         storage: options.storage,
+        importedDefinition: options.importedDefinition,
         wrappers: wrappersAround(
           pattern,
           pack,
@@ -5620,7 +5835,10 @@ function buildRouteUnit(options) {
     storage: storageLookup
   } = options;
   const template = (0, import_extractor5.valueToReadFurtherFrom)(routePath);
-  const ctx = definitionsCtx ?? createAnnotationContext(module2.scopeFor);
+  const ctx = definitionsCtx ?? createAnnotationContext(
+    module2.scopeFor,
+    options.importedDefinition ?? null
+  );
   const parameters = readParameters(
     definitionNode,
     enclosingScope,
@@ -5701,7 +5919,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) } : {},
@@ -5796,7 +6014,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,
@@ -5830,7 +6048,7 @@ function calleeName2(call) {
   }
   return null;
 }
-function isInjectedParameter(param, injectedCallees) {
+function isInjectedParameter(param, injectedCallees, scope, ctx) {
   if (injectedCallees.size === 0) {
     return false;
   }
@@ -5844,18 +6062,26 @@ 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
@@ -5991,6 +6217,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
 var import_behavioral_ir4 = require("@suss/behavioral-ir");
 var import_datalog2 = require("@suss/datalog");
@@ -6048,14 +6326,9 @@ var EXPRESSION_RESOLVERS = {
     }
     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");
+    return callee === null ? stop("noDeclaration") : instanceBuiltBy(resolveExpression(callee, site, ctx), "noDeclaration");
   },
   parenthesized_expression: (node, site, ctx) => {
     const inner = node.namedChildren[0];
@@ -6066,6 +6339,12 @@ function resolveExpression(node, site, ctx) {
   const resolver = EXPRESSION_RESOLVERS[node.type];
   return resolver === void 0 ? stop("noDeclaration") : resolver(node, site, ctx);
 }
+function instanceBuiltBy(built, otherwise) {
+  if (built.kind === "class" || built.kind === "stop") {
+    return built;
+  }
+  return built.kind === "package" ? stop("outsideRun") : stop(otherwise);
+}
 function resolveIdentifier(name, site, ctx) {
   if (site.rebound.has(name)) {
     return stop("unsettledValue");
@@ -6131,8 +6410,10 @@ function aliasedValue(value, 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");
+    return callee === null ? stop("unsettledValue") : instanceBuiltBy(
+      aliasedValue(callee, file, scope, ctx, visited),
+      "unsettledValue"
+    );
   }
   if (value.type === "attribute") {
     const object = field(value, "object");
@@ -7222,6 +7503,7 @@ async function extractPythonProject(options) {
       storageFor
     })
   );
+  const importedDefinition = importedDefinitionLookup(db, bound);
   const discovered = /* @__PURE__ */ new Map();
   for (const boundFile of bound) {
     const { file, root, module: moduleBinding } = boundFile;
@@ -7235,6 +7517,7 @@ async function extractPythonProject(options) {
         routerIndex,
         gapHandling,
         wrappers: wrapperIndex,
+        importedDefinition,
         ...needsValues ? { facts: db } : {},
         ...storage === void 0 ? {} : { storage }
       })