@suss/adapter-python 0.31.2 → 0.33.0

package/dist/index.js

@@ -29,6 +29,12 @@ var LATER_BODY_TYPES = /* @__PURE__ */ new Set([
   "lambda",
   "class_definition"
 ]);
+function isModule(node) {
+  return node.type === "module";
+}
+function runsAtModuleLoad(node) {
+  return !LATER_BODY_TYPES.has(node.type) && node.type !== "decorator";
+}
 function enclosingFunction(node) {
   let current = node.parent;
   while (current !== null) {
@@ -724,6 +730,15 @@ import {
 function resolveCalls(db, callKeys) {
   askResolution(db, callKeys);
 }
+function resolveEnvObjects(db, objectKeys) {
+  askResolution(db, objectKeys, "wantedEnvObject");
+}
+function resolvedFunctions(db, key) {
+  return [
+    ...db.lookup("wantedResolves", 0, key),
+    ...db.lookup("wantedGivesBack", 0, key)
+  ].map((row) => String(row[1]));
+}
 function writtenValueUnder(db, key, site) {
   if (askResolutionUnder(db, [[key, site]]) === "abandoned") {
     return null;
@@ -742,6 +757,13 @@ function writtenValuesOf(db, key) {
   resolveCalls(db, [key]);
   return sharedWrittenValuesOf(db, key, (keys) => resolveCalls(db, keys));
 }
+function settleWrittenValues(db, keys) {
+  if (keys.length === 0) {
+    return;
+  }
+  resolveCalls(db, keys);
+  writtenValuesByKey(db, keys, (behind) => resolveCalls(db, behind));
+}
 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]) }));
