@suss/adapter-python 0.34.0 → 0.35.0

package/dist/index.js

@@ -82,10 +82,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;
@@ -97,7 +94,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);
@@ -129,11 +148,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 IdSet {
 };
 var NodeMap = class extends IdMap {
@@ -195,7 +262,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;
     }
@@ -224,12 +291,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);
   }
 }
@@ -270,10 +337,7 @@ function bindImportStatement(stmt, scope) {
 function relativeImportParts(node) {
   let relativeLevel = 0;
   let module = "";
-  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;
@@ -290,8 +354,8 @@ function bindImportFromStatement(stmt, scope, ctx) {
     return;
   }
   const { module, 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(
@@ -349,10 +413,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" });
@@ -369,9 +430,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")) {
@@ -398,8 +457,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;
@@ -416,15 +475,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" });
     }
   }
@@ -573,18 +632,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) {
@@ -592,6 +642,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 };
@@ -618,8 +685,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(
@@ -628,7 +696,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);
@@ -645,12 +713,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);
@@ -702,22 +768,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;
@@ -727,6 +815,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 };
@@ -743,8 +834,10 @@ import { nodeOfKey, noteKeyRead } from "@suss/resolution";
 import { Evaluator, force, literalOf as literalOf2 } from "@suss/values";
 
 // src/facts/resolve.ts
+import { isTestFile } from "@suss/behavioral-ir";
 import {
   allocationSitesOf,
+  answersFromTestsLeftOut,
   askResolution,
   askResolutionUnder,
   askSources,
@@ -802,7 +895,13 @@ function constructionSites(db, classKey) {
 }
 function writtenValueOf(db, key) {
   resolveWritten(db, [key]);
-  return sharedWrittenValueOf(db, key, (keys) => resolveWritten(db, keys));
+  return sharedWrittenValueOf(
+    db,
+    key,
+    (keys) => resolveWritten(db, keys),
+    void 0,
+    answersFromTestsLeftOut(key, isTestFile)
+  );
 }
 function writtenValuesOf(db, key) {
   resolveWritten(db, [key]);
@@ -886,10 +985,14 @@ function objectReturnedBy(db, callKey) {
 
 // src/facts/values.ts
 import {
+  addEntryRows,
+  addTemplateRows,
   NAMED_STORE_NAME,
   RECEIVER_STORE_NAME,
+  SPREAD_ENTRY,
   startsAtName,
   UNPLACED_STORE_NAME,
+  VALUE_ENTRY,
   valueLeftByWrites,
   writesRunInOrder
 } from "@suss/resolution";
@@ -900,6 +1003,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) {
@@ -1071,8 +1176,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);
   }
 }
@@ -1121,6 +1225,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,
@@ -1130,12 +1235,21 @@ function emitSequence(emitter, sequence) {
       valueKey(emitter, element)
     );
     position += 1;
+    if (element.type !== "comment") {
+      entries.push(writtenEntry(emitter, element));
+    }
   }
+  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;
     }
@@ -1144,6 +1258,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;
@@ -1156,6 +1271,15 @@ function emitDictionary(emitter, dictionary) {
       valueKey(emitter, value)
     );
   }
+  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: VALUE_ENTRY } : { key: valueKey(emitter, unpacked), form: SPREAD_ENTRY };
+}
+function rowsOf(emitter) {
+  return (relation, row) => add(emitter, relation, ...row);
 }
 function emitAttribute(emitter, attribute) {
   const object = field(attribute, "object");
@@ -1220,13 +1344,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);
@@ -1362,6 +1523,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);
@@ -1369,6 +1610,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);
@@ -1398,6 +1640,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) {
+    addTemplateRows(rowsOf(emitter), nodeId(emitter.filePath, child), pieces);
+  }
   const branches = fallbackBranchesOf(child, type);
   if (branches !== null) {
     for (const branch of branches) {
@@ -1430,10 +1679,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);
@@ -1505,7 +1754,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;
@@ -1916,6 +2165,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) {
@@ -1935,6 +2187,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;
@@ -2543,9 +2809,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" };
@@ -2639,6 +2903,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: [
@@ -2727,6 +2992,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";
 }
@@ -3139,6 +3417,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;
@@ -3361,7 +3643,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" };
@@ -3372,10 +3654,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");
@@ -3501,10 +3780,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]
@@ -3527,8 +3806,14 @@ import {
 import { constantOf as constantOf5, literalOf as literalOf6, pathOf as pathOf2 } from "@suss/values";
 
 // src/clientCalls.ts
-import { hasNameHole, restBinding } from "@suss/behavioral-ir";
-import { pathOf } from "@suss/values";
+import {
+  hasNameHole,
+  restBinding,
+  statusMembersOf,
+  testsStatus
+} from "@suss/behavioral-ir";
+import { redirectDeliveryWhenSet } from "@suss/extractor";
+import { hostOf, pathOf, scalarOf } from "@suss/values";
 
 // src/paths/bodyBranches.ts
 import { enumerateOrDegrade as enumerateOrDegrade2, guardsHoldOn } from "@suss/extractor";
@@ -3549,7 +3834,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);
@@ -3601,7 +3886,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) {
@@ -3630,14 +3915,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) {
@@ -3652,11 +3937,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)
     );
   }
