@suss/adapter-python 0.22.2 → 0.22.3

package/dist/index.js

@@ -34,6 +34,40 @@ function enclosingFunction(node) {
   }
   return null;
 }
+function stringContentValue(content) {
+  const base = content.startIndex;
+  let text2 = "";
+  let cursor = 0;
+  for (const child of children(content)) {
+    if (child.type !== "escape_interpolation") {
+      continue;
+    }
+    text2 += content.text.slice(cursor, child.startIndex - base);
+    text2 += child.text.slice(0, 1);
+    cursor = child.endIndex - base;
+  }
+  return text2 + content.text.slice(cursor);
+}
+function parameterNameAndType(param) {
+  if (param.type === "identifier") {
+    return { name: param.text, typeNode: null };
+  }
+  if (param.type === "typed_parameter") {
+    const inner = param.namedChildren.find(
+      (child) => child !== null && child.type === "identifier"
+    );
+    return inner !== void 0 ? { name: inner.text, typeNode: field(param, "type") } : null;
+  }
+  if (param.type === "default_parameter") {
+    const nameNode = field(param, "name");
+    return nameNode?.type === "identifier" ? { name: nameNode.text, typeNode: null } : null;
+  }
+  if (param.type === "typed_default_parameter") {
+    const nameNode = field(param, "name");
+    return nameNode !== null ? { name: nameNode.text, typeNode: field(param, "type") } : null;
+  }
+  return null;
+}
 function stringLiteralValue(node) {
   if (node.type !== "string") {
     return null;
@@ -44,7 +78,7 @@ function stringLiteralValue(node) {
       continue;
     }
     if (child.type === "string_content") {
-      content += child.text;
+      content += stringContentValue(child);
       continue;
     }
     if (child.type === "interpolation") {
@@ -72,6 +106,8 @@ function stripDecorators(node) {
   );
   return { definition, decorators };
 }
+var NodeSet = class extends IdSet {
+};
 var NodeMap = class extends IdMap {
 };
 
@@ -1418,14 +1454,14 @@ var EXIT_KINDS = {
   continue_statement: "continue"
 };
 var NESTED_FUNCTION_TYPES = /* @__PURE__ */ new Set(["function_definition", "lambda"]);
-function exitKindOf(node) {
+function exitKindOf(node, thrown) {
   let sawReturn = false;
   const raises = (current) => {
     for (const child of current.namedChildren) {
       if (child === null || NESTED_FUNCTION_TYPES.has(child.type)) {
         continue;
       }
-      if (child.type === "raise_statement") {
+      if (child.type === "raise_statement" || thrown.has(child)) {
         return true;
       }
       if (child.type === "return_statement") {
@@ -1459,10 +1495,12 @@ function childBlock(node) {
 var Lowerer = class {
   // tree-sitter hands back a fresh wrapper object each time a child is
   // read, so a terminal is matched by its stable node id.
-  constructor(terminals) {
+  constructor(terminals, thrown) {
     this.terminals = terminals;
+    this.thrown = thrown;
   }
   terminals;
+  thrown;
   terminalsByStmt = /* @__PURE__ */ new Map();
   terminalHome = new NodeMap();
   attach(statement, candidates) {
@@ -1495,7 +1533,7 @@ var Lowerer = class {
       condition: handleOf(field(clause, "condition")),
       thenBody: this.lowerBlock(field(clause, "consequence")),
       elseBody: this.lowerIfTail(clauses, index + 1),
-      exitKind: exitKindOf(clause)
+      exitKind: exitKindOf(clause, this.thrown)
     };
     this.attach(nested, [field(clause, "condition")]);
     return [nested];
@@ -1509,7 +1547,7 @@ var Lowerer = class {
       condition: handleOf(field(node, "condition")),
       thenBody: this.lowerBlock(field(node, "consequence")),
       elseBody: this.lowerIfTail(clauses, 0),
-      exitKind: exitKindOf(node)
+      exitKind: exitKindOf(node, this.thrown)
     };
   }
   lowerTry(node) {
@@ -1524,7 +1562,7 @@ var Lowerer = class {
       tryBody: this.lowerBlock(field(node, "body")),
       catchBody: excepts.length > 0 ? excepts.flatMap((clause) => this.lowerBlock(childBlock(clause))) : null,
       finallyBody: finallyClause === null ? null : this.lowerBlock(childBlock(finallyClause)),
-      exitKind: exitKindOf(node)
+      exitKind: exitKindOf(node, this.thrown)
     };
   }
   lowerMatch(node) {
@@ -1541,15 +1579,21 @@ var Lowerer = class {
         body: this.lowerBlock(field(clause, "consequence"))
       };
     });
-    return { kind: "switch", groups, exitKind: exitKindOf(node) };
+    return { kind: "switch", groups, exitKind: exitKindOf(node, this.thrown) };
   }
   lower(node) {
-    const exit = EXIT_KINDS[node.type];
-    if (exit !== void 0) {
-      return this.attach({ kind: "exit", exit, exitKind: exitKindOf(node) }, [
+    if (this.thrown.has(node)) {
+      return this.attach({ kind: "exit", exit: "throw", exitKind: "throw" }, [
         node
       ]);
     }
+    const exit = EXIT_KINDS[node.type];
+    if (exit !== void 0) {
+      return this.attach(
+        { kind: "exit", exit, exitKind: exitKindOf(node, this.thrown) },
+        [node]
+      );
+    }
     if (node.type === "if_statement") {
       return this.attach(this.lowerIf(node), [field(node, "condition")]);
     }
@@ -1560,7 +1604,7 @@ var Lowerer = class {
           kind: "loop",
           condition: handleOf(header),
           body: this.lowerBlock(field(node, "body")),
-          exitKind: exitKindOf(node)
+          exitKind: exitKindOf(node, this.thrown)
         },
         [header]
       );
@@ -1571,12 +1615,16 @@ var Lowerer = class {
     if (node.type === "match_statement") {
       return this.attach(this.lowerMatch(node), [field(node, "subject")]);
     }
-    return this.attach({ kind: "opaque", exitKind: exitKindOf(node) }, [node]);
+    return this.attach(
+      { kind: "opaque", exitKind: exitKindOf(node, this.thrown) },
+      [node]
+    );
   }
 };
-function lowerPythonBody(body, terminals) {
+function lowerPythonBody(body, terminals, thrown = new NodeSet()) {
   const lowerer = new Lowerer(
-    new Map(terminals.map((terminal) => [terminal.id, terminal]))
+    new Map(terminals.map((terminal) => [terminal.id, terminal])),
+    thrown
   );
   return {
     statements: lowerer.lowerBlock(body),
@@ -1773,1192 +1821,1464 @@ function invocationEffects(definitionNode) {
   });
 }
 
-// src/paths/returnedShape.ts
-var MAX_DEPTH = 6;
-var SCALARS = {
-  none: { type: "null" },
-  true: { type: "boolean" },
-  false: { type: "boolean" }
+// src/paths/raisedResponses.ts
+import { constantOf } from "@suss/values";
+
+// src/values/evaluator.ts
+import { nodeOfKey } from "@suss/resolution";
+import { Evaluator, force, literalOf as literalOf2 } from "@suss/values";
+
+// src/values/lowering.ts
+var ROOT_TYPES = /* @__PURE__ */ new Set(["module", "function_definition", "lambda"]);
+var LITERAL_TYPES = {
+  integer: (node) => ({ kind: "literal", value: Number(node.text) }),
+  float: (node) => ({ kind: "literal", value: Number(node.text) }),
+  true: () => ({ kind: "literal", value: true }),
+  false: () => ({ kind: "literal", value: false }),
+  none: () => ({ kind: "literal", value: null })
 };
-function children2(node) {
-  return node.namedChildren.filter((child) => child !== null);
+var WRITING_ROWS = /* @__PURE__ */ new Set(["append", "extend"]);
+function readingMethodsOf(rows) {
+  return new Set(
+    rows.flatMap(
+      (row) => row.kind === "method" && !WRITING_ROWS.has(row.method) ? [row.method] : []
+    )
+  );
 }
-function recordShape(node, depth) {
-  const properties = {};
-  let everyKeyWritten = true;
-  for (const pair of children2(node)) {
-    if (pair.type !== "pair") {
-      everyKeyWritten = false;
-      continue;
-    }
-    const key = field(pair, "key");
-    const value = field(pair, "value");
-    if (key === null || value === null || key.type !== "string") {
-      everyKeyWritten = false;
-      continue;
-    }
-    properties[key.text.slice(1, -1)] = shapeOfReturned(value, depth + 1);
-  }
-  return everyKeyWritten && Object.keys(properties).length > 0 ? { type: "record", properties } : { type: "dictionary", values: { type: "unknown" } };
+function pythonLowering(options) {
+  const { context, originOf: originOf2, rows } = options;
+  const readingMethods = readingMethodsOf(rows);
+  const mutatedByRoot = /* @__PURE__ */ new Map();
+  return {
+    idOf: (node) => node.id,
+    expression: (node) => expressionOf(node, originOf2),
+    statement: statementOf,
+    siteOf,
+    functionOf,
+    writtenTo: (node) => context === null ? null : context.writtenTo(node),
+    callable: (node) => {
+      if (context === null || hasDictionarySplat(node)) {
+        return null;
+      }
+      return context.callable(node);
+    },
+    mutatedInNestedFunction: (root, name) => {
+      let mutated = mutatedByRoot.get(root.id);
+      if (mutated === void 0) {
+        mutated = namesMutatedInNestedFunctions(root, readingMethods);
+        mutatedByRoot.set(root.id, mutated);
+      }
+      return mutated.has(name);
+    },
+    freeNamesOf,
+    holeNameOf: placeholderName,
+    rows
+  };
 }
-function shapeOfReturned(node, depth = 0) {
-  if (depth > MAX_DEPTH) {
-    return { type: "unknown" };
-  }
-  const scalar = SCALARS[node.type];
-  if (scalar !== void 0) {
-    return scalar;
+function placeholderName(node) {
+  const peeled = peelValue(node);
+  if (peeled.type === "identifier") {
+    return peeled.text;
   }
-  if (node.type === "string") {
-    return { type: "literal", value: node.text.slice(1, -1) };
+  if (peeled.type === "attribute") {
+    return field(peeled, "attribute")?.text ?? "param";
   }
-  if (node.type === "integer") {
-    const value = Number.parseInt(node.text, 10);
-    return Number.isNaN(value) ? { type: "integer" } : { type: "literal", value };
+  return "param";
+}
+function peelValue(node) {
+  const wraps = node.type === "parenthesized_expression" || node.type === "await";
+  const inner = wraps ? children(node)[0] : void 0;
+  return inner === void 0 ? node : peelValue(inner);
+}
+var OPAQUE = { kind: "opaque" };
+function fromFields(node, names, fallback2, build) {
+  const found = names.map((name) => field(node, name));
+  if (found.some((part) => part === null)) {
+    return fallback2;
   }
-  if (node.type === "float") {
-    return { type: "number" };
+  return build(...found);
+}
+function expressionOf(node, originOf2) {
+  const peeled = peelValue(node);
+  const literal = LITERAL_TYPES[peeled.type];
+  if (literal !== void 0) {
+    return literal(peeled);
   }
-  if (node.type === "dictionary") {
-    return recordShape(node, depth);
+  if (peeled.type === "string") {
+    return stringExpression(peeled);
   }
-  if (node.type === "list" || node.type === "tuple" || node.type === "set") {
-    const first = children2(node)[0];
+  if (peeled.type === "concatenated_string") {
     return {
-      type: "array",
-      items: first === void 0 ? { type: "unknown" } : shapeOfReturned(first, depth + 1)
+      kind: "template",
+      parts: children(peeled).map((part) => ({ expression: part }))
     };
   }
-  if (node.type === "identifier" || node.type === "attribute") {
-    return { type: "ref", name: node.text };
-  }
-  return { type: "unknown" };
-}
-function returnedBodyShape(statement) {
-  const returned = statement.namedChildren[0];
-  if (returned == null) {
-    return null;
-  }
-  const value = returned.type === "expression_list" ? children2(returned)[0] : returned;
-  if (value === void 0) {
-    return null;
+  if (peeled.type === "identifier") {
+    return { kind: "name", text: peeled.text };
   }
-  const shape = shapeOfReturned(value);
-  return shape.type === "unknown" ? null : shape;
-}
-
-// 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 [];
+  if (peeled.type === "attribute") {
+    return fromFields(
+      peeled,
+      ["object", "attribute"],
+      OPAQUE,
+      (object, name) => ({
+        kind: "member",
+        object,
+        name: name.text
+      })
+    );
   }
-  const effects = [];
-  for (const call of calls) {
-    const pattern = patternFor(call, options);
-    if (pattern === void 0) {
-      continue;
-    }
-    const statement = statementIn(call);
-    if (statement === null) {
-      continue;
-    }
-    for (const access of readSqlAccess(statement, {
-      dialect: pattern.storageSystem
-    })) {
-      effects.push({
-        type: "interaction",
-        binding: storageBinding({
-          recognition: `python-${pattern.module}`,
-          storageSystem: pattern.storageSystem,
-          scope: pattern.module,
-          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 ?? ""
-        }
-      });
+  if (peeled.type === "subscript") {
+    const object = field(peeled, "value");
+    const index = field(peeled, "subscript");
+    if (object === null || index === null || index.type === "slice") {
+      return { kind: "opaque" };
     }
+    return { kind: "element", object, index };
   }
-  return effects;
-}
-function patternFor(call, options) {
-  const callee = field(call, "function");
-  if (callee === null || callee.type !== "identifier") {
-    return void 0;
+  if (peeled.type === "list" || peeled.type === "tuple" || peeled.type === "expression_list") {
+    return { kind: "array", items: children(peeled).map(elementOf) };
   }
-  const from = options.facts.facts("pyImportedName").find((row) => String(row[0]) === `${options.filePath}#${callee.text}`);
-  if (from === void 0) {
-    return void 0;
+  if (peeled.type === "dictionary") {
+    return { kind: "record", fields: children(peeled).flatMap(fieldOf) };
   }
-  const module = String(from[1]);
-  return options.patterns.find(
-    (pattern) => pattern.module === module && pattern.functions.includes(callee.text)
-  );
-}
-function statementIn(call) {
-  const args = field(call, "arguments");
-  const first = args?.namedChildren.find((child) => child !== null) ?? null;
-  if (first === null || first.type !== "string") {
-    return null;
+  if (peeled.type === "call") {
+    return callExpression(peeled, originOf2);
   }
-  const parts = [""];
-  for (const child of first.namedChildren) {
-    if (child === null) {
-      continue;
-    }
-    if (child.type === "string_content") {
-      parts[parts.length - 1] += child.text;
-      continue;
-    }
-    if (child.type === "interpolation") {
-      parts.push("");
-    }
-  }
-  const statement = sqlFromParts(parts);
-  return statement.trim() === "" ? null : statement;
-}
-
-// src/storage.ts
-import { storageBinding as storageBinding2 } from "@suss/ir-core";
-function receiverCall(call) {
-  const callee = field(call, "function");
-  if (callee === null || callee.type !== "attribute") {
-    return null;
+  if (peeled.type === "binary_operator" || peeled.type === "boolean_operator") {
+    return fromFields(
+      peeled,
+      ["left", "operator", "right"],
+      OPAQUE,
+      (left, operator, right) => ({
+        kind: "operator",
+        operator: operator.text,
+        operands: [left, right]
+      })
+    );
   }
-  const object = field(callee, "object");
-  return object !== null && object.type === "call" ? object : null;
-}
-function methodName(call) {
-  const callee = field(call, "function");
-  if (callee === null || callee.type !== "attribute") {
-    return callee?.text ?? "";
+  if (peeled.type === "comparison_operator") {
+    return comparisonExpression(peeled);
   }
-  return field(callee, "attribute")?.text ?? "";
-}
-function subjectOf(call) {
-  const callee = field(call, "function");
-  if (callee === null || callee.type !== "attribute") {
-    return callee?.text ?? "";
+  if (peeled.type === "not_operator") {
+    return fromFields(
+      peeled,
+      ["argument"],
+      OPAQUE,
+      (argument) => ({
+        kind: "operator",
+        operator: "not",
+        operands: [argument]
+      })
+    );
   }
-  return field(callee, "object")?.text ?? "";
-}
-function rootOf(call) {
-  const receiver = receiverCall(call);
-  return receiver === null ? call : rootOf(receiver);
-}
-function chainsIn(calls) {
-  const endsWith = /* @__PURE__ */ new Map();
-  for (const call of calls) {
-    const receiver = receiverCall(call);
-    if (receiver === null) {
-      continue;
-    }
-    const start = rootOf(receiver);
-    const kept = endsWith.get(start.id);
-    if (kept === void 0 || call.endIndex > kept.endIndex) {
-      endsWith.set(start.id, call);
+  if (peeled.type === "conditional_expression") {
+    const [whenTrue, condition, whenFalse] = children(peeled);
+    if (whenTrue === void 0 || condition === void 0 || whenFalse === void 0) {
+      return { kind: "opaque" };
     }
+    return { kind: "conditional", condition, whenTrue, whenFalse };
   }
-  const chains = [];
-  for (const call of calls) {
-    if (receiverCall(call) !== null) {
-      continue;
-    }
-    const last = endsWith.get(call.id) ?? call;
-    chains.push({
-      root: call,
-      last,
-      subject: subjectOf(call),
-      operation: methodName(last),
-      between: calls.filter(
-        (other) => other !== call && other !== last && other.startIndex >= call.startIndex && other.endIndex <= last.endIndex
-      )
-    });
+  if (peeled.type === "lambda") {
+    return { kind: "function", node: peeled };
   }
-  return chains;
+  return { kind: "opaque" };
 }
-function importedQueryFunction(options, chain) {
-  const callee = field(chain.root, "function");
-  if (callee === null || callee.type !== "identifier") {
-    return void 0;
-  }
-  const from = options.facts.facts("pyImportedName").find((row) => String(row[0]) === `${options.filePath}#${callee.text}`);
-  if (from === void 0) {
-    return void 0;
+function stringExpression(node) {
+  const plain = stringLiteralValue(node);
+  if (plain !== null) {
+    return { kind: "literal", value: plain };
   }
-  return options.patterns.find(
-    (pattern) => String(from[1]) === pattern.module && (pattern.queryFunctions ?? []).includes(String(from[2]))
-  );
-}
-function fieldsOf(chain) {
-  const args = field(chain.root, "arguments");
-  const named = [];
-  for (const argument of args === null ? [] : children(args)) {
-    if (argument.type === "keyword_argument") {
-      const name = field(argument, "name");
-      if (name !== null) {
-        named.push(name.text);
-      }
+  const parts = [];
+  for (const child of children(node)) {
+    if (child.type === "string_content") {
+      parts.push({ text: stringContentValue(child) });
       continue;
     }
-    if (argument.type === "attribute") {
-      const property = field(argument, "attribute");
-      if (property !== null) {
-        named.push(property.text);
+    if (child.type === "interpolation") {
+      const expression = field(child, "expression") ?? children(child)[0];
+      if (expression !== void 0) {
+        parts.push({ expression });
       }
     }
   }
-  return named;
+  return { kind: "template", parts };
 }
-function selectorOf(call) {
-  const args = field(call, "arguments");
-  const picked = [];
-  for (const argument of args === null ? [] : children(args)) {
-    if (argument.type === "keyword_argument") {
-      const name = field(argument, "name");
-      if (name !== null) {
-        picked.push(name.text);
-      }
-    }
+function comparisonExpression(node) {
+  const operands = children(node);
+  const operators = node.children.filter(
+    (child) => child !== null && !child.isNamed
+  );
+  const operator = operators[0];
+  if (operands.length !== 2 || operators.length !== 1 || operator === void 0) {
+    return { kind: "opaque" };
   }
-  return picked;
-}
-function effectFor(pattern, chain, options) {
-  const picked = [
-    ...new Set([chain.last, ...chain.between].flatMap(selectorOf))
-  ];
   return {
-    type: "interaction",
-    binding: storageBinding2({
-      recognition: "python-storage",
-      storageSystem: pattern.storageSystem,
-      scope: pattern.module,
-      container: chain.subject
-    }),
-    callee: chain.last.text,
-    interaction: {
-      class: "storage-access",
-      kind: pattern.writes.includes(chain.operation) ? "write" : "read",
-      fields: fieldsOf(chain),
-      operation: chain.operation,
-      ...picked.length > 0 ? { selector: picked } : {}
-    }
+    kind: "operator",
+    operator: operator.text,
+    operands: [operands[0], operands[1]]
   };
 }
-function fileOf(key) {
-  const at = key.lastIndexOf(":");
-  return at === -1 ? key : key.slice(0, at);
+function callExpression(node, originOf2) {
+  return fromFields(
+    node,
+    ["function", "arguments"],
+    OPAQUE,
+    (callee, argumentList) => {
+      const peeledCallee = peelValue(callee);
+      const args = argumentList.type === "argument_list" ? argumentsOf(argumentList) : [];
+      const isMethod2 = peeledCallee.type === "attribute";
+      return {
+        kind: "call",
+        callee: {
+          receiver: isMethod2 ? field(peeledCallee, "object") : null,
+          name: calleeName(peeledCallee),
+          origin: () => originOf2(peeledCallee)
+        },
+        args,
+        constructs: false
+      };
+    }
+  );
 }
-function returnTypeName(node) {
-  if (node === void 0) {
-    return null;
+function calleeName(callee) {
+  if (callee.type === "identifier") {
+    return callee.text;
   }
-  const annotation = field(node, "return_type");
-  if (annotation === null) {
-    return null;
+  if (callee.type === "attribute") {
+    return field(callee, "attribute")?.text ?? null;
   }
-  return annotation.type === "subscript" ? field(annotation, "value")?.text ?? null : annotation.text;
+  return null;
 }
-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) => nodeId(filePath, callee));
+function argumentsOf(argumentList) {
+  return children(argumentList).flatMap((argument) => {
+    if (argument.type === "dictionary_splat") {
+      return [];
+    }
+    if (argument.type === "keyword_argument") {
+      const name = field(argument, "name");
+      const value = field(argument, "value");
+      return name === null || value === null ? [] : [{ kind: "named", name: name.text, node: value }];
+    }
+    return [elementOf(argument)];
+  });
 }
-function storageEffects(calls, options) {
-  if (options.patterns.length === 0) {
-    return [];
+function hasDictionarySplat(call) {
+  const argumentList = field(call, "arguments");
+  if (argumentList === null) {
+    return false;
   }
-  const named = new Set(
-    options.patterns.flatMap((pattern) => pattern.queryFunctions ?? [])
-  );
-  const chains = chainsIn(calls).filter(
-    (chain) => options.couldMatch.has(methodName(chain.root)) || named.has(methodName(chain.root))
+  return children(argumentList).some(
+    (argument) => argument.type === "dictionary_splat"
   );
-  if (chains.length === 0) {
+}
+function elementOf(node) {
+  if (node.type === "list_splat") {
+    const inner = children(node)[0];
+    return inner === void 0 ? { kind: "value", node } : { kind: "spread", node: inner };
+  }
+  return { kind: "value", node };
+}
+function fieldOf(node) {
+  if (node.type === "dictionary_splat") {
+    const inner = children(node)[0];
+    return inner === void 0 ? [] : [{ kind: "spread", node: inner }];
+  }
+  if (node.type !== "pair") {
     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)
-    )
-  );
-  const effects = [];
-  for (const chain of chains) {
-    const callee = field(chain.root, "function");
-    if (callee === null) {
-      continue;
+  return fromFields(node, ["key", "value"], [], (key, value) => {
+    const name = stringLiteralValue(key);
+    return name === null ? [{ kind: "computed", name: key, value }] : [{ kind: "field", name, value }];
+  });
+}
+var STATEMENT_TYPES = {
+  expression_statement: expressionStatement,
+  if_statement: ifStatement,
+  elif_clause: ifStatement,
+  for_statement: loopStatement,
+  while_statement: loopStatement,
+  return_statement: (node) => ({
+    kind: "return",
+    value: children(node)[0] ?? null
+  }),
+  try_statement: (node) => ({
+    kind: "block",
+    body: [
+      ...blockStatements2(field(node, "body")),
+      ...children(node).flatMap(
+        (clause) => clause.type === "finally_clause" ? blockStatements2(children(clause)[0] ?? null) : []
+      )
+    ]
+  }),
+  with_statement: (node) => ({
+    kind: "block",
+    body: blockStatements2(field(node, "body"))
+  })
+};
+function statementOf(node) {
+  const lower = STATEMENT_TYPES[node.type];
+  return lower === void 0 ? { kind: "opaque" } : lower(node);
+}
+function expressionStatement(node) {
+  const inner = children(node)[0];
+  if (inner === void 0) {
+    return { kind: "opaque" };
+  }
+  if (inner.type === "assignment") {
+    return assignment(inner, null);
+  }
+  if (inner.type === "augmented_assignment") {
+    const operator = field(inner, "operator");
+    return assignment(
+      inner,
+      operator === null ? null : operator.text.slice(0, -1)
+    );
+  }
+  return { kind: "expression", value: inner };
+}
+function assignment(node, operator) {
+  return fromFields(
+    node,
+    ["left", "right"],
+    OPAQUE,
+    (target, value) => {
+      if (target.type === "pattern_list" || target.type === "tuple_pattern") {
+        return {
+          kind: "declare",
+          bindings: patternNames(target).map((name) => ({ name, value: null }))
+        };
+      }
+      return { kind: "assign", target, operator, value };
     }
-    const imported = importedQueryFunction(options, chain);
-    if (imported !== void 0) {
-      effects.push(effectFor(imported, chain, options));
-      continue;
+  );
+}
+function patternNames(pattern) {
+  return children(pattern).flatMap(
+    (child) => child.type === "identifier" ? [child.text] : patternNames(child)
+  );
+}
+function ifStatement(node) {
+  return fromFields(
+    node,
+    ["condition", "consequence"],
+    OPAQUE,
+    (condition, consequence) => ({
+      kind: "branch",
+      condition,
+      arms: [blockStatements2(consequence), otherArm(node)]
+    })
+  );
+}
+function otherArm(clause) {
+  const statement = clause.type === "if_statement" ? clause : clause.parent;
+  const clauses = statement === null ? [] : children(statement);
+  const next = clauses.slice(clauses.findIndex((child) => child.id === clause.id) + 1).find(
+    (child) => child.type === "elif_clause" || child.type === "else_clause"
+  );
+  if (next === void 0) {
+    return [];
+  }
+  return next.type === "elif_clause" ? [next] : blockStatements2(field(next, "body"));
+}
+function loopStatement(node) {
+  return { kind: "loop", body: blockStatements2(field(node, "body")) };
+}
+function blockStatements2(block) {
+  return block === null ? [] : children(block);
+}
+function isRoot(node) {
+  return ROOT_TYPES.has(node.type);
+}
+function isPathStatement(node, parent) {
+  return parent.type === "module" || parent.type === "block" || node.type === "elif_clause";
+}
+function siteOf(node) {
+  const path6 = [];
+  let current = node;
+  for (; ; ) {
+    const parent = current.parent;
+    if (parent === null) {
+      return null;
     }
-    const resolved = options.facts.facts("wantedResolves").filter((row) => String(row[0]) === nodeId(options.filePath, callee)).map((row) => String(row[1]));
-    const settled = resolved.length === 1 ? resolved[0] : void 0;
-    if (settled === void 0) {
-      continue;
+    if (isPathStatement(current, parent)) {
+      path6.unshift(current);
     }
-    const typeName = returnTypeName(options.definitionAt(settled));
-    if (typeName === null) {
-      continue;
+    if (isRoot(parent)) {
+      return { root: parent, path: path6 };
     }
-    const pattern = options.patterns.find(
-      (candidate) => candidate.queryTypes.includes(typeName) && options.facts.facts("pyImport").some(
-        (row) => String(row[0]) === fileOf(settled) && String(row[1]) === candidate.module
-      )
+    current = parent;
+  }
+}
+function functionOf(node) {
+  if (node.type === "module") {
+    return { parameters: [], body: children(node) };
+  }
+  if (node.type === "lambda") {
+    const body = field(node, "body");
+    if (body === null) {
+      return null;
+    }
+    return { parameters: parameterShapes(node), body: { expression: body } };
+  }
+  if (node.type !== "function_definition") {
+    return null;
+  }
+  const parameters = parameterShapes(node);
+  return {
+    parameters: isMethod(node) ? parameters.slice(1) : parameters,
+    body: blockStatements2(field(node, "body"))
+  };
+}
+function isMethod(fn) {
+  const owner = fn.parent?.type === "decorated_definition" ? fn.parent.parent : fn.parent;
+  return owner?.type === "block" && owner.parent?.type === "class_definition";
+}
+function namesMutatedInNestedFunctions(root, readingMethods) {
+  const mutated = /* @__PURE__ */ new Set();
+  const visit = (node, nested) => {
+    const name = writtenNameOf(node, readingMethods);
+    if (nested && name !== null) {
+      mutated.add(name);
+    }
+    for (const child of children(node)) {
+      visit(child, nested || isRoot(child));
+    }
+  };
+  for (const child of children(root)) {
+    visit(child, isRoot(child));
+  }
+  return mutated;
+}
+function writtenNameOf(node, readingMethods) {
+  if (node.type === "assignment" || node.type === "augmented_assignment") {
+    const target = field(node, "left");
+    return target?.type === "identifier" ? target.text : null;
+  }
+  if (node.type === "call") {
+    const callee = field(node, "function");
+    if (callee?.type !== "attribute") {
+      return null;
+    }
+    const receiver = field(callee, "object");
+    const method = field(callee, "attribute");
+    if (receiver?.type === "identifier" && method !== null && !readingMethods.has(method.text)) {
+      return receiver.text;
+    }
+  }
+  return null;
+}
+var DECLARING_PARENTS = /* @__PURE__ */ new Set([
+  "parameters",
+  "default_parameter",
+  "typed_parameter",
+  "typed_default_parameter",
+  "lambda_parameters",
+  "pattern_list",
+  "tuple_pattern",
+  "for_statement"
+]);
+function freeNamesOf(fn) {
+  const declared = /* @__PURE__ */ new Set();
+  const read = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    for (const child of children(node)) {
+      if (child.type !== "identifier") {
+        visit(child);
+        continue;
+      }
+      if (node.type === "attribute" && field(node, "attribute")?.id === child.id) {
+        continue;
+      }
+      if (node.type === "keyword_argument" && field(node, "name")?.id === child.id) {
+        continue;
+      }
+      if (DECLARING_PARENTS.has(node.type) || node.type === "assignment" && field(node, "left")?.id === child.id) {
+        declared.add(child.text);
+        continue;
+      }
+      read.add(child.text);
+    }
+  };
+  visit(fn);
+  return [...read].filter((name) => !declared.has(name));
+}
+
+// src/values/origin.ts
+function originOf(callee, module) {
+  const chain = memberChainOf(callee);
+  if (chain === null) {
+    return null;
+  }
+  const [rootName, ...rest] = chain;
+  if (rootName === void 0) {
+    return null;
+  }
+  const binding = resolveName(scopeAt(callee, module), rootName);
+  if (binding === null) {
+    return rest.length === 0 ? { module: "builtins", name: rootName } : null;
+  }
+  const path6 = importedPathOf(binding, rootName);
+  if (path6 === null) {
+    return null;
+  }
+  const dotted = [...path6, ...rest];
+  const name = dotted.pop();
+  if (name === void 0 || dotted.length === 0) {
+    return null;
+  }
+  return { module: dotted.join("."), name };
+}
+function importedPathOf(binding, localName) {
+  if (binding.kind === "importFrom") {
+    if (binding.relativeLevel > 0) {
+      return null;
+    }
+    return [...binding.module.split("."), binding.importedName];
+  }
+  if (binding.kind !== "import") {
+    return null;
+  }
+  const unaliasedDotted = binding.module !== localName && binding.module.startsWith(`${localName}.`);
+  return unaliasedDotted ? [localName] : binding.module.split(".");
+}
+function memberChainOf(node) {
+  const names = [];
+  let current = peelValue(node);
+  while (current.type === "attribute") {
+    const object = field(current, "object");
+    const attribute = field(current, "attribute");
+    if (object === null || attribute === null) {
+      return null;
+    }
+    names.unshift(attribute.text);
+    current = peelValue(object);
+  }
+  if (current.type !== "identifier") {
+    return null;
+  }
+  return [current.text, ...names];
+}
+function scopeAt(node, module) {
+  let current = node;
+  while (current !== null) {
+    const scope = module.scopeFor.get(current.id);
+    if (scope !== void 0) {
+      return scope;
+    }
+    current = current.parent;
+  }
+  return module.moduleScope;
+}
+
+// src/values/rows.ts
+import {
+  appended,
+  concat,
+  constant,
+  environmentRead,
+  equals,
+  extended,
+  fallback,
+  formatArguments,
+  hole,
+  joined,
+  joinedPath,
+  literalOf,
+  negated,
+  operand,
+  percentFormatted,
+  plus,
+  readableFallback,
+  stripped,
+  text,
+  truthOf
+} from "@suss/values";
+var operatorRows = [
+  {
+    kind: "operator",
+    operator: "+",
+    arity: 2,
+    apply: ([a, b]) => plus(operand(a), operand(b))
+  },
+  {
+    kind: "operator",
+    operator: "%",
+    arity: 2,
+    apply: ([a, b], contentOf) => percentFormatted(operand(a), formatArguments(contentOf(operand(b))))
+  },
+  {
+    kind: "operator",
+    operator: "==",
+    arity: 2,
+    apply: ([a, b]) => equals(operand(a), operand(b))
+  },
+  {
+    kind: "operator",
+    operator: "!=",
+    arity: 2,
+    apply: ([a, b]) => negated(equals(operand(a), operand(b)))
+  },
+  {
+    kind: "operator",
+    operator: "is",
+    arity: 2,
+    apply: ([a, b]) => equals(operand(a), operand(b))
+  },
+  {
+    kind: "operator",
+    operator: "is not",
+    arity: 2,
+    apply: ([a, b]) => negated(equals(operand(a), operand(b)))
+  },
+  {
+    kind: "operator",
+    operator: "not",
+    arity: 1,
+    apply: ([a]) => negated(operand(a))
+  },
+  {
+    kind: "operator",
+    operator: "or",
+    arity: 2,
+    apply: ([a, b]) => readableFallback(operand(a), operand(b), truthOf)
+  },
+  {
+    kind: "operator",
+    operator: "and",
+    arity: 2,
+    apply: ([a, b]) => fallback(operand(a), operand(b), (left) => {
+      const truth = truthOf(left);
+      return truth === null ? null : !truth;
+    })
+  }
+];
+var stringRows = [
+  {
+    kind: "method",
+    method: "join",
+    on: "string",
+    apply: ({ receiver, args, contentOf }) => ({
+      result: joined(contentOf(operand(args[0])), operand(receiver))
+    })
+  },
+  {
+    kind: "method",
+    method: "format",
+    on: "string",
+    apply: ({ receiver, args }) => ({
+      result: braceFormatted(operand(receiver), args)
+    })
+  },
+  {
+    kind: "method",
+    method: "strip",
+    on: "string",
+    apply: ({ receiver, args }) => ({
+      result: args.length === 0 ? stripped(operand(receiver)) : hole("value")
+    })
+  },
+  {
+    kind: "method",
+    method: "rstrip",
+    on: "string",
+    apply: ({ receiver, args }) => ({
+      result: args.length === 0 ? stripped(operand(receiver), "end") : hole("value")
+    })
+  },
+  {
+    kind: "method",
+    method: "lstrip",
+    on: "string",
+    apply: ({ receiver, args }) => ({
+      result: args.length === 0 ? stripped(operand(receiver), "start") : hole("value")
+    })
+  }
+];
+var sequenceRows = ["sequence", "unbounded"].flatMap((on) => [
+  {
+    kind: "method",
+    method: "append",
+    on,
+    apply: ({ receiver, args }) => ({
+      result: constant(null),
+      receiver: appended(operand(receiver), args)
+    })
+  },
+  {
+    kind: "method",
+    method: "extend",
+    on,
+    apply: ({ receiver, args, contentOf }) => ({
+      result: constant(null),
+      receiver: extended(operand(receiver), contentOf(operand(args[0])))
+    })
+  }
+]);
+var calleeRows = [
+  {
+    kind: "callee",
+    origin: { module: "builtins", name: "str" },
+    apply: ({ args }) => ({ result: concat([operand(args[0])]) })
+  },
+  {
+    kind: "callee",
+    origin: { module: "os.path", name: "join" },
+    apply: ({ args }) => ({ result: joinedPath(args) })
+  },
+  {
+    kind: "callee",
+    origin: { module: "os", name: "getenv" },
+    apply: ({ args }) => ({ result: environmentRead(args) })
+  },
+  {
+    kind: "callee",
+    origin: { module: "os.environ", name: "get" },
+    apply: ({ args }) => ({ result: environmentRead(args) })
+  }
+];
+var BRACE_PLACEHOLDER = /\{([^{}]*)\}/g;
+function braceFormatted(receiver, args) {
+  const template = literalOf(receiver);
+  if (template === null) {
+    return hole("value");
+  }
+  const parts = [];
+  let last = 0;
+  let position = 0;
+  for (const match of template.matchAll(BRACE_PLACEHOLDER)) {
+    parts.push(text(template.slice(last, match.index)));
+    const argument = args[position];
+    const placeholder = match[1] ?? "";
+    parts.push(
+      argument === void 0 ? hole(
+        placeholder === "" ? "value" : placeholder.split(/[!:]/)[0] ?? "value"
+      ) : concat([argument])
     );
-    if (pattern === void 0) {
-      continue;
-    }
-    effects.push(effectFor(pattern, chain, options));
+    position += 1;
+    last = match.index + match[0].length;
   }
-  return effects;
+  parts.push(text(template.slice(last)));
+  return concat(parts);
 }
+var pythonRows = [
+  ...operatorRows,
+  ...stringRows,
+  ...sequenceRows,
+  ...calleeRows
+];
 
 // src/values/evaluator.ts
-import { nodeOfKey } from "@suss/resolution";
-import { Evaluator, force, literalOf as literalOf2 } from "@suss/values";
-
-// src/values/lowering.ts
-var ROOT_TYPES = /* @__PURE__ */ new Set(["module", "function_definition", "lambda"]);
-var LITERAL_TYPES = {
-  integer: (node) => ({ kind: "literal", value: Number(node.text) }),
-  float: (node) => ({ kind: "literal", value: Number(node.text) }),
-  true: () => ({ kind: "literal", value: true }),
-  false: () => ({ kind: "literal", value: false }),
-  none: () => ({ kind: "literal", value: null })
-};
-var WRITING_ROWS = /* @__PURE__ */ new Set(["append", "extend"]);
-function readingMethodsOf(rows) {
-  return new Set(
-    rows.flatMap(
-      (row) => row.kind === "method" && !WRITING_ROWS.has(row.method) ? [row.method] : []
+var evaluators = /* @__PURE__ */ new WeakMap();
+var withoutFacts = /* @__PURE__ */ new WeakMap();
+var modulesByTree = /* @__PURE__ */ new WeakMap();
+function bindEvaluator(db, nodes) {
+  for (const entry of nodes.files) {
+    modulesByTree.set(entry.root.tree, entry.module);
+  }
+  evaluators.set(
+    db,
+    new Evaluator(
+      pythonLowering({
+        context: contextOver(db, nodes),
+        originOf: calleeOrigin,
+        rows: pythonRows
+      })
     )
   );
 }
-function pythonLowering(options) {
-  const { context, originOf: originOf2, rows } = options;
-  const readingMethods = readingMethodsOf(rows);
-  const mutatedByRoot = /* @__PURE__ */ new Map();
-  return {
-    idOf: (node) => node.id,
-    expression: (node) => expressionOf(node, originOf2),
-    statement: statementOf,
-    siteOf,
-    functionOf,
-    writtenTo: (node) => context === null ? null : context.writtenTo(node),
-    callable: (node) => {
-      if (context === null || hasDictionarySplat(node)) {
-        return null;
-      }
-      return context.callable(node);
-    },
-    mutatedInNestedFunction: (root, name) => {
-      let mutated = mutatedByRoot.get(root.id);
-      if (mutated === void 0) {
-        mutated = namesMutatedInNestedFunctions(root, readingMethods);
-        mutatedByRoot.set(root.id, mutated);
-      }
-      return mutated.has(name);
-    },
-    freeNamesOf,
-    holeNameOf: placeholderName,
-    rows
-  };
-}
-function placeholderName(node) {
-  const peeled = peelValue(node);
-  if (peeled.type === "identifier") {
-    return peeled.text;
-  }
-  if (peeled.type === "attribute") {
-    return field(peeled, "attribute")?.text ?? "param";
-  }
-  return "param";
-}
-function peelValue(node) {
-  const wraps = node.type === "parenthesized_expression" || node.type === "await";
-  const inner = wraps ? children(node)[0] : void 0;
-  return inner === void 0 ? node : peelValue(inner);
+function evaluatedValue(node, db) {
+  return force(evaluatorFor(node, db).evaluate(node));
 }
-var OPAQUE = { kind: "opaque" };
-function fromFields(node, names, fallback2, build) {
-  const found = names.map((name) => field(node, name));
-  if (found.some((part) => part === null)) {
-    return fallback2;
-  }
-  return build(...found);
+function stringValueOf(node, db) {
+  return literalOf2(evaluatedValue(node, db));
 }
-function expressionOf(node, originOf2) {
-  const peeled = peelValue(node);
-  const literal = LITERAL_TYPES[peeled.type];
-  if (literal !== void 0) {
-    return literal(peeled);
-  }
-  if (peeled.type === "string") {
-    return stringExpression(peeled);
-  }
-  if (peeled.type === "concatenated_string") {
-    return {
-      kind: "template",
-      parts: children(peeled).map((part) => ({ expression: part }))
-    };
-  }
-  if (peeled.type === "identifier") {
-    return { kind: "name", text: peeled.text };
-  }
-  if (peeled.type === "attribute") {
-    return fromFields(
-      peeled,
-      ["object", "attribute"],
-      OPAQUE,
-      (object, name) => ({
-        kind: "member",
-        object,
-        name: name.text
-      })
-    );
-  }
-  if (peeled.type === "subscript") {
-    const object = field(peeled, "value");
-    const index = field(peeled, "subscript");
-    if (object === null || index === null || index.type === "slice") {
-      return { kind: "opaque" };
-    }
-    return { kind: "element", object, index };
-  }
-  if (peeled.type === "list" || peeled.type === "tuple" || peeled.type === "expression_list") {
-    return { kind: "array", items: children(peeled).map(elementOf) };
-  }
-  if (peeled.type === "dictionary") {
-    return { kind: "record", fields: children(peeled).flatMap(fieldOf) };
-  }
-  if (peeled.type === "call") {
-    return callExpression(peeled, originOf2);
+function evaluatorFor(node, db) {
+  const bound = db === void 0 ? void 0 : evaluators.get(db);
+  if (bound !== void 0) {
+    return bound;
   }
-  if (peeled.type === "binary_operator" || peeled.type === "boolean_operator") {
-    return fromFields(
-      peeled,
-      ["left", "operator", "right"],
-      OPAQUE,
-      (left, operator, right) => ({
-        kind: "operator",
-        operator: operator.text,
-        operands: [left, right]
+  const tree = node.tree;
+  let local = withoutFacts.get(tree);
+  if (local === void 0) {
+    local = new Evaluator(
+      pythonLowering({
+        context: null,
+        originOf: calleeOrigin,
+        rows: pythonRows
       })
     );
+    withoutFacts.set(tree, local);
   }
-  if (peeled.type === "comparison_operator") {
-    return comparisonExpression(peeled);
+  return local;
+}
+function moduleOf(node) {
+  const tree = node.tree;
+  let module = modulesByTree.get(tree);
+  if (module === void 0) {
+    module = bindModule(tree.rootNode);
+    modulesByTree.set(tree, module);
   }
-  if (peeled.type === "not_operator") {
-    return fromFields(
-      peeled,
-      ["argument"],
-      OPAQUE,
-      (argument) => ({
-        kind: "operator",
-        operator: "not",
-        operands: [argument]
-      })
-    );
+  return module;
+}
+function calleeOrigin(callee) {
+  return originOf(callee, moduleOf(callee));
+}
+function contextOver(db, nodes) {
+  const filesByRoot = /* @__PURE__ */ new Map();
+  const rootsByFile = /* @__PURE__ */ new Map();
+  for (const entry of nodes.files) {
+    filesByRoot.set(entry.root.id, entry);
+    rootsByFile.set(entry.file, entry.root);
   }
-  if (peeled.type === "conditional_expression") {
-    const [whenTrue, condition, whenFalse] = children(peeled);
-    if (whenTrue === void 0 || condition === void 0 || whenFalse === void 0) {
-      return { kind: "opaque" };
+  const keyOf2 = (node) => {
+    const entry = filesByRoot.get(node.tree.rootNode.id);
+    if (entry === void 0) {
+      return null;
     }
-    return { kind: "conditional", condition, whenTrue, whenFalse };
-  }
-  if (peeled.type === "lambda") {
-    return { kind: "function", node: peeled };
-  }
-  return { kind: "opaque" };
+    return readKey(entry.file, node, enclosingFunction(node));
+  };
+  return {
+    writtenTo: (node) => {
+      const key = keyOf2(node);
+      if (key === null) {
+        return null;
+      }
+      const answer = writtenValueOf(db, key);
+      return answer === null ? null : nodeOfKey(rootsByFile, answer);
+    },
+    callable: (call) => {
+      const callee = field(call, "function");
+      const key = callee === null ? null : keyOf2(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;
+      return settled === void 0 ? null : nodes.definitions.get(settled) ?? null;
+    }
+  };
 }
-function stringExpression(node) {
-  const plain = stringLiteralValue(node);
-  if (plain !== null) {
-    return { kind: "literal", value: plain };
+
+// src/paths/raisedResponses.ts
+var NESTED_DEFINITION_TYPES2 = /* @__PURE__ */ new Set(["function_definition", "lambda"]);
+function raisedResponses(body, options) {
+  if (body === null || options.calls.length === 0) {
+    return [];
   }
-  const parts = [];
-  for (const child of children(node)) {
-    if (child.type === "string_content") {
-      parts.push({ text: child.text });
-      continue;
-    }
-    if (child.type === "interpolation") {
-      const expression = field(child, "expression") ?? children(child)[0];
-      if (expression !== void 0) {
-        parts.push({ expression });
+  const found = [];
+  const walk = (node) => {
+    for (const child of node.namedChildren) {
+      if (child === null || NESTED_DEFINITION_TYPES2.has(child.type)) {
+        continue;
+      }
+      const response = raisedResponseOf(child, options);
+      if (response !== null) {
+        found.push(response);
       }
+      walk(child);
     }
+  };
+  walk(body);
+  return found;
+}
+var ENDING_EXPRESSION = {
+  raise_statement: (statement) => statement.namedChildren[0] ?? null,
+  expression_statement: (statement) => {
+    const only = statement.namedChildren[0];
+    return only?.type === "call" ? only : null;
   }
-  return { kind: "template", parts };
+};
+function raisedResponseOf(statement, options) {
+  const expression = ENDING_EXPRESSION[statement.type]?.(statement) ?? null;
+  if (expression === null) {
+    return null;
+  }
+  const thrownByCall = statement.type !== "raise_statement";
+  const call = expression.type === "call" ? expression : null;
+  const callee = calleeOf(expression, call);
+  const declared = declaredCallFor(callee, options);
+  if (declared === void 0 && thrownByCall) {
+    return null;
+  }
+  return {
+    statement,
+    thrownByCall,
+    terminal: terminalOf(statement, callee, call, declared, options.facts)
+  };
 }
-function comparisonExpression(node) {
-  const operands = children(node);
-  const operators = node.children.filter(
-    (child) => child !== null && !child.isNamed
-  );
-  const operator = operators[0];
-  if (operands.length !== 2 || operators.length !== 1 || operator === void 0) {
-    return { kind: "opaque" };
+function calleeOf(expression, call) {
+  return call === null ? expression : field(call, "function") ?? expression;
+}
+function declaredCallFor(callee, options) {
+  const origin = originOf(callee, options.module);
+  if (origin === null) {
+    return void 0;
   }
+  const qualified = `${origin.module}.${origin.name}`;
+  return options.calls.find((call) => call.callee === qualified);
+}
+function terminalOf(statement, callee, call, declared, facts) {
   return {
-    kind: "operator",
-    operator: operator.text,
-    operands: [operands[0], operands[1]]
+    kind: "throw",
+    statusCode: declared === void 0 ? null : statusOf(declared, call, facts),
+    body: null,
+    exceptionType: lastSegmentOf(declared?.callee ?? callee.text),
+    message: call === null ? null : writtenMessageOf(call),
+    ...declared === void 0 ? {} : { producesResponse: true },
+    component: null,
+    renderTree: null,
+    delegateTarget: null,
+    emitEvent: null,
+    location: rangeOf(statement)
   };
 }
-function callExpression(node, originOf2) {
-  return fromFields(
-    node,
-    ["function", "arguments"],
-    OPAQUE,
-    (callee, argumentList) => {
-      const peeledCallee = peelValue(callee);
-      const args = argumentList.type === "argument_list" ? argumentsOf(argumentList) : [];
-      const isMethod2 = peeledCallee.type === "attribute";
-      return {
-        kind: "call",
-        callee: {
-          receiver: isMethod2 ? field(peeledCallee, "object") : null,
-          name: calleeName(peeledCallee),
-          origin: () => originOf2(peeledCallee)
-        },
-        args,
-        constructs: false
-      };
-    }
+function lastSegmentOf(dotted) {
+  const segment = dotted.split(".").pop();
+  return segment === void 0 || segment === "" ? null : segment;
+}
+function statusOf(declared, call, facts) {
+  const written = call === null ? null : statusArgumentOf(declared, call);
+  if (written === null) {
+    return declared.defaultStatusCode === void 0 ? null : { type: "literal", value: declared.defaultStatusCode };
+  }
+  const value = constantOf(evaluatedValue(written, facts));
+  if (typeof value === "number") {
+    return { type: "literal", value };
+  }
+  return { type: "dynamic", sourceText: written.text };
+}
+function argumentsOf2(call) {
+  return (field(call, "arguments")?.namedChildren ?? []).filter(
+    (child) => child !== null
   );
 }
-function calleeName(callee) {
-  if (callee.type === "identifier") {
-    return callee.text;
+function statusArgumentOf(declared, call) {
+  const args = argumentsOf2(call);
+  const keyed = args.find(
+    (arg) => arg.type === "keyword_argument" && field(arg, "name")?.text === declared.statusKeyword
+  );
+  if (keyed !== void 0) {
+    return field(keyed, "value");
   }
-  if (callee.type === "attribute") {
-    return field(callee, "attribute")?.text ?? null;
+  if (declared.statusArgument === void 0) {
+    return null;
+  }
+  const positional = args.filter((arg) => arg.type !== "keyword_argument");
+  return positional[declared.statusArgument] ?? null;
+}
+function writtenMessageOf(call) {
+  for (const arg of argumentsOf2(call)) {
+    const value = arg.type === "keyword_argument" ? field(arg, "value") : arg;
+    const literal = value === null ? null : stringLiteralValue(value);
+    if (literal !== null) {
+      return literal;
+    }
   }
   return null;
 }
-function argumentsOf(argumentList) {
-  return children(argumentList).flatMap((argument) => {
-    if (argument.type === "dictionary_splat") {
-      return [];
+
+// src/paths/returnedShape.ts
+var MAX_DEPTH = 6;
+var SCALARS = {
+  none: { type: "null" },
+  true: { type: "boolean" },
+  false: { type: "boolean" }
+};
+function children2(node) {
+  return node.namedChildren.filter((child) => child !== null);
+}
+function recordShape(node, depth) {
+  const properties = {};
+  let everyKeyWritten = true;
+  for (const pair of children2(node)) {
+    if (pair.type !== "pair") {
+      everyKeyWritten = false;
+      continue;
     }
-    if (argument.type === "keyword_argument") {
-      const name = field(argument, "name");
-      const value = field(argument, "value");
-      return name === null || value === null ? [] : [{ kind: "named", name: name.text, node: value }];
+    const key = field(pair, "key");
+    const value = field(pair, "value");
+    if (key === null || value === null || key.type !== "string") {
+      everyKeyWritten = false;
+      continue;
     }
-    return [elementOf(argument)];
-  });
-}
-function hasDictionarySplat(call) {
-  const argumentList = field(call, "arguments");
-  if (argumentList === null) {
-    return false;
+    properties[key.text.slice(1, -1)] = shapeOfReturned(value, depth + 1);
   }
-  return children(argumentList).some(
-    (argument) => argument.type === "dictionary_splat"
-  );
+  return everyKeyWritten && Object.keys(properties).length > 0 ? { type: "record", properties } : { type: "dictionary", values: { type: "unknown" } };
 }
-function elementOf(node) {
-  if (node.type === "list_splat") {
-    const inner = children(node)[0];
-    return inner === void 0 ? { kind: "value", node } : { kind: "spread", node: inner };
+function shapeOfReturned(node, depth = 0) {
+  if (depth > MAX_DEPTH) {
+    return { type: "unknown" };
   }
-  return { kind: "value", node };
-}
-function fieldOf(node) {
-  if (node.type === "dictionary_splat") {
-    const inner = children(node)[0];
-    return inner === void 0 ? [] : [{ kind: "spread", node: inner }];
+  const scalar = SCALARS[node.type];
+  if (scalar !== void 0) {
+    return scalar;
   }
-  if (node.type !== "pair") {
-    return [];
+  if (node.type === "string") {
+    return { type: "literal", value: node.text.slice(1, -1) };
   }
-  return fromFields(node, ["key", "value"], [], (key, value) => {
-    const name = stringLiteralValue(key);
-    return name === null ? [{ kind: "computed", name: key, value }] : [{ kind: "field", name, value }];
-  });
+  if (node.type === "integer") {
+    const value = Number.parseInt(node.text, 10);
+    return Number.isNaN(value) ? { type: "integer" } : { type: "literal", value };
+  }
+  if (node.type === "float") {
+    return { type: "number" };
+  }
+  if (node.type === "dictionary") {
+    return recordShape(node, depth);
+  }
+  if (node.type === "list" || node.type === "tuple" || node.type === "set") {
+    const first = children2(node)[0];
+    return {
+      type: "array",
+      items: first === void 0 ? { type: "unknown" } : shapeOfReturned(first, depth + 1)
+    };
+  }
+  if (node.type === "identifier" || node.type === "attribute") {
+    return { type: "ref", name: node.text };
+  }
+  return { type: "unknown" };
 }
-var STATEMENT_TYPES = {
-  expression_statement: expressionStatement,
-  if_statement: ifStatement,
-  elif_clause: ifStatement,
-  for_statement: loopStatement,
-  while_statement: loopStatement,
-  return_statement: (node) => ({
-    kind: "return",
-    value: children(node)[0] ?? null
-  }),
-  try_statement: (node) => ({
-    kind: "block",
-    body: [
-      ...blockStatements2(field(node, "body")),
-      ...children(node).flatMap(
-        (clause) => clause.type === "finally_clause" ? blockStatements2(children(clause)[0] ?? null) : []
-      )
-    ]
-  }),
-  with_statement: (node) => ({
-    kind: "block",
-    body: blockStatements2(field(node, "body"))
-  })
-};
-function statementOf(node) {
-  const lower = STATEMENT_TYPES[node.type];
-  return lower === void 0 ? { kind: "opaque" } : lower(node);
+function returnedBodyShape(statement) {
+  const returned = statement.namedChildren[0];
+  if (returned == null) {
+    return null;
+  }
+  const value = returned.type === "expression_list" ? children2(returned)[0] : returned;
+  if (value === void 0) {
+    return null;
+  }
+  const shape = shapeOfReturned(value);
+  return shape.type === "unknown" ? null : shape;
 }
-function expressionStatement(node) {
-  const inner = children(node)[0];
-  if (inner === void 0) {
-    return { kind: "opaque" };
+
+// 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 [];
+  }
+  const effects = [];
+  for (const call of calls) {
+    const pattern = patternFor(call, options);
+    if (pattern === void 0) {
+      continue;
+    }
+    const statement = statementIn(call);
+    if (statement === null) {
+      continue;
+    }
+    for (const access of readSqlAccess(statement, {
+      dialect: pattern.storageSystem
+    })) {
+      effects.push({
+        type: "interaction",
+        binding: storageBinding({
+          recognition: `python-${pattern.module}`,
+          storageSystem: pattern.storageSystem,
+          scope: pattern.module,
+          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 ?? ""
+        }
+      });
+    }
   }
-  if (inner.type === "assignment") {
-    return assignment(inner, null);
+  return effects;
+}
+function patternFor(call, options) {
+  const callee = field(call, "function");
+  if (callee === null || callee.type !== "identifier") {
+    return void 0;
   }
-  if (inner.type === "augmented_assignment") {
-    const operator = field(inner, "operator");
-    return assignment(
-      inner,
-      operator === null ? null : operator.text.slice(0, -1)
-    );
+  const from = options.facts.facts("pyImportedName").find((row) => String(row[0]) === `${options.filePath}#${callee.text}`);
+  if (from === void 0) {
+    return void 0;
   }
-  return { kind: "expression", value: inner };
-}
-function assignment(node, operator) {
-  return fromFields(
-    node,
-    ["left", "right"],
-    OPAQUE,
-    (target, value) => {
-      if (target.type === "pattern_list" || target.type === "tuple_pattern") {
-        return {
-          kind: "declare",
-          bindings: patternNames(target).map((name) => ({ name, value: null }))
-        };
-      }
-      return { kind: "assign", target, operator, value };
-    }
-  );
-}
-function patternNames(pattern) {
-  return children(pattern).flatMap(
-    (child) => child.type === "identifier" ? [child.text] : patternNames(child)
-  );
-}
-function ifStatement(node) {
-  return fromFields(
-    node,
-    ["condition", "consequence"],
-    OPAQUE,
-    (condition, consequence) => ({
-      kind: "branch",
-      condition,
-      arms: [blockStatements2(consequence), otherArm(node)]
-    })
+  const module = String(from[1]);
+  return options.patterns.find(
+    (pattern) => pattern.module === module && pattern.functions.includes(callee.text)
   );
 }
-function otherArm(clause) {
-  const statement = clause.type === "if_statement" ? clause : clause.parent;
-  const clauses = statement === null ? [] : children(statement);
-  const next = clauses.slice(clauses.findIndex((child) => child.id === clause.id) + 1).find(
-    (child) => child.type === "elif_clause" || child.type === "else_clause"
-  );
-  if (next === void 0) {
-    return [];
+function statementIn(call) {
+  const args = field(call, "arguments");
+  const first = args?.namedChildren.find((child) => child !== null) ?? null;
+  if (first === null || first.type !== "string") {
+    return null;
   }
-  return next.type === "elif_clause" ? [next] : blockStatements2(field(next, "body"));
-}
-function loopStatement(node) {
-  return { kind: "loop", body: blockStatements2(field(node, "body")) };
-}
-function blockStatements2(block) {
-  return block === null ? [] : children(block);
-}
-function isRoot(node) {
-  return ROOT_TYPES.has(node.type);
-}
-function isPathStatement(node, parent) {
-  return parent.type === "module" || parent.type === "block" || node.type === "elif_clause";
-}
-function siteOf(node) {
-  const path6 = [];
-  let current = node;
-  for (; ; ) {
-    const parent = current.parent;
-    if (parent === null) {
-      return null;
+  const parts = [""];
+  for (const child of first.namedChildren) {
+    if (child === null) {
+      continue;
     }
-    if (isPathStatement(current, parent)) {
-      path6.unshift(current);
+    if (child.type === "string_content") {
+      parts[parts.length - 1] += stringContentValue(child);
+      continue;
     }
-    if (isRoot(parent)) {
-      return { root: parent, path: path6 };
+    if (child.type === "interpolation") {
+      parts.push("");
     }
-    current = parent;
   }
+  const statement = sqlFromParts(parts);
+  return statement.trim() === "" ? null : statement;
 }
-function functionOf(node) {
-  if (node.type === "module") {
-    return { parameters: [], body: children(node) };
+
+// src/storage.ts
+import { storageBinding as storageBinding2 } from "@suss/ir-core";
+function receiverCall(call) {
+  const callee = field(call, "function");
+  if (callee === null || callee.type !== "attribute") {
+    return null;
   }
-  if (node.type === "lambda") {
-    const body = field(node, "body");
-    if (body === null) {
-      return null;
-    }
-    return { parameters: parameterShapes(node), body: { expression: body } };
+  const object = field(callee, "object");
+  return object !== null && object.type === "call" ? object : null;
+}
+function methodName(call) {
+  const callee = field(call, "function");
+  if (callee === null || callee.type !== "attribute") {
+    return callee?.text ?? "";
   }
-  if (node.type !== "function_definition") {
-    return null;
+  return field(callee, "attribute")?.text ?? "";
+}
+function subjectOf(call) {
+  const callee = field(call, "function");
+  if (callee === null || callee.type !== "attribute") {
+    return callee?.text ?? "";
   }
-  const parameters = parameterShapes(node);
-  return {
-    parameters: isMethod(node) ? parameters.slice(1) : parameters,
-    body: blockStatements2(field(node, "body"))
-  };
+  return field(callee, "object")?.text ?? "";
 }
-function isMethod(fn) {
-  const owner = fn.parent?.type === "decorated_definition" ? fn.parent.parent : fn.parent;
-  return owner?.type === "block" && owner.parent?.type === "class_definition";
+function rootOf(call) {
+  const receiver = receiverCall(call);
+  return receiver === null ? call : rootOf(receiver);
 }
-function namesMutatedInNestedFunctions(root, readingMethods) {
-  const mutated = /* @__PURE__ */ new Set();
-  const visit = (node, nested) => {
-    const name = writtenNameOf(node, readingMethods);
-    if (nested && name !== null) {
-      mutated.add(name);
+function chainsIn(calls) {
+  const endsWith = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const receiver = receiverCall(call);
+    if (receiver === null) {
+      continue;
     }
-    for (const child of children(node)) {
-      visit(child, nested || isRoot(child));
+    const start = rootOf(receiver);
+    const kept = endsWith.get(start.id);
+    if (kept === void 0 || call.endIndex > kept.endIndex) {
+      endsWith.set(start.id, call);
     }
-  };
-  for (const child of children(root)) {
-    visit(child, isRoot(child));
-  }
-  return mutated;
-}
-function writtenNameOf(node, readingMethods) {
-  if (node.type === "assignment" || node.type === "augmented_assignment") {
-    const target = field(node, "left");
-    return target?.type === "identifier" ? target.text : null;
   }
-  if (node.type === "call") {
-    const callee = field(node, "function");
-    if (callee?.type !== "attribute") {
-      return null;
-    }
-    const receiver = field(callee, "object");
-    const method = field(callee, "attribute");
-    if (receiver?.type === "identifier" && method !== null && !readingMethods.has(method.text)) {
-      return receiver.text;
+  const chains = [];
+  for (const call of calls) {
+    if (receiverCall(call) !== null) {
+      continue;
     }
+    const last = endsWith.get(call.id) ?? call;
+    chains.push({
+      root: call,
+      last,
+      subject: subjectOf(call),
+      operation: methodName(last),
+      between: calls.filter(
+        (other) => other !== call && other !== last && other.startIndex >= call.startIndex && other.endIndex <= last.endIndex
+      )
+    });
   }
-  return null;
+  return chains;
 }
-var DECLARING_PARENTS = /* @__PURE__ */ new Set([
-  "parameters",
-  "default_parameter",
-  "typed_parameter",
-  "typed_default_parameter",
-  "lambda_parameters",
-  "pattern_list",
-  "tuple_pattern",
-  "for_statement"
-]);
-function freeNamesOf(fn) {
-  const declared = /* @__PURE__ */ new Set();
-  const read = /* @__PURE__ */ new Set();
-  const visit = (node) => {
-    for (const child of children(node)) {
-      if (child.type !== "identifier") {
-        visit(child);
-        continue;
-      }
-      if (node.type === "attribute" && field(node, "attribute")?.id === child.id) {
-        continue;
-      }
-      if (node.type === "keyword_argument" && field(node, "name")?.id === child.id) {
-        continue;
-      }
-      if (DECLARING_PARENTS.has(node.type) || node.type === "assignment" && field(node, "left")?.id === child.id) {
-        declared.add(child.text);
-        continue;
-      }
-      read.add(child.text);
-    }
-  };
-  visit(fn);
-  return [...read].filter((name) => !declared.has(name));
+function importedQueryFunction(options, chain) {
+  const callee = field(chain.root, "function");
+  if (callee === null || callee.type !== "identifier") {
+    return void 0;
+  }
+  const from = options.facts.facts("pyImportedName").find((row) => String(row[0]) === `${options.filePath}#${callee.text}`);
+  if (from === void 0) {
+    return void 0;
+  }
+  return options.patterns.find(
+    (pattern) => String(from[1]) === pattern.module && (pattern.queryFunctions ?? []).includes(String(from[2]))
+  );
 }
-
-// src/values/origin.ts
-function originOf(callee, module) {
-  const chain = memberChainOf(callee);
-  if (chain === null) {
+function receiverName(chain) {
+  const callee = field(chain.root, "function");
+  if (callee === null || callee.type !== "attribute") {
     return null;
   }
-  const [rootName, ...rest] = chain;
-  if (rootName === void 0) {
-    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]);
   }
-  const binding = resolveName(scopeAt(callee, module), rootName);
-  if (binding === null) {
-    return rest.length === 0 ? { module: "builtins", name: rootName } : null;
+  if (annotation.type === "identifier") {
+    return annotation.text;
   }
-  const path6 = importedPathOf(binding, rootName);
-  if (path6 === null) {
-    return null;
+  const quoted = stringLiteralValue(annotation);
+  if (quoted !== null) {
+    return quoted;
   }
-  const dotted = [...path6, ...rest];
-  const name = dotted.pop();
-  if (name === void 0 || dotted.length === 0) {
-    return null;
+  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 { module: dotted.join("."), name };
+  return null;
 }
-function importedPathOf(binding, localName) {
-  if (binding.kind === "importFrom") {
-    if (binding.relativeLevel > 0) {
+function typeGivenBy(statement, name) {
+  if (statement.type === "assignment") {
+    if (field(statement, "left")?.text !== name) {
       return null;
     }
-    return [...binding.module.split("."), binding.importedName];
+    const annotation = field(statement, "type");
+    if (annotation !== null) {
+      return typeNameOf(annotation);
+    }
+    const right = field(statement, "right");
+    const callee = right?.type === "call" ? field(right, "function") : null;
+    return callee?.type === "identifier" ? callee.text : null;
   }
-  if (binding.kind !== "import") {
-    return 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;
   }
-  const unaliasedDotted = binding.module !== localName && binding.module.startsWith(`${localName}.`);
-  return unaliasedDotted ? [localName] : binding.module.split(".");
+  return null;
 }
-function memberChainOf(node) {
-  const names = [];
-  let current = peelValue(node);
-  while (current.type === "attribute") {
-    const object = field(current, "object");
-    const attribute = field(current, "attribute");
-    if (object === null || attribute === null) {
-      return null;
+function declaredTypeName(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);
     }
-    names.unshift(attribute.text);
-    current = peelValue(object);
   }
-  if (current.type !== "identifier") {
+  const visit = (node) => {
+    const given = typeGivenBy(node, name);
+    if (given !== null) {
+      return given;
+    }
+    for (const child of children(node)) {
+      if (child.type === "function_definition" || child.type === "lambda") {
+        continue;
+      }
+      const found = visit(child);
+      if (found !== null) {
+        return found;
+      }
+    }
     return null;
-  }
-  return [current.text, ...names];
-}
-function scopeAt(node, module) {
-  let current = node;
-  while (current !== null) {
-    const scope = module.scopeFor.get(current.id);
-    if (scope !== void 0) {
-      return scope;
+  };
+  const body = field(fn, "body");
+  for (const statement of body === null ? [] : bodyStatements(body)) {
+    const found = visit(statement);
+    if (found !== null) {
+      return found;
     }
-    current = current.parent;
   }
-  return module.moduleScope;
+  return null;
 }
-
-// src/values/rows.ts
-import {
-  appended,
-  concat,
-  constant,
-  environmentRead,
-  equals,
-  extended,
-  fallback,
-  formatArguments,
-  hole,
-  joined,
-  joinedPath,
-  literalOf,
-  negated,
-  operand,
-  percentFormatted,
-  plus,
-  readableFallback,
-  stripped,
-  text,
-  truthOf
-} from "@suss/values";
-var operatorRows = [
-  {
-    kind: "operator",
-    operator: "+",
-    arity: 2,
-    apply: ([a, b]) => plus(operand(a), operand(b))
-  },
-  {
-    kind: "operator",
-    operator: "%",
-    arity: 2,
-    apply: ([a, b], contentOf) => percentFormatted(operand(a), formatArguments(contentOf(operand(b))))
-  },
-  {
-    kind: "operator",
-    operator: "==",
-    arity: 2,
-    apply: ([a, b]) => equals(operand(a), operand(b))
-  },
-  {
-    kind: "operator",
-    operator: "!=",
-    arity: 2,
-    apply: ([a, b]) => negated(equals(operand(a), operand(b)))
-  },
-  {
-    kind: "operator",
-    operator: "is",
-    arity: 2,
-    apply: ([a, b]) => equals(operand(a), operand(b))
-  },
-  {
-    kind: "operator",
-    operator: "is not",
-    arity: 2,
-    apply: ([a, b]) => negated(equals(operand(a), operand(b)))
-  },
-  {
-    kind: "operator",
-    operator: "not",
-    arity: 1,
-    apply: ([a]) => negated(operand(a))
-  },
-  {
-    kind: "operator",
-    operator: "or",
-    arity: 2,
-    apply: ([a, b]) => readableFallback(operand(a), operand(b), truthOf)
-  },
-  {
-    kind: "operator",
-    operator: "and",
-    arity: 2,
-    apply: ([a, b]) => fallback(operand(a), operand(b), (left) => {
-      const truth = truthOf(left);
-      return truth === null ? null : !truth;
-    })
-  }
-];
-var stringRows = [
-  {
-    kind: "method",
-    method: "join",
-    on: "string",
-    apply: ({ receiver, args, contentOf }) => ({
-      result: joined(contentOf(operand(args[0])), operand(receiver))
-    })
-  },
-  {
-    kind: "method",
-    method: "format",
-    on: "string",
-    apply: ({ receiver, args }) => ({
-      result: braceFormatted(operand(receiver), args)
-    })
-  },
-  {
-    kind: "method",
-    method: "strip",
-    on: "string",
-    apply: ({ receiver, args }) => ({
-      result: args.length === 0 ? stripped(operand(receiver)) : hole("value")
-    })
-  },
-  {
-    kind: "method",
-    method: "rstrip",
-    on: "string",
-    apply: ({ receiver, args }) => ({
-      result: args.length === 0 ? stripped(operand(receiver), "end") : hole("value")
-    })
-  },
-  {
-    kind: "method",
-    method: "lstrip",
-    on: "string",
-    apply: ({ receiver, args }) => ({
-      result: args.length === 0 ? stripped(operand(receiver), "start") : hole("value")
-    })
-  }
-];
-var sequenceRows = ["sequence", "unbounded"].flatMap((on) => [
-  {
-    kind: "method",
-    method: "append",
-    on,
-    apply: ({ receiver, args }) => ({
-      result: constant(null),
-      receiver: appended(operand(receiver), args)
-    })
-  },
-  {
-    kind: "method",
-    method: "extend",
-    on,
-    apply: ({ receiver, args, contentOf }) => ({
-      result: constant(null),
-      receiver: extended(operand(receiver), contentOf(operand(args[0])))
-    })
+function typedReceiverPattern(options, chain) {
+  const receiver = receiverName(chain);
+  if (receiver === null) {
+    return void 0;
   }
-]);
-var calleeRows = [
-  {
-    kind: "callee",
-    origin: { module: "builtins", name: "str" },
-    apply: ({ args }) => ({ result: concat([operand(args[0])]) })
-  },
-  {
-    kind: "callee",
-    origin: { module: "os.path", name: "join" },
-    apply: ({ args }) => ({ result: joinedPath(args) })
-  },
-  {
-    kind: "callee",
-    origin: { module: "os", name: "getenv" },
-    apply: ({ args }) => ({ result: environmentRead(args) })
-  },
-  {
-    kind: "callee",
-    origin: { module: "os.environ", name: "get" },
-    apply: ({ args }) => ({ result: environmentRead(args) })
+  const typeName = declaredTypeName(receiver, chain.root);
+  if (typeName === null) {
+    return void 0;
   }
-];
-var BRACE_PLACEHOLDER = /\{([^{}]*)\}/g;
-function braceFormatted(receiver, args) {
-  const template = literalOf(receiver);
-  if (template === null) {
-    return hole("value");
+  const from = options.facts.facts("pyImportedName").find((row) => String(row[0]) === `${options.filePath}#${typeName}`);
+  if (from === void 0) {
+    return void 0;
   }
-  const parts = [];
-  let last = 0;
-  let position = 0;
-  for (const match of template.matchAll(BRACE_PLACEHOLDER)) {
-    parts.push(text(template.slice(last, match.index)));
-    const argument = args[position];
-    const placeholder = match[1] ?? "";
-    parts.push(
-      argument === void 0 ? hole(
-        placeholder === "" ? "value" : placeholder.split(/[!:]/)[0] ?? "value"
-      ) : concat([argument])
-    );
-    position += 1;
-    last = match.index + match[0].length;
+  return options.patterns.find(
+    (pattern) => String(from[1]) === pattern.module && pattern.queryTypes.includes(String(from[2]))
+  );
+}
+function fieldsOf(chain, valueMethods) {
+  const args = field(chain.root, "arguments");
+  const named = [];
+  for (const argument of args === null ? [] : children(args)) {
+    if (argument.type === "keyword_argument") {
+      const name = field(argument, "name");
+      if (name !== null) {
+        named.push(name.text);
+      }
+      continue;
+    }
+    if (argument.type === "attribute") {
+      const property = field(argument, "attribute");
+      if (property !== null) {
+        named.push(property.text);
+      }
+    }
   }
-  parts.push(text(template.slice(last)));
-  return concat(parts);
+  for (const call of laterCalls(chain)) {
+    if (valueMethods.includes(methodNameOf(call))) {
+      named.push(...keywordNames(call));
+    }
+  }
+  return [...new Set(named)];
 }
-var pythonRows = [
-  ...operatorRows,
-  ...stringRows,
-  ...sequenceRows,
-  ...calleeRows
-];
-
-// src/values/evaluator.ts
-var evaluators = /* @__PURE__ */ new WeakMap();
-var withoutFacts = /* @__PURE__ */ new WeakMap();
-var modulesByTree = /* @__PURE__ */ new WeakMap();
-function bindEvaluator(db, nodes) {
-  for (const entry of nodes.files) {
-    modulesByTree.set(entry.root.tree, entry.module);
+function laterCalls(chain) {
+  return [...chain.between, chain.last].filter((call) => call !== chain.root);
+}
+function methodNameOf(call) {
+  const callee = field(call, "function");
+  return callee?.type === "attribute" ? field(callee, "attribute")?.text ?? "" : callee?.text ?? "";
+}
+function keywordNames(call) {
+  const args = field(call, "arguments");
+  const picked = [];
+  for (const argument of args === null ? [] : children(args)) {
+    if (argument.type === "keyword_argument") {
+      const name = field(argument, "name");
+      if (name !== null) {
+        picked.push(name.text);
+      }
+    }
   }
-  evaluators.set(
-    db,
-    new Evaluator(
-      pythonLowering({
-        context: contextOver(db, nodes),
-        originOf: calleeOrigin,
-        rows: pythonRows
-      })
+  return picked;
+}
+function selectorOf(chain, valueMethods) {
+  return [
+    ...new Set(
+      laterCalls(chain).filter((call) => !valueMethods.includes(methodNameOf(call))).flatMap(keywordNames)
     )
-  );
+  ];
 }
-function evaluatedValue(node, db) {
-  return force(evaluatorFor(node, db).evaluate(node));
+function effectFor(pattern, chain, operation) {
+  const valueMethods = pattern.valueMethods ?? [];
+  const picked = selectorOf(chain, valueMethods);
+  return {
+    type: "interaction",
+    binding: storageBinding2({
+      recognition: "python-storage",
+      storageSystem: pattern.storageSystem,
+      scope: pattern.module,
+      container: chain.subject
+    }),
+    callee: chain.last.text,
+    interaction: {
+      class: "storage-access",
+      kind: pattern.writes.includes(operation) ? "write" : "read",
+      fields: fieldsOf(chain, valueMethods),
+      operation,
+      ...picked.length > 0 ? { selector: picked } : {}
+    }
+  };
 }
-function stringValueOf(node, db) {
-  return literalOf2(evaluatedValue(node, db));
+function fileOf(key) {
+  const at = key.lastIndexOf(":");
+  return at === -1 ? key : key.slice(0, at);
 }
-function evaluatorFor(node, db) {
-  const bound = db === void 0 ? void 0 : evaluators.get(db);
-  if (bound !== void 0) {
-    return bound;
+function returnTypeName(node) {
+  if (node === void 0) {
+    return null;
   }
-  const tree = node.tree;
-  let local = withoutFacts.get(tree);
-  if (local === void 0) {
-    local = new Evaluator(
-      pythonLowering({
-        context: null,
-        originOf: calleeOrigin,
-        rows: pythonRows
-      })
-    );
-    withoutFacts.set(tree, local);
+  const annotation = field(node, "return_type");
+  if (annotation === null) {
+    return null;
   }
-  return local;
+  return annotation.type === "subscript" ? field(annotation, "value")?.text ?? null : annotation.text;
 }
-function moduleOf(node) {
-  const tree = node.tree;
-  let module = modulesByTree.get(tree);
-  if (module === void 0) {
-    module = bindModule(tree.rootNode);
-    modulesByTree.set(tree, module);
+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;
+  if (settled === void 0) {
+    return void 0;
   }
-  return module;
-}
-function calleeOrigin(callee) {
-  return originOf(callee, moduleOf(callee));
+  const typeName = returnTypeName(options.definitionAt(settled));
+  if (typeName === null) {
+    return void 0;
+  }
+  return options.patterns.find(
+    (candidate) => candidate.queryTypes.includes(typeName) && options.facts.facts("pyImport").some(
+      (row) => String(row[0]) === fileOf(settled) && String(row[1]) === candidate.module
+    )
+  );
 }
-function contextOver(db, nodes) {
-  const filesByRoot = /* @__PURE__ */ new Map();
-  const rootsByFile = /* @__PURE__ */ new Map();
-  for (const entry of nodes.files) {
-    filesByRoot.set(entry.root.id, entry);
-    rootsByFile.set(entry.file, entry.root);
+function matchedChains(calls, options) {
+  if (options.patterns.length === 0) {
+    return [];
   }
-  const keyOf2 = (node) => {
-    const entry = filesByRoot.get(node.tree.rootNode.id);
-    if (entry === void 0) {
-      return null;
+  const named = new Set(
+    options.patterns.flatMap((pattern) => pattern.queryFunctions ?? [])
+  );
+  const chains = chainsIn(calls).filter(
+    (chain) => options.couldMatch.has(methodName(chain.root)) || named.has(methodName(chain.root)) || typedReceiverPattern(options, chain) !== void 0
+  );
+  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)
+    )
+  );
+  const matched = [];
+  for (const chain of chains) {
+    const callee = field(chain.root, "function");
+    if (callee === null) {
+      continue;
     }
-    return readKey(entry.file, node, enclosingFunction(node));
-  };
-  return {
-    writtenTo: (node) => {
-      const key = keyOf2(node);
-      if (key === null) {
-        return null;
-      }
-      const answer = writtenValueOf(db, key);
-      return answer === null ? null : nodeOfKey(rootsByFile, answer);
-    },
-    callable: (call) => {
-      const callee = field(call, "function");
-      const key = callee === null ? null : keyOf2(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;
-      return settled === void 0 ? null : nodes.definitions.get(settled) ?? null;
+    const imported = importedQueryFunction(options, chain);
+    if (imported !== void 0) {
+      matched.push({
+        chain,
+        pattern: imported,
+        operation: methodName(chain.root)
+      });
+      continue;
     }
-  };
+    const typed = typedReceiverPattern(options, chain);
+    if (typed !== void 0) {
+      const silent = (typed.recordsNothing ?? []).includes(
+        methodName(chain.root)
+      );
+      matched.push({
+        chain,
+        pattern: typed,
+        operation: silent ? null : chain.operation
+      });
+      continue;
+    }
+    const pattern = resolvedMethodPattern(options, callee);
+    if (pattern !== void 0) {
+      matched.push({ chain, pattern, operation: chain.operation });
+    }
+  }
+  return matched;
+}
+function storageCallIds(calls, options) {
+  return new Set(
+    matchedChains(calls, options).map(({ chain }) => chain.root.id)
+  );
+}
+function storageEffects(calls, options) {
+  return matchedChains(calls, options).flatMap(
+    ({ chain, pattern, operation }) => operation === null ? [] : [effectFor(pattern, chain, operation)]
+  );
 }
 
 // src/discovery.ts
@@ -3223,6 +3543,8 @@ function classRouteUnits(pattern, pack, classification, classNode, module, optio
             ...entry.mount !== void 0 ? { mount: entry.mount } : {},
             requestBodyFromAnnotatedClass: pattern.annotatedClassIsRequestBody === true,
             readsReturnedStatus: pattern.statusFromReturnedTuple === true,
+            responseStatusCalls: pattern.responseStatusCalls ?? [],
+            facts: options.facts,
             injectedCallees: new Set(pattern.injectedParameterCallees ?? []),
             definitionNode: maybeMethod,
             enclosingScope: classScope,
@@ -3407,36 +3729,106 @@ function effectsReaching(effects, conditions) {
     (effect) => guardsHoldOn(effect.preconditions, conditions)
   );
 }
-function branchesFromReturns(readsReturnedStatus, definitionNode, effects, responseShape, declaredStatus) {
-  if (!readsReturnedStatus) {
-    return null;
+function returnStatusReading(statement, ctx) {
+  if (!ctx.readsReturnedStatus) {
+    return ctx.declaredStatus.reading;
   }
-  const body = field(definitionNode, "body");
-  const returns = returnStatements(body);
-  if (returns.length < 2) {
+  const read = statusOfReturn(statement);
+  const range = rangeOf(statement);
+  if (read.kind === "status") {
+    return writtenReading(read.value, range);
+  }
+  if (read.kind === "none") {
+    return absentReading;
+  }
+  return unreadableReading(
+    "This return gives a status this reading cannot resolve to a number, so this outcome claims none",
+    range
+  );
+}
+function returnBranch(statement, ctx) {
+  const range = rangeOf(statement);
+  const writtenBody = returnedBodyShape(statement);
+  return {
+    terminal: {
+      kind: "response",
+      // These stay null here. The extractor fills them in from the two
+      // readings below.
+      statusCode: null,
+      body: { typeText: null, shape: null },
+      exceptionType: null,
+      message: null,
+      component: null,
+      renderTree: null,
+      delegateTarget: null,
+      emitEvent: null,
+      location: range
+    },
+    statusCodeReading: {
+      reading: returnStatusReading(statement, ctx),
+      ...ctx.declaredStatus.libraryDefault !== void 0 ? { libraryDefault: ctx.declaredStatus.libraryDefault } : {}
+    },
+    bodyShapeReading: {
+      reading: writtenBody === null ? ctx.responseShape.reading : writtenReading(writtenBody, range)
+    },
+    location: range
+  };
+}
+function terminalBranchOf(found, ctx) {
+  const table = {
+    return: (variant) => returnBranch(variant.statement, ctx),
+    raise: (variant) => ({
+      terminal: variant.terminal,
+      location: rangeOf(variant.statement)
+    })
+  };
+  return dispatchByType(table, found);
+}
+function routeTerminals(body, raised) {
+  const found = [
+    ...returnStatements(body).map(
+      (statement) => ({ type: "return", statement })
+    ),
+    ...raised.map(
+      (response) => ({
+        type: "raise",
+        statement: response.statement,
+        terminal: response.terminal
+      })
+    )
+  ];
+  return found.sort((a, b) => a.statement.startIndex - b.statement.startIndex);
+}
+function branchesPerTerminal(options) {
+  const body = field(options.definitionNode, "body");
+  const raised = raisedResponses(body, {
+    calls: options.responseStatusCalls,
+    module: options.module,
+    facts: options.facts
+  });
+  const terminals = routeTerminals(body, raised);
+  if (terminals.length < 2) {
     return null;
   }
-  const lowered = lowerPythonBody(body, returns);
+  const statements = terminals.map((found) => found.statement);
+  const thrownByCall = new NodeSet(
+    raised.filter((response) => response.thrownByCall).map((response) => response.statement)
+  );
+  const lowered = lowerPythonBody(body, statements, thrownByCall);
   const enumerated = enumerateOrDegrade2(
     {
       statements: lowered.statements,
       terminalsByStmt: lowered.terminalsByStmt
     },
-    returns
+    statements
   );
   const branches = [];
-  for (const statement of returns) {
-    const paths = enumerated.byTerminal.get(statement);
+  for (const found of terminals) {
+    const paths = enumerated.byTerminal.get(found.statement);
     if (paths === void 0) {
       continue;
     }
-    const read = statusOfReturn(statement);
-    const range = rangeOf(statement);
-    const writtenBody = returnedBodyShape(statement);
-    const statusReading = read.kind === "status" ? writtenReading(read.value, range) : read.kind === "none" ? absentReading : unreadableReading(
-      "This return gives a status this reading cannot resolve to a number, so this outcome claims none",
-      range
-    );
+    const branch = terminalBranchOf(found, options.ctx);
     for (const path6 of paths) {
       const conditions = path6.map((condition) => ({
         sourceText: condition.sourceText,
@@ -3445,28 +3837,9 @@ function branchesFromReturns(readsReturnedStatus, definitionNode, effects, respo
         source: condition.source
       }));
       branches.push({
+        ...branch,
         conditions,
-        terminal: {
-          kind: "response",
-          statusCode: null,
-          body: { typeText: null, shape: null },
-          exceptionType: null,
-          message: null,
-          component: null,
-          renderTree: null,
-          delegateTarget: null,
-          emitEvent: null,
-          location: range
-        },
-        statusCodeReading: {
-          reading: statusReading,
-          ...declaredStatus.libraryDefault !== void 0 ? { libraryDefault: declaredStatus.libraryDefault } : {}
-        },
-        bodyShapeReading: {
-          reading: writtenBody === null ? responseShape.reading : writtenReading(writtenBody, range)
-        },
-        effects: effectsReaching(effects, conditions),
-        location: range,
+        effects: effectsReaching(options.effects, conditions),
         isDefault: path6.length === 0
       });
     }
@@ -3571,6 +3944,8 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
         ...entry.mount !== void 0 ? { mount: entry.mount } : {},
         requestBodyFromAnnotatedClass: pattern.annotatedClassIsRequestBody === true,
         readsReturnedStatus: pattern.statusFromReturnedTuple === true,
+        responseStatusCalls: pattern.responseStatusCalls ?? [],
+        facts: options.facts,
         injectedCallees: new Set(pattern.injectedParameterCallees ?? []),
         definitionNode: functionNode,
         enclosingScope: module.moduleScope,
@@ -3679,17 +4054,18 @@ function buildRouteUnit(options) {
   );
   const effects = invocationEffects(definitionNode);
   const extra = recognizedBodyEffects(definitionNode, module, storageLookup);
-  const perReturn = branchesFromReturns(
-    readsReturnedStatus,
+  const perTerminal = branchesPerTerminal({
     definitionNode,
     effects,
-    responseShape,
-    statusCode
-  );
-  const branches = (perReturn ?? []).map(
+    module,
+    facts: options.facts,
+    responseStatusCalls: options.responseStatusCalls,
+    ctx: { readsReturnedStatus, responseShape, declaredStatus: statusCode }
+  });
+  const branches = (perTerminal ?? []).map(
     (branch) => extra.length === 0 ? branch : { ...branch, extraEffects: extra }
   );
-  if (perReturn === null && (responseShape.reading.kind !== "absent" || statusCode.reading.kind !== "absent" || extra.length > 0 || effects.length > 0)) {
+  if (perTerminal === null && (responseShape.reading.kind !== "absent" || statusCode.reading.kind !== "absent" || extra.length > 0 || effects.length > 0)) {
     branches.push({
       conditions: [],
       terminal: {
@@ -3771,6 +4147,15 @@ function recognizedBodyEffects(definitionNode, module, storageLookup) {
   ];
   return [...envReadEffects(definitionNode, module), ...storage];
 }
+function recognizedCallIds(definitionNode, storageLookup) {
+  if (storageLookup === void 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  return storageCallIds(bodyCalls(definitionNode), {
+    ...storageLookup,
+    filePath: storageLookup.factsPath
+  });
+}
 function bodyContentOf(bodyNode) {
   for (const stmt of bodyStatements(bodyNode)) {
     if (stmt.type === "pass_statement") {
@@ -3885,26 +4270,6 @@ function isInjectedParameter(param, injectedCallees) {
   };
   return containsInjectorCall(field(param, "type"), 0);
 }
-function parameterNameAndType(param) {
-  if (param.type === "identifier") {
-    return { name: param.text, typeNode: null };
-  }
-  if (param.type === "typed_parameter") {
-    const inner = param.namedChildren.find(
-      (child) => child !== null && child.type === "identifier"
-    );
-    return inner !== void 0 ? { name: inner.text, typeNode: field(param, "type") } : null;
-  }
-  if (param.type === "default_parameter") {
-    const nameNode = field(param, "name");
-    return nameNode?.type === "identifier" ? { name: nameNode.text, typeNode: null } : null;
-  }
-  if (param.type === "typed_default_parameter") {
-    const nameNode = field(param, "name");
-    return nameNode !== null ? { name: nameNode.text, typeNode: field(param, "type") } : null;
-  }
-  return null;
-}
 
 // src/facts/why.ts
 import fs4 from "fs";
@@ -4449,7 +4814,11 @@ function reachedFunctions(seeds, options) {
       if (source === void 0) {
         continue;
       }
-      const scan = scanBody(source, ctx);
+      const scan = scanBody(
+        source,
+        ctx,
+        recognizedCallIds(source.node, options.storageFor(source.file))
+      );
       if (scan.stops.length > 0) {
         stopsByKey.set(key, scan.stops);
       }
@@ -4514,7 +4883,7 @@ var EMPTY_SCAN = {
   parameterCalls: [],
   passedPositions: /* @__PURE__ */ new Set()
 };
-function scanBody(source, ctx) {
+function scanBody(source, ctx, recognized) {
   const followed = [];
   const stops = [];
   const placements = new TargetPlacements();
@@ -4579,7 +4948,7 @@ function scanBody(source, ctx) {
     );
     if (outcome.kind === "stopped") {
       const stopKey = `${outcome.reason}:${callee}`;
-      if (!seen.has(stopKey) && worthRecording(outcome.reason)) {
+      if (!seen.has(stopKey) && !recognized.has(call.id) && worthRecording(outcome.reason)) {
         seen.add(stopKey);
         stops.push({ callee, reason: outcome.reason });
       }