@@ -936,31 +958,46 @@ function emitCall(emitter, call) {
   if (!emitter.insideMethod) {
     add(emitter, "callOutsideMethod", callKey);
   }
+  for (const argument of callArguments(call)) {
+    if (argument.kind === "keyword") {
+      add(
+        emitter,
+        "callKeywordArg",
+        callKey,
+        argument.name,
+        valueKey(emitter, argument.node)
+      );
+      continue;
+    }
+    add(
+      emitter,
+      "callArg",
+      callKey,
+      String(argument.position),
+      valueKey(emitter, argument.node)
+    );
+  }
+}
+function callArguments(call) {
+  const args = field(call, "arguments");
+  if (args === null) {
+    return [];
+  }
+  const written = [];
   let position = 0;
   for (const argument of children(args)) {
     if (argument.type === "keyword_argument") {
       const name = field(argument, "name");
       const value = field(argument, "value");
       if (name !== null && value !== null) {
-        add(
-          emitter,
-          "callKeywordArg",
-          callKey,
-          name.text,
-          valueKey(emitter, value)
-        );
+        written.push({ kind: "keyword", name: name.text, node: value });
       }
       continue;
     }
-    add(
-      emitter,
-      "callArg",
-      callKey,
-      String(position),
-      valueKey(emitter, argument)
-    );
+    written.push({ kind: "positional", position, node: argument });
     position += 1;
   }
+  return written;
 }
 function valueKey(emitter, value) {
   if (value.type !== "identifier") {
@@ -1027,9 +1064,51 @@ function walkExpressions(emitter, node, visit) {
     walkExpressions(emitter, child, visit);
   }
 }
+var WRITTEN_KEY_TYPES = /* @__PURE__ */ new Set(["string", "integer", "concatenated_string"]);
+function emitKeyedRead(emitter, site, container, key) {
+  if (WRITTEN_KEY_TYPES.has(key.type)) {
+    return;
+  }
+  add(
+    emitter,
+    "readsKeyed",
+    nodeId(emitter.filePath, site),
+    valueKey(emitter, container),
+    valueKey(emitter, key)
+  );
+}
+function singleSubscript(node) {
+  const written = fields(node, "subscript");
+  return written.length === 1 ? written[0] ?? null : null;
+}
+function mappingGetRead(call) {
+  const callee = field(call, "function");
+  if (callee === null || callee.type !== "attribute") {
+    return null;
+  }
+  const container = field(callee, "object");
+  if (container === null || field(callee, "attribute")?.text !== "get") {
+    return null;
+  }
+  const first = callArguments(call).find(
+    (argument) => argument.kind === "positional" && argument.position === 0
+  );
+  return first === void 0 ? null : { container, key: first.node };
+}
 function emitExpressionFact(emitter, child) {
   if (child.type === "call") {
     emitCall(emitter, child);
+    const mapping = mappingGetRead(child);
+    if (mapping !== null) {
+      emitKeyedRead(emitter, child, mapping.container, mapping.key);
+    }
+  }
+  if (child.type === "subscript") {
+    const index = singleSubscript(child);
+    const container = field(child, "value");
+    if (index !== null && container !== null) {
+      emitKeyedRead(emitter, child, container, index);
+    }
   }
   if (child.type === "dictionary") {
     emitDictionary(emitter, child);
@@ -1097,6 +1176,9 @@ function emitFunctionFacts(emitter, fn, classKey) {
     return funcKey;
   }
   emitNestedDefinitions(inside, body);
+  if (fn.type === "lambda") {
+    emitExpressionFact(inside, body);
+  }
   let statesReturn = false;
   const stores = /* @__PURE__ */ new Map();
   walkExpressions(inside, body, (child) => {
@@ -2476,6 +2558,10 @@ function writtenNodeOf(node, db) {
   const bound = db === void 0 ? void 0 : projects.get(db);
   return bound?.context.writtenTo(node) ?? null;
 }
+function resolutionKeyOf(node, db) {
+  const bound = db === void 0 ? void 0 : projects.get(db);
+  return bound?.keyOf(node) ?? null;
+}
 var NOTHING_BUILT = { type: "noCall" };
 function constructionBehind(node, db) {
   if (db === void 0) {
@@ -2510,8 +2596,17 @@ function askWrittenValues(nodes, db) {
   if (bound === void 0) {
     return;
   }
-  const keys = nodes.map((node) => bound.keyOf(node)).filter((key) => key !== null);
-  resolveCalls(db, keys);
+  settleWrittenValues(db, resolutionKeysOf(nodes, bound));
+}
+function resolutionKeysOf(nodes, bound) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    const key = bound.keyOf(node);
+    if (key !== null) {
+      keys.add(key);
+    }
+  }
+  return [...keys];
 }
 function evaluatedValue(node, db, site) {
   const evaluator = evaluatorFor(node, db);
@@ -2579,7 +2674,7 @@ function projectOver(db, nodes) {
     filesByRoot.set(entry.root.id, entry);
     rootsByFile.set(entry.file, entry.root);
   }
-  const keyOf2 = (node) => {
+  const keyOf3 = (node) => {
     const entry = filesByRoot.get(node.tree.rootNode.id);
     if (entry === void 0) {
       return null;
@@ -2588,7 +2683,7 @@ function projectOver(db, nodes) {
   };
   const context = {
     writtenTo: (node, site) => {
-      const key = keyOf2(node);
+      const key = keyOf3(node);
       if (key === null) {
         return null;
       }
@@ -2597,17 +2692,17 @@ function projectOver(db, nodes) {
     },
     callable: (call) => {
       const callee = field(call, "function");
-      const key = callee === null ? null : keyOf2(callee);
+      const key = callee === null ? null : keyOf3(callee);
       if (key === null) {
         return null;
       }
       resolveCalls(db, [key]);
-      const resolved = db.facts("wantedResolves").filter((row) => String(row[0]) === key).map((row) => String(row[1]));
-      const settled = resolved.length === 1 ? resolved[0] : void 0;
+      const resolved = db.lookup("wantedResolves", 0, key);
+      const settled = resolved.length === 1 ? String(resolved[0]?.[1]) : void 0;
       return settled === void 0 ? null : nodes.definitions.get(settled) ?? null;
     }
   };
-  return { keyOf: keyOf2, roots: rootsByFile, context };
+  return { keyOf: keyOf3, roots: rootsByFile, context };
 }
 
 // src/decorators.ts
@@ -3245,6 +3340,18 @@ function bodyCalls(node, found = []) {
   }
   return found;
 }
+function moduleLoadCalls(node, found = []) {
+  for (const child of node.namedChildren) {
+    if (child === null || !runsAtModuleLoad(child)) {
+      continue;
+    }
+    if (child.type === "call") {
+      found.push(child);
+    }
+    moduleLoadCalls(child, found);
+  }
+  return found;
+}
 function enclosingStatement(call, body) {
   let current = call;
   while (current !== null && current.parent !== null) {
@@ -3269,15 +3376,18 @@ function argOf(node, facts) {
   }
   return { kind: "identifier", name: node.text };
 }
-function argsOf(call, facts) {
+function argumentNodes(call) {
   const args = field(call, "arguments");
   if (args === null) {
     return [];
   }
   return args.namedChildren.filter((child) => child !== null).map(
-    (child) => child.type === "keyword_argument" ? argOf(field(child, "value") ?? child, facts) : argOf(child, facts)
+    (child) => child.type === "keyword_argument" ? field(child, "value") ?? child : child
   );
 }
+function argsOf(call, facts) {
+  return argumentNodes(call).map((node) => argOf(node, facts));
+}
 function calleeText(call) {
   return field(call, "function")?.text ?? call.text;
 }
@@ -3286,7 +3396,40 @@ function invocationEffects(definitionNode, facts) {
   if (body === null) {
     return [];
   }
-  const calls = bodyCalls(body).sort((a, b) => a.endIndex - b.endIndex);
+  return invocationEffectsIn(body, bodyCalls(body), facts);
+}
+function moduleLoadInvocationEffects(moduleNode, facts) {
+  return invocationEffectsIn(moduleNode, moduleLoadCalls(moduleNode), facts);
+}
+var ASKED_ABOUT_TYPES = /* @__PURE__ */ new Set(["identifier", "attribute", "call"]);
+function askedNodesUnder(node, found = []) {
+  if (ASKED_ABOUT_TYPES.has(node.type)) {
+    found.push(node);
+  }
+  for (const child of node.namedChildren) {
+    if (child !== null && !NESTED_DEFINITION_TYPES.has(child.type)) {
+      askedNodesUnder(child, found);
+    }
+  }
+  return found;
+}
+function bodyValueNodes(definitionNode) {
+  const body = field(definitionNode, "body");
+  return body === null ? [] : askedNodesUnder(body);
+}
+function effectValueNodes(call, gating) {
+  const found = argumentNodes(call).flatMap((node) => askedNodesUnder(node));
+  for (const path6 of gating ?? []) {
+    for (const condition of path6) {
+      if (condition.expression !== null) {
+        askedNodesUnder(condition.expression, found);
+      }
+    }
+  }
+  return found;
+}
+function invocationEffectsIn(body, written, facts) {
+  const calls = [...written].sort((a, b) => a.endIndex - b.endIndex);
   if (calls.length === 0) {
     return [];
   }
@@ -3308,10 +3451,17 @@ function invocationEffects(definitionNode, facts) {
     },
     statements
   );
-  return calls.map((call) => {
+  const gatingOf = calls.map((call) => {
     const statement = statementOf3.get(call.id);
+    return statement === void 0 ? void 0 : enumerated.byTerminal.get(statement);
+  });
+  askWrittenValues(
+    calls.flatMap((call, index) => effectValueNodes(call, gatingOf[index])),
+    facts
+  );
+  return calls.map((call, index) => {
     const conditions = sharedGatingConditions(
-      statement === void 0 ? void 0 : enumerated.byTerminal.get(statement),
+      gatingOf[index],
       (condition) => predicateOf(condition, facts)
     );
     return {
@@ -3342,6 +3492,22 @@ function clientCallUnits(root, module, pack, pattern, options) {
   }
   return units;
 }
+function clientCallReceivers(root, module) {
+  const found = [];
+  for (const definition of functionDefinitions(root)) {
+    for (const call of bodyCalls(definition)) {
+      const callee = field(call, "function");
+      if (callee === null || originOf(callee, module) !== null) {
+        continue;
+      }
+      const object = field(callee, "object");
+      if (object !== null && field(callee, "attribute") !== null) {
+        found.push(object);
+      }
+    }
+  }
+  return found;
+}
 function functionDefinitions(node, found = []) {
   for (const child of children(node)) {
     if (isFunction(child)) {
@@ -3550,14 +3716,22 @@ import { runtimeConfigBinding } from "@suss/behavioral-ir";
 import { SKIP_CHILDREN, walkDescendants } from "@suss/extractor";
 var PYTHON_ENV_RECOGNITION = "python-env";
 var DEFERRED_BODY_TYPES = /* @__PURE__ */ new Set(["function_definition", "lambda"]);
-function envReadEffects(root, module) {
-  const effects = [];
+function envReadEffects(root, module, facts) {
+  const slots = [];
+  const readsHelpers = facts !== void 0 && sitesByDb.has(facts);
   const startScope = module.scopeFor.get(root.id) ?? module.moduleScope;
   walkDescendants(root, startScope, {
     at: (node, scope) => {
-      const read = envReadAt(node, scope);
-      if (read !== null) {
-        effects.push(configReadEffect(read));
+      const syntax = envReadSyntaxAt(node, scope);
+      if (syntax !== null) {
+        const name = stringLiteralValue(syntax.name);
+        if (name !== null) {
+          slots.push({ read: { name, defaulted: syntax.defaulted } });
+        }
+        return;
+      }
+      if (readsHelpers && node.type === "call") {
+        slots.push({ call: node });
       }
     },
     into: (node, scope) => {
@@ -3567,7 +3741,16 @@ function envReadEffects(root, module) {
       return module.scopeFor.get(node.id) ?? scope;
     }
   });
-  return effects;
+  const throughHelpers = helperReadsByCall(
+    slots.flatMap((slot) => "call" in slot ? [slot.call] : []),
+    facts
+  );
+  return slots.flatMap((slot) => {
+    if ("read" in slot) {
+      return [configReadEffect(slot.read)];
+    }
+    return throughHelpers.get(slot.call.id) ?? [];
+  });
 }
 function configReadEffect(read) {
   return {
@@ -3585,7 +3768,7 @@ function configReadEffect(read) {
     }
   };
 }
-function envReadAt(node, scope) {
+function envReadSyntaxAt(node, scope) {
   if (node.type === "subscript") {
     return subscriptRead(node, scope);
   }
@@ -3600,11 +3783,10 @@ function subscriptRead(node, scope) {
   if (value === null || index === null || !isEnviron(value, scope)) {
     return null;
   }
-  const name = stringLiteralValue(index);
-  if (name === null || isAssignedTo(node)) {
+  if (isAssignedTo(node)) {
     return null;
   }
-  return { name, defaulted: isDefaultedAt(node) };
+  return { name: index, defaulted: isDefaultedAt(node) };
 }
 function isAssignedTo(node) {
   const parent = node.parent;
@@ -3618,22 +3800,20 @@ function isAssignedTo(node) {
 }
 function callRead(node, scope) {
   const callee = field(node, "function");
-  const args = field(node, "arguments");
-  if (callee === null || args === null || !isEnvGetter(callee, scope)) {
+  if (callee === null || !isEnvGetter(callee, scope)) {
     return null;
   }
-  const positional = args.namedChildren.filter(
-    (arg) => arg !== null && arg.type !== "keyword_argument"
+  const written = callArguments(node);
+  const name = written.find(
+    (argument) => argument.kind === "positional" && argument.position === 0
   );
-  const name = positional[0] === void 0 ? null : stringLiteralValue(positional[0]);
-  if (name === null) {
+  if (name === void 0) {
     return null;
   }
-  const keywords = args.namedChildren.filter(
-    (arg) => arg !== null && arg.type === "keyword_argument"
+  const hasDefault = written.some(
+    (argument) => argument.kind === "positional" && argument.position === 1 || argument.kind === "keyword" && argument.name === "default"
   );
-  const hasDefault = positional.length > 1 || keywords.some((arg) => field(arg, "name")?.text === "default");
-  return { name, defaulted: hasDefault || isDefaultedAt(node) };
+  return { name: name.node, defaulted: hasDefault || isDefaultedAt(node) };
 }
 function isEnvGetter(callee, scope) {
   if (callee.type === "attribute") {
@@ -3690,6 +3870,194 @@ function isDefaultedAt(node) {
   }
   return false;
 }
+function envFactsIn(filePath, root, module) {
+  const found = { sites: [], objects: [] };
+  walkDescendants(root, module.moduleScope, {
+    at: (node, scope) => {
+      if (isEnviron(node, scope) && handsOnward(node)) {
+        found.objects.push(keyOf(filePath, node));
+      }
+      const syntax = envReadSyntaxAt(node, scope);
+      if (syntax === null || stringLiteralValue(syntax.name) !== null) {
+        return;
+      }
+      found.sites.push({
+        site: nodeId(filePath, node),
+        nameKey: keyOf(filePath, syntax.name),
+        defaulted: syntax.defaulted,
+        functionKey: functionReadKey(filePath, node, scope)
+      });
+    },
+    into: (node, scope) => module.scopeFor.get(node.id) ?? scope
+  });
+  return found;
+}
+var keyOf = (filePath, node) => readKey(filePath, node, enclosingFunction(node));
+function functionReadKey(filePath, node, scope) {
+  if (node.type !== "call") {
+    return null;
+  }
+  const callee = field(node, "function");
+  if (callee === null || isEnviron(field(callee, "object") ?? callee, scope)) {
+    return null;
+  }
+  return keyOf(filePath, callee);
+}
+function handsOnward(node) {
+  const parent = node.parent;
+  if (parent === null) {
+    return true;
+  }
+  if (parent.type === "subscript" && field(parent, "value")?.id === node.id) {
+    return !writesTheKey(field(parent, "subscript"));
+  }
+  if (parent.type === "attribute" && field(parent, "object")?.id === node.id) {
+    const call = parent.parent;
+    return field(parent, "attribute")?.text === "get" && call !== null && call.type === "call" && !writesTheKey(firstArgumentOf(call));
+  }
+  return true;
+}
+var writesTheKey = (key) => key !== null && stringLiteralValue(key) !== null;
+function firstArgumentOf(call) {
+  const first = callArguments(call).find(
+    (argument) => argument.kind === "positional" && argument.position === 0
+  );
+  return first?.node ?? null;
+}
+var sitesByDb = /* @__PURE__ */ new WeakMap();
+function bindEnvFacts(db, found) {
+  const sites = found.flatMap((one) => one.sites);
+  const objects = found.flatMap((one) => one.objects);
+  if (sites.length === 0 && objects.length === 0) {
+    return;
+  }
+  let index = sitesByDb.get(db);
+  if (index === void 0) {
+    index = { byId: /* @__PURE__ */ new Map(), objects: /* @__PURE__ */ new Set(), sitesByParameter: null };
+    sitesByDb.set(db, index);
+  }
+  for (const object of objects) {
+    db.add("environmentObject", [object]);
+    index.objects.add(object);
+  }
+  for (const site of sites) {
+    index.byId.set(site.site, site);
+    if (site.functionKey === null) {
+      continue;
+    }
+    db.add("environmentObject", [site.functionKey]);
+    db.add("readsKeyed", [site.site, site.functionKey, site.nameKey]);
+    index.objects.add(site.functionKey);
+  }
+}
+function sitesEachParameterNames(db, index) {
+  if (index.sitesByParameter !== null) {
+    return index.sitesByParameter;
+  }
+  resolveEnvObjects(db, [...index.objects]);
+  const found = /* @__PURE__ */ new Map();
+  for (const row of db.facts("wantedParamNamesEnv")) {
+    const parameter = String(row[0]);
+    const named = found.get(parameter) ?? [];
+    named.push(String(row[1]));
+    found.set(parameter, named);
+  }
+  index.sitesByParameter = found;
+  return found;
+}
+function helperReadsByCall(calls, db) {
+  const found = /* @__PURE__ */ new Map();
+  const index = db === void 0 ? void 0 : sitesByDb.get(db);
+  if (db === void 0 || index === void 0 || calls.length === 0) {
+    return found;
+  }
+  const named = sitesEachParameterNames(db, index);
+  if (named.size === 0) {
+    return found;
+  }
+  const calleeKeys = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const callee = field(call, "function");
+    const key = callee === null ? null : resolutionKeyOf(callee, db);
+    if (key !== null) {
+      calleeKeys.set(call.id, key);
+    }
+  }
+  if (calleeKeys.size === 0) {
+    return found;
+  }
+  resolveCalls(db, [...new Set(calleeKeys.values())]);
+  for (const call of calls) {
+    const key = calleeKeys.get(call.id);
+    if (key === void 0) {
+      continue;
+    }
+    const argumentAt2 = argumentsByParameter(db, call, key);
+    if (argumentAt2.size === 0) {
+      continue;
+    }
+    const reads = readsThroughHelper(db, call, argumentAt2, index.byId, named);
+    if (reads.length > 0) {
+      found.set(call.id, reads);
+    }
+  }
+  return found;
+}
+function argumentsByParameter(db, call, calleeKey) {
+  const written = callArguments(call);
+  if (written.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const positional = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  for (const argument of written) {
+    if (argument.kind === "keyword") {
+      byName.set(argument.name, argument.node);
+      continue;
+    }
+    positional.set(String(argument.position), argument.node);
+  }
+  const argumentAt2 = /* @__PURE__ */ new Map();
+  for (const callee of resolvedFunctions(db, calleeKey)) {
+    for (const row of db.lookup("paramOf", 0, callee)) {
+      const at = positional.get(String(row[1]));
+      if (at !== void 0) {
+        argumentAt2.set(String(row[2]), at);
+      }
+    }
+    for (const row of db.lookup("paramNamed", 0, callee)) {
+      const at = byName.get(String(row[1]));
+      if (at !== void 0) {
+        argumentAt2.set(String(row[2]), at);
+      }
+    }
+  }
+  return argumentAt2;
+}
+function readsThroughHelper(db, call, argumentAt2, siteById, named) {
+  const reads = /* @__PURE__ */ new Map();
+  for (const [parameter, argument] of argumentAt2) {
+    const sites = named.get(parameter);
+    if (sites === void 0) {
+      continue;
+    }
+    const name = stringLiteralValue(argument) ?? stringValueOf(argument, db);
+    if (name === null) {
+      continue;
+    }
+    for (const id of sites) {
+      const defaulted = siteById.get(id)?.defaulted ?? false;
+      reads.set(name, (reads.get(name) ?? true) && defaulted);
+    }
+  }
+  if (reads.size === 0) {
+    return [];
+  }
+  const defaultedAtCall = isDefaultedAt(call);
+  return [...reads].map(
+    ([name, defaulted]) => configReadEffect({ name, defaulted: defaulted || defaultedAtCall })
+  );
+}
 
 // src/paths/raisedResponses.ts
 import { constantOf as constantOf3 } from "@suss/values";
@@ -3898,72 +4266,302 @@ function returnedBodyShape(statement) {
 
 // src/rawSql.ts
 import { storageBinding } from "@suss/ir-core";
-import { readSqlAccess, sqlFromParts } from "@suss/sql";
-function rawSqlEffects(calls, options) {
-  if (options.patterns.length === 0) {
-    return [];
+import { readSqlAccess, splitQualifiedTable, sqlFromParts } from "@suss/sql";
+import { force as force2 } from "@suss/values";
+
+// src/receiverTypes.ts
+var UNDECLARED_MODULE = "builtins";
+function annotationTarget(annotation) {
+  if (annotation.type === "type" && annotation.namedChildren[0]) {
+    return annotationTarget(annotation.namedChildren[0]);
   }
-  const effects = [];
-  for (const call of calls) {
-    const pattern = patternFor(call, options);
-    if (pattern === void 0) {
-      continue;
+  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 : annotationTarget(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 annotationTarget(first);
     }
-    const statement = statementIn(call, options.facts);
-    if (statement === null) {
+    return outer ?? null;
+  }
+  return annotation;
+}
+function typeNameOf(annotation) {
+  const target = annotationTarget(annotation);
+  if (target === null) {
+    return null;
+  }
+  return target.type === "identifier" ? target.text : stringLiteralValue(target);
+}
+function firstInBody(node, read) {
+  const here = read(node);
+  if (here !== null) {
+    return here;
+  }
+  for (const child of children(node)) {
+    if (child.type === "function_definition" || child.type === "lambda") {
       continue;
     }
-    for (const access of readSqlAccess(statement, {
-      dialect: pattern.storageSystem
-    })) {
-      effects.push({
-        type: "interaction",
-        binding: storageBinding({
-          recognition: `python-${pattern.module}`,
-          storageSystem: pattern.storageSystem,
-          scope: "default",
-          container: access.table
-        }),
-        callee: field(call, "function")?.text ?? "",
-        interaction: {
-          class: "storage-access",
-          kind: access.kind,
-          fields: access.fields,
-          ...access.selector.length > 0 ? { selector: access.selector } : {},
-          operation: field(call, "function")?.text ?? ""
-        }
-      });
+    const found = firstInBody(child, read);
+    if (found !== null) {
+      return found;
     }
   }
-  return effects;
+  return null;
 }
-function patternFor(call, options) {
+function statedBy(statement, name) {
+  if (statement.type === "assignment") {
+    const annotation = field(statement, "type");
+    return field(statement, "left")?.text === name ? annotation : null;
+  }
+  if (statement.type === "as_pattern") {
+    const alias = field(statement, "alias");
+    const value = statement.namedChildren[0] ?? null;
+    const callee = value?.type === "call" ? field(value, "function") : null;
+    return alias?.text === name ? callee : null;
+  }
+  return null;
+}
+function statedTypeNode(name, from) {
+  const fn = enclosingFunction(from);
+  if (fn === null) {
+    return null;
+  }
+  const params = field(fn, "parameters");
+  for (const param of params === null ? [] : children(params)) {
+    const info = parameterNameAndType(param);
+    if (info?.name === name && info.typeNode !== null) {
+      return info.typeNode;
+    }
+  }
+  const body = field(fn, "body");
+  return body === null ? null : firstInBody(body, (statement) => statedBy(statement, name));
+}
+function statedTypeName(name, from) {
+  const stated = statedTypeNode(name, from);
+  return stated === null ? null : typeNameOf(stated);
+}
+function statedOrigins(stated, options) {
+  const name = typeNameOf(stated);
+  const byRule = name === null ? [] : originsOf(options.facts, `${options.filePath}#${name}`);
+  const target = annotationTarget(stated);
+  const imported = target === null ? null : originOf(target, moduleOf(target));
+  if (imported === null || imported.module === UNDECLARED_MODULE) {
+    return byRule;
+  }
+  return [...byRule, imported];
+}
+function receiverTypeOrigins(receiver, options) {
+  const stated = statedTypeNode(receiver.text, receiver);
+  if (stated !== null) {
+    return statedOrigins(stated, options);
+  }
+  const built = constructionBehind(receiver, options.facts);
+  if (built.type === "oneCall") {
+    return [built.construction.origin];
+  }
+  const key = nameKeyIn(
+    options.filePath,
+    enclosingFunction(receiver),
+    receiver.text
+  );
+  return subjectConstructions(options.facts, [key]).get(key)?.origins ?? [];
+}
+
+// src/rawSql.ts
+function rawSqlEffects(calls, options) {
+  return matchesIn(calls, options).flatMap(
+    (match) => match.accesses.flatMap((access) => effectFor(match, access))
+  );
+}
+function rawSqlCallIds(calls, options) {
+  return new Set(matchesIn(calls, options).map((match) => match.call.id));
+}
+function matchesIn(calls, options) {
+  if (options.patterns.length === 0 && (options.clients ?? []).length === 0) {
+    return [];
+  }
+  const matched = [];
+  for (const call of calls) {
+    const one = importedFunctionMatch(call, options) ?? clientMatch(call, options);
+    if (one !== null) {
+      matched.push(one);
+    }
+  }
+  return matched;
+}
+function effectFor(match, access) {
+  const operation = field(match.call, "function")?.text ?? "";
+  return [
+    {
+      type: "interaction",
+      binding: storageBinding({
+        recognition: match.recognition,
+        storageSystem: match.storageSystem,
+        scope: access.qualifier[access.qualifier.length - 1] ?? NO_GROUP,
+        container: access.table
+      }),
+      callee: operation,
+      interaction: {
+        class: "storage-access",
+        kind: access.kind,
+        fields: access.fields,
+        ...access.selector.length > 0 ? { selector: access.selector } : {},
+        operation
+      }
+    }
+  ];
+}
+var NO_GROUP = "default";
+function importedFunctionMatch(call, options) {
   const callee = field(call, "function");
   if (callee === null || callee.type !== "identifier") {
-    return void 0;
+    return null;
   }
   const from = options.facts.facts("pyImportedName").find((row) => String(row[0]) === `${options.filePath}#${callee.text}`);
   if (from === void 0) {
-    return void 0;
+    return null;
   }
   const module = String(from[1]);
-  return options.patterns.find(
-    (pattern) => pattern.module === module && pattern.functions.includes(callee.text)
+  const pattern = options.patterns.find(
+    (candidate) => candidate.module === module && candidate.functions.includes(callee.text)
   );
-}
-function statementIn(call, facts) {
+  if (pattern === void 0) {
+    return null;
+  }
   const args = field(call, "arguments");
   const first = args?.namedChildren.find((child) => child !== null) ?? null;
-  if (first === null) {
+  const statement = first === null ? null : statementAt(first, void 0, options.facts);
+  if (statement === null) {
     return null;
   }
-  const parts = literalParts(evaluatedValue(first, facts));
+  return {
+    call,
+    recognition: `python-${pattern.module}`,
+    storageSystem: pattern.storageSystem,
+    accesses: readSqlAccess(statement, { dialect: pattern.storageSystem })
+  };
+}
+function clientMatch(call, options) {
+  const callee = field(call, "function");
+  if (callee === null || callee.type !== "attribute") {
+    return null;
+  }
+  const method = field(callee, "attribute")?.text ?? "";
+  const receiver = field(callee, "object");
+  if (receiver === null) {
+    return null;
+  }
+  for (const pattern of options.clients ?? []) {
+    const accesses = accessesOf(call, method, pattern, options);
+    if (accesses === null || !isClientOf(receiver, pattern, options)) {
+      continue;
+    }
+    return {
+      call,
+      recognition: `python-${pattern.module}`,
+      storageSystem: pattern.storageSystem,
+      accesses
+    };
+  }
+  return null;
+}
+function accessesOf(call, method, pattern, options) {
+  const dialect = pattern.dialect ?? pattern.storageSystem;
+  for (const takes of pattern.statements ?? []) {
+    if (takes.method !== method) {
+      continue;
+    }
+    const written = argumentNode(call, takes);
+    const statement = written === null ? null : statementAt(written, takes.path, options.facts);
+    return statement === null ? [] : readSqlAccess(statement, { dialect });
+  }
+  for (const takes of pattern.tables ?? []) {
+    if (takes.method !== method) {
+      continue;
+    }
+    const written = argumentNode(call, takes);
+    const name = written === null ? null : stringValueOf(written, options.facts);
+    const split = name === null ? null : splitQualifiedTable(name);
+    return split === null ? [] : [{ ...split, kind: takes.kind, fields: [], selector: [] }];
+  }
+  return null;
+}
+function isClientOf(receiver, pattern, options) {
+  return receiverOrigins(receiver, options).some(
+    (origin) => origin.module === pattern.module && pattern.clientTypes.includes(origin.name)
+  );
+}
+function receiverOrigins(receiver, options) {
+  if (receiver.type === "identifier") {
+    return receiverTypeOrigins(receiver, options);
+  }
+  return receiver.type === "call" ? handedBack(receiver, options) : [];
+}
+function handedBack(call, options) {
+  const callee = field(call, "function");
+  if (callee === null || callee.type !== "attribute") {
+    return [];
+  }
+  const method = field(callee, "attribute")?.text ?? "";
+  const inner = field(callee, "object");
+  if (inner === null) {
+    return [];
+  }
+  const found = [];
+  for (const pattern of options.clients ?? []) {
+    const handoff = (pattern.handsBack ?? []).find(
+      (one) => one.method === method
+    );
+    if (handoff !== void 0 && isClientOf(inner, pattern, options)) {
+      found.push({ module: handoff.module, name: handoff.name });
+    }
+  }
+  return found;
+}
+function argumentNode(call, at) {
+  const args = field(call, "arguments");
+  const written = args === null ? [] : children(args);
+  const named = written.find(
+    (one) => one.type === "keyword_argument" && at.keyword !== void 0 && field(one, "name")?.text === at.keyword
+  );
+  const value = named === void 0 ? null : field(named, "value");
+  if (value !== null) {
+    return value;
+  }
+  if (at.argument === void 0) {
+    return null;
+  }
+  return written.filter((one) => one.type !== "keyword_argument")[at.argument] ?? null;
+}
+function statementAt(node, path6, facts) {
+  const reached = valueAt(evaluatedValue(node, facts), path6 ?? []);
+  const parts = reached === null ? null : literalParts(reached);
   if (parts === null) {
     return null;
   }
   const statement = sqlFromParts(parts);
   return statement.trim() === "" ? null : statement;
 }
+function valueAt(value, path6) {
+  let reached = value;
+  for (const key of path6) {
+    if (reached.kind !== "record") {
+      return null;
+    }
+    const item = reached.fields.get(key);
+    if (item === void 0) {
+      return null;
+    }
+    reached = force2(item.value);
+  }
+  return reached;
+}
 function literalParts(value) {
   if (value.kind !== "string") {
     return null;
@@ -4061,78 +4659,7 @@ function receiverName(chain) {
     return null;
   }
   const object = field(callee, "object");
-  return object !== null && object.type === "identifier" ? object.text : null;
-}
-function typeNameOf(annotation) {
-  if (annotation.type === "type" && annotation.namedChildren[0]) {
-    return typeNameOf(annotation.namedChildren[0]);
-  }
-  if (annotation.type === "identifier") {
-    return annotation.text;
-  }
-  const quoted = stringLiteralValue(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 statedTypeName(name, from) {
-  const fn = enclosingFunction(from);
-  if (fn === null) {
-    return null;
-  }
-  const params = field(fn, "parameters");
-  for (const param of params === null ? [] : children(params)) {
-    const info = parameterNameAndType(param);
-    if (info?.name === name && info.typeNode !== null) {
-      return typeNameOf(info.typeNode);
-    }
-  }
-  const body = field(fn, "body");
-  return body === null ? null : firstInBody(body, (statement) => statedBy(statement, name));
-}
-function firstInBody(node, read) {
-  const here = read(node);
-  if (here !== null) {
-    return here;
-  }
-  for (const child of children(node)) {
-    if (child.type === "function_definition" || child.type === "lambda") {
-      continue;
-    }
-    const found = firstInBody(child, read);
-    if (found !== null) {
-      return found;
-    }
-  }
-  return null;
-}
-function statedBy(statement, name) {
-  if (statement.type === "assignment") {
-    const annotation = field(statement, "type");
-    return field(statement, "left")?.text === name && annotation !== null ? typeNameOf(annotation) : null;
-  }
-  if (statement.type === "as_pattern") {
-    const alias = field(statement, "alias");
-    const value = statement.namedChildren[0] ?? null;
-    const callee = value?.type === "call" ? field(value, "function") : null;
-    return alias?.text === name && callee?.type === "identifier" ? callee.text : null;
-  }
-  return null;
+  return object !== null && object.type === "identifier" ? object : null;
 }
 function builtType(call, options) {
   const root = rootOf(call);
@@ -4180,7 +4707,7 @@ function typedReceiverPattern(options, chain) {
   if (receiver === null) {
     return void 0;
   }
-  for (const origin of receiverTypeOrigins(options, receiver, chain.root)) {
+  for (const origin of receiverTypeOrigins(receiver, options)) {
     const pattern = queryTypePattern(options, origin.module, origin.name);
     if (pattern !== void 0) {
       return pattern;
@@ -4188,14 +4715,6 @@ function typedReceiverPattern(options, chain) {
   }
   return void 0;
 }
-function receiverTypeOrigins(options, name, from) {
-  const stated = statedTypeName(name, from);
-  if (stated !== null) {
-    return originsOf(options.facts, `${options.filePath}#${stated}`);
-  }
-  const key = nameKeyIn(options.filePath, enclosingFunction(from), name);
-  return subjectConstructions(options.facts, [key]).get(key)?.origins ?? [];
-}
 function queryTypePattern(options, module, name) {
   return options.patterns.find(
     (pattern) => module === pattern.module && pattern.queryTypes.includes(name)
@@ -4317,7 +4836,7 @@ function classBehind(typeName, options) {
 function isClassName(name) {
   return /^[A-Z][A-Za-z0-9_]*$/.test(name) && name !== name.toUpperCase();
 }
-function effectFor(pattern, chain, operation, options) {
+function effectFor2(pattern, chain, operation, options) {
   const valueMethods = pattern.valueMethods ?? [];
   const picked = selectorOf(chain, valueMethods);
   return {
@@ -4427,7 +4946,7 @@ function storageCallIds(calls, options) {
 }
 function storageEffects(calls, options) {
   return matchedChains(calls, options).flatMap(
-    ({ chain, pattern, operation }) => operation === null ? [] : [effectFor(pattern, chain, operation, options)]
+    ({ chain, pattern, operation }) => operation === null ? [] : [effectFor2(pattern, chain, operation, options)]
   );
 }
 
@@ -4462,8 +4981,10 @@ function decoratedStatements(root, module, facts) {
   }));
 }
 function discoverUnits(root, module, options) {
+  const decorated = decoratedStatements(root, module, options.facts);
+  askWrittenValues(clientCallReceivers(root, module), options.facts);
   return [
-    ...decoratedStatements(root, module, options.facts).flatMap(
+    ...decorated.flatMap(
       (decoratedStatement) => decoratedUnits(decoratedStatement, module, options)
     ),
     ...clientUnits(root, module, options)
@@ -5153,7 +5674,12 @@ function buildRouteUnit(options) {
     () => readReturnAnnotation(definitionNode, enclosingScope, ctx)
   );
   const effects = invocationEffects(definitionNode, options.facts);
-  const extra = recognizedBodyEffects(definitionNode, module, storageLookup);
+  const extra = recognizedBodyEffects(
+    definitionNode,
+    module,
+    storageLookup,
+    options.facts
+  );
   const perTerminal = branchesPerTerminal({
     definitionNode,
     effects,
@@ -5238,28 +5764,35 @@ function unreadRoleReadings(parameters, range) {
     )
   ];
 }
-function recognizedBodyEffects(definitionNode, module, storageLookup) {
+function recognizedBodyEffects(definitionNode, module, storageLookup, facts) {
   const storage = storageLookup === void 0 ? [] : [
     ...storageEffects(bodyCalls(definitionNode), {
       ...storageLookup,
       filePath: storageLookup.factsPath
     }),
-    ...rawSqlEffects(bodyCalls(definitionNode), {
-      facts: storageLookup.facts,
-      filePath: storageLookup.factsPath,
-      patterns: storageLookup.rawSql ?? []
-    })
+    ...rawSqlEffects(bodyCalls(definitionNode), rawSqlOf(storageLookup))
   ];
-  return [...envReadEffects(definitionNode, module), ...storage];
+  return [...envReadEffects(definitionNode, module, facts), ...storage];
+}
+function rawSqlOf(storageLookup) {
+  return {
+    facts: storageLookup.facts,
+    filePath: storageLookup.factsPath,
+    patterns: storageLookup.rawSql ?? [],
+    clients: storageLookup.sqlClients ?? []
+  };
 }
-function recognizedCallIds(definitionNode, storageLookup) {
+function recognizedCallIds(calls, storageLookup) {
   if (storageLookup === void 0) {
     return /* @__PURE__ */ new Set();
   }
-  return storageCallIds(bodyCalls(definitionNode), {
-    ...storageLookup,
-    filePath: storageLookup.factsPath
-  });
+  return /* @__PURE__ */ new Set([
+    ...storageCallIds(calls, {
+      ...storageLookup,
+      filePath: storageLookup.factsPath
+    }),
+    ...rawSqlCallIds(calls, rawSqlOf(storageLookup))
+  ]);
 }
 function bodyContentOf(bodyNode) {
   for (const stmt of bodyStatements(bodyNode)) {
@@ -5599,6 +6132,7 @@ import {
   composeWrappers,
   createCacheLayer,
   createTimer,
+  effectToIR,
   moduleInitStructure,
   noopTimer,
   runDigest,
@@ -5731,11 +6265,14 @@ function resolveCallee2(call, site, ctx, read) {
   const outcome = read?.outcomes.get(spelling.key) ?? calleeOutcomeOf(ctx.facts, spelling.key);
   return asCallee(outcome, site.owner, ctx);
 }
-function functionNamed(nameKey2, ctx) {
+function namedOutcomes(keys, ctx) {
+  return calleeOutcomes(ctx.facts, [...new Set(keys)]);
+}
+function functionNamed(nameKey2, ctx, read) {
   if (assignedElsewhere(ctx.facts, nameKey2)) {
     return null;
   }
-  const outcome = calleeOutcomeOf(ctx.facts, nameKey2);
+  const outcome = read?.get(nameKey2) ?? calleeOutcomeOf(ctx.facts, nameKey2);
   return outcome.kind === "function" ? functionAt(outcome.key, ctx) : null;
 }
 function assignedElsewhere(facts, nameKey2) {
@@ -5943,6 +6480,7 @@ function reachedFunctions(seeds, options) {
   const stopsByKey = /* @__PURE__ */ new Map();
   const argTargetsByKey = /* @__PURE__ */ new Map();
   const parameterCallsByKey = /* @__PURE__ */ new Map();
+  const callsByKey = /* @__PURE__ */ new Map();
   const passedPositions = /* @__PURE__ */ new Set();
   for (const seed of seeds) {
     seedKeys.add(seed.key);
@@ -5969,12 +6507,21 @@ function reachedFunctions(seeds, options) {
       bodies.flatMap((body) => body.written),
       ctx
     );
+    const passed = namedOutcomes(
+      bodies.flatMap(
+        ({ source, written }) => written.flatMap(({ call }) => passedNameKeys(source.file, call))
+      ),
+      ctx
+    );
     for (const { key, source, body, written } of bodies) {
       const scan = scanBody(
         source,
         ctx,
-        recognizedCallIds(source.node, options.storageFor(source.file)),
-        { body, written, spellings }
+        recognizedCallIds(
+          written.map(({ call }) => call),
+          options.storageFor(source.file)
+        ),
+        { body, written, spellings, passed }
       );
       if (scan.stops.length > 0) {
         stopsByKey.set(key, scan.stops);
@@ -5987,21 +6534,27 @@ function reachedFunctions(seeds, options) {
       for (const position of scan.passedPositions) {
         passedPositions.add(position);
       }
+      const called = [];
       for (const target of scan.followed) {
-        const calleeKey = keyOf(target);
+        const calleeKey = keyOf2(target);
         if (!functionByKey.has(calleeKey)) {
           functionByKey.set(calleeKey, target);
         }
         db.add("calls", [key, calleeKey]);
+        called.push(calleeKey);
+      }
+      if (called.length > 0) {
+        callsByKey.set(key, called);
       }
     }
   }
+  const reached = db.facts("reachable").map(([keyAtom]) => String(keyAtom)).filter((key) => !seedKeys.has(key));
+  settleBodyValues(reached, functionByKey, options.facts);
   const summaries = [];
   const summariesByKey = /* @__PURE__ */ new Map();
-  for (const [keyAtom] of db.facts("reachable")) {
-    const key = String(keyAtom);
+  for (const key of reached) {
     const target = functionByKey.get(key);
-    if (seedKeys.has(key) || target === void 0) {
+    if (target === void 0) {
       continue;
     }
     const summary = assembleSummary(libraryUnit(target, options), {
@@ -6026,10 +6579,11 @@ function reachedFunctions(seeds, options) {
     stopsByKey,
     argTargetsByKey,
     parameterCallsByKey,
+    callsByKey,
     passedPositions
   };
 }
-function keyOf(target) {
+function keyOf2(target) {
   return nodeId(target.file.file, target.node);
 }
 var EMPTY_SCAN = {
@@ -6042,15 +6596,53 @@ var EMPTY_SCAN = {
 };
 function bodyOf(source) {
   const { file, node } = source;
-  const body = field(node, "body");
+  const body = isModule(node) ? node : field(node, "body");
   if (body === null) {
     return { body, written: [] };
   }
   return {
     body,
-    written: callsWritten(file, body, scopeAt2(file, node), keyOf(source))
+    written: callsWritten(file, body, scopeAt2(file, node), keyOf2(source), {
+      descendsInto: isModule(node) ? runsAtModuleLoad : outsideNestedDef
+    })
   };
 }
+function outsideNestedDef(node) {
+  return node.type !== "function_definition";
+}
+function settleBodyValues(reached, functionByKey, facts) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const key of reached) {
+    const target = functionByKey.get(key);
+    if (target === void 0) {
+      continue;
+    }
+    const listed = byFile.get(target.file.file) ?? [];
+    for (const node of bodyValueNodes(target.node)) {
+      listed.push(node);
+    }
+    byFile.set(target.file.file, listed);
+  }
+  for (const nodes of byFile.values()) {
+    askWrittenValues(nodes, facts);
+  }
+}
+function passedNameKeyOf(file, arg) {
+  if (arg === null || arg.type !== "identifier") {
+    return null;
+  }
+  return readKey(file.file, arg, enclosingFunction(arg));
+}
+function passedNameKeys(file, call) {
+  const args = field(call, "arguments");
+  if (args === null) {
+    return [];
+  }
+  return args.namedChildren.flatMap((arg) => {
+    const key = passedNameKeyOf(file, arg);
+    return key === null ? [] : [key];
+  });
+}
 function scanBody(source, ctx, recognized, read) {
   const followed = [];
   const stops = [];
@@ -6071,17 +6663,15 @@ function scanBody(source, ctx, recognized, read) {
       return;
     }
     args.namedChildren.forEach((arg, position) => {
-      if (arg === null || arg.type !== "identifier") {
+      const nameKey2 = passedNameKeyOf(file, arg);
+      if (nameKey2 === null) {
         return;
       }
-      const resolved = functionNamed(
-        readKey(file.file, arg, enclosingFunction(arg)),
-        ctx
-      );
+      const resolved = functionNamed(nameKey2, ctx, read.passed);
       if (resolved === null) {
         return;
       }
-      const key = keyOf(resolved);
+      const key = keyOf2(resolved);
       if (!seen.has(key)) {
         seen.add(key);
         followed.push(resolved);
@@ -6106,7 +6696,7 @@ function scanBody(source, ctx, recognized, read) {
     recordPassedArgs(
       call,
       callee,
-      outcome.kind === "followed" ? keyOf(outcome.target) : null
+      outcome.kind === "followed" ? keyOf2(outcome.target) : null
     );
     if (outcome.kind === "stopped") {
       const stopKey = `${outcome.reason}:${callee}`;
@@ -6123,7 +6713,7 @@ function scanBody(source, ctx, recognized, read) {
       }
       return;
     }
-    const key = keyOf(outcome.target);
+    const key = keyOf2(outcome.target);
     if (!seen.has(key)) {
       seen.add(key);
       followed.push(outcome.target);
@@ -6141,7 +6731,7 @@ function scanBody(source, ctx, recognized, read) {
     passedPositions
   };
 }
-function callsWritten(file, body, outer, owner) {
+function callsWritten(file, body, outer, owner, limit) {
   const found = [];
   walkDescendants3(body, outer, {
     at: (child, scope) => {
@@ -6149,7 +6739,7 @@ function callsWritten(file, body, outer, owner) {
         found.push({ call: child, site: { file, scope, owner } });
       }
     },
-    into: (child, scope) => child.type === "function_definition" ? SKIP_CHILDREN2 : file.module.scopeFor.get(child.id) ?? scope
+    into: (child, scope) => limit.descendsInto(child) ? file.module.scopeFor.get(child.id) ?? scope : SKIP_CHILDREN2
   });
   return found;
 }
@@ -6182,7 +6772,8 @@ function libraryUnit(target, options) {
   const extra = recognizedBodyEffects(
     node,
     file.module,
-    options.storageFor(file)
+    options.storageFor(file),
+    options.facts
   );
   const range = rangeOf(node);
   return {
@@ -7763,7 +8354,8 @@ function wrapperUnit(target, declared, options) {
   const extra = recognizedBodyEffects(
     node,
     file.module,
-    options.storageFor(file)
+    options.storageFor(file),
+    options.facts
   );
   const delegate = (at) => ({
     terminal: {
@@ -7921,6 +8513,7 @@ function factsForFile(options) {
     files: [{ file: options.file, root: options.root, module: options.module }],
     definitions
   });
+  bindEnvFacts(db, [envFactsIn(options.file, options.root, options.module)]);
   addPackWords(db, packWordsOf(options.packs));
   return db;
 }
@@ -7971,6 +8564,7 @@ async function extractPythonProject(options) {
   );
   const storagePatterns = options.packs.flatMap((pack) => pack.storage ?? []);
   const rawSqlPatterns = options.packs.flatMap((pack) => pack.rawSql ?? []);
+  const sqlClients = options.packs.flatMap((pack) => pack.sqlClients ?? []);
   const modelQueries = options.packs.flatMap((pack) => pack.models ?? []);
   const discovers = options.packs.some((pack) => pack.discovery.length > 0);
   const buildsReceivers = options.packs.some(
@@ -7978,7 +8572,15 @@ async function extractPythonProject(options) {
       (client) => (client.receiverConstructors ?? []).length > 0
     )
   );
-  const needsValues = discovers || mountsRouters || buildsReceivers || storagePatterns.length > 0 || modelQueries.length > 0;
+  const envFacts = bound.map(
+    (boundFile) => envFactsIn(boundFile.file, boundFile.root, boundFile.module)
+  );
+  const readsEnvThroughNames = envFacts.some(
+    (one) => one.sites.length > 0 || one.objects.length > 0
+  );
+  const needsValues = discovers || mountsRouters || buildsReceivers || readsEnvThroughNames || storagePatterns.length > 0 || modelQueries.length > 0 || // A statement written as SQL is a value, and so is the client the
+  // call that hands it over is read off.
+  rawSqlPatterns.length > 0 || sqlClients.length > 0;
   const definitions = /* @__PURE__ */ new Map();
   timer.time("discover", () => {
     for (const { file, root, module: moduleBinding } of bound) {
@@ -7990,6 +8592,7 @@ async function extractPythonProject(options) {
     }
     if (needsValues) {
       bindEvaluator(db, { files: bound, definitions });
+      bindEnvFacts(db, envFacts);
     }
     addPackWords(db, packWordsOf(options.packs));
   });
@@ -8005,13 +8608,14 @@ async function extractPythonProject(options) {
       ...mountsRouters ? { facts: db } : {}
     })
   );
-  const storageFor = (file) => storagePatterns.length > 0 || rawSqlPatterns.length > 0 ? {
+  const storageFor = (file) => storagePatterns.length > 0 || rawSqlPatterns.length > 0 || sqlClients.length > 0 ? {
     facts: db,
     factsPath: file.file,
     patterns: storagePatterns,
     definitionAt: (key) => definitions.get(key),
     couldMatch,
-    rawSql: rawSqlPatterns
+    rawSql: rawSqlPatterns,
+    sqlClients
   } : void 0;
   const wrapperIndex = timer.time(
     "discover",
@@ -8046,6 +8650,7 @@ async function extractPythonProject(options) {
   }
   const seeds = [];
   const summariesBySeed = /* @__PURE__ */ new Map();
+  const moduleRoots = [];
   for (const boundFile of bound) {
     const { file, root, module: moduleBinding } = boundFile;
     const displayPath = displayPathOf(file);
@@ -8078,23 +8683,17 @@ async function extractPythonProject(options) {
     }
     const loadTimeReads = timer.time(
       "discover",
-      () => envReadEffects(root, moduleBinding)
+      () => envReadEffects(root, moduleBinding, db)
     );
-    if (loadTimeReads.length > 0) {
-      const summary = timer.time(
-        "summarize",
-        () => assembleSummary2(
-          moduleInitStructure({
-            name: path3.basename(displayPath),
-            file: displayPath,
-            range: rangeOf(root),
-            effects: loadTimeReads
-          }),
-          { gapHandling }
-        )
-      );
-      summary.confidence = { source: "inferred_static", level: "low" };
-      summaries.push(summary);
+    const moduleKey = nodeId(file, root);
+    if (!summariesBySeed.has(moduleKey)) {
+      seeds.push({ key: moduleKey, file: boundFile, node: root });
+      moduleRoots.push({
+        boundFile,
+        displayPath,
+        key: moduleKey,
+        loadTimeReads
+      });
     }
   }
   const reached = timer.time(
@@ -8108,16 +8707,19 @@ async function extractPythonProject(options) {
       definitions
     })
   );
+  const placeWhatItReached = (summary, key) => {
+    if (gapHandling !== "silent") {
+      summary.gaps.push(
+        ...(reached.stopsByKey.get(key) ?? []).map(unfollowedCallGap2)
+      );
+    }
+    placeCalls2(summary, reached.targetsByKey.get(key));
+    placeArgTargets2(summary, reached.argTargetsByKey.get(key));
+    placeCalleeParameters2(summary, reached.parameterCallsByKey.get(key));
+  };
   for (const [key, owners] of summariesBySeed) {
     for (const summary of owners) {
-      if (gapHandling !== "silent") {
-        summary.gaps.push(
-          ...(reached.stopsByKey.get(key) ?? []).map(unfollowedCallGap2)
-        );
-      }
-      placeCalls2(summary, reached.targetsByKey.get(key));
-      placeArgTargets2(summary, reached.argTargetsByKey.get(key));
-      placeCalleeParameters2(summary, reached.parameterCallsByKey.get(key));
+      placeWhatItReached(summary, key);
     }
   }
   if (gapHandling !== "silent") {
@@ -8127,6 +8729,30 @@ async function extractPythonProject(options) {
       reached.passedPositions
     );
   }
+  for (const { boundFile, displayPath, key, loadTimeReads } of moduleRoots) {
+    const calledAtLoad = reached.callsByKey.get(key) ?? [];
+    if (loadTimeReads.length === 0 && calledAtLoad.length === 0) {
+      continue;
+    }
+    const summary = timer.time(
+      "summarize",
+      () => assembleSummary2(
+        moduleInitStructure({
+          name: path3.basename(displayPath),
+          file: displayPath,
+          range: rangeOf(boundFile.root),
+          effects: [
+            ...loadTimeReads,
+            ...moduleLoadInvocationEffects(boundFile.root, db).map(effectToIR)
+          ]
+        }),
+        { gapHandling }
+      )
+    );
+    summary.confidence = { source: "inferred_static", level: "low" };
+    placeWhatItReached(summary, key);
+    summaries.push(summary);
+  }
   summaries.push(...reached.summaries);
   const resolvedImports = resolvedImportsOf(db, displayPathOf);
   stampModuleImports(summaries, (file) => resolvedImports.get(file) ?? []);