@@ -3682,7 +3967,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;
       }
@@ -3710,12 +3995,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
@@ -3764,7 +4047,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 {
@@ -3776,10 +4059,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 {
@@ -3795,7 +4078,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 {
@@ -3876,7 +4159,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;
     }
@@ -3888,7 +4171,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;
     }
@@ -3928,7 +4211,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
   );
 }
@@ -3939,6 +4222,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 [];
@@ -3946,14 +4232,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);
     }
@@ -4027,11 +4317,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 } : {}
+      }
     };
   });
 }
@@ -4066,7 +4359,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;
   }
@@ -4262,7 +4555,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;
@@ -4626,7 +4919,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 [];
@@ -4645,13 +4938,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);
@@ -4716,14 +5033,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: storageBinding2({
       recognition: "python-storage",
       storageSystem: pattern.storageSystem,
       scope: "default",
-      container: modelOf(chain, options)
+      container: model
     }),
     callee: chain.last.text,
     interaction: {
@@ -4999,10 +5317,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;
     }
@@ -5059,7 +5374,8 @@ function enumerateBodyBranches(options) {
   const enumerated = enumerateOrDegrade2(
     {
       statements: lowered.statements,
-      terminalsByStmt: lowered.terminalsByStmt
+      terminalsByStmt: lowered.terminalsByStmt,
+      ...options.keepsArms === void 0 ? {} : { keepsArms: options.keepsArms }
     },
     statements
   );
@@ -5096,66 +5412,296 @@ function enumerateBodyBranches(options) {
   return branches;
 }
 
-// src/clientCalls.ts
-function clientCallUnits(root, module, 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, module, options)) {
-        units.push(
-          clientUnit(definition, name, request, pattern, pack, options)
-        );
-      }
-    }
+// src/paths/raisedResponses.ts
+import { constantOf as constantOf4 } from "@suss/values";
+function statusNumberOf(node, options) {
+  const value = constantOf4(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, module) {
+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, module) !== 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, module, options) {
-  const callee = field(call, "function");
-  const attribute = callee === null ? null : calledAttribute(callee, pattern, module, 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 && !hasNameHole(plain.path)) {
-    return [plain];
+  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 byBoundary = /* @__PURE__ */ new Map();
-  for (const site of constructionSitesOf(call, options.facts)) {
-    const stated = requestCall(call, attribute, pattern, options, site);
+  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
+import { helperPathsOnVariables, splitAtHandOffs } from "@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) => 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 : 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, module, 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, module, options)) {
+        units.push(
+          clientUnit(definition, name, request, pattern, pack, options)
+        );
+      }
+    }
+  }
+  return units;
+}
+function clientCallReceivers(root, module) {
+  const found = [];
+  for (const definition of functionDefinitions(root)) {
+    for (const call of bodyCalls(definition)) {
+      const callee = field(call, "function");
+      if (callee === null || originOf(callee, module) !== null) {
+        continue;
+      }
+      const object = field(callee, "object");
+      if (object !== null && field(callee, "attribute") !== null) {
+        found.push(object);
+      }
+    }
+  }
+  return found;
+}
+function functionDefinitions(node, found = []) {
+  for (const child of children(node)) {
+    if (isFunction(child)) {
+      found.push(child);
+    }
+    functionDefinitions(child, found);
+  }
+  return found;
+}
+function requestCalls(call, pattern, module, options) {
+  const callee = field(call, "function");
+  const attribute = callee === null ? null : calledAttribute(callee, pattern, module, options.facts);
+  if (attribute === null) {
+    return [];
+  }
+  const plain = requestCall(call, attribute, pattern, options);
+  if (plain !== null && !hasNameHole(plain.path)) {
+    return [plain];
+  }
+  const byBoundary = /* @__PURE__ */ new Map();
+  for (const site of constructionSitesOf(call, options.facts)) {
+    const stated = requestCall(call, attribute, pattern, options, site);
     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);
     }
