@suss/adapter-python 0.34.0 → 0.35.0

package/dist/index.cjs

@@ -153,10 +153,7 @@ function stringLiteralValue(node) {
     return null;
   }
   let content = "";
-  for (const child of node.namedChildren) {
-    if (child === null) {
-      continue;
-    }
+  for (const child of children(node)) {
     if (child.type === "string_content") {
       content += stringContentValue(child);
       continue;
@@ -168,7 +165,29 @@ function stringLiteralValue(node) {
   return content;
 }
 function children(node) {
-  return node.namedChildren.filter((child) => child !== null);
+  if (node === null || node === void 0) {
+    return [];
+  }
+  const found = [];
+  const count = node.namedChildCount;
+  for (let index = 0; index < count; index++) {
+    const child = node.namedChild(index);
+    if (child !== null) {
+      found.push(child);
+    }
+  }
+  return found;
+}
+function allChildren(node) {
+  const found = [];
+  const count = node.childCount;
+  for (let index = 0; index < count; index++) {
+    const child = node.child(index);
+    if (child !== null) {
+      found.push(child);
+    }
+  }
+  return found;
 }
 function bodyStatements(body) {
   return children(body);
@@ -200,11 +219,59 @@ function stripDecorators(node) {
   if (definition === null) {
     throw new Error("decorated_definition with no definition field");
   }
-  const decorators = node.namedChildren.filter(
-    (child) => child !== null && child.type === "decorator"
+  const decorators = children(node).filter(
+    (child) => child.type === "decorator"
   );
   return { definition, decorators };
 }
+var isChild = (fieldName) => (parent, child) => field(parent, fieldName)?.id === child.id;
+var always = () => true;
+var asCondition = isChild("condition");
+var isConditionalTest = (parent, child) => parent.namedChild(1)?.id === child.id;
+var VALUE_USED_UNDER = {
+  assignment: isChild("right"),
+  augmented_assignment: isChild("right"),
+  named_expression: isChild("value"),
+  attribute: isChild("object"),
+  subscript: always,
+  argument_list: always,
+  keyword_argument: isChild("value"),
+  pair: always,
+  list: always,
+  tuple: always,
+  set: always,
+  dictionary: always,
+  interpolation: always,
+  comparison_operator: always,
+  binary_operator: always,
+  unary_operator: always,
+  not_operator: always,
+  if_statement: asCondition,
+  elif_clause: asCondition,
+  while_statement: asCondition,
+  conditional_expression: isConditionalTest,
+  assert_statement: always,
+  for_statement: isChild("right"),
+  for_in_clause: isChild("right"),
+  with_item: always,
+  as_pattern: always
+};
+var PASSES_VALUE_ON = {
+  parenthesized_expression: always,
+  await: always,
+  boolean_operator: always,
+  conditional_expression: (parent, child) => !isConditionalTest(parent, child)
+};
+function resultUsedAsValue(node) {
+  let child = node;
+  let parent = node.parent;
+  while (parent !== null && PASSES_VALUE_ON[parent.type]?.(parent, child) === true) {
+    child = parent;
+    parent = parent.parent;
+  }
+  const used = parent === null ? void 0 : VALUE_USED_UNDER[parent.type];
+  return parent !== null && used !== void 0 && used(parent, child);
+}
 var NodeSet = class extends import_extractor.IdSet {
 };
 var NodeMap = class extends import_extractor.IdMap {
@@ -266,7 +333,7 @@ function bindWithStatement(stmt, scope, ctx) {
   }
 }
 function asPatternsIn(stmt, found = []) {
-  for (const child of stmt.namedChildren) {
+  for (const child of children(stmt)) {
     if (child === null || child.type === "block") {
       continue;
     }
@@ -295,12 +362,12 @@ function bindDeleteStatement(stmt, scope) {
       return;
     }
     if (node.type === "expression_list") {
-      for (const child of node.namedChildren) {
+      for (const child of children(node)) {
         unbind(child);
       }
     }
   };
-  for (const child of stmt.namedChildren) {
+  for (const child of children(stmt)) {
     unbind(child);
   }
 }
@@ -341,10 +408,7 @@ function bindImportStatement(stmt, scope) {
 function relativeImportParts(node) {
   let relativeLevel = 0;
   let module2 = "";
-  for (const child of node.namedChildren) {
-    if (child === null) {
-      continue;
-    }
+  for (const child of children(node)) {
     if (child.type === "import_prefix") {
       relativeLevel += child.text.length;
       continue;
@@ -361,8 +425,8 @@ function bindImportFromStatement(stmt, scope, ctx) {
     return;
   }
   const { module: module2, relativeLevel } = moduleNode.type === "relative_import" ? relativeImportParts(moduleNode) : { module: moduleNode.text, relativeLevel: 0 };
-  const hasWildcard = stmt.namedChildren.some(
-    (child) => child !== null && child.type === "wildcard_import"
+  const hasWildcard = children(stmt).some(
+    (child) => child.type === "wildcard_import"
   );
   if (hasWildcard) {
     ctx.openImports.push(
@@ -420,10 +484,7 @@ function bindFunctionDefinition(stmt, scope, ctx) {
   }
 }
 function bindParameters(parametersNode, functionScope) {
-  for (const param of parametersNode.namedChildren) {
-    if (param === null) {
-      continue;
-    }
+  for (const param of children(parametersNode)) {
     const name = parameterName(param);
     if (name !== null) {
       bindName(functionScope, name, { kind: "parameter" });
@@ -440,9 +501,7 @@ function parameterName(param) {
     "list_splat_pattern",
     "dictionary_splat_pattern"
   )) {
-    const inner = param.namedChildren.find(
-      (child) => child !== null && child.type === "identifier"
-    );
+    const inner = children(param).find((child) => child.type === "identifier");
     return inner?.text ?? null;
   }
   if (isType(param, "default_parameter", "typed_default_parameter")) {
@@ -469,8 +528,8 @@ function bindClassDefinition(stmt, scope, ctx) {
   }
 }
 function bindExpressionStatement(stmt, scope) {
-  const assignment2 = stmt.namedChildren.find(
-    (child) => child !== null && child.type === "assignment"
+  const assignment2 = children(stmt).find(
+    (child) => child.type === "assignment"
   );
   if (assignment2 === void 0 || assignment2 === null) {
     return;
@@ -487,15 +546,15 @@ function bindExpressionStatement(stmt, scope) {
   }
 }
 function bindGlobalStatement(stmt, scope) {
-  for (const child of stmt.namedChildren) {
-    if (child !== null && child.type === "identifier") {
+  for (const child of children(stmt)) {
+    if (child.type === "identifier") {
       scope.bindings.set(child.text, { kind: "global" });
     }
   }
 }
 function bindNonlocalStatement(stmt, scope) {
-  for (const child of stmt.namedChildren) {
-    if (child !== null && child.type === "identifier") {
+  for (const child of children(stmt)) {
+    if (child.type === "identifier") {
       scope.bindings.set(child.text, { kind: "nonlocal" });
     }
   }
@@ -644,18 +703,9 @@ function shapeFromName(name, scope, ctx) {
   if (DICT_NAMES.has(name)) {
     return { type: "dictionary", values: { type: "unknown" } };
   }
-  const binding = resolveName(scope, name);
-  if (binding?.kind === "classDef") {
-    return recordShapeRef(name, binding.node, ctx);
-  }
-  if (binding?.kind === "import" || binding?.kind === "importFrom") {
-    const imported = ctx.importedDefinition?.(scope, name) ?? null;
-    if (imported?.node.type === "class_definition") {
-      if (!ctx.scopeMaps.includes(imported.scopeFor)) {
-        ctx.scopeMaps.push(imported.scopeFor);
-      }
-      return recordShapeRef(name, imported.node, ctx);
-    }
+  const classNode = projectClassNamed(name, scope, ctx);
+  if (classNode !== null) {
+    return recordShapeRef(name, classNode, ctx);
   }
   const alias = aliasValueOf(name, scope, ctx);
   if (alias !== null) {
@@ -663,6 +713,23 @@ function shapeFromName(name, scope, ctx) {
   }
   return { type: "ref", name };
 }
+function projectClassNamed(name, scope, ctx) {
+  const binding = resolveName(scope, name);
+  if (binding?.kind === "classDef") {
+    return binding.node;
+  }
+  if (binding?.kind !== "import" && binding?.kind !== "importFrom") {
+    return null;
+  }
+  const imported = ctx.importedDefinition?.(scope, name) ?? null;
+  if (imported?.node.type !== "class_definition") {
+    return null;
+  }
+  if (!ctx.scopeMaps.includes(imported.scopeFor)) {
+    ctx.scopeMaps.push(imported.scopeFor);
+  }
+  return imported.node;
+}
 function shapeFromAliasValue(name, alias, ctx) {
   if (ctx.expanding.has(alias.node.id)) {
     return { type: "ref", name };
@@ -689,8 +756,9 @@ function shapeFromSubscript(node, scope, ctx) {
   );
 }
 function annotationTarget(annotation) {
-  if (annotation.type === "type" && annotation.namedChildren[0]) {
-    return annotationTarget(annotation.namedChildren[0]);
+  const inner = annotation.type === "type" ? annotation.namedChild(0) : null;
+  if (inner !== null) {
+    return annotationTarget(inner);
   }
   if (annotation.type === "binary_operator") {
     const named = [field(annotation, "left"), field(annotation, "right")].find(
@@ -699,7 +767,7 @@ function annotationTarget(annotation) {
     return named === void 0 || named === null ? null : annotationTarget(named);
   }
   if (annotation.type === "generic_type") {
-    const outer = annotation.namedChildren[0];
+    const outer = annotation.namedChild(0);
     const first = genericTypeArgs(annotation)[0];
     if ((outer?.text === "Annotated" || outer?.text === "Optional") && first !== void 0) {
       return annotationTarget(first);
@@ -716,12 +784,10 @@ function typeNameOf(annotation) {
   return target.type === "identifier" ? target.text : stringLiteralValue(target);
 }
 function genericTypeArgs(node) {
-  const typeParameter = node.namedChildren.find(
-    (child) => child !== null && child.type === "type_parameter"
+  const typeParameter = children(node).find(
+    (child) => child.type === "type_parameter"
   );
-  return typeParameter?.namedChildren.filter(
-    (child) => child !== null && child.type === "type"
-  ) ?? [];
+  return children(typeParameter).filter((child) => child.type === "type");
 }
 function shapeFromGenericType(node, scope, ctx) {
   const base = node.namedChild(0);
@@ -773,22 +839,44 @@ function recordShapeRef(name, classNode, ctx) {
     return ref;
   }
   ctx.definitions.set(key, null);
+  ctx.definitions.set(key, {
+    type: "record",
+    properties: classFields(classNode, ctx, /* @__PURE__ */ new Set())
+  });
+  return ref;
+}
+function classFields(classNode, ctx, visiting) {
   const bodyNode = field(classNode, "body");
   const classScope = scopeOfNode(ctx, classNode);
-  ctx.definitions.set(
-    key,
-    bodyNode !== null && classScope !== void 0 ? recordShapeOf(bodyNode, classScope, ctx) : { type: "record", properties: {} }
+  if (bodyNode === null || classScope === void 0 || visiting.has(classNode.id)) {
+    return {};
+  }
+  visiting.add(classNode.id);
+  const inherited = baseClassNames(classNode).flatMap((name) => {
+    const base = projectClassNamed(name, classScope, ctx);
+    return base === null ? [] : [classFields(base, ctx, visiting)];
+  });
+  const own = recordShapeOf(bodyNode, classScope, ctx);
+  return Object.assign(
+    {},
+    ...inherited.reverse(),
+    own.type === "record" ? own.properties : {}
+  );
+}
+function baseClassNames(classNode) {
+  const superclasses = field(classNode, "superclasses");
+  return children(superclasses).flatMap(
+    (child) => child.type === "identifier" ? [child.text] : []
   );
-  return ref;
 }
 function recordShapeOf(bodyNode, classScope, ctx) {
   const properties = {};
-  for (const stmt of bodyNode.namedChildren) {
+  for (const stmt of children(bodyNode)) {
     if (stmt === null || stmt.type !== "expression_statement") {
       continue;
     }
-    const assignment2 = stmt.namedChildren.find(
-      (child) => child !== null && child.type === "assignment"
+    const assignment2 = children(stmt).find(
+      (child) => child.type === "assignment"
     );
     if (assignment2 === void 0 || assignment2 === null) {
       continue;
@@ -798,6 +886,9 @@ function recordShapeOf(bodyNode, classScope, ctx) {
     if (left === null || left.type !== "identifier" || typeNode === null) {
       continue;
     }
+    if (typeNameOf(typeNode) === "ClassVar") {
+      continue;
+    }
     properties[left.text] = annotationToShape(typeNode, classScope, ctx);
   }
   return { type: "record", properties };
@@ -807,13 +898,14 @@ function shortHash(text2) {
 }
 
 // src/decorators.ts
-var import_behavioral_ir = require("@suss/behavioral-ir");
+var import_behavioral_ir2 = require("@suss/behavioral-ir");
 
 // src/values/evaluator.ts
 var import_resolution4 = require("@suss/resolution");
 var import_values4 = require("@suss/values");
 
 // src/facts/resolve.ts
+var import_behavioral_ir = require("@suss/behavioral-ir");
 var import_resolution = require("@suss/resolution");
 var import_resolution2 = require("@suss/resolution");
 var evaluationsUnderSite = /* @__PURE__ */ new WeakMap();
@@ -859,7 +951,13 @@ function constructionSites(db, classKey) {
 }
 function writtenValueOf(db, key) {
   resolveWritten(db, [key]);
-  return (0, import_resolution.writtenValueOf)(db, key, (keys) => resolveWritten(db, keys));
+  return (0, import_resolution.writtenValueOf)(
+    db,
+    key,
+    (keys) => resolveWritten(db, keys),
+    void 0,
+    (0, import_resolution.answersFromTestsLeftOut)(key, import_behavioral_ir.isTestFile)
+  );
 }
 function writtenValuesOf(db, key) {
   resolveWritten(db, [key]);
@@ -950,6 +1048,8 @@ var CONVERTING_BUILTINS = /* @__PURE__ */ new Set([
   "str",
   "float"
 ]);
+var ATTRIBUTE_GETTER = "getattr";
+var POSITION_COUNTER = "enumerate";
 
 // src/facts/values.ts
 function nodeId(filePath, node) {
@@ -1121,8 +1221,7 @@ function emitConversion(emitter, call, callKey) {
     return;
   }
   const name = callee.text;
-  const builtin = nameKey(emitter.filePath, emitter.enclosing, name) === nameId(emitter.filePath, name) && !emitter.moduleNames().has(name);
-  if (builtin) {
+  if (isBuiltin(emitter, name)) {
     add(emitter, "converts", callKey, valueKey(emitter, first.node), name);
   }
 }
@@ -1171,6 +1270,7 @@ function emitSequence(emitter, sequence) {
   const objectKey = nodeId(emitter.filePath, sequence);
   add(emitter, "objectValue", objectKey);
   let position = 0;
+  const entries = [];
   for (const element of children(sequence)) {
     add(
       emitter,
@@ -1180,12 +1280,21 @@ function emitSequence(emitter, sequence) {
       valueKey(emitter, element)
     );
     position += 1;
+    if (element.type !== "comment") {
+      entries.push(writtenEntry(emitter, element));
+    }
   }
+  (0, import_resolution3.addEntryRows)(rowsOf(emitter), objectKey, entries);
 }
 function emitDictionary(emitter, dictionary) {
   const objectKey = nodeId(emitter.filePath, dictionary);
   add(emitter, "objectValue", objectKey);
+  const entries = [];
   for (const pair of children(dictionary)) {
+    if (SPREAD_TYPES.has(pair.type)) {
+      entries.push(writtenEntry(emitter, pair));
+      continue;
+    }
     if (pair.type !== "pair") {
       continue;
     }
@@ -1194,6 +1303,7 @@ function emitDictionary(emitter, dictionary) {
     if (key === null || value === null) {
       continue;
     }
+    entries.push(writtenEntry(emitter, value));
     if (key.type !== "string") {
       add(emitter, "holdsUnderKey", objectKey, valueKey(emitter, value));
       continue;
@@ -1206,6 +1316,15 @@ function emitDictionary(emitter, dictionary) {
       valueKey(emitter, value)
     );
   }
+  (0, import_resolution3.addEntryRows)(rowsOf(emitter), objectKey, entries);
+}
+var SPREAD_TYPES = /* @__PURE__ */ new Set(["list_splat", "dictionary_splat"]);
+function writtenEntry(emitter, entry) {
+  const unpacked = SPREAD_TYPES.has(entry.type) ? children(entry)[0] : void 0;
+  return unpacked === void 0 ? { key: valueKey(emitter, entry), form: import_resolution3.VALUE_ENTRY } : { key: valueKey(emitter, unpacked), form: import_resolution3.SPREAD_ENTRY };
+}
+function rowsOf(emitter) {
+  return (relation, row) => add(emitter, relation, ...row);
 }
 function emitAttribute(emitter, attribute) {
   const object = field(attribute, "object");
@@ -1270,13 +1389,50 @@ function emitKeyedRead(emitter, site, container, key) {
   if (WRITTEN_KEY_TYPES.has(key.type)) {
     return;
   }
-  add(
-    emitter,
-    "readsKeyed",
-    nodeId(emitter.filePath, site),
-    valueKey(emitter, container),
-    valueKey(emitter, key)
+  const siteKey = nodeId(emitter.filePath, site);
+  const containerKey = valueKey(emitter, container);
+  add(emitter, "readsKeyed", siteKey, containerKey, valueKey(emitter, key));
+  add(emitter, "choosesEntry", siteKey, containerKey);
+}
+function emitAttributeChoice(emitter, call) {
+  const callee = field(call, "function");
+  const [target, name] = callArguments(call);
+  if (callee?.type !== "identifier" || callee.text !== ATTRIBUTE_GETTER || !isBuiltin(emitter, callee.text) || target?.kind !== "positional" || name?.kind !== "positional") {
+    return;
+  }
+  const siteKey = nodeId(emitter.filePath, call);
+  const targetKey = valueKey(emitter, target.node);
+  const written = plainStringOf(name.node);
+  if (written !== null) {
+    add(emitter, "choosesNamedEntry", siteKey, targetKey, written);
+    return;
+  }
+  const ends = writtenEnds(name.node);
+  if (ends === null) {
+    add(emitter, "choosesEntry", siteKey, targetKey);
+    return;
+  }
+  add(emitter, "choosesEntryLike", siteKey, targetKey, ends.start, ends.end);
+}
+function writtenEnds(node) {
+  if (node.type !== "string") {
+    return null;
+  }
+  const parts = children(node).filter(
+    (part) => part.type !== "string_start" && part.type !== "string_end"
   );
+  const written = (part) => part.type === "string_content";
+  const firstComputed = parts.findIndex((part) => !written(part));
+  if (firstComputed === -1) {
+    return null;
+  }
+  const lastComputed = parts.length - 1 - [...parts].reverse().findIndex((part) => !written(part));
+  const start = parts.slice(0, firstComputed).map((part) => part.text).join("");
+  const end = parts.slice(lastComputed + 1).map((part) => part.text).join("");
+  return start === "" && end === "" ? null : { start, end };
+}
+function isBuiltin(emitter, name) {
+  return nameKey(emitter.filePath, emitter.enclosing, name) === nameId(emitter.filePath, name) && !emitter.moduleNames().has(name);
 }
 function emitWrittenKeyRead(emitter, site, container, key) {
   const name = plainStringOf(key);
@@ -1412,6 +1568,86 @@ function emitComprehensionElement(emitter, comprehension) {
     );
   }
 }
+var PAIR_TARGET_TYPES = /* @__PURE__ */ new Set(["pattern_list", "tuple_pattern"]);
+function emitElementVariables(emitter, clause) {
+  const target = field(clause, "left");
+  const over = field(clause, "right");
+  if (target === null || over === null) {
+    return;
+  }
+  const names = PAIR_TARGET_TYPES.has(target.type) ? children(target) : [];
+  const [position, element] = names;
+  const counted = countedCollection(emitter, over);
+  if (counted !== null && names.length === 2 && position?.type === "identifier" && element !== void 0) {
+    emitElementTaken(emitter, element, valueKey(emitter, counted), position);
+    return;
+  }
+  emitElementTaken(emitter, target, valueKey(emitter, over), null);
+}
+function emitElementTaken(emitter, target, overKey, position) {
+  const variables = target.type === "identifier" ? [{ node: target, part: null }] : partsTakenApart(target);
+  for (const variable of variables) {
+    const key = valueKey(emitter, variable.node);
+    if (variable.part === null) {
+      add(emitter, "elementOf", key, overKey);
+      continue;
+    }
+    add(emitter, "elementPartOf", key, overKey, variable.part);
+  }
+  const [first] = variables;
+  if (position !== null && first !== void 0) {
+    add(
+      emitter,
+      "positionOf",
+      valueKey(emitter, position),
+      valueKey(emitter, first.node)
+    );
+  }
+}
+function partsTakenApart(target) {
+  const parts = [];
+  if (!PAIR_TARGET_TYPES.has(target.type)) {
+    return parts;
+  }
+  for (const [position, part] of children(target).entries()) {
+    if (part.type === "list_splat_pattern") {
+      break;
+    }
+    if (part.type === "identifier") {
+      parts.push({ node: part, part: String(position) });
+    }
+  }
+  return parts;
+}
+function countedCollection(emitter, over) {
+  const callee = over.type === "call" ? field(over, "function") : null;
+  const args = field(over, "arguments");
+  const [first] = callArguments(over);
+  if (callee?.type !== "identifier" || callee.text !== POSITION_COUNTER || !isBuiltin(emitter, POSITION_COUNTER) || args === null || writtenArgumentCount(args) !== 1 || first?.kind !== "positional") {
+    return null;
+  }
+  return first.node;
+}
+function interpolatedPieces(emitter, string2) {
+  const parts = children(string2);
+  if (!parts.some((part) => part.type === "interpolation")) {
+    return [];
+  }
+  return parts.flatMap((part) => {
+    if (part.type === "string_content") {
+      return [{ text: stringContentValue(part) }];
+    }
+    const expression = part.type === "interpolation" ? field(part, "expression") ?? children(part)[0] : void 0;
+    return expression === void 0 ? [] : [{ hole: valueKey(emitter, expression) }];
+  });
+}
+function adjacentPieces(emitter, joined2) {
+  return children(joined2).filter((part) => part.type !== "comment").map((part) => ({ hole: valueKey(emitter, part) }));
+}
+var TEMPLATE_PIECES = {
+  string: interpolatedPieces,
+  concatenated_string: adjacentPieces
+};
 function emitExpressionFact(emitter, child, type) {
   if (type === "call") {
     emitCall(emitter, child);
@@ -1419,6 +1655,7 @@ function emitExpressionFact(emitter, child, type) {
     if (mapping !== null) {
       emitKeyedRead(emitter, child, mapping.container, mapping.key);
     }
+    emitAttributeChoice(emitter, child);
   }
   if (type === "subscript") {
     const index = singleSubscript(child);
@@ -1448,6 +1685,13 @@ function emitExpressionFact(emitter, child, type) {
   if (COMPREHENSION_TYPES.has(type)) {
     emitComprehensionElement(emitter, child);
   }
+  if (type === "for_in_clause") {
+    emitElementVariables(emitter, child);
+  }
+  const pieces = TEMPLATE_PIECES[type]?.(emitter, child) ?? [];
+  if (pieces.length > 0) {
+    (0, import_resolution3.addTemplateRows)(rowsOf(emitter), nodeId(emitter.filePath, child), pieces);
+  }
   const branches = fallbackBranchesOf(child, type);
   if (branches !== null) {
     for (const branch of branches) {
@@ -1480,10 +1724,10 @@ function emitExpressionFacts(emitter, node) {
   });
 }
 function yieldedValue(node) {
-  if (node.children.some((child) => child?.type === "from")) {
+  if (allChildren(node).some((child) => child.type === "from")) {
     return null;
   }
-  return node.namedChildren.find((child) => child?.type !== "comment") ?? null;
+  return children(node).find((child) => child?.type !== "comment") ?? null;
 }
 function emitFunctionFacts(emitter, fn, classKey) {
   const funcKey = nodeId(emitter.filePath, fn);
@@ -1555,7 +1799,7 @@ function emitFunctionFacts(emitter, fn, classKey) {
   const stores = /* @__PURE__ */ new Map();
   const visit = (child, type) => {
     if (type === "return_statement") {
-      const returned = child.namedChildren[0];
+      const returned = child.namedChild(0);
       if (returned != null) {
         add(inside, "returnsValue", funcKey, valueKey(inside, returned));
         statesReturn = true;
@@ -1966,6 +2210,9 @@ function readUnderName(emitter, statement, funcKey, accessed) {
 function emitNestedDefinitions(emitter, node) {
   for (const child of children(node)) {
     const type = child.type;
+    if (type === "decorated_definition") {
+      emitDecoratorCalls(emitter, child);
+    }
     if (FUNCTION_TYPES.has(type)) {
       emitFunctionFacts(emitter, child);
       if (emitter.enclosing !== null) {
@@ -1985,6 +2232,20 @@ function emitNestedDefinitions(emitter, node) {
     emitNestedDefinitions(emitter, child);
   }
 }
+function emitDecoratorCalls(emitter, decorated) {
+  const { definition, decorators } = stripDecorators(decorated);
+  let applied = nodeId(emitter.filePath, definition);
+  for (const decorator of [...decorators].reverse()) {
+    const [expression] = children(decorator);
+    if (expression === void 0) {
+      continue;
+    }
+    const callKey = nodeId(emitter.filePath, decorator);
+    add(emitter, "call", callKey, valueKey(emitter, expression));
+    add(emitter, "callArg", callKey, "0", applied);
+    applied = callKey;
+  }
+}
 var readingsByTree = /* @__PURE__ */ new WeakMap();
 function scopeReadingOf(fn, given) {
   const tree = fn.tree;
@@ -2593,9 +2854,7 @@ function stringExpression(node) {
 }
 function comparisonExpression(node) {
   const operands = children(node);
-  const operators = node.children.filter(
-    (child) => child !== null && !child.isNamed
-  );
+  const operators = allChildren(node).filter((child) => !child.isNamed);
   const operator = operators[0];
   if (operands.length !== 2 || operators.length !== 1 || operator === void 0) {
     return { kind: "opaque" };
@@ -2689,6 +2948,7 @@ var STATEMENT_TYPES = {
     kind: "return",
     value: children(node)[0] ?? null
   }),
+  raise_statement: (node) => caughtInSameFunction(node) ? OPAQUE : { kind: "throw" },
   try_statement: (node) => ({
     kind: "block",
     body: [
@@ -2777,6 +3037,19 @@ function blockStatements(block) {
 function isRoot(node) {
   return ROOT_TYPES.has(node.type);
 }
+var EXCEPT_CLAUSE_TYPES = /* @__PURE__ */ new Set(["except_clause", "except_group_clause"]);
+function caughtInSameFunction(node) {
+  let child = node;
+  let parent = node.parent;
+  while (parent !== null && !isRoot(parent)) {
+    if (parent.type === "try_statement" && field(parent, "body")?.id === child.id && children(parent).some((clause) => EXCEPT_CLAUSE_TYPES.has(clause.type))) {
+      return true;
+    }
+    child = parent;
+    parent = parent.parent;
+  }
+  return false;
+}
 function isPathStatement(node, parent) {
   return parent.type === "module" || parent.type === "block" || node.type === "elif_clause";
 }
@@ -3167,6 +3440,10 @@ function writtenNodeOf(node, db) {
   const bound = db === void 0 ? void 0 : projects.get(db);
   return bound?.context.writtenTo(node) ?? null;
 }
+function calledDefinition(call, db) {
+  const bound = db === void 0 ? void 0 : projects.get(db);
+  return bound?.context.callable(call) ?? null;
+}
 function resolutionKeyOf(node, db) {
   const bound = db === void 0 ? void 0 : projects.get(db);
   return bound?.keyOf(node) ?? null;
@@ -3389,7 +3666,7 @@ function argShapeOf(node) {
   if (node.type === "list") {
     return {
       kind: "list",
-      items: node.namedChildren.filter((child) => child !== null).map(readArg)
+      items: children(node).map(readArg)
     };
   }
   return { kind: "other" };
@@ -3400,10 +3677,7 @@ function readCallArguments(argumentList) {
   if (argumentList === null) {
     return { args, keywordArgs };
   }
-  for (const child of argumentList.namedChildren) {
-    if (child === null) {
-      continue;
-    }
+  for (const child of children(argumentList)) {
     if (child.type === "keyword_argument") {
       const nameNode = field(child, "name");
       const valueNode = field(child, "value");
@@ -3447,7 +3721,7 @@ function builtObjectCallee(built, attributeName, objectName) {
       return { importedName: attributeName, module: agreed, objectName };
     }
   };
-  return (0, import_behavioral_ir.dispatchByType)(table, built);
+  return (0, import_behavioral_ir2.dispatchByType)(table, built);
 }
 function resolveCallee(expr, module2, facts) {
   if (expr.type === "identifier") {
@@ -3529,10 +3803,10 @@ function unwrapDecorator(decoratorNode, facts) {
 }
 function passesParametersThrough(def, inner) {
   const params = field(def, "parameters");
-  const names = (params?.namedChildren ?? []).filter((child) => child?.type === "identifier").map((child) => child.text);
+  const names = children(params).filter((child) => child.type === "identifier").map((child) => child.text);
   const argumentList = field(inner, "arguments");
-  const positional = (argumentList?.namedChildren ?? []).filter(
-    (child) => child !== null && child.type !== "keyword_argument"
+  const positional = children(argumentList).filter(
+    (child) => child.type !== "keyword_argument"
   );
   return positional.length === names.length && positional.every(
     (argument, at) => argument.type === "identifier" && argument.text === names[at]
@@ -3540,13 +3814,14 @@ function passesParametersThrough(def, inner) {
 }
 
 // src/discovery.ts
-var import_behavioral_ir5 = require("@suss/behavioral-ir");
-var import_extractor7 = require("@suss/extractor");
-var import_values19 = require("@suss/values");
+var import_behavioral_ir6 = require("@suss/behavioral-ir");
+var import_extractor9 = require("@suss/extractor");
+var import_values20 = require("@suss/values");
 
 // src/clientCalls.ts
-var import_behavioral_ir2 = require("@suss/behavioral-ir");
-var import_values12 = require("@suss/values");
+var import_behavioral_ir3 = require("@suss/behavioral-ir");
+var import_extractor6 = require("@suss/extractor");
+var import_values14 = require("@suss/values");
 
 // src/paths/bodyBranches.ts
 var import_extractor4 = require("@suss/extractor");
@@ -3567,7 +3842,7 @@ var COMPARISONS = {
   "<=": "lte"
 };
 function operatorText(node) {
-  return node.children.filter((child) => child !== null && !child.isNamed).map((child) => child.text).join(" ");
+  return allChildren(node).filter((child) => !child.isNamed).map((child) => child.text).join(" ");
 }
 function valueRefOf(node, facts, inputs) {
   const value = evaluatedValue(node, facts);
@@ -3619,7 +3894,7 @@ function nullCheckOf(subject, negated2, facts, inputs) {
   };
 }
 function comparisonOf(node, facts, inputs) {
-  const [left, right] = node.namedChildren.filter(
+  const [left, right] = children(node).filter(
     (child) => child !== null
   );
   if (left === void 0 || right === void 0) {
@@ -3648,14 +3923,14 @@ function comparisonOf(node, facts, inputs) {
 }
 function predicateOf(node, facts, inputs) {
   if (node.type === "parenthesized_expression") {
-    const inner = node.namedChildren[0];
+    const inner = node.namedChild(0);
     return inner == null ? opaqueOf(node) : predicateOf(inner, facts, inputs);
   }
   if (node.type === "comparison_operator") {
     return comparisonOf(node, facts, inputs);
   }
   if (node.type === "not_operator") {
-    const operand2 = field(node, "argument") ?? node.namedChildren[0];
+    const operand2 = field(node, "argument") ?? node.namedChild(0);
     return operand2 == null ? opaqueOf(node) : { type: "negation", operand: predicateOf(operand2, facts, inputs) };
   }
   if (node.type === "identifier" || node.type === "attribute" || inputs?.has(node.id) === true) {
@@ -3670,11 +3945,11 @@ function predicateOf(node, facts, inputs) {
 var SUBJECT_TYPES = /* @__PURE__ */ new Set(["identifier", "attribute", "subscript"]);
 function operandsOf(node) {
   if (node.type === "parenthesized_expression" || node.type === "not_operator") {
-    const inner = field(node, "argument") ?? node.namedChildren[0];
+    const inner = field(node, "argument") ?? node.namedChild(0);
     return inner == null ? [] : operandsOf(inner);
   }
   if (node.type === "comparison_operator") {
-    return node.namedChildren.filter(
+    return children(node).filter(
       (child) => child !== null && SUBJECT_TYPES.has(child.type)
     );
   }
@@ -3700,7 +3975,7 @@ var NESTED_FUNCTION_TYPES = /* @__PURE__ */ new Set(["function_definition", "lam
 function exitKindOf(node, thrown) {
   let sawReturn = false;
   const raises = (current) => {
-    for (const child of current.namedChildren) {
+    for (const child of children(current)) {
       if (child === null || NESTED_FUNCTION_TYPES.has(child.type)) {
         continue;
       }
@@ -3728,12 +4003,10 @@ function blockStatements2(block) {
   if (block === null) {
     return [];
   }
-  return block.namedChildren.filter((child) => child !== null);
+  return children(block);
 }
 function childBlock(node) {
-  return node.namedChildren.find(
-    (child) => child !== null && child.type === "block"
-  ) ?? null;
+  return children(node).find((child) => child.type === "block") ?? null;
 }
 var Lowerer = class {
   // tree-sitter hands back a fresh wrapper object each time a child is
@@ -3782,7 +4055,7 @@ var Lowerer = class {
     return [nested];
   }
   lowerIf(node) {
-    const clauses = node.namedChildren.filter(
+    const clauses = children(node).filter(
       (child) => child !== null && (child.type === "elif_clause" || child.type === "else_clause")
     );
     return {
@@ -3794,10 +4067,10 @@ var Lowerer = class {
     };
   }
   lowerTry(node) {
-    const excepts = node.namedChildren.filter(
+    const excepts = children(node).filter(
       (child) => child !== null && (child.type === "except_clause" || child.type === "except_group_clause")
     );
-    const finallyClause = node.namedChildren.find(
+    const finallyClause = children(node).find(
       (child) => child !== null && child.type === "finally_clause"
     ) ?? null;
     return {
@@ -3813,7 +4086,7 @@ var Lowerer = class {
       (child) => child.type === "case_clause"
     );
     const groups = cases.map((clause) => {
-      const pattern = clause.namedChildren.find(
+      const pattern = children(clause).find(
         (child) => child !== null && child.type === "case_pattern"
       ) ?? null;
       return {
@@ -3894,7 +4167,7 @@ function literalArgOf(node, facts) {
   return null;
 }
 function bodyCalls(node, found = []) {
-  for (const child of node.namedChildren) {
+  for (const child of children(node)) {
     if (child === null || NESTED_DEFINITION_TYPES.has(child.type)) {
       continue;
     }
@@ -3906,7 +4179,7 @@ function bodyCalls(node, found = []) {
   return found;
 }
 function moduleLoadCalls(node, found = []) {
-  for (const child of node.namedChildren) {
+  for (const child of children(node)) {
     if (child === null || !runsAtModuleLoad(child)) {
       continue;
     }
@@ -3946,7 +4219,7 @@ function argumentNodes(call) {
   if (args === null) {
     return [];
   }
-  return args.namedChildren.filter((child) => child !== null).map(
+  return children(args).map(
     (child) => child.type === "keyword_argument" ? field(child, "value") ?? child : child
   );
 }
@@ -3957,6 +4230,9 @@ function calleeText(call) {
   return field(call, "function")?.text ?? call.text;
 }
 function invocationEffects(definitionNode, facts) {
+  return invocationSites(definitionNode, facts).map((site) => site.effect);
+}
+function invocationSites(definitionNode, facts) {
   const body = field(definitionNode, "body");
   if (body === null) {
     return [];
@@ -3964,14 +4240,18 @@ function invocationEffects(definitionNode, facts) {
   return invocationEffectsIn(body, bodyCalls(body), facts);
 }
 function moduleLoadInvocationEffects(moduleNode, facts) {
-  return invocationEffectsIn(moduleNode, moduleLoadCalls(moduleNode), facts);
+  return invocationEffectsIn(
+    moduleNode,
+    moduleLoadCalls(moduleNode),
+    facts
+  ).map((site) => site.effect);
 }
 var ASKED_ABOUT_TYPES = /* @__PURE__ */ new Set(["identifier", "attribute", "call"]);
 function askedNodesUnder(node, found = []) {
   if (ASKED_ABOUT_TYPES.has(node.type)) {
     found.push(node);
   }
-  for (const child of node.namedChildren) {
+  for (const child of children(node)) {
     if (child !== null && !NESTED_DEFINITION_TYPES.has(child.type)) {
       askedNodesUnder(child, found);
     }
@@ -4045,11 +4325,14 @@ function invocationEffectsIn(body, written, facts) {
       (condition) => predicateOf(condition, facts, inputs)
     );
     return {
-      type: "invocation",
-      callee: calleeText(call),
-      args: argsOf(call, facts),
-      async: false,
-      ...conditions.length > 0 ? { preconditions: conditions } : {}
+      call,
+      effect: {
+        type: "invocation",
+        callee: calleeText(call),
+        args: argsOf(call, facts),
+        async: false,
+        ...conditions.length > 0 ? { preconditions: conditions } : {}
+      }
     };
   });
 }
@@ -4084,7 +4367,7 @@ function statedBy(statement, name) {
   }
   if (statement.type === "as_pattern") {
     const alias = field(statement, "alias");
-    const value = statement.namedChildren[0] ?? null;
+    const value = statement.namedChild(0) ?? null;
     const callee = value?.type === "call" ? field(value, "function") : null;
     return alias?.text === name ? callee : null;
   }
@@ -4280,7 +4563,7 @@ function importedFunctionMatch(call, options) {
     return null;
   }
   const args = field(call, "arguments");
-  const first = args?.namedChildren.find((child) => child !== null) ?? null;
+  const first = children(args)[0] ?? null;
   const statement = first === null ? null : writtenStatement(first, void 0, options.facts);
   if (statement === null) {
     return null;
@@ -4644,7 +4927,7 @@ function columnComparisons(node) {
     const args = field(node, "arguments");
     return (args === null ? [] : children(args)).flatMap(columnComparisons);
   }
-  const operator = node.children.find((child) => !child?.isNamed);
+  const operator = allChildren(node).find((child) => !child.isNamed);
   const [left, right, ...rest] = children(node);
   if (node.type !== "comparison_operator" || operator?.type !== "==" || left === void 0 || right === void 0 || rest.length > 0) {
     return [];
@@ -4663,13 +4946,37 @@ function modelColumn(node) {
   }
   return field(node, "attribute")?.text ?? null;
 }
-function selectorOf(chain, valueMethods) {
+function selectorOf(chain, valueMethods, model) {
+  const picking = laterCalls(chain).filter(
+    (call) => !valueMethods.includes(methodNameOf(call))
+  );
   return [
-    ...new Set(
-      laterCalls(chain).filter((call) => !valueMethods.includes(methodNameOf(call))).flatMap((call) => pickedBy(call).map((one) => one.name))
-    )
+    .../* @__PURE__ */ new Set([
+      ...picking.flatMap((call) => pickedBy(call).map((one) => one.name)),
+      ...model === null ? [] : picking.flatMap((call) => columnsComparedBy(call, model))
+    ])
   ];
 }
+var COMBINED_TESTS = ["and_", "or_", "not_"];
+function columnsComparedBy(call, model) {
+  const args = field(call, "arguments");
+  return (args === null ? [] : children(args)).flatMap(
+    (argument) => columnsCompared(argument, model)
+  );
+}
+function columnsCompared(node, model) {
+  if (node.type === "call" && COMBINED_TESTS.includes(methodNameOf(node))) {
+    return columnsComparedBy(node, model);
+  }
+  if (node.type !== "comparison_operator") {
+    return [];
+  }
+  return children(node).flatMap((side) => {
+    const object = side.type === "attribute" ? field(side, "object") : null;
+    const column = object?.text === model ? field(side, "attribute") : null;
+    return column === null ? [] : [column.text];
+  });
+}
 var TABLE_METHODS = ["select_from", "join"];
 function modelOf(chain, options) {
   const fromRoot = modelArgument(chain.root, chain.root, options);
@@ -4734,14 +5041,15 @@ function isClassName(name) {
 }
 function effectFor2(pattern, chain, operation, options) {
   const valueMethods = pattern.valueMethods ?? [];
-  const picked = selectorOf(chain, valueMethods);
+  const model = modelOf(chain, options);
+  const picked = selectorOf(chain, valueMethods, model);
   const effect = {
     type: "interaction",
     binding: (0, import_ir_core2.storageBinding)({
       recognition: "python-storage",
       storageSystem: pattern.storageSystem,
       scope: "default",
-      container: modelOf(chain, options)
+      container: model
     }),
     callee: chain.last.text,
     interaction: {
@@ -5017,10 +5325,7 @@ function literalAt(key, facts) {
 
 // src/paths/bodyBranches.ts
 function returnStatements(node, found = []) {
-  for (const child of node?.namedChildren ?? []) {
-    if (child === null) {
-      continue;
-    }
+  for (const child of children(node)) {
     if (child.type === "function_definition" || child.type === "lambda") {
       continue;
     }
@@ -5077,7 +5382,8 @@ function enumerateBodyBranches(options) {
   const enumerated = (0, import_extractor4.enumerateOrDegrade)(
     {
       statements: lowered.statements,
-      terminalsByStmt: lowered.terminalsByStmt
+      terminalsByStmt: lowered.terminalsByStmt,
+      ...options.keepsArms === void 0 ? {} : { keepsArms: options.keepsArms }
     },
     statements
   );
@@ -5114,57 +5420,287 @@ function enumerateBodyBranches(options) {
   return branches;
 }
 
-// src/clientCalls.ts
-function clientCallUnits(root, module2, pack, pattern, options) {
-  const units = [];
-  for (const definition of functionDefinitions(root)) {
-    const name = field(definition, "name")?.text;
-    if (name === void 0) {
-      continue;
-    }
-    for (const call of bodyCalls(definition)) {
-      for (const request of requestCalls(call, pattern, module2, options)) {
-        units.push(
-          clientUnit(definition, name, request, pattern, pack, options)
-        );
-      }
-    }
+// src/paths/raisedResponses.ts
+var import_values12 = require("@suss/values");
+function statusNumberOf(node, options) {
+  const value = (0, import_values12.constantOf)(evaluatedValue(node, options.facts));
+  if (typeof value === "number") {
+    return value;
   }
-  return units;
+  const origin = originOf(node, options.module);
+  return origin === null ? null : options.constants?.[`${origin.module}.${origin.name}`] ?? null;
 }
-function clientCallReceivers(root, module2) {
+var NESTED_DEFINITION_TYPES2 = /* @__PURE__ */ new Set(["function_definition", "lambda"]);
+function raisedResponses(body, options) {
+  if (options.calls.length === 0) {
+    return [];
+  }
+  return raisesIn(body, options);
+}
+function raisesIn(body, options) {
+  if (body === null) {
+    return [];
+  }
   const found = [];
-  for (const definition of functionDefinitions(root)) {
-    for (const call of bodyCalls(definition)) {
-      const callee = field(call, "function");
-      if (callee === null || originOf(callee, module2) !== null) {
+  const walk = (node) => {
+    for (const child of children(node)) {
+      if (child === null || NESTED_DEFINITION_TYPES2.has(child.type)) {
         continue;
       }
-      const object = field(callee, "object");
-      if (object !== null && field(callee, "attribute") !== null) {
-        found.push(object);
+      const response = raisedResponseOf(child, options);
+      if (response !== null) {
+        found.push(response);
       }
+      walk(child);
     }
-  }
+  };
+  walk(body);
   return found;
 }
-function functionDefinitions(node, found = []) {
-  for (const child of children(node)) {
-    if (isFunction(child)) {
-      found.push(child);
-    }
-    functionDefinitions(child, found);
+var ENDING_EXPRESSION = {
+  raise_statement: (statement) => statement.namedChild(0) ?? null,
+  expression_statement: (statement) => {
+    const only = statement.namedChild(0);
+    return only?.type === "call" ? only : null;
   }
-  return found;
-}
-function requestCalls(call, pattern, module2, options) {
-  const callee = field(call, "function");
-  const attribute = callee === null ? null : calledAttribute(callee, pattern, module2, options.facts);
-  if (attribute === null) {
-    return [];
+};
+function raisedResponseOf(statement, options) {
+  const expression = ENDING_EXPRESSION[statement.type]?.(statement) ?? null;
+  if (expression === null) {
+    return null;
   }
-  const plain = requestCall(call, attribute, pattern, options);
-  if (plain !== null && !(0, import_behavioral_ir2.hasNameHole)(plain.path)) {
+  const thrownByCall = statement.type !== "raise_statement";
+  const prebuilt = thrownByCall ? null : prebuiltCallOf(expression, options);
+  if (prebuilt !== null) {
+    return {
+      statement,
+      thrownByCall,
+      terminal: terminalOf(
+        statement,
+        calleeOf(prebuilt.call, prebuilt.call),
+        prebuilt.call,
+        prebuilt.declared,
+        prebuilt.options
+      )
+    };
+  }
+  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)
+  };
+}
+function prebuiltCallOf(expression, options) {
+  if (expression.type !== "identifier" && expression.type !== "attribute") {
+    return null;
+  }
+  const written = writtenNodeOf(expression, options.facts);
+  if (written === null || written.type !== "call") {
+    return null;
+  }
+  const inItsFile = { ...options, module: moduleOf(written) };
+  const declared = declaredCallFor(calleeOf(written, written), inItsFile);
+  return declared === void 0 ? null : { call: written, declared, options: inItsFile };
+}
+function returnedResponseStatus(statement, options) {
+  const returned = statement.namedChild(0);
+  if (options.calls.length === 0 || returned === void 0 || returned === null || returned.type !== "call") {
+    return null;
+  }
+  const callee = field(returned, "function");
+  if (callee === null) {
+    return null;
+  }
+  const declared = declaredCallFor(callee, options);
+  return declared === void 0 ? null : statusOf(declared, returned, options);
+}
+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, options) {
+  return {
+    kind: "throw",
+    statusCode: declared === void 0 ? null : statusOf(declared, call, options),
+    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 lastSegmentOf(dotted) {
+  const segment = dotted.split(".").pop();
+  return segment === void 0 || segment === "" ? null : segment;
+}
+function statusOf(declared, call, options) {
+  const written = call === null ? null : statusArgumentOf(declared, call);
+  if (written === null) {
+    return declared.defaultStatusCode === void 0 ? null : { type: "literal", value: declared.defaultStatusCode };
+  }
+  const value = statusNumberOf(written, options);
+  return value === null ? { type: "dynamic", sourceText: written.text } : { type: "literal", value };
+}
+function argumentsOf2(call) {
+  return children(field(call, "arguments"));
+}
+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 (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;
+}
+
+// src/responseHandOff.ts
+var import_extractor5 = require("@suss/extractor");
+function throughResponseHelpers(branches, sites, options) {
+  const handOffs = [];
+  for (const { call, effect } of sites) {
+    const helper = helperBranchesAt(call, options);
+    if (helper !== null) {
+      handOffs.push({
+        helper,
+        preconditions: effect.preconditions,
+        line: rangeOf(call).start,
+        at: rangeOf(call)
+      });
+    }
+  }
+  return handOffs.length === 0 ? [...branches] : branches.flatMap((branch) => (0, import_extractor5.splitAtHandOffs)(branch, handOffs));
+}
+function helperBranchesAt(call, options) {
+  const handed = callArguments(call).filter(
+    (argument) => argument.node.type === "identifier" && refersToResponse(argument.node, options)
+  );
+  if (handed.length === 0) {
+    return null;
+  }
+  const helper = calledDefinition(call, options.facts);
+  if (helper === null || helper.type !== "function_definition") {
+    return null;
+  }
+  const passed = /* @__PURE__ */ new Map();
+  const parameters = parameterShapes(helper, isMethod(helper) ? 1 : 0);
+  for (const argument of handed) {
+    const parameter = parameters.find(
+      (one) => argument.kind === "positional" ? one.position === argument.position : one.name === argument.name
+    );
+    if (parameter !== void 0) {
+      passed.set(parameter.name, argument.node.text);
+    }
+  }
+  return passed.size === 0 ? null : (0, import_extractor5.helperPathsOnVariables)(options.readHelper(helper), passed);
+}
+function refersToResponse(name, options) {
+  const written = awaited(writtenNodeOf(name, options.facts));
+  if (written === null) {
+    return false;
+  }
+  if (sameNode(written, options.request)) {
+    return true;
+  }
+  const callee = written.type === "call" ? field(written, "function") : null;
+  const method = callee === null ? null : field(callee, "attribute");
+  const receiver = callee === null ? null : field(callee, "object");
+  if (method === null || receiver?.type !== "identifier" || !options.bodyMethods.includes(method.text)) {
+    return false;
+  }
+  const parsedFrom = awaited(writtenNodeOf(receiver, options.facts));
+  return parsedFrom !== null && sameNode(parsedFrom, options.request);
+}
+function awaited(node) {
+  return node?.type === "await" ? node.namedChild(0) ?? null : node;
+}
+function sameNode(a, b) {
+  return a.startIndex === b.startIndex && a.endIndex === b.endIndex && a.tree === b.tree;
+}
+
+// src/clientCalls.ts
+function clientCallUnits(root, module2, pack, pattern, options) {
+  const units = [];
+  for (const definition of functionDefinitions(root)) {
+    const name = field(definition, "name")?.text;
+    if (name === void 0) {
+      continue;
+    }
+    for (const call of bodyCalls(definition)) {
+      for (const request of requestCalls(call, pattern, module2, options)) {
+        units.push(
+          clientUnit(definition, name, request, pattern, pack, options)
+        );
+      }
+    }
+  }
+  return units;
+}
+function clientCallReceivers(root, module2) {
+  const found = [];
+  for (const definition of functionDefinitions(root)) {
+    for (const call of bodyCalls(definition)) {
+      const callee = field(call, "function");
+      if (callee === null || originOf(callee, module2) !== null) {
+        continue;
+      }
+      const object = field(callee, "object");
+      if (object !== null && field(callee, "attribute") !== null) {
+        found.push(object);
+      }
+    }
+  }
+  return found;
+}
+function functionDefinitions(node, found = []) {
+  for (const child of children(node)) {
+    if (isFunction(child)) {
+      found.push(child);
+    }
+    functionDefinitions(child, found);
+  }
+  return found;
+}
+function requestCalls(call, pattern, module2, options) {
+  const callee = field(call, "function");
+  const attribute = callee === null ? null : calledAttribute(callee, pattern, module2, options.facts);
+  if (attribute === null) {
+    return [];
+  }
+  const plain = requestCall(call, attribute, pattern, options);
+  if (plain !== null && !(0, import_behavioral_ir3.hasNameHole)(plain.path)) {
     return [plain];
   }
   const byBoundary = /* @__PURE__ */ new Map();
@@ -5173,7 +5709,7 @@ function requestCalls(call, pattern, module2, options) {
     if (stated === null) {
       continue;
     }
-    const key = `${stated.method} ${stated.path}`;
+    const key = `${stated.method} ${stated.host ?? ""} ${stated.path}`;
     if (!byBoundary.has(key)) {
       byBoundary.set(key, stated);
     }
@@ -5184,16 +5720,33 @@ function requestCalls(call, pattern, module2, options) {
   return plain === null ? [] : [plain];
 }
 function requestCall(call, attribute, pattern, options, site) {
+  const stated = methodAndPath(call, attribute, pattern, options, site);
+  if (stated === null) {
+    return null;
+  }
+  const redirectDelivery = redirectDeliveryAt(call, pattern, options, site);
+  return redirectDelivery === void 0 ? stated : { ...stated, redirectDelivery };
+}
+function redirectDeliveryAt(call, pattern, options, site) {
+  const option = pattern.response?.redirectOption;
+  const argument = option === void 0 ? null : argumentAt(call, null, option.name);
+  if (option === void 0 || argument === null) {
+    return void 0;
+  }
+  const value = (0, import_values14.scalarOf)(evaluatedValue(argument, options.facts, site));
+  return value === null ? void 0 : (0, import_extractor6.redirectDeliveryWhenSet)(option, value);
+}
+function methodAndPath(call, attribute, pattern, options, site) {
   const verb = pattern.verbAttributeNames[attribute];
   if (verb !== void 0) {
-    const path9 = urlAt(
+    const target2 = urlAt(
       call,
       pattern.url.position,
       pattern.url.keyword,
       options,
       site
     );
-    return path9 === null ? null : { method: verb, path: path9, range: rangeOf(call) };
+    return target2 === null ? null : { method: verb, ...target2, range: rangeOf(call), node: call };
   }
   const methodCall = pattern.methodCall;
   if (methodCall === void 0 || methodCall.attribute !== attribute) {
@@ -5208,14 +5761,19 @@ function requestCall(call, attribute, pattern, options, site) {
   if (method === null) {
     return null;
   }
-  const path8 = urlAt(
+  const target = urlAt(
     call,
     methodCall.urlPosition,
     pattern.url.keyword,
     options,
     site
   );
-  return path8 === null ? null : { method: method.toUpperCase(), path: path8, range: rangeOf(call) };
+  return target === null ? null : {
+    method: method.toUpperCase(),
+    ...target,
+    range: rangeOf(call),
+    node: call
+  };
 }
 function calledAttribute(callee, pattern, module2, facts) {
   const origin = originOf(callee, module2);
@@ -5248,7 +5806,9 @@ function urlAt(call, position, keyword, options, site) {
   if (argument === null) {
     return null;
   }
-  return (0, import_values12.pathOf)(evaluatedValue(argument, options.facts, site)) ?? null;
+  const value = evaluatedValue(argument, options.facts, site);
+  const path8 = (0, import_values14.pathOf)(value);
+  return path8 === void 0 ? null : { path: path8, host: (0, import_values14.hostOf)(value) };
 }
 function argumentAt(call, position, keyword) {
   const args = field(call, "arguments");
@@ -5266,25 +5826,33 @@ function argumentAt(call, position, keyword) {
     }
     positional.push(child);
   }
-  return positional[position] ?? null;
+  return position === null ? null : positional[position] ?? null;
 }
-function callerBranches(definition, range, facts) {
+function callerBranches(definition, reading) {
+  const range = rangeOf(definition);
   const body = field(definition, "body");
-  const effects = invocationEffects(definition, facts);
-  const terminals = bodyTerminals(body, []);
-  if (body === null || terminals.length === 0) {
+  const sites = invocationSites(definition, reading.facts);
+  const effects = sites.map((site) => site.effect);
+  if (body === null) {
     return [handsBack(range, effects)];
   }
+  const raised = raisesIn(body, {
+    calls: [],
+    module: moduleOf(definition),
+    facts: reading.facts
+  });
   const branches = enumerateBodyBranches({
     body,
-    terminals,
-    raised: [],
+    terminals: bodyTerminals(body, raised),
+    raised,
     effects,
-    branchOf: (found) => found.type === "raise" ? { terminal: found.terminal, location: rangeOf(found.statement) } : handsBackAt(rangeOf(found.statement)),
+    branchOf: (found2) => found2.type === "raise" ? { terminal: found2.terminal, location: rangeOf(found2.statement) } : handsBackAt(rangeOf(found2.statement)),
     fallthrough: handsBackAt(range),
-    facts
+    facts: reading.facts,
+    keepsArms: (condition) => (0, import_behavioral_ir3.testsStatus)(predicateOf(condition, reading.facts), reading.statusMembers)
   });
-  return branches.length === 0 ? [handsBack(range, effects)] : branches;
+  const found = branches.length === 0 ? [handsBack(range, effects)] : branches;
+  return reading.handOff === void 0 ? found : throughResponseHelpers(found, sites, reading.handOff);
 }
 function handsBackAt(range) {
   return {
@@ -5320,11 +5888,24 @@ function responseAccessors(pattern) {
     ...response.body === void 0 ? {} : { bodyAccessors: response.body },
     ...response.statusCode === void 0 ? {} : { statusAccessors: response.statusCode },
     ...response.success === void 0 ? {} : { successAccessors: response.success },
-    ...response.failureDelivery === void 0 ? {} : { failureDelivery: response.failureDelivery }
+    ...response.failureDelivery === void 0 ? {} : { failureDelivery: response.failureDelivery },
+    ...response.redirectDelivery === void 0 ? {} : { redirectDelivery: response.redirectDelivery }
   };
 }
 function clientUnit(definition, name, request, pattern, pack, options) {
   const range = rangeOf(definition);
+  const accessors = responseAccessors(pattern);
+  const statusMembers = (0, import_behavioral_ir3.statusMembersOf)(accessors);
+  const reading = {
+    facts: options.facts,
+    statusMembers,
+    handOff: {
+      request: request.node,
+      bodyMethods: accessors.bodyAccessors ?? [],
+      facts: options.facts,
+      readHelper: (helper) => callerBranches(helper, { facts: options.facts, statusMembers })
+    }
+  };
   return {
     identity: {
       name,
@@ -5336,15 +5917,17 @@ function clientUnit(definition, name, request, pattern, pack, options) {
       exportName: name,
       exportPath: [name]
     },
-    boundaryBinding: (0, import_behavioral_ir2.restBinding)({
+    boundaryBinding: (0, import_behavioral_ir3.restBinding)({
       transport: pack.protocol,
       method: request.method,
       path: request.path,
+      host: request.host,
       recognition: pack.name
     }),
     parameters: [],
-    branches: callerBranches(definition, range, options.facts),
-    ...responseAccessors(pattern),
+    branches: callerBranches(definition, reading),
+    ...accessors,
+    ...request.redirectDelivery === void 0 ? {} : { redirectDelivery: request.redirectDelivery },
     bodyContent: "statements",
     dependencyCalls: [],
     declaredContract: null
@@ -5388,8 +5971,8 @@ function routeOnDroppedApp(facts, object, constructionKey, pattern) {
 }
 
 // src/envReads.ts
-var import_behavioral_ir3 = require("@suss/behavioral-ir");
-var import_extractor5 = require("@suss/extractor");
+var import_behavioral_ir4 = require("@suss/behavioral-ir");
+var import_extractor7 = require("@suss/extractor");
 var import_resolution7 = require("@suss/resolution");
 
 // src/envSpellings.ts
@@ -5567,7 +6150,7 @@ function isTestedAt(parent, child, subject, seen) {
 }
 function conditionOf(node) {
   if (node.type === "conditional_expression") {
-    return node.namedChildren[1] ?? null;
+    return node.namedChild(1) ?? null;
   }
   return CONDITIONED_TYPES.has(node.type) ? field(node, "condition") : null;
 }
@@ -5590,7 +6173,7 @@ function isPresentAt(node, subject) {
 }
 function isBranchWherePresent(parent, child, subject) {
   if (parent.type === "conditional_expression") {
-    const [whenTrue, test2, whenFalse] = parent.namedChildren;
+    const [whenTrue, test2, whenFalse] = children(parent);
     return test2 !== void 0 && test2 !== null && (whenTrue?.id === child.id && isPresentWhen(test2, true, subject) || whenFalse?.id === child.id && isPresentWhen(test2, false, subject));
   }
   if (parent.type === "boolean_operator") {
@@ -5628,7 +6211,7 @@ function followsExitWhenAbsent(parent, child, subject) {
   if (parent.type !== "block" && parent.type !== "module") {
     return false;
   }
-  const statements = parent.namedChildren;
+  const statements = children(parent);
   const at = statements.findIndex((statement) => statement?.id === child.id);
   return statements.slice(0, at).some(
     (statement) => statement !== null && leavesWhenAbsent(statement, subject)
@@ -5672,7 +6255,7 @@ function continuationRaises(from) {
   let parent = current.parent;
   while (parent !== null) {
     if (parent.type === "block" || parent.type === "module") {
-      const statements = parent.namedChildren;
+      const statements = children(parent);
       const at = statements.findIndex((one) => one?.id === current.id);
       const exit = firstExit(statements.slice(at + 1));
       if (exit !== null) {
@@ -5716,7 +6299,7 @@ function exitOf(statement) {
   if (LEAVING_TYPES.has(statement.type)) {
     return "leave";
   }
-  return statement.type === "block" ? firstExit(statement.namedChildren) : null;
+  return statement.type === "block" ? firstExit(children(statement)) : null;
 }
 function isPresentWhen(test, outcome, subject) {
   const expression = peelParens(test);
@@ -5756,7 +6339,7 @@ function isPresentAfterComparison(comparison, outcome, subject) {
 }
 function comparisonParts(comparison) {
   const operators = fields(comparison, "operators");
-  const operands = comparison.namedChildren.filter(
+  const operands = children(comparison).filter(
     (child) => child !== null && !operators.some((one) => one.id === child.id)
   );
   const [left, right] = operands;
@@ -5779,7 +6362,7 @@ function comparedWithNone(comparison) {
 }
 var NONE_OPERATORS = /* @__PURE__ */ new Set(["is", "is not", "==", "!="]);
 function peelParens(node) {
-  const inner = node.type === "parenthesized_expression" ? node.namedChildren[0] : null;
+  const inner = node.type === "parenthesized_expression" ? node.namedChild(0) : null;
   return inner === null || inner === void 0 ? node : peelParens(inner);
 }
 function climbParens(node) {
@@ -5837,7 +6420,7 @@ function envReadEffects(root, module2, facts) {
   const slots = [];
   const readsHelpers = facts !== void 0 && sitesByDb.has(facts);
   const startScope = module2.scopeFor.get(root.id) ?? module2.moduleScope;
-  (0, import_extractor5.walkDescendants)(root, startScope, {
+  (0, import_extractor7.walkDescendants)(root, startScope, children, {
     at: (node, scope) => {
       const syntax = envReadSyntaxAt(node, scope);
       if (syntax !== null) {
@@ -5853,7 +6436,7 @@ function envReadEffects(root, module2, facts) {
     },
     into: (node, scope) => {
       if (DEFERRED_BODY_TYPES.has(node.type)) {
-        return import_extractor5.SKIP_CHILDREN;
+        return import_extractor7.SKIP_CHILDREN;
       }
       return module2.scopeFor.get(node.id) ?? scope;
     }
@@ -5872,7 +6455,7 @@ function envReadEffects(root, module2, facts) {
 function configReadEffect(read) {
   return {
     type: "interaction",
-    binding: (0, import_behavioral_ir3.runtimeConfigBinding)({ recognition: PYTHON_ENV_RECOGNITION }),
+    binding: (0, import_behavioral_ir4.runtimeConfigBinding)({ recognition: PYTHON_ENV_RECOGNITION }),
     callee: `os.environ["${read.name}"]`,
     interaction: {
       class: "config-read",
@@ -5896,7 +6479,7 @@ function hasFallback(node, spelling, scope) {
 }
 function envFactsIn(filePath, root, module2) {
   const found = { sites: [], objects: [] };
-  (0, import_extractor5.walkDescendants)(root, module2.moduleScope, {
+  (0, import_extractor7.walkDescendants)(root, module2.moduleScope, children, {
     at: (node, scope) => {
       if (isEnviron(node, scope) && handsOnward(node)) {
         found.objects.push(keyOf(filePath, node));
@@ -6114,137 +6697,6 @@ function readsThroughHelper(db, call, argumentAt2, siteById, named) {
   );
 }
 
-// src/paths/raisedResponses.ts
-var import_values17 = require("@suss/values");
-var NESTED_DEFINITION_TYPES2 = /* @__PURE__ */ new Set(["function_definition", "lambda"]);
-function raisedResponses(body, options) {
-  if (body === null || options.calls.length === 0) {
-    return [];
-  }
-  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;
-  }
-};
-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 returnedResponseStatus(statement, options) {
-  const returned = statement.namedChildren[0];
-  if (options.calls.length === 0 || returned === void 0 || returned === null || returned.type !== "call") {
-    return null;
-  }
-  const callee = field(returned, "function");
-  if (callee === null) {
-    return null;
-  }
-  const declared = declaredCallFor(callee, options);
-  return declared === void 0 ? null : statusOf(declared, returned, options.facts);
-}
-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: "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 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 = (0, import_values17.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 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 (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;
-}
-
 // src/paths/returnedShape.ts
 var MAX_DEPTH = 6;
 var SCALARS = {
@@ -6304,7 +6756,7 @@ function shapeOfReturned(node, depth = 0) {
   return { type: "unknown" };
 }
 function returnedBodyShape(statement) {
-  const returned = statement.namedChildren[0];
+  const returned = statement.namedChild(0);
   if (returned == null) {
     return null;
   }
@@ -6317,8 +6769,8 @@ function returnedBodyShape(statement) {
 }
 
 // src/streamWrites.ts
-var import_behavioral_ir4 = require("@suss/behavioral-ir");
-var import_extractor6 = require("@suss/extractor");
+var import_behavioral_ir5 = require("@suss/behavioral-ir");
+var import_extractor8 = require("@suss/extractor");
 
 // src/stdlibNames.ts
 function isStdlibModule(node, scope, module2) {
@@ -6328,7 +6780,7 @@ function isStdlibModule(node, scope, module2) {
   const binding = resolveName(scope, node.text);
   return binding?.kind === "import" && binding.module === module2 && binding.relativeLevel === 0;
 }
-function isBuiltin(node, scope, name) {
+function isBuiltin2(node, scope, name) {
   return node.type === "identifier" && node.text === name && resolveName(scope, name) === null;
 }
 function isStdlibMember(node, scope, module2, name) {
@@ -6350,7 +6802,7 @@ var DEFERRED_BODY_TYPES2 = /* @__PURE__ */ new Set(["function_definition", "lamb
 function streamWriteEffects(root, module2) {
   const found = [];
   const startScope = module2.scopeFor.get(root.id) ?? module2.moduleScope;
-  (0, import_extractor6.walkDescendants)(root, startScope, {
+  (0, import_extractor8.walkDescendants)(root, startScope, children, {
     at: (node, scope) => {
       if (node.type !== "call") {
         return;
@@ -6362,7 +6814,7 @@ function streamWriteEffects(root, module2) {
     },
     into: (node, scope) => {
       if (DEFERRED_BODY_TYPES2.has(node.type)) {
-        return import_extractor6.SKIP_CHILDREN;
+        return import_extractor8.SKIP_CHILDREN;
       }
       return module2.scopeFor.get(node.id) ?? scope;
     }
@@ -6376,7 +6828,7 @@ function streamWriteAt(call, scope) {
   }
   const written = callArguments(call);
   const positional = written.filter((argument) => argument.kind === "positional").map((argument) => argument.node);
-  if (callee.type === "identifier" && isBuiltin(callee, scope, "print")) {
+  if (callee.type === "identifier" && isBuiltin2(callee, scope, "print")) {
     const file = written.find(
       (argument) => argument.kind === "keyword" && argument.name === "file"
     );
@@ -6398,7 +6850,7 @@ function writeEffect(site) {
   const { call, callee, target } = site;
   return {
     type: "interaction",
-    binding: (0, import_behavioral_ir4.ioBinding)({ recognition: PYTHON_STREAM_RECOGNITION, target }),
+    binding: (0, import_behavioral_ir5.ioBinding)({ recognition: PYTHON_STREAM_RECOGNITION, target }),
     callee,
     groupId: `${call.startPosition.row + 1}:${call.startPosition.column + 1}`,
     interaction: {
@@ -6437,7 +6889,7 @@ function jsonDumped(node, scope) {
 // src/discovery.ts
 function decoratedNodes(root) {
   const found = [];
-  (0, import_extractor7.walkDescendants)(root, null, {
+  (0, import_extractor9.walkDescendants)(root, null, children, {
     at: (node) => {
       if (node.type !== "decorated_definition") {
         return;
@@ -6588,18 +7040,18 @@ function unitsFor(pattern, pack, decoratorModule, classification, definition, mo
       );
     }
   };
-  return (0, import_behavioral_ir5.dispatchByType)(table, pattern);
+  return (0, import_behavioral_ir6.dispatchByType)(table, pattern);
 }
 function readPathArgument(classification, options) {
   const first = classification.args[0];
   if (first !== void 0) {
     const value = evaluatedValue(first.node, options.facts);
-    const path8 = (0, import_values19.literalOf)(value) ?? (0, import_values19.pathOf)(value);
+    const path8 = (0, import_values20.literalOf)(value) ?? (0, import_values20.pathOf)(value);
     if (path8 !== void 0) {
-      return (0, import_extractor7.writtenReading)(path8, classification.range);
+      return (0, import_extractor9.writtenReading)(path8, classification.range);
     }
   }
-  return (0, import_extractor7.unreadableReading)(
+  return (0, import_extractor9.unreadableReading)(
     "The path in this route's decorator is not a string literal, so the binding names no path and nothing pairs with it",
     classification.range
   );
@@ -6624,16 +7076,16 @@ var PATH_TEMPLATE_READERS = {
 function readPathTemplate(pattern, path8, range) {
   const syntax = pattern.pathParamSyntax;
   if (syntax === void 0) {
-    return (0, import_extractor7.writtenReading)({ path: path8, paramNames: NO_PATH_PARAMS }, range);
+    return (0, import_extractor9.writtenReading)({ path: path8, paramNames: NO_PATH_PARAMS }, range);
   }
   const reader = PATH_TEMPLATE_READERS[syntax];
   if (reader === void 0) {
-    return (0, import_extractor7.unreadableReading)(
+    return (0, import_extractor9.unreadableReading)(
       `The route's pack declares path-parameter syntax "${syntax}", which this adapter has no reader for, so the binding names no path and nothing pairs with it`,
       range
     );
   }
-  return (0, import_extractor7.writtenReading)(reader(path8), range);
+  return (0, import_extractor9.writtenReading)(reader(path8), range);
 }
 function classRouteUnits(pattern, pack, classification, classNode, module2, options) {
   const pathArgument = readPathArgument(classification, options);
@@ -6684,7 +7136,7 @@ function classRouteUnits(pattern, pack, classification, classNode, module2, opti
             module: module2,
             filePath: options.filePath,
             skipReceiverParam: true,
-            responseShape: import_extractor7.absentReading,
+            responseShape: import_extractor9.absentReading,
             statusCode: defaultedStatus(
               readReturnedStatus(pattern, maybeMethod, {
                 module: module2,
@@ -6711,11 +7163,11 @@ function classRouteUnits(pattern, pack, classification, classNode, module2, opti
   return units;
 }
 function readRoutePath(pattern, pathArgument, classification, module2, options) {
-  const composed = (0, import_extractor7.andThenReading)(
+  const composed = (0, import_extractor9.andThenReading)(
     pathArgument,
     (literal, range) => composeRoutePath(pattern, classification, module2, options, literal, range)
   );
-  return (0, import_extractor7.andThenReading)(
+  return (0, import_extractor9.andThenReading)(
     composed,
     (path8, range) => readPathTemplate(pattern, path8, range)
   );
@@ -6741,10 +7193,10 @@ function readRoutePaths(pattern, pathArgument, classification, module2, options)
     ];
   }
   return resolution.values.map((prefix) => ({
-    routePath: (0, import_extractor7.andThenReading)(
-      (0, import_extractor7.andThenReading)(
+    routePath: (0, import_extractor9.andThenReading)(
+      (0, import_extractor9.andThenReading)(
         pathArgument,
-        (literal, range) => (0, import_extractor7.writtenReading)(servedSpelling(pattern, prefix + literal), range)
+        (literal, range) => (0, import_extractor9.writtenReading)(servedSpelling(pattern, prefix + literal), range)
       ),
       (path8, range) => readPathTemplate(pattern, path8, range)
     ),
@@ -6785,9 +7237,9 @@ function composeRoutePath(pattern, classification, module2, options, literal, ra
     range
   );
   if (prefix.kind === "absent") {
-    return (0, import_extractor7.writtenReading)(servedSpelling(pattern, literal), range);
+    return (0, import_extractor9.writtenReading)(servedSpelling(pattern, literal), range);
   }
-  return (0, import_extractor7.mapReading)(
+  return (0, import_extractor9.mapReading)(
     prefix,
     (value) => servedSpelling(pattern, value + literal)
   );
@@ -6807,32 +7259,36 @@ function readRouterPrefix(pattern, classification, module2, options, range) {
     options
   );
   if (resolution === null) {
-    return import_extractor7.absentReading;
+    return import_extractor9.absentReading;
   }
   if (resolution.kind === "abstain") {
-    return (0, import_extractor7.unreadableReading)(
+    return (0, import_extractor9.unreadableReading)(
       `The router this route is declared on ${resolution.reason}, so the binding names no path and nothing pairs with it`,
       range
     );
   }
   if (resolution.kind === "composed") {
-    return (0, import_extractor7.writtenReading)(resolution.value, range);
+    return (0, import_extractor9.writtenReading)(resolution.value, range);
   }
-  return import_extractor7.absentReading;
+  return import_extractor9.absentReading;
 }
-function readStatusCode(pattern, classification) {
+function readStatusCode(pattern, classification, options) {
   if (pattern.statusCodeKeyword === void 0) {
-    return import_extractor7.absentReading;
+    return import_extractor9.absentReading;
   }
   const arg = classification.keywordArgs[pattern.statusCodeKeyword];
   if (arg === void 0) {
-    return import_extractor7.absentReading;
+    return import_extractor9.absentReading;
   }
-  if (arg.kind === "number") {
-    return (0, import_extractor7.writtenReading)(arg.value, classification.range);
+  const status = statusNumberOf(arg.node, {
+    ...options,
+    constants: pattern.statusCodeConstants ?? {}
+  });
+  if (status !== null) {
+    return (0, import_extractor9.writtenReading)(status, classification.range);
   }
-  return (0, import_extractor7.unreadableReading)(
-    "The status this route's decorator states is not a literal number, so the response claims no status",
+  return (0, import_extractor9.unreadableReading)(
+    "The status this route's decorator states does not come to a number here, so the response claims no status",
     classification.range
   );
 }
@@ -6841,11 +7297,11 @@ function statusFromReturnedValue(node, facts) {
     return null;
   }
   const value = evaluatedValue(node, facts);
-  const number = (0, import_values19.constantOf)(value);
+  const number = (0, import_values20.constantOf)(value);
   if (typeof number === "number") {
     return Number.isInteger(number) ? number : null;
   }
-  const text2 = (0, import_values19.literalOf)(value);
+  const text2 = (0, import_values20.literalOf)(value);
   if (text2 === null) {
     return null;
   }
@@ -6853,30 +7309,49 @@ function statusFromReturnedValue(node, facts) {
   return digits === null ? null : Number.parseInt(digits[1], 10);
 }
 function statusOfReturn(statement, facts) {
-  const returned = statement.namedChildren[0];
+  const returned = statement.namedChild(0);
   if (returned?.type !== "expression_list") {
     return { kind: "none" };
   }
-  const status = statusFromReturnedValue(returned.namedChildren[1], facts);
+  const status = statusFromReturnedValue(
+    returned.namedChild(1) ?? void 0,
+    facts
+  );
   return status === null ? { kind: "unreadable" } : { kind: "status", value: status };
 }
 function returnStatusReading(statement, ctx) {
   const read = statusOfReturnIn(statement, ctx.pattern, ctx);
   const range = rangeOf(statement);
   if (read.kind === "status") {
-    return (0, import_extractor7.writtenReading)(read.value, range);
+    return (0, import_extractor9.writtenReading)(read.value, range);
   }
   if (read.kind === "unreadable") {
-    return (0, import_extractor7.unreadableReading)(
+    return (0, import_extractor9.unreadableReading)(
       "This return gives a status this reading cannot resolve to a number, so this outcome claims none",
       range
     );
   }
-  return ctx.pattern.statusFromReturnedTuple === true ? import_extractor7.absentReading : ctx.declaredStatus.reading;
+  return ctx.pattern.statusFromReturnedTuple === true ? import_extractor9.absentReading : ctx.declaredStatus.reading;
 }
 function returnBranch(statement, ctx) {
   const range = rangeOf(statement);
   const writtenBody = returnedBodyShape(statement);
+  return responseBranchAt(
+    range,
+    returnStatusReading(statement, ctx),
+    writtenBody === null ? ctx.responseShape.reading : (0, import_extractor9.writtenReading)(writtenBody, range),
+    ctx
+  );
+}
+function fallthroughBranch(definitionNode, ctx) {
+  return responseBranchAt(
+    rangeOf(definitionNode),
+    ctx.pattern.statusFromReturnedTuple === true ? import_extractor9.absentReading : ctx.declaredStatus.reading,
+    ctx.responseShape.reading,
+    ctx
+  );
+}
+function responseBranchAt(range, status, body, ctx) {
   return {
     terminal: {
       kind: "response",
@@ -6893,12 +7368,10 @@ function returnBranch(statement, ctx) {
       location: range
     },
     statusCodeReading: {
-      reading: returnStatusReading(statement, ctx),
+      reading: status,
       ...ctx.declaredStatus.libraryDefault !== void 0 ? { libraryDefault: ctx.declaredStatus.libraryDefault } : {}
     },
-    bodyShapeReading: {
-      reading: writtenBody === null ? ctx.responseShape.reading : (0, import_extractor7.writtenReading)(writtenBody, range)
-    },
+    bodyShapeReading: { reading: body },
     location: range
   };
 }
@@ -6912,18 +7385,19 @@ function terminalBranchOf(found, ctx) {
     // A route has no continuation, so none is ever collected for it.
     continuation: (variant) => returnBranch(variant.statement, ctx)
   };
-  return (0, import_behavioral_ir5.dispatchByType)(table, found);
+  return (0, import_behavioral_ir6.dispatchByType)(table, found);
 }
 function branchesPerTerminal(options) {
   const body = field(options.definitionNode, "body");
   const raised = raisedResponses(body, {
     calls: options.responseStatusCalls,
     module: options.ctx.module,
-    facts: options.ctx.facts
+    facts: options.ctx.facts,
+    constants: options.ctx.pattern.statusCodeConstants ?? {}
   });
   const terminals = bodyTerminals(body, raised);
   const soleReturnWritesBody = terminals.length === 1 && terminals[0]?.type === "return" && returnedBodyShape(terminals[0].statement) !== null;
-  if (terminals.length < 2 && !soleReturnWritesBody) {
+  if (terminals.length === 0) {
     return null;
   }
   const branches = enumerateBodyBranches({
@@ -6932,6 +7406,7 @@ function branchesPerTerminal(options) {
     raised,
     effects: options.effects,
     branchOf: (found) => terminalBranchOf(found, options.ctx),
+    fallthrough: fallthroughBranch(options.definitionNode, options.ctx),
     facts: options.ctx.facts
   });
   return branches.length > 1 || soleReturnWritesBody ? branches : null;
@@ -6940,7 +7415,8 @@ function statusOfReturnIn(statement, pattern, options) {
   const constructed = returnedResponseStatus(statement, {
     calls: pattern.responseConstructors ?? [],
     module: options.module,
-    facts: options.facts
+    facts: options.facts,
+    constants: pattern.statusCodeConstants ?? {}
   });
   if (constructed !== null) {
     return constructed.type === "literal" ? { kind: "status", value: constructed.value } : { kind: "unreadable" };
@@ -6952,7 +7428,7 @@ function statusOfReturnIn(statement, pattern, options) {
 }
 function readReturnedStatus(pattern, definitionNode, options) {
   if (pattern.statusFromReturnedTuple !== true && (pattern.responseConstructors ?? []).length === 0) {
-    return import_extractor7.absentReading;
+    return import_extractor9.absentReading;
   }
   const range = rangeOf(definitionNode);
   const statuses = /* @__PURE__ */ new Set();
@@ -6969,23 +7445,23 @@ function readReturnedStatus(pattern, definitionNode, options) {
     }
   }
   if (unreadable > 0) {
-    return (0, import_extractor7.unreadableReading)(
+    return (0, import_extractor9.unreadableReading)(
       "This route returns a status this reading cannot resolve to a number, so no status is claimed for it",
       range
     );
   }
   if (statuses.size === 0) {
-    return import_extractor7.absentReading;
+    return import_extractor9.absentReading;
   }
   const candidates = [...statuses];
   if (statuses.size > 1 || plainReturns > 0) {
-    return (0, import_extractor7.ambiguousReading)(
+    return (0, import_extractor9.ambiguousReading)(
       candidates,
       "This route returns more than one status depending on which branch runs, and nothing here reads which, so no status is claimed for it",
       range
     );
   }
-  return (0, import_extractor7.writtenReading)(candidates[0], range);
+  return (0, import_extractor9.writtenReading)(candidates[0], range);
 }
 function declaredOrReturnedStatus(declared, returned) {
   return declared.kind === "absent" ? returned : declared;
@@ -6998,19 +7474,19 @@ function defaultedStatus(reading, pattern) {
 }
 function readResponseModel(pattern, classification, module2, ctx) {
   if (pattern.responseModelKeyword === void 0) {
-    return import_extractor7.absentReading;
+    return import_extractor9.absentReading;
   }
   const arg = classification.keywordArgs[pattern.responseModelKeyword];
   if (arg === void 0) {
-    return import_extractor7.absentReading;
+    return import_extractor9.absentReading;
   }
   if (arg.kind === "identifier") {
-    return (0, import_extractor7.writtenReading)(
+    return (0, import_extractor9.writtenReading)(
       shapeFromName(arg.name, module2.moduleScope, ctx),
       classification.range
     );
   }
-  return (0, import_extractor7.unreadableReading)(
+  return (0, import_extractor9.unreadableReading)(
     "The response model this route's decorator states is not a name, so the response claims no body shape",
     classification.range
   );
@@ -7018,9 +7494,9 @@ function readResponseModel(pattern, classification, module2, ctx) {
 function readReturnAnnotation(definitionNode, scope, ctx) {
   const returnTypeNode = field(definitionNode, "return_type");
   if (returnTypeNode === null) {
-    return import_extractor7.absentReading;
+    return import_extractor9.absentReading;
   }
-  return (0, import_extractor7.writtenReading)(
+  return (0, import_extractor9.writtenReading)(
     annotationToShape(returnTypeNode, scope, ctx),
     rangeOf(returnTypeNode)
   );
@@ -7034,6 +7510,25 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
     module2.scopeFor,
     options.importedDefinition ?? null
   );
+  const wrappers = wrappersAround(
+    pattern,
+    pack,
+    classification,
+    functionNode,
+    module2,
+    options
+  );
+  const dependencyParameters = options.wrappers?.dependencyParameters(
+    wrappers
+  ) ?? { names: /* @__PURE__ */ new Set(), declaresSource: false };
+  const declaredStatuses = declaredStatusesOf(
+    pattern,
+    pack,
+    classification,
+    functionNode,
+    module2,
+    options
+  );
   return readRoutePaths(
     pattern,
     readPathArgument(classification, options),
@@ -7046,6 +7541,8 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
         pack,
         name: functionName,
         exportPath: [functionName],
+        dependencyParameters,
+        declaredStatuses,
         method: verb,
         routePath: entry.routePath,
         ...entry.mount !== void 0 ? { mount: entry.mount } : {},
@@ -7062,7 +7559,10 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
         responseShape: readResponseModel(pattern, classification, module2, ctx),
         statusCode: defaultedStatus(
           declaredOrReturnedStatus(
-            readStatusCode(pattern, classification),
+            readStatusCode(pattern, classification, {
+              module: module2,
+              facts: options.facts
+            }),
             readReturnedStatus(pattern, functionNode, {
               module: module2,
               facts: options.facts
@@ -7073,14 +7573,7 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
         definitionsCtx: ctx,
         storage: options.storage,
         importedDefinition: options.importedDefinition,
-        wrappers: wrappersAround(
-          pattern,
-          pack,
-          classification,
-          functionNode,
-          module2,
-          options
-        )
+        wrappers
       },
       options
     )
@@ -7099,11 +7592,43 @@ function wrappersAround(pattern, pack, classification, definitionNode, module2,
     definitionNode
   });
 }
+function declaredStatusesOf(pattern, pack, classification, definitionNode, module2, options) {
+  const keyword = pattern.responsesKeyword;
+  if (keyword === void 0) {
+    return [];
+  }
+  const above = options.wrappers?.callsAbove({
+    pack,
+    pattern,
+    file: options.absoluteFile ?? options.filePath,
+    module: module2,
+    classification,
+    definitionNode
+  }) ?? [];
+  const dictionaries = [
+    classification.keywordArgs[keyword]?.node,
+    ...above.map(
+      (call) => readCallArguments(field(call, "arguments")).keywordArgs[keyword]?.node
+    )
+  ].filter((node) => node?.type === "dictionary");
+  const statuses = dictionaries.flatMap(
+    (dictionary) => children(dictionary).flatMap((pair) => {
+      const key = pair?.type === "pair" ? field(pair, "key") : null;
+      const status = key === null ? null : statusNumberOf(key, {
+        module: moduleOf(key),
+        facts: options.facts,
+        constants: pattern.statusCodeConstants ?? {}
+      });
+      return status === null ? [] : [status];
+    })
+  );
+  return [...new Set(statuses)].sort((a, b) => a - b);
+}
 function readResponseShape(declared, readAnnotation) {
   if (declared.kind === "written") {
     return { reading: declared, passedOver: [] };
   }
-  return (0, import_extractor7.firstWrittenReading)([declared, readAnnotation()]);
+  return (0, import_extractor9.firstWrittenReading)([declared, readAnnotation()]);
 }
 function routeUnitOrAbstention(unitOptions, options) {
   try {
@@ -7131,7 +7656,7 @@ function unbuiltRouteUnit(unitOptions, error) {
       exportName: unitOptions.exportPath[0] ?? unitOptions.name,
       exportPath: unitOptions.exportPath
     },
-    boundaryBinding: (0, import_behavioral_ir5.restBinding)({
+    boundaryBinding: (0, import_behavioral_ir6.restBinding)({
       transport: unitOptions.pack.protocol,
       method: nullIfEmpty(unitOptions.method),
       path: null,
@@ -7143,7 +7668,7 @@ function unbuiltRouteUnit(unitOptions, error) {
     dependencyCalls: [],
     declaredContract: null,
     readings: [
-      (0, import_extractor7.unreadableReading)(
+      (0, import_extractor9.unreadableReading)(
         `This route could not be read into a unit (${message}), so the binding names no path and nothing pairs with it`,
         range
       )
@@ -7169,7 +7694,7 @@ function buildRouteUnit(options) {
     definitionsCtx,
     storage: storageLookup
   } = options;
-  const template = (0, import_extractor7.valueToReadFurtherFrom)(routePath);
+  const template = (0, import_extractor9.valueToReadFurtherFrom)(routePath);
   const ctx = definitionsCtx ?? createAnnotationContext(
     module2.scopeFor,
     options.importedDefinition ?? null
@@ -7182,6 +7707,8 @@ function buildRouteUnit(options) {
       pathParamNames: template?.paramNames ?? null,
       requestBodyFromAnnotatedClass,
       injectedCallees,
+      injectedTypes: new Set(pattern.injectedParameterTypes ?? []),
+      module: module2,
       sources: pattern.parameterSources ?? {},
       aliasKeyword: pattern.parameterAliasKeyword
     },
@@ -7238,6 +7765,22 @@ function buildRouteUnit(options) {
     };
     branches.push(withBodyEffects(bare, extra));
   }
+  if (branches.length > 0) {
+    branches.push(
+      ...validationFailureBranches(
+        pattern,
+        readsTheRequest(
+          parameters,
+          template,
+          options.dependencyParameters ?? {
+            names: /* @__PURE__ */ new Set(),
+            declaresSource: false
+          }
+        ),
+        rangeOf(definitionNode)
+      )
+    );
+  }
   const bodyNode = field(definitionNode, "body");
   return {
     identity: {
@@ -7250,7 +7793,7 @@ function buildRouteUnit(options) {
       exportName: exportPath[0] ?? name,
       exportPath
     },
-    boundaryBinding: (0, import_behavioral_ir5.restBinding)({
+    boundaryBinding: (0, import_behavioral_ir6.restBinding)({
       transport: pack.protocol,
       method,
       path: template?.path ?? null,
@@ -7269,15 +7812,57 @@ function buildRouteUnit(options) {
     ...collectedDefinitions(ctx) !== null ? { definitions: collectedDefinitions(ctx) } : {},
     ...options.mount !== void 0 ? { mount: options.mount } : {},
     ...options.wrappers !== void 0 && options.wrappers.length > 0 ? { wrappers: options.wrappers } : {},
-    ...pack.requestSpelling === void 0 ? {} : { requestSpelling: pack.requestSpelling }
+    ...pack.requestSpelling === void 0 ? {} : { requestSpelling: pack.requestSpelling },
+    ...options.declaredStatuses !== void 0 && options.declaredStatuses.length > 0 ? { declaredStatuses: options.declaredStatuses } : {}
   };
 }
+function readsTheRequest(parameters, template, dependencies) {
+  if (dependencies.declaresSource || parameters.some((parameter) => parameter.role !== null)) {
+    return true;
+  }
+  return [...template?.paramNames ?? []].some(
+    (name) => dependencies.names.has(name)
+  );
+}
+function validationFailureBranches(pattern, readsRequest, range) {
+  const status = pattern.validationFailureStatus;
+  if (status === void 0 || !readsRequest) {
+    return [];
+  }
+  return [
+    {
+      conditions: [
+        {
+          sourceText: "request input fails validation",
+          structured: null,
+          polarity: "positive",
+          source: "earlyThrow"
+        }
+      ],
+      terminal: {
+        kind: "response",
+        statusCode: { type: "literal", value: status },
+        body: null,
+        exceptionType: null,
+        message: null,
+        component: null,
+        renderTree: null,
+        delegateTarget: null,
+        emitEvent: null,
+        location: range
+      },
+      effects: [],
+      location: range,
+      isDefault: false
+    }
+  ];
+}
 function unreadRoleReadings(parameters, range) {
   if (!parameters.some((parameter) => parameter.role === null)) {
     return [];
   }
   return [
-    (0, import_extractor7.unreadableReading)(
+    (0, import_extractor9.unreadableReading)(
       "Nothing read this route's path, so its parameters name no role and a path parameter here does not read as one",
       range
     )
@@ -7338,10 +7923,7 @@ function readParameters(definitionNode, reading, skipReceiverParam) {
   }
   const out = [];
   let position = 0;
-  for (const param of parametersNode.namedChildren) {
-    if (param === null) {
-      continue;
-    }
+  for (const param of children(parametersNode)) {
     if (skipReceiverParam && position === 0 && isReceiverParam(param)) {
       position += 1;
       continue;
@@ -7365,7 +7947,7 @@ function readParameter(param, reading, position) {
   const { name, typeNode } = info;
   const shape = typeNode !== null ? annotationToShape(typeNode, reading.scope, reading.ctx) : null;
   const typeText = typeNode !== null ? typeNode.text : null;
-  if (isInjectedParameter(param, reading)) {
+  if (isInjectedParameter(param, reading) || isInjectedType(typeNode, reading)) {
     return { name, position, role: null, typeText };
   }
   const declared = declaringCall(
@@ -7445,6 +8027,14 @@ function calleeName2(call) {
 function isInjectedParameter(param, reading) {
   return declaringCall(param, reading.injectedCallees, reading) !== null;
 }
+function isInjectedType(typeNode, reading) {
+  if (typeNode === null || reading.injectedTypes.size === 0) {
+    return false;
+  }
+  const written = typeNode.type === "type" ? typeNode.namedChild(0) ?? null : typeNode;
+  const origin = written === null ? null : originOf(written, reading.module);
+  return origin !== null && reading.injectedTypes.has(`${origin.module}.${origin.name}`);
+}
 function declaringCall(param, callees, reading) {
   if (callees.size === 0) {
     return null;
@@ -7668,15 +8258,15 @@ function parseWith(language, source) {
 // src/project.ts
 var import_node_fs4 = __toESM(require("fs"), 1);
 var import_node_path5 = __toESM(require("path"), 1);
-var import_behavioral_ir9 = require("@suss/behavioral-ir");
+var import_behavioral_ir10 = require("@suss/behavioral-ir");
 var import_datalog2 = require("@suss/datalog");
-var import_extractor16 = require("@suss/extractor");
+var import_extractor18 = require("@suss/extractor");
 var import_resolution18 = require("@suss/resolution");
 
 // src/diagnostics.ts
-var import_extractor8 = require("@suss/extractor");
+var import_extractor10 = require("@suss/extractor");
 function buildPythonExtractionReport(args) {
-  return (0, import_extractor8.buildUngatedExtractionReport)({
+  return (0, import_extractor10.buildUngatedExtractionReport)({
     packs: args.packs.map((pack) => ({
       name: pack.name,
       version: pack.version ?? null,
@@ -7689,14 +8279,14 @@ function buildPythonExtractionReport(args) {
 }
 
 // src/exits.ts
-var import_extractor9 = require("@suss/extractor");
+var import_extractor11 = require("@suss/extractor");
 var import_resolution9 = require("@suss/resolution");
-var import_values20 = require("@suss/values");
+var import_values21 = require("@suss/values");
 var DEFERRED_BODY_TYPES3 = /* @__PURE__ */ new Set(["function_definition", "lambda"]);
 function exitSites(root, module2) {
   const found = [];
   const startScope = module2.scopeFor.get(root.id) ?? module2.moduleScope;
-  (0, import_extractor9.walkDescendants)(root, startScope, {
+  (0, import_extractor11.walkDescendants)(root, startScope, children, {
     at: (node, scope) => {
       const site = exitSiteAt(node, scope);
       if (site !== null) {
@@ -7705,7 +8295,7 @@ function exitSites(root, module2) {
     },
     into: (node, scope) => {
       if (DEFERRED_BODY_TYPES3.has(node.type)) {
-        return import_extractor9.SKIP_CHILDREN;
+        return import_extractor11.SKIP_CHILDREN;
       }
       return module2.scopeFor.get(node.id) ?? scope;
     }
@@ -7713,7 +8303,7 @@ function exitSites(root, module2) {
   return found;
 }
 function exitSiteAt(statement, scope) {
-  const expression = statement.namedChildren[0] ?? null;
+  const expression = statement.namedChild(0) ?? null;
   if (expression === null) {
     return null;
   }
@@ -7727,12 +8317,12 @@ function exitSiteAt(statement, scope) {
     return endsTheProcess(callee, scope) ? { statement, code, raised: false } : null;
   }
   if (statement.type === "raise_statement") {
-    return isBuiltin(callee, scope, "SystemExit") ? { statement, code, raised: true } : null;
+    return isBuiltin2(callee, scope, "SystemExit") ? { statement, code, raised: true } : null;
   }
   return null;
 }
 function endsTheProcess(callee, scope) {
-  return isStdlibMember(callee, scope, "sys", "exit") || isBuiltin(callee, scope, "exit") || isBuiltin(callee, scope, "quit");
+  return isStdlibMember(callee, scope, "sys", "exit") || isBuiltin2(callee, scope, "exit") || isBuiltin2(callee, scope, "quit");
 }
 function firstArgument(call) {
   return callArguments(call).find(
@@ -7760,7 +8350,7 @@ function exitCodeOf(code, facts) {
   if (stringLiteralValue(code) !== null) {
     return { type: "literal", value: 1 };
   }
-  const value = (0, import_values20.constantOf)(evaluatedValue(code, facts));
+  const value = (0, import_values21.constantOf)(evaluatedValue(code, facts));
   return typeof value === "number" ? { type: "literal", value } : { type: "dynamic", sourceText: code.text };
 }
 function exitingBranches(definition, module2, effects, facts) {
@@ -7794,7 +8384,7 @@ function markExitCodeFunctions(summaries, exits, facts, workspaceRoot) {
       (site) => site.code === null ? [] : [nodeId(file, site.code)]
     )
   );
-  (0, import_extractor9.markReturnsAsExitCode)(
+  (0, import_extractor11.markReturnsAsExitCode)(
     summaries,
     (0, import_resolution9.exitCodeFunctions)(facts, sinks),
     workspaceRoot
@@ -7879,25 +8469,25 @@ function definedNodeOf(binding) {
 }
 
 // src/moduleSurface.ts
-var import_behavioral_ir7 = require("@suss/behavioral-ir");
-var import_extractor12 = require("@suss/extractor");
+var import_behavioral_ir8 = require("@suss/behavioral-ir");
+var import_extractor14 = require("@suss/extractor");
 var import_resolution13 = require("@suss/resolution");
 
 // src/reach/closure.ts
-var import_behavioral_ir6 = require("@suss/behavioral-ir");
+var import_behavioral_ir7 = require("@suss/behavioral-ir");
 var import_datalog = require("@suss/datalog");
-var import_extractor11 = require("@suss/extractor");
+var import_extractor13 = require("@suss/extractor");
 var import_resolution12 = require("@suss/resolution");
 
 // src/flags.ts
-var import_extractor10 = require("@suss/extractor");
+var import_extractor12 = require("@suss/extractor");
 var PARSE_METHODS = /* @__PURE__ */ new Set(["parse_args", "parse_known_args"]);
 var DEFERRED_BODY_TYPES4 = /* @__PURE__ */ new Set(["function_definition", "lambda"]);
 function argparseFlagReads(definition, module2, parameterNames2) {
   const parsers = /* @__PURE__ */ new Map();
   const handedTo = /* @__PURE__ */ new Map();
   const startScope = module2.scopeFor.get(definition.id) ?? module2.moduleScope;
-  (0, import_extractor10.walkDescendants)(definition, startScope, {
+  (0, import_extractor12.walkDescendants)(definition, startScope, children, {
     at: (node, scope) => {
       noteParser(node, scope, parsers);
       noteArgument(node, parsers);
@@ -7905,7 +8495,7 @@ function argparseFlagReads(definition, module2, parameterNames2) {
     },
     into: (node, scope) => {
       if (DEFERRED_BODY_TYPES4.has(node.type)) {
-        return import_extractor10.SKIP_CHILDREN;
+        return import_extractor12.SKIP_CHILDREN;
       }
       return module2.scopeFor.get(node.id) ?? scope;
     }
@@ -7999,11 +8589,77 @@ function resolveCallee2(call, site, ctx, read) {
     return spelling;
   }
   const outcome = read?.outcomes.get(spelling.key) ?? (0, import_resolution11.calleeOutcomeOf)(ctx.facts, spelling.key);
+  if (selfCallInMixin(call, outcome, site, ctx)) {
+    return { kind: "stopped", reason: "selfCallInMixin" };
+  }
   return asCallee(outcome, site.owner, ctx);
 }
+function selfCallInMixin(call, outcome, site, ctx) {
+  if (outcome.kind !== "callerSupplied" || !outcome.key.startsWith(`${site.owner}#`)) {
+    return false;
+  }
+  const callee = readThrough(field(call, "function"));
+  const receiver = callee?.type === "attribute" ? field(callee, "object") : null;
+  const name = callee === null ? null : field(callee, "attribute")?.text;
+  if (receiver?.type !== "identifier" || name === void 0 || name === null) {
+    return false;
+  }
+  if (outcome.key !== `${site.owner}#${receiver.text}`) {
+    return false;
+  }
+  return ctx.facts.lookup("instanceOf", 0, outcome.key).some((row) => {
+    const classKey = String(row[1]);
+    return ctx.facts.has("plainClass", [classKey]) && !instancesHaveAttribute(ctx.facts, classKey, name);
+  });
+}
+var FALLBACK_ATTRIBUTE = "__getattr__";
+function instancesHaveAttribute(facts, classKey, name) {
+  return facts.lookup("holdsProperty", 0, classKey).some((member) => {
+    if (String(member[1]) === FALLBACK_ATTRIBUTE) {
+      return true;
+    }
+    return facts.lookup("storesProperty", 0, String(member[2])).some(
+      (store) => String(store[1]) === name && store[3] === import_resolution11.RECEIVER_STORE_NAME
+    );
+  });
+}
 function namedOutcomes(keys, ctx) {
   return (0, import_resolution11.calleeOutcomes)(ctx.facts, [...new Set(keys)]);
 }
+function dispatchedCalls(calls, ctx) {
+  const byKey = new Map(
+    calls.map(({ call, site }) => [nodeId(site.file.file, call), call])
+  );
+  const found = /* @__PURE__ */ new Map();
+  for (const [key, outcome] of (0, import_resolution11.dispatchOutcomes)(ctx.facts, [...byKey.keys()])) {
+    const call = byKey.get(key);
+    if (call === void 0) {
+      continue;
+    }
+    const targets = /* @__PURE__ */ new Map();
+    for (const fn of outcome.functions) {
+      for (const target of reachedThrough(fn, outcome.through, ctx)) {
+        targets.set(nodeId(target.file.file, target.node), target);
+      }
+    }
+    found.set(call.id, {
+      targets: [...targets.values()],
+      certain: outcome.certain && outcome.functions.every((fn) => !isLambda(fn, ctx)),
+      unresolved: outcome.unresolved
+    });
+  }
+  return found;
+}
+function reachedThrough(key, through, ctx) {
+  const keys = isLambda(key, ctx) ? through.get(key) ?? [] : [key];
+  return keys.flatMap((one) => {
+    const target = isLambda(one, ctx) ? null : functionAt(one, ctx);
+    return target === null ? [] : [target];
+  });
+}
+function isLambda(key, ctx) {
+  return ctx.definitions.get(key)?.type === "lambda";
+}
 function functionNamed(nameKey2, ctx, read) {
   if (assignedElsewhere(ctx.facts, nameKey2)) {
     return null;
@@ -8222,6 +8878,7 @@ function reachedFunctions(seeds, options) {
   const targetsByKey = /* @__PURE__ */ new Map();
   const stopsByKey = /* @__PURE__ */ new Map();
   const argTargetsByKey = /* @__PURE__ */ new Map();
+  const possibleTargetsByKey = /* @__PURE__ */ new Map();
   const parameterCallsByKey = /* @__PURE__ */ new Map();
   const callsByKey = /* @__PURE__ */ new Map();
   const passedPositions = /* @__PURE__ */ new Set();
@@ -8284,6 +8941,7 @@ function reachedFunctions(seeds, options) {
       }
       targetsByKey.set(key, scan.targets);
       argTargetsByKey.set(key, scan.argTargets);
+      possibleTargetsByKey.set(key, scan.possibleTargets);
       if (scan.parameterCalls.length > 0) {
         parameterCallsByKey.set(key, scan.parameterCalls);
       }
@@ -8324,17 +8982,18 @@ function reachedFunctions(seeds, options) {
       continue;
     }
     const build = () => {
-      const summary2 = (0, import_extractor11.assembleSummary)(libraryUnit(target, options), {
+      const summary2 = (0, import_extractor13.assembleSummary)(libraryUnit(target, options), {
         gapHandling: options.gapHandling
       });
       if (options.gapHandling !== "silent") {
         summary2.gaps.push(
-          ...(stopsByKey.get(key) ?? []).map(import_behavioral_ir6.unfollowedCallGap)
+          ...(stopsByKey.get(key) ?? []).map(import_behavioral_ir7.unfollowedCallGap)
         );
       }
-      (0, import_behavioral_ir6.placeCalls)(summary2, targetsByKey.get(key));
-      (0, import_behavioral_ir6.placeArgTargets)(summary2, argTargetsByKey.get(key));
-      (0, import_behavioral_ir6.placeCalleeParameters)(summary2, parameterCallsByKey.get(key));
+      (0, import_behavioral_ir7.placeCalls)(summary2, targetsByKey.get(key));
+      (0, import_behavioral_ir7.placeArgTargets)(summary2, argTargetsByKey.get(key));
+      (0, import_behavioral_ir7.placePossibleCalls)(summary2, possibleTargetsByKey.get(key));
+      (0, import_behavioral_ir7.placeCalleeParameters)(summary2, parameterCallsByKey.get(key));
       return summary2;
     };
     const summary = ledger === void 0 ? build() : ledger.charging(chargeOf(charges, key), () => {
@@ -8350,13 +9009,14 @@ function reachedFunctions(seeds, options) {
     summaries.push(summary);
   }
   if (options.gapHandling !== "silent") {
-    (0, import_behavioral_ir6.recordParameterGaps)(parameterCallsByKey, summariesByKey, passedPositions);
+    (0, import_behavioral_ir7.recordParameterGaps)(parameterCallsByKey, summariesByKey, passedPositions);
   }
   return {
     summaries,
     targetsByKey,
     stopsByKey,
     argTargetsByKey,
+    possibleTargetsByKey,
     parameterCallsByKey,
     callsByKey,
     passedPositions,
@@ -8380,24 +9040,42 @@ function chargeOf(charges, key) {
   }
   return charge;
 }
+function dispatchedAmong(written, spellings, ctx) {
+  return dispatchedCalls(
+    written.filter(({ call, site }) => {
+      if (!ENTRY_CALLEE_TYPES.has(field(call, "function")?.type ?? "")) {
+        return false;
+      }
+      const outcome = resolveCallee2(call, site, ctx, spellings);
+      return outcome.kind === "stopped" && outcome.reason !== "callerSupplied";
+    }),
+    ctx
+  );
+}
+var ENTRY_CALLEE_TYPES = /* @__PURE__ */ new Set(["subscript", "call", "identifier"]);
 function batchedReads(round, ctx) {
   const bodies = round.flatMap(
     (entry) => "source" in entry ? [{ key: entry.key, source: entry.source, ...bodyOf(entry.source) }] : []
   );
-  const spellings = calleeSpellings(
-    bodies.flatMap((body) => body.written),
-    ctx
-  );
+  const written = bodies.flatMap((body) => body.written);
+  const spellings = calleeSpellings(written, ctx);
   const passed = namedOutcomes(
     bodies.flatMap(
-      ({ source, written }) => written.flatMap(({ call }) => passedNameKeys(source.file, call))
+      ({ source, written: written2 }) => written2.flatMap(({ call }) => passedNameKeys(source.file, call))
     ),
     ctx
   );
+  const dispatched = dispatchedAmong(written, spellings, ctx);
   return new Map(
     bodies.map((body) => [
       body.key,
-      { body: body.body, written: body.written, spellings, passed }
+      {
+        body: body.body,
+        written: body.written,
+        spellings,
+        passed,
+        dispatched
+      }
     ])
   );
 }
@@ -8428,13 +9106,15 @@ function scanOnce(source, key, ctx, options, read, charges) {
 }
 function ownReads(source, ctx) {
   const body = bodyOf(source);
+  const spellings = calleeSpellings(body.written, ctx);
   return {
     ...body,
-    spellings: calleeSpellings(body.written, ctx),
+    spellings,
     passed: namedOutcomes(
       body.written.flatMap(({ call }) => passedNameKeys(source.file, call)),
       ctx
-    )
+    ),
+    dispatched: dispatchedAmong(body.written, spellings, ctx)
   };
 }
 function storedScan(scan) {
@@ -8450,6 +9130,10 @@ function storedScan(scan) {
       callee,
       [...byPosition]
     ]),
+    possibleTargets: [...scan.possibleTargets].map(([callee, places]) => [
+      callee,
+      [...places]
+    ]),
     parameterCalls: [...scan.parameterCalls],
     passedPositions: [...scan.passedPositions]
   };
@@ -8465,6 +9149,7 @@ function scanFromStored(stored, functionFor) {
         new Map(byPosition)
       ])
     ),
+    possibleTargets: new Map(stored.possibleTargets),
     parameterCalls: stored.parameterCalls,
     passedPositions: new Set(stored.passedPositions)
   };
@@ -8493,6 +9178,7 @@ var EMPTY_SCAN = {
   stops: [],
   targets: /* @__PURE__ */ new Map(),
   argTargets: /* @__PURE__ */ new Map(),
+  possibleTargets: /* @__PURE__ */ new Map(),
   parameterCalls: [],
   passedPositions: /* @__PURE__ */ new Set()
 };
@@ -8550,15 +9236,15 @@ function passedNameKeys(file, call) {
   if (args === null) {
     return [];
   }
-  return args.namedChildren.flatMap((arg) => {
+  return children(args).flatMap((arg) => {
     const key = passedNameKeyOf(file, arg);
     return key === null ? [] : [key];
   });
 }
 function scanBody(source, ctx, recognized, read, implied) {
   const followed = [];
-  const stops = [];
-  const placements = new import_behavioral_ir6.TargetPlacements();
+  const stops = new import_behavioral_ir7.StopList();
+  const placements = new import_behavioral_ir7.TargetPlacements();
   const parameterCalls = [];
   const passedPositions = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
@@ -8569,12 +9255,25 @@ function scanBody(source, ctx, recognized, read, implied) {
     return EMPTY_SCAN;
   }
   const ownParameters = callParameterNames(node, source.exportPath.length > 1);
+  const follow = (target) => {
+    const key = keyOf2(target);
+    if (!seen.has(key)) {
+      seen.add(key);
+      followed.push(target);
+    }
+  };
   const recordPassedArgs = (call, callee, calleeKey2) => {
     const args = field(call, "arguments");
     if (args === null) {
       return;
     }
-    args.namedChildren.forEach((arg, position) => {
+    children(args).forEach((arg, position) => {
+      if (arg.type === "lambda") {
+        if (calleeKey2 !== null) {
+          passedPositions.add(`${calleeKey2}#${position}`);
+        }
+        return;
+      }
       const nameKey2 = passedNameKeyOf(file, arg);
       if (nameKey2 === null) {
         return;
@@ -8583,11 +9282,7 @@ function scanBody(source, ctx, recognized, read, implied) {
       if (resolved === null) {
         return;
       }
-      const key = keyOf2(resolved);
-      if (!seen.has(key)) {
-        seen.add(key);
-        followed.push(resolved);
-      }
+      follow(resolved);
       placements.placeArg(callee, position, {
         file: resolved.file.displayPath,
         span: spanOf(resolved.node)
@@ -8597,9 +9292,30 @@ function scanBody(source, ctx, recognized, read, implied) {
       }
     });
   };
+  const recordPossible = (call, callee, dispatched) => {
+    dispatched.targets.forEach(follow);
+    placements.placePossible(
+      callee,
+      dispatched.targets.map((target) => ({
+        file: target.file.displayPath,
+        span: spanOf(target.node)
+      }))
+    );
+    recordPassedArgs(call, callee, null);
+    if (dispatched.unresolved > 0 && !recognized.has(call.id)) {
+      stops.add({ callee, reason: "unsettledValue" });
+    }
+  };
   const record = (call, site) => {
     const callee = calleeText(call);
-    const outcome = resolveCallee2(call, site, ctx, spellings);
+    const settled = resolveCallee2(call, site, ctx, spellings);
+    const dispatched = settled.kind === "stopped" ? read.dispatched.get(call.id) : void 0;
+    const [only] = dispatched?.targets ?? [];
+    if (dispatched !== void 0 && only !== void 0 && !dispatched.certain) {
+      recordPossible(call, callee, dispatched);
+      return;
+    }
+    const outcome = only === void 0 ? settled : { kind: "followed", target: only };
     placeCallee(placements, callee, outcome, call, file);
     recordPassedArgs(
       call,
@@ -8607,10 +9323,12 @@ function scanBody(source, ctx, recognized, read, implied) {
       outcome.kind === "followed" ? keyOf2(outcome.target) : null
     );
     if (outcome.kind === "stopped") {
-      const stopKey = `${outcome.reason}:${callee}`;
-      if (!seen.has(stopKey) && !recognized.has(call.id) && (0, import_behavioral_ir6.worthRecording)(outcome.reason)) {
-        seen.add(stopKey);
-        stops.push({ callee, reason: outcome.reason });
+      if (!recognized.has(call.id) && (0, import_behavioral_ir7.worthRecording)(outcome.reason)) {
+        stops.add({
+          callee,
+          reason: outcome.reason,
+          ...resultUsedAsValue(call) ? { usedAsValue: true } : {}
+        });
       }
       if (outcome.reason === "callerSupplied" && !parameterCallsSeen.has(callee)) {
         const parameterIndex = ownParameters.indexOf(callee);
@@ -8621,11 +9339,7 @@ function scanBody(source, ctx, recognized, read, implied) {
       }
       return;
     }
-    const key = keyOf2(outcome.target);
-    if (!seen.has(key)) {
-      seen.add(key);
-      followed.push(outcome.target);
-    }
+    follow(outcome.target);
   };
   for (const { call, site } of written) {
     record(call, site);
@@ -8635,30 +9349,27 @@ function scanBody(source, ctx, recognized, read, implied) {
       file: target.file.displayPath,
       span: spanOf(target.node)
     });
-    const key = keyOf2(target);
-    if (!seen.has(key)) {
-      seen.add(key);
-      followed.push(target);
-    }
+    follow(target);
   }
   return {
     followed,
-    stops,
+    stops: stops.stops,
     targets: placements.targets,
     argTargets: placements.argTargets,
+    possibleTargets: placements.possibleTargets,
     parameterCalls,
     passedPositions
   };
 }
 function callsWritten(file, body, outer, owner, limit) {
   const found = [];
-  (0, import_extractor11.walkDescendants)(body, outer, {
+  (0, import_extractor13.walkDescendants)(body, outer, children, {
     at: (child, scope) => {
       if (child.type === "call") {
         found.push({ call: child, site: { file, scope, owner } });
       }
     },
-    into: (child, scope) => limit.descendsInto(child) ? file.module.scopeFor.get(child.id) ?? scope : import_extractor11.SKIP_CHILDREN
+    into: (child, scope) => limit.descendsInto(child) ? file.module.scopeFor.get(child.id) ?? scope : import_extractor13.SKIP_CHILDREN
   });
   return found;
 }
@@ -8678,14 +9389,14 @@ function identifiersUnder(node, found = []) {
     found.push(node.text);
     return found;
   }
-  for (const child of node.namedChildren) {
+  for (const child of children(node)) {
     if (child !== null && child.type !== "attribute" && child.type !== "subscript") {
       identifiersUnder(child, found);
     }
   }
   return found;
 }
-function libraryUnit(target, options, binding = (0, import_behavioral_ir6.functionCallBinding)({
+function libraryUnit(target, options, binding = (0, import_behavioral_ir7.functionCallBinding)({
   transport: "in-process",
   recognition: "reachable"
 })) {
@@ -8779,10 +9490,7 @@ function positionalParameters(node, isMethod2) {
   }
   const out = [];
   let position = 0;
-  for (const param of parameters.namedChildren) {
-    if (param === null) {
-      continue;
-    }
+  for (const param of children(parameters)) {
     const name = parameterName2(param);
     if (name === null) {
       continue;
@@ -8802,10 +9510,7 @@ function callParameterNames(node, isMethod2) {
     return [];
   }
   const names = [];
-  for (const param of parameters.namedChildren) {
-    if (param === null) {
-      continue;
-    }
+  for (const param of children(parameters)) {
     const name = parameterName2(param);
     if (name === null) {
       continue;
@@ -8830,10 +9535,10 @@ function parameterName2(param) {
 
 // src/moduleSurface.ts
 function settlePythonModules(modules) {
-  return (0, import_extractor12.settleModules)(modules, ["__init__.py"]);
+  return (0, import_extractor14.settleModules)(modules, ["__init__.py"]);
 }
 function moduleExportUnits(file, options) {
-  const module2 = (0, import_extractor12.moduleOfFile)(options.modules, file.file);
+  const module2 = (0, import_extractor14.moduleOfFile)(options.modules, file.file);
   if (module2 === void 0) {
     return [];
   }
@@ -8855,8 +9560,8 @@ function moduleExportUnits(file, options) {
             exportPath: [...one.exportPath]
           },
           options,
-          (0, import_behavioral_ir7.moduleExportBinding)({
-            recognition: import_extractor12.MODULE_SURFACE_RECOGNITION,
+          (0, import_behavioral_ir8.moduleExportBinding)({
+            recognition: import_extractor14.MODULE_SURFACE_RECOGNITION,
             module: module2.name,
             exportName
           })
@@ -8902,7 +9607,7 @@ function exportsOf(file, node, exportName) {
   if (node.type !== "class_definition" || body === null) {
     return [];
   }
-  return body.namedChildren.flatMap((child) => {
+  return children(body).flatMap((child) => {
     if (child === null) {
       return [];
     }
@@ -8975,6 +9680,10 @@ var PackPositions = class {
     const [packAt, patternAt] = id.split("/").map(Number);
     return this.packs[packAt ?? -1]?.discovery[patternAt ?? -1];
   }
+  packOf(id) {
+    const [packAt] = id.split("/").map(Number);
+    return this.packs[packAt ?? -1];
+  }
   formAt(at) {
     const pack = this.packs[at[0]];
     const pattern = pack?.discovery[at[1]];
@@ -9025,6 +9734,11 @@ function watchRouterIndex(index, db, positions, fileOfModule) {
         found
       );
       return found;
+    },
+    // The wrapper index notes what it reads through the mounts, in terms
+    // it can look up again.
+    mountsAbove(pattern, constructionKey) {
+      return index.mountsAbove(pattern, constructionKey);
     }
   };
 }
@@ -9129,9 +9843,33 @@ function buildRouterIndex(files, packs, resolverOptions) {
         };
       }
       return NOT_ROUTER;
+    },
+    mountsAbove(pattern, constructionKey) {
+      const index = byPattern.get(pattern);
+      return index === void 0 ? null : hopsAbove(index, constructionKey);
     }
   };
 }
+function hopsAbove(index, key) {
+  const hops = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = key;
+  while (current !== null) {
+    const construction = index.byValueKey.get(current);
+    if (construction === void 0 || seen.has(current)) {
+      return null;
+    }
+    seen.add(current);
+    const states = index.mounts.get(construction) ?? [];
+    const only = states.length === 1 ? states[0] : void 0;
+    if (only?.kind !== "mounted" || only.written === void 0) {
+      return null;
+    }
+    hops.push({ ...only.written, parentKey: only.parentValueKey });
+    current = only.parentValueKey;
+  }
+  return hops;
+}
 function composedPrefixOf(index, construction, routerPath) {
   const ownPrefix = composedOwnPrefix(construction.prefix, index.composition);
   if (ownPrefix.kind === "abstain") {
@@ -9414,8 +10152,8 @@ function constructionStatement(stmt, module2, importModule) {
   if (stmt.type !== "expression_statement") {
     return null;
   }
-  const assignment2 = stmt.namedChildren.find(
-    (child) => child !== null && child.type === "assignment"
+  const assignment2 = children(stmt).find(
+    (child) => child.type === "assignment"
   );
   if (assignment2 === void 0) {
     return null;
@@ -9489,7 +10227,7 @@ function collectReturnedConstructions(bound, importModule, composition, index) {
       if (inner.type !== "return_statement") {
         continue;
       }
-      const returned = inner.namedChildren[0];
+      const returned = inner.namedChild(0);
       if (returned?.type !== "call") {
         continue;
       }
@@ -9669,7 +10407,7 @@ function sequenceElementNames(node) {
     return null;
   }
   const names = [];
-  for (const child of node.namedChildren) {
+  for (const child of children(node)) {
     if (child?.type !== "identifier") {
       return null;
     }
@@ -9882,8 +10620,9 @@ function recordMountStatement(stmt, position, scan) {
     scan.index.facts
   );
   const mounted = args[0] ?? (scan.composition.routerKeyword === void 0 ? void 0 : keywordArgs[scan.composition.routerKeyword]);
+  const recorded = state.kind === "mounted" ? { ...state, written: { call: mountCall.call, file: scan.bound.file } } : state;
   for (const target of mountedConstructions(mounted, position, scan)) {
-    recordMount(scan.index, target, state);
+    recordMount(scan.index, target, recorded);
   }
 }
 function mountStateOf(includerConstructorName, includer, keywordArgs, objectPrefix, composition, site, facts) {
@@ -10324,10 +11063,10 @@ function poetryPackages(pyproject) {
 
 // src/testCases.ts
 var import_node_path4 = __toESM(require("path"), 1);
-var import_behavioral_ir8 = require("@suss/behavioral-ir");
-var import_extractor13 = require("@suss/extractor");
+var import_behavioral_ir9 = require("@suss/behavioral-ir");
+var import_extractor15 = require("@suss/extractor");
 var import_resolution16 = require("@suss/resolution");
-var import_values26 = require("@suss/values");
+var import_values27 = require("@suss/values");
 function pythonTestIndex(packs, context) {
   const patterns = packs.flatMap((pack) => pack.tests ?? []);
   return patterns.length === 0 ? null : new PythonTestIndex(patterns, context);
@@ -10344,7 +11083,7 @@ var PythonTestIndex = class {
   implied = /* @__PURE__ */ new Map();
   /** The tests in one file, when the file is collected and listed. */
   unitsIn(file, options) {
-    return this.testsIn(file).filter((test) => (0, import_extractor13.isListedTestFile)(file.file, test.pattern.files)).map((test) => this.testUnit(file, test, options));
+    return this.testsIn(file).filter((test) => (0, import_extractor15.isListedTestFile)(file.file, test.pattern.files)).map((test) => this.testUnit(file, test, options));
   }
   /** What pytest calls before this function runs, when it is a test or a fixture. */
   impliedCalls(source) {
@@ -10394,7 +11133,7 @@ var PythonTestIndex = class {
       )
     ).flatMap(
       (marker) => positionalArguments(marker).flatMap((arg) => {
-        const name = (0, import_values26.literalOf)(evaluatedValue(arg, this.context.facts));
+        const name = (0, import_values27.literalOf)(evaluatedValue(arg, this.context.facts));
         return name === null ? [] : [name];
       })
     );
@@ -10418,7 +11157,7 @@ var PythonTestIndex = class {
       ...raw,
       identity: {
         ...raw.identity,
-        name: (0, import_behavioral_ir8.testUnitName)(test.titles),
+        name: (0, import_behavioral_ir9.testUnitName)(test.titles),
         nameKind: "label",
         kind: "test",
         exportName: null,
@@ -10430,7 +11169,7 @@ var PythonTestIndex = class {
   }
   patternFor(file) {
     return this.patterns.find(
-      (pattern) => (0, import_extractor13.matchesTestFileName)(file.file, pattern.filePatterns)
+      (pattern) => (0, import_extractor15.matchesTestFileName)(file.file, pattern.filePatterns)
     ) ?? null;
   }
   testsIn(file) {
@@ -10808,11 +11547,11 @@ var PythonTestIndex = class {
       return null;
     }
     const written = oneLine(call.text);
-    const target = (0, import_values26.literalOf)(evaluatedValue(first, this.context.facts));
+    const target = (0, import_values27.literalOf)(evaluatedValue(first, this.context.facts));
     if (target !== null) {
       return { ...this.dottedTarget(target), written };
     }
-    const member = second === void 0 ? null : (0, import_values26.literalOf)(evaluatedValue(second, this.context.facts));
+    const member = second === void 0 ? null : (0, import_values27.literalOf)(evaluatedValue(second, this.context.facts));
     if (member === null) {
       return null;
     }
@@ -10950,8 +11689,8 @@ function fixtureDeclaration(definition, file, pattern, facts) {
   const renamed = keywordArgument(decorator, pattern.fixtureNameKeyword);
   const autouse = keywordArgument(decorator, pattern.autouseKeyword);
   return {
-    name: (renamed === null ? null : (0, import_values26.literalOf)(evaluatedValue(renamed, facts))) ?? defName,
-    autouse: autouse !== null && (0, import_values26.constantOf)(evaluatedValue(autouse, facts)) === true
+    name: (renamed === null ? null : (0, import_values27.literalOf)(evaluatedValue(renamed, facts))) ?? defName,
+    autouse: autouse !== null && (0, import_values27.constantOf)(evaluatedValue(autouse, facts)) === true
   };
 }
 function keywordArgument(call, name) {
@@ -10983,18 +11722,20 @@ function oneLine(text2) {
 }
 
 // src/version.ts
-var import_extractor14 = require("@suss/extractor");
+var import_extractor16 = require("@suss/extractor");
 var ADAPTER_VERSION = "0.1.0";
-var adapterStamp = (0, import_extractor14.createAdapterStamp)({
+var adapterStamp = (0, import_extractor16.createAdapterStamp)({
   moduleUrl: importMetaUrl,
   version: ADAPTER_VERSION
 });
 
 // src/wrappers.ts
-var import_extractor15 = require("@suss/extractor");
+var import_extractor17 = require("@suss/extractor");
 var import_resolution17 = require("@suss/resolution");
 var EVERY_ROUTE = "wrapEvery ";
 var OWN_ROUTES = "wrapOwn ";
+var MOUNTED = "wrapMounted ";
+var MOUNTED_SEPARATOR = "\0";
 function describeRegistered(found) {
   return (found ?? []).map(
     ({ reference }) => `${reference.file}:${reference.name}:${reference.onThrow === true}`
@@ -11032,8 +11773,15 @@ var PythonWrapperIndex = class {
   /** By construction key: what a router or a blueprint registered. */
   ownRoutes = /* @__PURE__ */ new Map();
   unitsByKey = /* @__PURE__ */ new Map();
+  /** By pack name: the app constructions its routes run under. */
+  appCalls = /* @__PURE__ */ new Map();
+  /** By wrapper reference: the parameters a dependency function declares, and its file. */
+  dependencyParameterTable = /* @__PURE__ */ new Map();
   unitsByFile = /* @__PURE__ */ new Map();
-  /** Told about every registration, so a cache can repeat the ones a file's discovery made. */
+  /**
+   * Told about every registration, a pack's form or a project decorator's
+   * closure, so a cache can repeat the ones a file's discovery made.
+   */
   onRegistered = null;
   /**
    * The same lookup `wrappersFor` noted under `id`, made again over this
@@ -11050,6 +11798,12 @@ var PythonWrapperIndex = class {
         this.ownRoutes.get(id.slice(OWN_ROUTES.length))
       );
     }
+    if (id.startsWith(MOUNTED)) {
+      const [packName, position, key] = id.slice(MOUNTED.length).split(MOUNTED_SEPARATOR);
+      const pack = this.options.packs.find((one) => one.name === packName);
+      const pattern = pack?.discovery[Number(position)];
+      return pack === void 0 || pattern === void 0 || key === void 0 ? describeRegistered([]) : describeRegistered(this.registeredAbove(pack, pattern, key));
+    }
     return null;
   }
   noted(kind, key, found) {
@@ -11091,14 +11845,65 @@ var PythonWrapperIndex = class {
       inFile.push(unit);
       this.unitsByFile.set(target.file.file, inFile);
     }
-    return {
-      reference: {
-        file: target.file.displayPath,
-        name: target.name,
-        ...isThrowForm(declared.form) ? { onThrow: true } : {}
-      },
-      form: declared.form
+    const reference = {
+      file: target.file.displayPath,
+      name: target.name,
+      ...isThrowForm(declared.form) ? { onThrow: true } : {}
     };
+    if (declared.form.type === "dependency") {
+      this.dependencyParameterTable.set(referenceKey(reference), {
+        file: target.file.file,
+        names: parameterNamesOf(target.node),
+        declaresSource: declaresSourcedParameter(
+          target.node,
+          Object.keys(declared.pattern.parameterSources ?? {})
+        )
+      });
+    }
+    return { reference, form: declared.form };
+  }
+  /**
+   * The unit for the closure a project's decorator hands back, built once
+   * however many routes the decorator is written on. Its name is what
+   * calling the decorator writes, since the decorator may have a summary
+   * of its own under its name.
+   */
+  registeredClosure(target, closure) {
+    this.onRegistered?.(target, closure);
+    const span = spanOf(target.node);
+    const key = `${target.file.file}:${span.start}-${span.end}`;
+    if (!this.unitsByKey.has(key)) {
+      const unit = closureUnit(target, closure, this.options);
+      this.unitsByKey.set(key, unit);
+      const inFile = this.unitsByFile.get(target.file.file) ?? [];
+      inFile.push(unit);
+      this.unitsByFile.set(target.file.file, inFile);
+    }
+    return { file: target.file.displayPath, name: target.name };
+  }
+  /**
+   * The parameters the dependencies among these wrappers declare, and
+   * whether one is declared through a parameter source such as `Query()`.
+   * The library fills those from the request and validates them, the same
+   * as parameters the route declares.
+   */
+  dependencyParameters(references) {
+    const names = /* @__PURE__ */ new Set();
+    let declaresSource = false;
+    for (const reference of references) {
+      const found = this.dependencyParameterTable.get(referenceKey(reference));
+      if (found === void 0) {
+        continue;
+      }
+      if (this.options.facts !== void 0) {
+        (0, import_resolution17.noteKeyRead)(this.options.facts, found.file);
+      }
+      for (const name of found.names) {
+        names.add(name);
+      }
+      declaresSource ||= found.declaresSource;
+    }
+    return { names, declaresSource };
   }
   wrappersFor(query) {
     const file = this.filesByPath.get(query.file);
@@ -11107,16 +11912,22 @@ var PythonWrapperIndex = class {
       pattern: query.pattern,
       form
     }));
-    if (file === void 0 || forms.length === 0) {
+    if (file === void 0) {
       return [];
     }
+    const decorators = this.decoratorLayers(query, file);
+    if (forms.length === 0) {
+      return decorators;
+    }
+    const own = this.ownRoutesOf(query);
     const found = [
       ...this.noted(
         EVERY_ROUTE,
         query.pack.name,
         this.everyRoute.get(query.pack.name)
       ),
-      ...this.ownRoutesOf(query)
+      ...own === null ? [] : this.mountedAbove(query, own.key),
+      ...own?.registered ?? []
     ];
     for (const declared of forms) {
       if (declared.form.type !== "dependency") {
@@ -11145,13 +11956,128 @@ var PythonWrapperIndex = class {
       seen.add(key);
       ordered.push(wrapper.reference);
     }
-    return ordered;
+    return [
+      ...ordered.filter((one) => one.onThrow !== true),
+      ...decorators,
+      ...ordered.filter((one) => one.onThrow === true)
+    ];
+  }
+  /**
+   * The decorators written on the route's function below the one that
+   * registers it, outermost first. Each wraps the function the library
+   * calls. None has a summary: a library's has no body in the run, and a
+   * project's own is not composed into the route yet, so a project
+   * decorator goes by what calling it writes, `require_admin(fn)`, which
+   * no summary is named. The decorators the packs read, such as the
+   * route's own and the namespace's `@ns.doc`, are left out.
+   */
+  decoratorLayers(query, file) {
+    const decorated = query.definitionNode.parent;
+    if (decorated === null || decorated.type !== "decorated_definition") {
+      return [];
+    }
+    const written = stripDecorators(decorated).decorators;
+    const routeAt = written.findIndex(
+      (decorator) => sameRange(rangeOf(decorator), query.classification.range)
+    );
+    return written.slice(routeAt + 1).flatMap((decorator) => this.decoratorLayer(decorator, query, file));
+  }
+  decoratorLayer(decorator, query, file) {
+    const facts = this.options.facts;
+    const direct = classifyDecorator(decorator, query.module, facts);
+    const written = decoratorCallee(decorator);
+    if (written === null || direct.module !== null && readByAPack(direct.module, this.options) || direct.objectName !== null && direct.objectName === query.classification.objectName || unwrapDecorator(decorator, facts) !== null) {
+      return [];
+    }
+    const project = written.type === "identifier" ? this.functionCalled(file.file, written.text) : null;
+    if (project !== null) {
+      if (facts !== void 0) {
+        (0, import_resolution17.noteKeyRead)(facts, project.file.file);
+      }
+      return [this.projectDecoratorLayer(project, query)];
+    }
+    return [{ file: direct.module ?? file.displayPath, name: written.text }];
+  }
+  /**
+   * The layer a project's own decorator puts around the route. When it
+   * hands back a closure written inside it that returns what calling the
+   * function it was given returns, the closure is summarized and
+   * composed into the route. Any other decorator, including one whose
+   * closure keeps going after that call, goes by the same name with no
+   * summary behind it.
+   */
+  projectDecoratorLayer(decorator, query) {
+    const continuation = parameterNamesOf(decorator.node)[0] ?? "";
+    const name = `${decorator.name}(${continuation})`;
+    const closure = closureReturnedBy(decorator.node);
+    const handsOn = closure === null || continuation === "" ? [] : callsThrough(closure, continuation);
+    if (closure === null || handsOn.length === 0 || !handsOn.every((statement) => returnsCallTo(statement, continuation))) {
+      return { file: decorator.file.displayPath, name };
+    }
+    return this.registeredClosure(
+      { file: decorator.file, node: closure, name, exportPath: [] },
+      { pack: query.pack, pattern: query.pattern, continuation }
+    );
+  }
+  /**
+   * What the mounts above the route's router register on the way down:
+   * the dependencies an `include_router` call lists, and those of each
+   * router it is mounted onto, outermost first, the order they run in.
+   */
+  mountedAbove(query, key) {
+    const position = query.pack.discovery.indexOf(query.pattern);
+    return [
+      ...this.noted(
+        MOUNTED,
+        [query.pack.name, position, key].join(MOUNTED_SEPARATOR),
+        this.registeredAbove(query.pack, query.pattern, key)
+      )
+    ];
+  }
+  registeredAbove(pack, pattern, key) {
+    const hops = this.options.routers?.mountsAbove(pattern, key) ?? null;
+    if (hops === null) {
+      return [];
+    }
+    const forms = (pattern.wrappers ?? []).flatMap(
+      (form) => form.type === "dependency" ? [{ pack, pattern, form }] : []
+    );
+    const found = [];
+    for (const hop of [...hops].reverse()) {
+      found.push(
+        ...hop.parentKey === null ? [] : this.ownRoutes.get(hop.parentKey) ?? []
+      );
+      const { keywordArgs } = readCallArguments(field(hop.call, "arguments"));
+      for (const declared of forms) {
+        const listed = keywordArgs[declared.form.keyword];
+        const names = listed === void 0 ? [] : dependencyNamesIn(listed.node, declared.form);
+        for (const name of names) {
+          const target = this.functionCalled(hop.file, name);
+          if (target !== null) {
+            found.push(this.registered(target, declared));
+          }
+        }
+      }
+    }
+    return found;
   }
   ownRoutesOf(query) {
+    const match = this.ownRouterOf(query);
+    return match === null ? null : {
+      key: match.key,
+      registered: this.noted(
+        OWN_ROUTES,
+        match.key,
+        this.ownRoutes.get(match.key)
+      )
+    };
+  }
+  /** The construction call of the router a route is decorated on, when a registrar reads it. */
+  ownRouterOf(query) {
     const site = this.objectSiteOf(query);
     const bound = site === null ? void 0 : this.filesByPath.get(site.file);
     if (site === null || bound === void 0) {
-      return [];
+      return null;
     }
     if (this.options.facts !== void 0) {
       (0, import_resolution17.noteKeyRead)(this.options.facts, site.file);
@@ -11165,12 +12091,46 @@ var PythonWrapperIndex = class {
         { pack: query.pack, pattern: query.pattern, form }
       );
       if (match !== null && match.registrar.covers === "ownRoutes") {
-        return [
-          ...this.noted(OWN_ROUTES, match.key, this.ownRoutes.get(match.key))
-        ];
+        return match;
       }
     }
-    return [];
+    return null;
+  }
+  /** Records the app a pack's routes run under, for the keywords written on its construction. */
+  recordApp(pack, call, file) {
+    const calls = this.appCalls.get(pack) ?? [];
+    if (!calls.some((one) => one.call === call)) {
+      calls.push({ call, file });
+    }
+    this.appCalls.set(pack, calls);
+  }
+  /**
+   * Every call that registers something for a route on the way to it:
+   * the app's construction, the mount calls and the routers they mount
+   * onto, and the route's own router. A caller reads a keyword off each.
+   */
+  callsAbove(query) {
+    const own = this.ownRouterOf(query);
+    const hops = own === null ? [] : this.options.routers?.mountsAbove(query.pattern, own.key) ?? [];
+    const parents = hops.flatMap((hop) => {
+      const node = hop.parentKey === null ? null : nodeOfResolutionKey(hop.parentKey, this.options.facts);
+      return node === null ? [] : [node];
+    });
+    const files = [
+      ...(this.appCalls.get(query.pack.name) ?? []).map((one) => one.file),
+      ...hops.map((hop) => hop.file)
+    ];
+    if (this.options.facts !== void 0) {
+      for (const file of files) {
+        (0, import_resolution17.noteKeyRead)(this.options.facts, file);
+      }
+    }
+    return [
+      ...(this.appCalls.get(query.pack.name) ?? []).map((one) => one.call),
+      ...hops.map((hop) => hop.call),
+      ...parents,
+      ...own === null ? [] : [own.call]
+    ];
   }
   /**
    * Where the decorator's object was built: the route's own file, the file
@@ -11215,6 +12175,38 @@ var PythonWrapperIndex = class {
     return this.unitsByFile.get(file) ?? [];
   }
 };
+function referenceKey(reference) {
+  return `${reference.file}::${reference.name}`;
+}
+function readByAPack(module2, options) {
+  return options.packs.some(
+    (pack) => pack.discovery.some((pattern) => pattern.importModule.includes(module2))
+  );
+}
+function decoratorCallee(decorator) {
+  const written = decorator.namedChild(0);
+  if (written === null) {
+    return null;
+  }
+  return written.type === "call" ? field(written, "function") : written;
+}
+function sameRange(a, b) {
+  return a.start === b.start && a.end === b.end;
+}
+function parameterNamesOf(definition) {
+  return children(field(definition, "parameters")).flatMap((parameter) => {
+    const named = parameterNameAndType(parameter);
+    return named === null ? [] : [named.name];
+  });
+}
+function declaresSourcedParameter(definition, sources) {
+  return children(field(definition, "parameters")).some((parameter) => {
+    const value = field(parameter, "value");
+    const callee = value?.type === "call" ? field(value, "function") : null;
+    const name = callee?.type === "attribute" ? field(callee, "attribute")?.text : callee?.text;
+    return name !== void 0 && sources.includes(name);
+  });
+}
 function isThrowForm(form) {
   return form.type === "decoratedWrapper" && form.throwParam !== void 0;
 }
@@ -11261,8 +12253,8 @@ function registerFrom(file, declared, index) {
 }
 function registerConstructorDependencies(file, declared, form, index) {
   const scope = file.module.moduleScope;
-  for (const stmt of file.root.namedChildren) {
-    const assignment2 = stmt?.type === "expression_statement" ? stmt.namedChildren.find((child) => child?.type === "assignment") : void 0;
+  for (const stmt of children(file.root)) {
+    const assignment2 = stmt?.type === "expression_statement" ? children(stmt).find((child) => child?.type === "assignment") : void 0;
     const left = assignment2 === void 0 || assignment2 === null ? null : field(assignment2, "left");
     if (left?.type !== "identifier") {
       continue;
@@ -11277,6 +12269,9 @@ function registerConstructorDependencies(file, declared, form, index) {
     if (match === null) {
       continue;
     }
+    if (match.registrar.covers === "everyRoute") {
+      index.recordApp(declared.pack.name, match.call, file.file);
+    }
     const { keywordArgs } = readCallArguments(field(match.call, "arguments"));
     const listed = keywordArgs[form.keyword];
     if (listed === void 0) {
@@ -11294,7 +12289,7 @@ function coverageOf(match, pack) {
   return match.registrar.covers === "everyRoute" ? { kind: "everyRoute", pack: pack.name } : { kind: "ownRoutes", key: match.key };
 }
 function registerDecorated(file, declared, form, index) {
-  (0, import_extractor15.walkDescendants)(file.root, file.module.moduleScope, {
+  (0, import_extractor17.walkDescendants)(file.root, file.module.moduleScope, children, {
     at: (node, scope) => {
       if (node.type !== "decorated_definition") {
         return;
@@ -11330,7 +12325,7 @@ function registerDecorated(file, declared, form, index) {
   });
 }
 function dependencyNamesIn(node, form) {
-  const calls = node.type === "list" ? node.namedChildren : [node];
+  const calls = node.type === "list" ? children(node) : [node];
   const names = [];
   for (const call of calls) {
     const name = call === null ? null : dependencyNameOf(call, form);
@@ -11349,7 +12344,7 @@ function dependencyNameOf(node, form) {
   if (calleeName3 === null || !form.callees.includes(calleeName3)) {
     return null;
   }
-  const first = field(node, "arguments")?.namedChildren[0];
+  const first = field(node, "arguments")?.namedChild(0);
   return first?.type === "identifier" ? first.text : null;
 }
 function decoratorDependencies(classification, form) {
@@ -11367,7 +12362,7 @@ function parameterDependencies(definitionNode, form) {
     if (direct !== null) {
       return direct;
     }
-    for (const child of node.namedChildren) {
+    for (const child of children(node)) {
       const found = findIn(child, depth + 1);
       if (found !== null) {
         return found;
@@ -11375,10 +12370,7 @@ function parameterDependencies(definitionNode, form) {
     }
     return null;
   };
-  for (const param of field(definitionNode, "parameters")?.namedChildren ?? []) {
-    if (param === null) {
-      continue;
-    }
+  for (const param of children(field(definitionNode, "parameters"))) {
     const inDefault = field(param, "value");
     const found = inDefault === null ? findIn(field(param, "type"), 0) : dependencyNameOf(inDefault, form);
     if (found !== null) {
@@ -11388,15 +12380,42 @@ function parameterDependencies(definitionNode, form) {
   return names;
 }
 function wrapperUnit(target, declared, options) {
+  return unitAround(
+    target,
+    declared.pattern,
+    {
+      continuations: continuationStatements(target.node, declared.form),
+      continuationName: null,
+      form: declared.form,
+      nameKind: "binding"
+    },
+    options
+  );
+}
+function closureUnit(target, closure, options) {
+  return unitAround(
+    target,
+    closure.pattern,
+    {
+      continuations: callsThrough(target.node, closure.continuation),
+      continuationName: closure.continuation,
+      form: null,
+      nameKind: "label"
+    },
+    options
+  );
+}
+function unitAround(target, pattern, reading, options) {
   const { file, node, name, exportPath } = target;
   const body = field(node, "body");
   const range = rangeOf(node);
   const raised = raisedResponses(body, {
-    calls: declared.pattern.responseStatusCalls ?? [],
+    calls: pattern.responseStatusCalls ?? [],
     module: file.module,
-    facts: options.facts
+    facts: options.facts,
+    constants: pattern.statusCodeConstants ?? {}
   });
-  const continuations = continuationStatements(node, declared.form);
+  const continuations = reading.continuations;
   const terminals = bodyTerminals(body, raised, continuations);
   const effects = invocationEffects(node, options.facts);
   const extra = recognizedBodyEffects(
@@ -11405,7 +12424,7 @@ function wrapperUnit(target, declared, options) {
     options.storageFor(file),
     options.facts
   );
-  const delegate = (at) => ({
+  const delegate = (at, to = null) => ({
     terminal: {
       kind: "delegate",
       statusCode: null,
@@ -11414,18 +12433,18 @@ function wrapperUnit(target, declared, options) {
       message: null,
       component: null,
       renderTree: null,
-      delegateTarget: null,
+      delegateTarget: to,
       emitEvent: null,
       location: rangeOf(at)
     },
     location: rangeOf(at)
   });
   const respond = (statement) => returnBranch(statement, {
-    pattern: declared.pattern,
-    responseShape: { reading: import_extractor15.absentReading },
+    pattern,
+    responseShape: { reading: import_extractor17.absentReading },
     declaredStatus: {
-      reading: import_extractor15.absentReading,
-      ...declared.pattern.defaultStatusCode !== void 0 ? { libraryDefault: declared.pattern.defaultStatusCode } : {}
+      reading: import_extractor17.absentReading,
+      ...pattern.defaultStatusCode !== void 0 ? { libraryDefault: pattern.defaultStatusCode } : {}
     },
     module: file.module,
     facts: options.facts
@@ -11437,7 +12456,10 @@ function wrapperUnit(target, declared, options) {
         location: rangeOf(terminal.statement)
       };
     }
-    if (terminal.type === "continuation" || returnHandsOn(terminal.statement, declared.form)) {
+    if (terminal.type === "continuation") {
+      return delegate(terminal.statement, reading.continuationName);
+    }
+    if (reading.form !== null && returnHandsOn(terminal.statement, reading.form)) {
       return delegate(terminal.statement);
     }
     return respond(terminal.statement);
@@ -11454,7 +12476,7 @@ function wrapperUnit(target, declared, options) {
   return {
     identity: {
       name,
-      nameKind: "binding",
+      nameKind: reading.nameKind,
       kind: "middleware",
       file: file.displayPath,
       range,
@@ -11478,7 +12500,7 @@ function returnHandsOn(statement, form) {
     return false;
   }
   if (form.returnedValueResponds === true) {
-    const returned = statement.namedChildren[0];
+    const returned = statement.namedChild(0);
     return returned === void 0 || returned === null || returned.type === "none";
   }
   return true;
@@ -11487,32 +12509,52 @@ function continuationStatements(node, form) {
   if (form.type !== "decoratedWrapper" || form.continuationParam === void 0) {
     return [];
   }
-  const params = (field(node, "parameters")?.namedChildren ?? []).filter(
-    (param2) => param2 !== null
-  );
+  const params = children(field(node, "parameters"));
   const param = params[form.continuationParam];
   const continuation = param === void 0 ? null : field(param, "name")?.text ?? (param.type === "identifier" ? param.text : null);
-  if (continuation === null) {
-    return [];
-  }
+  return continuation === null ? [] : callsThrough(node, continuation);
+}
+function callsThrough(node, callee) {
   const body = field(node, "body");
   if (body === null) {
     return [];
   }
   const found = [];
   for (const call of bodyCalls(body)) {
-    const callee = field(call, "function");
-    const statement = callee?.type === "identifier" && callee.text === continuation ? enclosingStatement(call, body) : null;
+    const called = field(call, "function");
+    const statement = called?.type === "identifier" && called.text === callee ? enclosingStatement(call, body) : null;
     if (statement !== null) {
       found.push(statement);
     }
   }
   return found;
 }
+function returnsCallTo(statement, callee) {
+  if (statement.type !== "return_statement") {
+    return false;
+  }
+  const value = statement.namedChild(0);
+  const call = value?.type === "await" ? value.namedChild(0) : value;
+  return call?.type === "call" && field(call, "function")?.text === callee;
+}
+function closureReturnedBy(decorator) {
+  const statements = children(field(decorator, "body"));
+  const returned = statements.find((statement) => statement.type === "return_statement")?.namedChild(0);
+  if (returned?.type !== "identifier") {
+    return null;
+  }
+  for (const statement of statements) {
+    const { definition } = stripDecorators(statement);
+    if (definition.type === "function_definition" && field(definition, "name")?.text === returned.text) {
+      return definition;
+    }
+  }
+  return null;
+}
 
 // src/project.ts
 function keptPythonParses() {
-  return new import_extractor16.KeptParses(({ root }) => root.tree.delete());
+  return new import_extractor18.KeptParses(({ root }) => root.tree.delete());
 }
 async function parsePythonAhead(files, kept) {
   for (const file of files) {
@@ -11601,16 +12643,16 @@ function factsForFile(options) {
 }
 async function extractPythonProject(options) {
   const { roots, unreadManifests } = rootsOfRun(options);
-  const timer = options.onTiming !== void 0 ? (0, import_extractor16.createTimer)() : (0, import_extractor16.noopTimer)();
+  const timer = options.onTiming !== void 0 ? (0, import_extractor18.createTimer)() : (0, import_extractor18.noopTimer)();
   const cacheDir = adapterStamp.declineWhenRunFromSource(
-    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? import_node_path5.default.join(options.projectRoot, ".suss", "cache") : null)
+    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? (0, import_extractor18.extractionCacheDirFor)(options.projectRoot) : null)
   );
-  const layer = (0, import_extractor16.createCacheLayer)(cacheDir);
+  const layer = (0, import_extractor18.createCacheLayer)(cacheDir);
   const packsDigest = `${adapterStamp.packsDigest(
     options.packs.map(
       (pack) => pack.version !== void 0 ? { name: pack.name, version: pack.version } : { name: pack.name }
     )
-  )}|${(0, import_extractor16.extractionConfigStamp)({
+  )}|${(0, import_extractor18.extractionConfigStamp)({
     gapHandling: options.gapHandling,
     workspaceRoot: options.workspaceRoot,
     projectRoot: options.projectRoot,
@@ -11620,17 +12662,20 @@ async function extractPythonProject(options) {
   })}`;
   const input = {
     files: cacheDir === null ? [] : options.files,
-    adapterPacksDigest: cacheDir === null ? packsDigest : (0, import_extractor16.runDigest)(packsDigest, options.packs, options.files)
+    adapterPacksDigest: cacheDir === null ? packsDigest : (0, import_extractor18.runDigest)(packsDigest, options.packs, options.files)
   };
   const lookup = await timer.timeAsync(
     "cache.lookup",
     () => layer.lookup(input)
   );
+  const composed = (stored) => (0, import_extractor18.composeWrappers)(stored, {
+    gapHandling: options.gapHandling ?? "permissive"
+  });
   if (lookup.kind === "hit") {
     options.onCacheDiagnostic?.(lookup.diagnostic);
     options.onTiming?.(timer.report());
     return {
-      summaries: lookup.summaries,
+      summaries: composed(lookup.summaries),
       facts: new import_datalog2.Database(),
       roots,
       unreadManifests
@@ -11645,7 +12690,7 @@ async function extractPythonProject(options) {
     options.onCacheDiagnostic?.({ kind: "hit" });
     options.onTiming?.(timer.report());
     return {
-      summaries: plan.allSummaries(),
+      summaries: composed(plan.allSummaries()),
       facts: new import_datalog2.Database(),
       roots,
       unreadManifests
@@ -11682,7 +12727,7 @@ async function runPython(options, roots, cache, previous) {
   const db = new import_datalog2.Database();
   const summaries = [];
   const gapHandling = options.gapHandling ?? "permissive";
-  const tallies = (0, import_extractor8.createPackTallies)(options.packs);
+  const tallies = (0, import_extractor10.createPackTallies)(options.packs);
   const ledger = cacheDir === null ? null : new import_resolution18.DependencyLedger(options.files);
   const log = ledger === null ? null : new import_resolution18.FactLog(db, ledger);
   if (ledger !== null) {
@@ -11790,7 +12835,8 @@ async function runPython(options, roots, cache, previous) {
       roots,
       facts: needsValues ? db : void 0,
       definitions,
-      storageFor
+      storageFor,
+      routers: plainRouterIndex
     })
   );
   const importedDefinition2 = importedDefinitionLookup(db, bound);
@@ -11826,15 +12872,10 @@ async function runPython(options, roots, cache, previous) {
   });
   let registering = null;
   if (ledger !== null) {
-    wrapperIndex.onRegistered = (target, declared) => {
-      const form = positions.positionOf(declared);
-      if (registering !== null && form !== void 0) {
-        registering.push({
-          key: nodeId(target.file.file, target.node),
-          name: target.name,
-          exportPath: target.exportPath,
-          form
-        });
+    wrapperIndex.onRegistered = (target, how) => {
+      const stored = storedRegistration(target, how, positions);
+      if (registering !== null && stored !== null) {
+        registering.push(stored);
       }
     };
   }
@@ -11847,12 +12888,11 @@ async function runPython(options, roots, cache, previous) {
     if (record !== void 0) {
       discoveries.set(file, record);
       for (const registration of record.registrations) {
-        const declared = positions.formAt(registration.form);
-        const target = storedFunction(registration, definitions, filesByPath);
-        if (declared === void 0 || target === null) {
-          throw new ReplayFailed(registration.key);
-        }
-        wrapperIndex.registered(target, declared);
+        registerAgain(registration, {
+          positions,
+          wrapperIndex,
+          target: storedFunction(registration, definitions, filesByPath)
+        });
       }
       continue;
     }
@@ -11937,11 +12977,11 @@ async function runPython(options, roots, cache, previous) {
   const assemble = (raw, boundFile) => {
     const summary = timer.time(
       "summarize",
-      () => (0, import_extractor16.assembleSummary)(raw, { gapHandling })
+      () => (0, import_extractor18.assembleSummary)(raw, { gapHandling })
     );
     summaries.push(summary);
     assembledHere.add(summary);
-    (0, import_extractor8.tallyUnit)(tallies, raw.boundaryBinding?.recognition);
+    (0, import_extractor10.tallyUnit)(tallies, raw.boundaryBinding?.recognition);
     const span = raw.identity.span;
     const key = span === void 0 ? null : `${boundFile.file}:${span.start}-${span.end}`;
     if (key !== null) {
@@ -11958,7 +12998,7 @@ async function runPython(options, roots, cache, previous) {
         const summary = structuredClone(unit.summary);
         summariesReused += 1;
         summaries.push(summary);
-        (0, import_extractor8.tallyUnit)(tallies, unit.recognition);
+        (0, import_extractor10.tallyUnit)(tallies, unit.recognition);
         if (unit.seedKey !== void 0) {
           seedFrom(unit.seedKey, boundFile, summary);
         }
@@ -12016,12 +13056,13 @@ async function runPython(options, roots, cache, previous) {
   const placeWhatItReached = (summary, key) => {
     if (gapHandling !== "silent") {
       summary.gaps.push(
-        ...(reached.stopsByKey.get(key) ?? []).map(import_behavioral_ir9.unfollowedCallGap)
+        ...(reached.stopsByKey.get(key) ?? []).map(import_behavioral_ir10.unfollowedCallGap)
       );
     }
-    (0, import_behavioral_ir9.placeCalls)(summary, reached.targetsByKey.get(key));
-    (0, import_behavioral_ir9.placeArgTargets)(summary, reached.argTargetsByKey.get(key));
-    (0, import_behavioral_ir9.placeCalleeParameters)(summary, reached.parameterCallsByKey.get(key));
+    (0, import_behavioral_ir10.placeCalls)(summary, reached.targetsByKey.get(key));
+    (0, import_behavioral_ir10.placeArgTargets)(summary, reached.argTargetsByKey.get(key));
+    (0, import_behavioral_ir10.placePossibleCalls)(summary, reached.possibleTargetsByKey.get(key));
+    (0, import_behavioral_ir10.placeCalleeParameters)(summary, reached.parameterCallsByKey.get(key));
   };
   for (const [key, owners] of summariesBySeed) {
     for (const summary of owners) {
@@ -12038,7 +13079,7 @@ async function runPython(options, roots, cache, previous) {
     }
   }
   if (gapHandling !== "silent") {
-    (0, import_behavioral_ir9.recordParameterGaps)(
+    (0, import_behavioral_ir10.recordParameterGaps)(
       reached.parameterCallsByKey,
       summariesBySeed,
       reached.passedPositions
@@ -12062,8 +13103,8 @@ async function runPython(options, roots, cache, previous) {
     }
     const summary = timer.time(
       "summarize",
-      () => (0, import_extractor16.assembleSummary)(
-        (0, import_extractor16.moduleInitStructure)({
+      () => (0, import_extractor18.assembleSummary)(
+        (0, import_extractor18.moduleInitStructure)({
           name: import_node_path5.default.basename(displayPath),
           file: displayPath,
           range: rangeOf(boundFile.root),
@@ -12072,7 +13113,7 @@ async function runPython(options, roots, cache, previous) {
             ...charged(
               boundFile.file,
               () => moduleLoadInvocationEffects(boundFile.root, db)
-            ).map(import_extractor16.effectToIR)
+            ).map(import_extractor18.effectToIR)
           ]
         }),
         { gapHandling }
@@ -12092,34 +13133,38 @@ async function runPython(options, roots, cache, previous) {
     throw new ReplayFailed("");
   }
   const resolvedImports = (0, import_resolution18.importedFilesByFile)(db, displayPathOf);
-  (0, import_extractor16.stampModuleImports)(summaries, (file) => resolvedImports.get(file) ?? []);
-  (0, import_extractor16.stampModules)(summaries, declaredModules, options.workspaceRoot);
+  (0, import_extractor18.stampModuleImports)(summaries, (file) => resolvedImports.get(file) ?? []);
+  (0, import_extractor18.stampModules)(summaries, declaredModules, options.workspaceRoot);
   const idRoot = options.projectRoot ?? options.workspaceRoot;
   for (const summary of summaries) {
     const absoluteFile = options.workspaceRoot === void 0 ? summary.location.file : import_node_path5.default.resolve(options.workspaceRoot, summary.location.file);
-    summary.identity.id = (0, import_behavioral_ir9.summaryIdFromParts)({
+    summary.identity.id = (0, import_behavioral_ir10.summaryIdFromParts)({
       workspace: void 0,
       file: idRoot === void 0 ? absoluteFile : import_node_path5.default.relative(idRoot, absoluteFile),
       name: summary.identity.name,
       exportPath: summary.identity.exportPath
     });
   }
-  (0, import_behavioral_ir9.disambiguateSummaryIds)(summaries);
-  (0, import_behavioral_ir9.linkCallsToSummaries)(summaries);
+  (0, import_behavioral_ir10.disambiguateSummaryIds)(summaries);
+  (0, import_behavioral_ir10.linkCallsToSummaries)(summaries);
   const composed = timer.time("summarize", () => {
     markExitCodeFunctions(summaries, exits, db, options.workspaceRoot);
-    return (0, import_extractor16.composeWrappers)(summaries, { gapHandling });
+    return (0, import_extractor18.composeWrappers)(summaries, { gapHandling });
   });
+  const walkedFiles = new Map(
+    bound.map(({ file, displayPath }) => [displayPath, file])
+  );
   await timer.timeAsync("cache.write", async () => {
-    if (cacheDir === null || composed.length === 0) {
+    if (cacheDir === null || summaries.length === 0) {
       return;
     }
     try {
       await cache.layer.write(
         cache.input,
-        composed,
+        summaries,
         log === null || ledger === null || overBudget ? void 0 : pythonAttribution({
-          composed,
+          summaries,
+          walkedFileOf: (locationFile) => walkedFiles.get(locationFile),
           discoveries,
           charges,
           unitDrafts,
@@ -12174,6 +13219,39 @@ async function runPython(options, roots, cache, previous) {
   options.onTiming?.(timer.report());
   return { summaries: composed, facts: db };
 }
+function storedRegistration(target, how, positions) {
+  const at = {
+    key: nodeId(target.file.file, target.node),
+    name: target.name,
+    exportPath: target.exportPath
+  };
+  if ("continuation" in how) {
+    const pattern = positions.idOf(how.pattern);
+    return pattern === void 0 ? null : { ...at, pattern, continuation: how.continuation };
+  }
+  const form = positions.positionOf(how);
+  return form === void 0 ? null : { ...at, form };
+}
+function registerAgain(registration, context) {
+  const { positions, wrapperIndex, target } = context;
+  const how = howRegistered(registration, positions);
+  if (target === null || how === null) {
+    throw new ReplayFailed(registration.key);
+  }
+  if ("continuation" in how) {
+    wrapperIndex.registeredClosure(target, how);
+    return;
+  }
+  wrapperIndex.registered(target, how);
+}
+function howRegistered(registration, positions) {
+  if (!("continuation" in registration)) {
+    return positions.formAt(registration.form) ?? null;
+  }
+  const pack = positions.packOf(registration.pattern);
+  const pattern = positions.patternOf(registration.pattern);
+  return pack === void 0 || pattern === void 0 ? null : { pack, pattern, continuation: registration.continuation };
+}
 function pythonAttribution(args) {
   const walkedByFile = (0, import_resolution18.walkRecordsByFile)({
     scans: args.reached.scans,
@@ -12202,7 +13280,10 @@ function pythonAttribution(args) {
       }
     };
   });
-  return { roots, owners: args.composed.map(() => []) };
+  return {
+    roots,
+    owners: (0, import_extractor18.ownersWhereWritten)(args.summaries, args.walkedFileOf)
+  };
 }
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
   "__pycache__",
@@ -12233,7 +13314,7 @@ function indexDefinitions(into, file, node) {
   if (isFunction(node)) {
     into.set(nodeId(file, node), node);
   }
-  for (const child of node.namedChildren) {
+  for (const child of children(node)) {
     if (child !== null) {
       indexDefinitions(into, file, child);
     }
@@ -12499,7 +13580,7 @@ function importSitesIn(root) {
         found.push({ module: entry.module, name: entry.name, line });
       }
     }
-    for (const child of node.namedChildren) {
+    for (const child of children(node)) {
       if (child !== null) {
         visit(child);
       }