@@ -5166,16 +5712,33 @@ function requestCalls(call, pattern, module, 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 = scalarOf(evaluatedValue(argument, options.facts, site));
+  return value === null ? void 0 : 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) {
@@ -5190,14 +5753,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, module, facts) {
   const origin = originOf(callee, module);
@@ -5230,7 +5798,9 @@ function urlAt(call, position, keyword, options, site) {
   if (argument === null) {
     return null;
   }
-  return pathOf(evaluatedValue(argument, options.facts, site)) ?? null;
+  const value = evaluatedValue(argument, options.facts, site);
+  const path8 = pathOf(value);
+  return path8 === void 0 ? null : { path: path8, host: hostOf(value) };
 }
 function argumentAt(call, position, keyword) {
   const args = field(call, "arguments");
@@ -5248,25 +5818,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) => 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 {
@@ -5302,11 +5880,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 = 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,
@@ -5322,11 +5913,13 @@ function clientUnit(definition, name, request, pattern, pack, options) {
       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
@@ -5549,7 +6142,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;
 }
@@ -5572,7 +6165,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") {
@@ -5610,7 +6203,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)
@@ -5654,7 +6247,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) {
@@ -5698,7 +6291,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);
@@ -5738,7 +6331,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;
@@ -5761,7 +6354,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) {
@@ -5819,7 +6412,7 @@ function envReadEffects(root, module, facts) {
   const slots = [];
   const readsHelpers = facts !== void 0 && sitesByDb.has(facts);
   const startScope = module.scopeFor.get(root.id) ?? module.moduleScope;
-  walkDescendants(root, startScope, {
+  walkDescendants(root, startScope, children, {
     at: (node, scope) => {
       const syntax = envReadSyntaxAt(node, scope);
       if (syntax !== null) {
@@ -5878,7 +6471,7 @@ function hasFallback(node, spelling, scope) {
 }
 function envFactsIn(filePath, root, module) {
   const found = { sites: [], objects: [] };
-  walkDescendants(root, module.moduleScope, {
+  walkDescendants(root, module.moduleScope, children, {
     at: (node, scope) => {
       if (isEnviron(node, scope) && handsOnward(node)) {
         found.objects.push(keyOf(filePath, node));
@@ -6096,137 +6689,6 @@ function readsThroughHelper(db, call, argumentAt2, siteById, named) {
   );
 }
 
-// src/paths/raisedResponses.ts
-import { constantOf as constantOf4 } from "@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 = constantOf4(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 = {
@@ -6286,7 +6748,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;
   }
@@ -6310,7 +6772,7 @@ function isStdlibModule(node, scope, module) {
   const binding = resolveName(scope, node.text);
   return binding?.kind === "import" && binding.module === module && 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, module, name) {
@@ -6332,7 +6794,7 @@ var DEFERRED_BODY_TYPES2 = /* @__PURE__ */ new Set(["function_definition", "lamb
 function streamWriteEffects(root, module) {
   const found = [];
   const startScope = module.scopeFor.get(root.id) ?? module.moduleScope;
-  walkDescendants2(root, startScope, {
+  walkDescendants2(root, startScope, children, {
     at: (node, scope) => {
       if (node.type !== "call") {
         return;
@@ -6358,7 +6820,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"
     );
@@ -6419,7 +6881,7 @@ function jsonDumped(node, scope) {
 // src/discovery.ts
 function decoratedNodes(root) {
   const found = [];
-  walkDescendants3(root, null, {
+  walkDescendants3(root, null, children, {
     at: (node) => {
       if (node.type !== "decorated_definition") {
         return;
@@ -6802,7 +7264,7 @@ function readRouterPrefix(pattern, classification, module, options, range) {
   }
   return absentReading;
 }
-function readStatusCode(pattern, classification) {
+function readStatusCode(pattern, classification, options) {
   if (pattern.statusCodeKeyword === void 0) {
     return absentReading;
   }
@@ -6810,11 +7272,15 @@ function readStatusCode(pattern, classification) {
   if (arg === void 0) {
     return absentReading;
   }
-  if (arg.kind === "number") {
-    return writtenReading(arg.value, classification.range);
+  const status = statusNumberOf(arg.node, {
+    ...options,
+    constants: pattern.statusCodeConstants ?? {}
+  });
+  if (status !== null) {
+    return writtenReading(status, classification.range);
   }
   return unreadableReading(
-    "The status this route's decorator states is not a literal number, so the response claims no status",
+    "The status this route's decorator states does not come to a number here, so the response claims no status",
     classification.range
   );
 }
@@ -6835,11 +7301,14 @@ 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) {
@@ -6859,6 +7328,22 @@ function returnStatusReading(statement, ctx) {
 function returnBranch(statement, ctx) {
   const range = rangeOf(statement);
   const writtenBody = returnedBodyShape(statement);
+  return responseBranchAt(
+    range,
+    returnStatusReading(statement, ctx),
+    writtenBody === null ? ctx.responseShape.reading : writtenReading(writtenBody, range),
+    ctx
+  );
+}
+function fallthroughBranch(definitionNode, ctx) {
+  return responseBranchAt(
+    rangeOf(definitionNode),
+    ctx.pattern.statusFromReturnedTuple === true ? absentReading : ctx.declaredStatus.reading,
+    ctx.responseShape.reading,
+    ctx
+  );
+}
+function responseBranchAt(range, status, body, ctx) {
   return {
     terminal: {
       kind: "response",
@@ -6875,12 +7360,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 : writtenReading(writtenBody, range)
-    },
+    bodyShapeReading: { reading: body },
     location: range
   };
 }
@@ -6901,11 +7384,12 @@ function branchesPerTerminal(options) {
   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({
@@ -6914,6 +7398,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;
@@ -6922,7 +7407,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" };
@@ -7016,6 +7502,25 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
     module.scopeFor,
     options.importedDefinition ?? null
   );
+  const wrappers = wrappersAround(
+    pattern,
+    pack,
+    classification,
+    functionNode,
+    module,
+    options
+  );
+  const dependencyParameters = options.wrappers?.dependencyParameters(
+    wrappers
+  ) ?? { names: /* @__PURE__ */ new Set(), declaresSource: false };
+  const declaredStatuses = declaredStatusesOf(
+    pattern,
+    pack,
+    classification,
+    functionNode,
+    module,
+    options
+  );
   return readRoutePaths(
     pattern,
     readPathArgument(classification, options),
@@ -7028,6 +7533,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 } : {},
@@ -7044,7 +7551,10 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
         responseShape: readResponseModel(pattern, classification, module, ctx),
         statusCode: defaultedStatus(
           declaredOrReturnedStatus(
-            readStatusCode(pattern, classification),
+            readStatusCode(pattern, classification, {
+              module,
+              facts: options.facts
+            }),
             readReturnedStatus(pattern, functionNode, {
               module,
               facts: options.facts
@@ -7055,14 +7565,7 @@ function functionRouteUnits(pattern, pack, verb, classification, functionNode, m
         definitionsCtx: ctx,
         storage: options.storage,
         importedDefinition: options.importedDefinition,
-        wrappers: wrappersAround(
-          pattern,
-          pack,
-          classification,
-          functionNode,
-          module,
-          options
-        )
+        wrappers
       },
       options
     )
@@ -7081,6 +7584,38 @@ function wrappersAround(pattern, pack, classification, definitionNode, module, o
     definitionNode
   });
 }
+function declaredStatusesOf(pattern, pack, classification, definitionNode, module, options) {
+  const keyword = pattern.responsesKeyword;
+  if (keyword === void 0) {
+    return [];
+  }
+  const above = options.wrappers?.callsAbove({
+    pack,
+    pattern,
+    file: options.absoluteFile ?? options.filePath,
+    module,
+    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: [] };
@@ -7164,6 +7699,8 @@ function buildRouteUnit(options) {
       pathParamNames: template?.paramNames ?? null,
       requestBodyFromAnnotatedClass,
       injectedCallees,
+      injectedTypes: new Set(pattern.injectedParameterTypes ?? []),
+      module,
       sources: pattern.parameterSources ?? {},
       aliasKeyword: pattern.parameterAliasKeyword
     },
@@ -7220,6 +7757,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: {
@@ -7251,9 +7804,51 @@ 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 [];
@@ -7320,10 +7915,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;
@@ -7347,7 +7939,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(
@@ -7427,6 +8019,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;
@@ -7660,6 +8260,7 @@ import {
   placeArgTargets as placeArgTargets2,
   placeCalleeParameters as placeCalleeParameters2,
   placeCalls as placeCalls2,
+  placePossibleCalls as placePossibleCalls2,
   recordParameterGaps as recordParameterGaps2,
   summaryIdFromParts,
   unfollowedCallGap as unfollowedCallGap2
@@ -7671,10 +8272,12 @@ import {
   createCacheLayer,
   createTimer,
   effectToIR,
+  extractionCacheDirFor,
   extractionConfigStamp,
   KeptParses,
   moduleInitStructure,
   noopTimer,
+  ownersWhereWritten,
   runDigest,
   stampModuleImports,
   stampModules
@@ -7724,7 +8327,7 @@ var DEFERRED_BODY_TYPES3 = /* @__PURE__ */ new Set(["function_definition", "lamb
 function exitSites(root, module) {
   const found = [];
   const startScope = module.scopeFor.get(root.id) ?? module.moduleScope;
-  walkDescendants4(root, startScope, {
+  walkDescendants4(root, startScope, children, {
     at: (node, scope) => {
       const site = exitSiteAt(node, scope);
       if (site !== null) {
@@ -7741,7 +8344,7 @@ function exitSites(root, module) {
   return found;
 }
 function exitSiteAt(statement, scope) {
-  const expression = statement.namedChildren[0] ?? null;
+  const expression = statement.namedChild(0) ?? null;
   if (expression === null) {
     return null;
   }
@@ -7755,12 +8358,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(
@@ -7921,7 +8524,9 @@ import {
   placeArgTargets,
   placeCalleeParameters,
   placeCalls,
+  placePossibleCalls,
   recordParameterGaps,
+  StopList,
   TargetPlacements,
   unfollowedCallGap,
   worthRecording
@@ -7944,7 +8549,7 @@ function argparseFlagReads(definition, module, parameterNames2) {
   const parsers = /* @__PURE__ */ new Map();
   const handedTo = /* @__PURE__ */ new Map();
   const startScope = module.scopeFor.get(definition.id) ?? module.moduleScope;
-  walkDescendants5(definition, startScope, {
+  walkDescendants5(definition, startScope, children, {
     at: (node, scope) => {
       noteParser(node, scope, parsers);
       noteArgument(node, parsers);
@@ -8020,7 +8625,9 @@ function methodCalledOn(call) {
 import {
   calleeOutcomeOf,
   calleeOutcomes,
+  dispatchOutcomes,
   noteKeyRead as noteKeyRead3,
+  RECEIVER_STORE_NAME as RECEIVER_STORE_NAME2,
   writtenSourcesOf
 } from "@suss/resolution";
 var STOP_FOR = {
@@ -8051,11 +8658,77 @@ function resolveCallee2(call, site, ctx, read) {
     return spelling;
   }
   const outcome = read?.outcomes.get(spelling.key) ?? 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] === RECEIVER_STORE_NAME2
+    );
+  });
+}
 function namedOutcomes(keys, ctx) {
   return 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 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;
@@ -8274,6 +8947,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();
@@ -8336,6 +9010,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);
       }
@@ -8386,6 +9061,7 @@ function reachedFunctions(seeds, options) {
       }
       placeCalls(summary2, targetsByKey.get(key));
       placeArgTargets(summary2, argTargetsByKey.get(key));
+      placePossibleCalls(summary2, possibleTargetsByKey.get(key));
       placeCalleeParameters(summary2, parameterCallsByKey.get(key));
       return summary2;
     };
@@ -8409,6 +9085,7 @@ function reachedFunctions(seeds, options) {
     targetsByKey,
     stopsByKey,
     argTargetsByKey,
+    possibleTargetsByKey,
     parameterCallsByKey,
     callsByKey,
     passedPositions,
@@ -8432,24 +9109,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
+      }
     ])
   );
 }
@@ -8480,13 +9175,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) {
@@ -8502,6 +9199,10 @@ function storedScan(scan) {
       callee,
       [...byPosition]
     ]),
+    possibleTargets: [...scan.possibleTargets].map(([callee, places]) => [
+      callee,
+      [...places]
+    ]),
     parameterCalls: [...scan.parameterCalls],
     passedPositions: [...scan.passedPositions]
   };
@@ -8517,6 +9218,7 @@ function scanFromStored(stored, functionFor) {
         new Map(byPosition)
       ])
     ),
+    possibleTargets: new Map(stored.possibleTargets),
     parameterCalls: stored.parameterCalls,
     passedPositions: new Set(stored.passedPositions)
   };
@@ -8545,6 +9247,7 @@ var EMPTY_SCAN = {
   stops: [],
   targets: /* @__PURE__ */ new Map(),
   argTargets: /* @__PURE__ */ new Map(),
+  possibleTargets: /* @__PURE__ */ new Map(),
   parameterCalls: [],
   passedPositions: /* @__PURE__ */ new Set()
 };
@@ -8602,14 +9305,14 @@ 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 stops = new StopList();
   const placements = new TargetPlacements();
   const parameterCalls = [];
   const passedPositions = /* @__PURE__ */ new Set();
@@ -8621,12 +9324,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;
@@ -8635,11 +9351,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)
@@ -8649,9 +9361,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,
@@ -8659,10 +9392,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) && worthRecording(outcome.reason)) {
-        seen.add(stopKey);
-        stops.push({ callee, reason: outcome.reason });
+      if (!recognized.has(call.id) && 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);
@@ -8673,11 +9408,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);
@@ -8687,24 +9418,21 @@ 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 = [];
-  walkDescendants6(body, outer, {
+  walkDescendants6(body, outer, children, {
     at: (child, scope) => {
       if (child.type === "call") {
         found.push({ call: child, site: { file, scope, owner } });
@@ -8730,7 +9458,7 @@ 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);
     }
@@ -8831,10 +9559,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;
@@ -8854,10 +9579,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;
@@ -8954,7 +9676,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 [];
     }
@@ -9027,6 +9749,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]];
@@ -9077,6 +9803,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);
     }
   };
 }
@@ -9181,9 +9912,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") {
@@ -9466,8 +10221,8 @@ function constructionStatement(stmt, module, 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;
@@ -9541,7 +10296,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;
       }
@@ -9721,7 +10476,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;
     }
@@ -9934,8 +10689,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) {
@@ -11047,6 +11803,8 @@ import { absentReading as absentReading2, walkDescendants as walkDescendants7 }
 import { noteKeyRead as noteKeyRead6, noteLookup as noteLookup3 } from "@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}`
@@ -11084,8 +11842,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
@@ -11102,6 +11867,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) {
@@ -11143,14 +11914,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) {
+        noteKeyRead6(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);
@@ -11159,16 +11981,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") {
@@ -11197,13 +12025,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) {
+        noteKeyRead6(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) {
       noteKeyRead6(this.options.facts, site.file);
@@ -11217,12 +12160,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) {
+        noteKeyRead6(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
@@ -11267,6 +12244,38 @@ var PythonWrapperIndex = class {
     return this.unitsByFile.get(file) ?? [];
   }
 };
+function referenceKey(reference) {
+  return `${reference.file}::${reference.name}`;
+}
+function readByAPack(module, options) {
+  return options.packs.some(
+    (pack) => pack.discovery.some((pattern) => pattern.importModule.includes(module))
+  );
+}
+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;
 }
@@ -11313,8 +12322,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;
@@ -11329,6 +12338,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) {
@@ -11346,7 +12358,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) {
-  walkDescendants7(file.root, file.module.moduleScope, {
+  walkDescendants7(file.root, file.module.moduleScope, children, {
     at: (node, scope) => {
       if (node.type !== "decorated_definition") {
         return;
@@ -11382,7 +12394,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);
@@ -11401,7 +12413,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) {
@@ -11419,7 +12431,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;
@@ -11427,10 +12439,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) {
@@ -11440,15 +12449,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(
@@ -11457,7 +12493,7 @@ function wrapperUnit(target, declared, options) {
     options.storageFor(file),
     options.facts
   );
-  const delegate = (at) => ({
+  const delegate = (at, to = null) => ({
     terminal: {
       kind: "delegate",
       statusCode: null,
@@ -11466,18 +12502,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,
+    pattern,
     responseShape: { reading: absentReading2 },
     declaredStatus: {
       reading: absentReading2,
-      ...declared.pattern.defaultStatusCode !== void 0 ? { libraryDefault: declared.pattern.defaultStatusCode } : {}
+      ...pattern.defaultStatusCode !== void 0 ? { libraryDefault: pattern.defaultStatusCode } : {}
     },
     module: file.module,
     facts: options.facts
@@ -11489,7 +12525,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);
@@ -11506,7 +12545,7 @@ function wrapperUnit(target, declared, options) {
   return {
     identity: {
       name,
-      nameKind: "binding",
+      nameKind: reading.nameKind,
       kind: "middleware",
       file: file.displayPath,
       range,
@@ -11530,7 +12569,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;
@@ -11539,28 +12578,48 @@ 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() {
@@ -11655,7 +12714,7 @@ async function extractPythonProject(options) {
   const { roots, unreadManifests } = rootsOfRun(options);
   const timer = options.onTiming !== void 0 ? createTimer() : noopTimer();
   const cacheDir = adapterStamp.declineWhenRunFromSource(
-    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? path5.join(options.projectRoot, ".suss", "cache") : null)
+    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? extractionCacheDirFor(options.projectRoot) : null)
   );
   const layer = createCacheLayer(cacheDir);
   const packsDigest = `${adapterStamp.packsDigest(
@@ -11678,11 +12737,14 @@ async function extractPythonProject(options) {
     "cache.lookup",
     () => layer.lookup(input)
   );
+  const composed = (stored) => 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 Database2(),
       roots,
       unreadManifests
@@ -11697,7 +12759,7 @@ async function extractPythonProject(options) {
     options.onCacheDiagnostic?.({ kind: "hit" });
     options.onTiming?.(timer.report());
     return {
-      summaries: plan.allSummaries(),
+      summaries: composed(plan.allSummaries()),
       facts: new Database2(),
       roots,
       unreadManifests
@@ -11842,7 +12904,8 @@ async function runPython(options, roots, cache, previous) {
       roots,
       facts: needsValues ? db : void 0,
       definitions,
-      storageFor
+      storageFor,
+      routers: plainRouterIndex
     })
   );
   const importedDefinition2 = importedDefinitionLookup(db, bound);
@@ -11878,15 +12941,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);
       }
     };
   }
@@ -11899,12 +12957,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;
     }
@@ -12073,6 +13130,7 @@ async function runPython(options, roots, cache, previous) {
     }
     placeCalls2(summary, reached.targetsByKey.get(key));
     placeArgTargets2(summary, reached.argTargetsByKey.get(key));
+    placePossibleCalls2(summary, reached.possibleTargetsByKey.get(key));
     placeCalleeParameters2(summary, reached.parameterCallsByKey.get(key));
   };
   for (const [key, owners] of summariesBySeed) {
@@ -12162,16 +13220,20 @@ async function runPython(options, roots, cache, previous) {
     markExitCodeFunctions(summaries, exits, db, options.workspaceRoot);
     return 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,
@@ -12226,6 +13288,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 = walkRecordsByFile({
     scans: args.reached.scans,
@@ -12254,7 +13349,10 @@ function pythonAttribution(args) {
       }
     };
   });
-  return { roots, owners: args.composed.map(() => []) };
+  return {
+    roots,
+    owners: ownersWhereWritten(args.summaries, args.walkedFileOf)
+  };
 }
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
   "__pycache__",
@@ -12285,7 +13383,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);
     }
@@ -12551,7 +13649,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);
       }