@suss/adapter-ruby 0.34.0 → 0.34.1

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(index_exports, {
   bindEvaluator: () => bindEvaluator,
   bodyStatements: () => bodyStatements,
   booleanLiteralValue: () => booleanLiteralValue,
+  children: () => children,
   collectFileConstants: () => collectFileConstants,
   createConstantFileCache: () => createConstantFileCache,
   createFileCache: () => createFileCache,
@@ -97,7 +98,29 @@ function field(node, name) {
   return node.childForFieldName(name);
 }
 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);
@@ -159,6 +182,13 @@ var MODULE_SCOPE_STOPS = /* @__PURE__ */ new Set([
 var NESTING_TYPES = /* @__PURE__ */ new Set(["class", "module"]);
 var METHOD_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method"]);
 var LAMBDA_TYPE = "lambda";
+var RAISING_METHODS = /* @__PURE__ */ new Set(["raise", "fail"]);
+function isRaiseCall(node) {
+  if (node.type === "identifier") {
+    return RAISING_METHODS.has(node.text);
+  }
+  return node.type === "call" && field(node, "receiver") === null && RAISING_METHODS.has(field(node, "method")?.text ?? "");
+}
 function enclosingDefinition(node) {
   return definitionsAround.of(node);
 }
@@ -234,7 +264,7 @@ function runStatements(body, blockConfigures = () => false) {
     }
     return !(node.type === "call" && blockConfigures(node));
   };
-  (0, import_extractor.walkDescendants)(body, null, {
+  (0, import_extractor.walkDescendants)(body, null, children, {
     at: (node) => {
       found.push(node);
     },
@@ -521,6 +551,51 @@ function readCallArgs(argumentList) {
   }
   return { positional, keyword };
 }
+var CONTROL_OPERATORS = /* @__PURE__ */ new Set([
+  "and",
+  "or",
+  "&&",
+  "||"
+]);
+var HANDS_ON = /* @__PURE__ */ new Set(["return", "next", "break"]);
+var isChild = (fieldName) => (parent, child) => field(parent, fieldName)?.id === child.id;
+var always = () => true;
+var asCondition = isChild("condition");
+var VALUE_USED_UNDER = {
+  assignment: isChild("right"),
+  operator_assignment: isChild("right"),
+  call: isChild("receiver"),
+  element_reference: always,
+  argument_list: (parent) => !HANDS_ON.has(parent.parent?.type ?? ""),
+  pair: always,
+  array: always,
+  hash: always,
+  interpolation: always,
+  unary: always,
+  binary: (parent) => !CONTROL_OPERATORS.has(field(parent, "operator")?.text ?? ""),
+  if: asCondition,
+  unless: asCondition,
+  while: asCondition,
+  until: asCondition,
+  if_modifier: asCondition,
+  unless_modifier: asCondition,
+  while_modifier: asCondition,
+  until_modifier: asCondition,
+  conditional: asCondition,
+  case: isChild("value")
+};
+function resultUsedAsValue(node) {
+  let child = node;
+  let parent = node.parent;
+  while (parent !== null && parent.type === "parenthesized_statements" && parent.namedChildCount === 1) {
+    child = parent;
+    parent = parent.parent;
+  }
+  if (parent === null) {
+    return false;
+  }
+  return VALUE_USED_UNDER[parent.type]?.(parent, child) ?? false;
+}
 var NodeSet = class extends import_extractor.IdSet {
 };
 var NodeMap = class extends import_extractor.IdMap {
@@ -555,19 +630,23 @@ var PATH_CONVENTIONS = {
 function createConstantFileCache() {
   return { autoloadDirectories: /* @__PURE__ */ new Map(), resolved: /* @__PURE__ */ new Map() };
 }
-function resolveConstantFile(root, qualifiedName, convention, acronyms = [], cache = createConstantFileCache()) {
+function resolveConstantFile(root, qualifiedName, convention, acronyms = [], cache = createConstantFileCache(), autoloadRoots = []) {
   const relative = `${PATH_CONVENTIONS[convention](qualifiedName, acronyms)}.rb`;
-  const key = `${root}\0${relative}`;
+  const key = [root, ...autoloadRoots, relative].join("\0");
   const known = cache.resolved.get(key);
   if (known !== void 0) {
     return known;
   }
-  const found = firstExisting(root, relative, cache);
+  const found = firstExisting(root, relative, cache, autoloadRoots);
   cache.resolved.set(key, found);
   return found;
 }
-function firstExisting(root, relative, cache) {
-  for (const candidate of [root, ...autoloadDirectoriesOf(root, cache)]) {
+function firstExisting(root, relative, cache, autoloadRoots) {
+  for (const candidate of [
+    root,
+    ...autoloadDirectoriesOf(root, cache),
+    ...autoloadRoots
+  ]) {
     const file = import_node_path.default.join(candidate, relative);
     if (import_node_fs.default.existsSync(file)) {
       return file;
@@ -614,6 +693,7 @@ var import_resolution5 = require("@suss/resolution");
 var import_values2 = require("@suss/values");
 
 // src/facts/resolve.ts
+var import_behavioral_ir = require("@suss/behavioral-ir");
 var import_datalog = require("@suss/datalog");
 var import_resolution = require("@suss/resolution");
 
@@ -630,6 +710,71 @@ var CONVERTING_FUNCTIONS = /* @__PURE__ */ new Set([
   "String",
   "Float"
 ]);
+var OBJECT_METHODS = /* @__PURE__ */ new Set([
+  "Array",
+  "Float",
+  "Hash",
+  "Integer",
+  "String",
+  "abort",
+  "binding",
+  "block_given?",
+  "caller",
+  "catch",
+  "class",
+  "clone",
+  "define_singleton_method",
+  "dup",
+  "eql?",
+  "equal?",
+  "eval",
+  "exit",
+  "extend",
+  "fail",
+  "format",
+  "freeze",
+  "frozen?",
+  "hash",
+  "inspect",
+  "instance_of?",
+  "instance_variable_defined?",
+  "instance_variable_get",
+  "instance_variable_set",
+  "instance_variables",
+  "is_a?",
+  "itself",
+  "kind_of?",
+  "lambda",
+  "loop",
+  "method",
+  "methods",
+  "nil?",
+  "object_id",
+  "p",
+  "pp",
+  "print",
+  "printf",
+  "proc",
+  "public_send",
+  "puts",
+  "raise",
+  "rand",
+  "require",
+  "require_relative",
+  "respond_to?",
+  "send",
+  "singleton_class",
+  "sleep",
+  "sprintf",
+  "srand",
+  "system",
+  "tap",
+  "then",
+  "throw",
+  "to_s",
+  "warn",
+  "yield_self"
+]);
 var CONSTRUCTOR = "new";
 
 // src/facts/resolve.ts
@@ -677,7 +822,13 @@ function resolveEnvObjects(db, objects) {
 }
 function writtenValueOf(db, key) {
   resolveValues(db, [key]);
-  return (0, import_resolution.writtenValueOf)(db, key, (keys) => resolveValues(db, keys));
+  return (0, import_resolution.writtenValueOf)(
+    db,
+    key,
+    (keys) => resolveValues(db, keys),
+    void 0,
+    (0, import_resolution.answersFromTestsLeftOut)(key, import_behavioral_ir.isTestFile)
+  );
 }
 function writtenValueUnder(db, key, site) {
   const program = (0, import_resolution.resolutionUnderProgram)(RUBY_RULES);
@@ -709,7 +860,7 @@ function isFieldOf(parent, node, name) {
 function namedAt(parent, node) {
   return isFieldOf(parent, node, "name");
 }
-function always() {
+function always2() {
   return true;
 }
 var SPELLS_A_NAME = {
@@ -724,14 +875,14 @@ var SPELLS_A_NAME = {
   hash_splat_parameter: namedAt,
   keyword_parameter: namedAt,
   block_parameter: namedAt,
-  destructured_parameter: always,
-  left_assignment_list: always,
-  rest_assignment: always,
-  destructured_left_assignment: always,
-  exception_variable: always,
-  undef: always,
-  alias: always,
-  ...Object.fromEntries(PARAMETER_LIST_TYPES.map((type) => [type, always]))
+  destructured_parameter: always2,
+  left_assignment_list: always2,
+  rest_assignment: always2,
+  destructured_left_assignment: always2,
+  exception_variable: always2,
+  undef: always2,
+  alias: always2,
+  ...Object.fromEntries(PARAMETER_LIST_TYPES.map((type) => [type, always2]))
 };
 function addNamesUnder(node, names) {
   if (node === null) {
@@ -1550,9 +1701,7 @@ function emitKeyedElement(emitter, node, parent) {
   if (object === null || isWriteTarget(node, parent)) {
     return;
   }
-  const index = node.namedChildren.find(
-    (child) => child !== null && child.id !== object.id
-  );
+  const index = children(node).find((child) => child.id !== object.id);
   if (index !== void 0) {
     emitKeyedRead(emitter, node, object, index, node);
     emitWrittenKeyRead(emitter, node, object, index);
@@ -1593,17 +1742,17 @@ function fallbackBranchesOf(node, type, enclosing) {
   }
   return [left, right].filter((side) => !raises(side, enclosing));
 }
-var RAISING_METHODS = /* @__PURE__ */ new Set(["raise", "fail"]);
+var RAISING_METHODS2 = /* @__PURE__ */ new Set(["raise", "fail"]);
 function raises(written, enclosing) {
   const node = readThrough(written);
   if (node.type === "identifier") {
-    return RAISING_METHODS.has(node.text) && isBareCall(node, enclosing);
+    return RAISING_METHODS2.has(node.text) && isBareCall(node, enclosing);
   }
   if (node.type !== "call") {
     return false;
   }
   const receiver = field(node, "receiver");
-  return RAISING_METHODS.has(field(node, "method")?.text ?? "") && (receiver === null || receiver.text === "Kernel");
+  return RAISING_METHODS2.has(field(node, "method")?.text ?? "") && (receiver === null || receiver.text === "Kernel");
 }
 function emitExpressionFacts(emitter, node) {
   emitDynamicDefinition(emitter, node, node.type, []);
@@ -2559,9 +2708,7 @@ var EXPRESSION_TYPES = {
   ),
   unary: (node) => {
     const operand2 = field(node, "operand");
-    const operator = node.children.find(
-      (child) => child !== null && !child.isNamed
-    );
+    const operator = allChildren(node).find((child) => !child.isNamed);
     if (operand2 === null || operator === void 0) {
       return OPAQUE;
     }
@@ -2763,8 +2910,25 @@ function statementOf(node) {
   if (appending !== null) {
     return appending;
   }
+  if (isRaiseCall(node) && !rescuedInSameFunction(node)) {
+    return { kind: "throw" };
+  }
   return isTailExpression(node) ? { kind: "return", value: node } : { kind: "expression", value: node };
 }
+var RESCUING_TYPES = /* @__PURE__ */ new Set(["begin", "body_statement"]);
+var UNRESCUED_PARTS = /* @__PURE__ */ new Set(["rescue", "else", "ensure"]);
+function rescuedInSameFunction(node) {
+  let child = node;
+  let parent = node.parent;
+  while (parent !== null && !isRoot(parent)) {
+    if (RESCUING_TYPES.has(parent.type) && !UNRESCUED_PARTS.has(child.type) && children(parent).some((part) => part.type === "rescue")) {
+      return true;
+    }
+    child = parent;
+    parent = parent.parent;
+  }
+  return false;
+}
 function appendingStatement(node) {
   if (node.type !== "binary" || field(node, "operator")?.text !== "<<") {
     return null;
@@ -3420,6 +3584,10 @@ function writtenNodeOf(node, db, site) {
   const context = db === void 0 ? void 0 : contexts.get(db);
   return context === void 0 ? null : context.writtenTo(node, site);
 }
+function calledDefinition(call, db) {
+  const context = db === void 0 ? void 0 : contexts.get(db);
+  return context === void 0 ? null : context.callable(call);
+}
 function askWrittenValues(nodes, db) {
   if (db === void 0 || !contexts.has(db)) {
     return;
@@ -3482,7 +3650,7 @@ function methodDefinitionsIn(file, root) {
     if (METHOD_TYPES.has(node.type)) {
       found.set(nodeId(file, node), node);
     }
-    for (const child of node.namedChildren) {
+    for (const child of children(node)) {
       if (child !== null) {
         visit(child);
       }
@@ -3808,12 +3976,27 @@ function graphqlTypeNameFromQualified(qualifiedName, convention) {
 
 // src/ancestry.ts
 async function reachDefinition(qualifiedName, lookup) {
+  const segments = qualifiedName.split("::");
+  for (let length = segments.length; length > 0; length--) {
+    const found = await definedInFileOf(
+      segments.slice(0, length).join("::"),
+      qualifiedName,
+      lookup
+    );
+    if (found !== null) {
+      return found;
+    }
+  }
+  return null;
+}
+async function definedInFileOf(fileConstant, qualifiedName, lookup) {
   const filePath = resolveConstantFile(
     lookup.root,
-    qualifiedName,
+    fileConstant,
     lookup.pathConvention,
     lookup.acronyms,
-    lookup.constantFiles
+    lookup.constantFiles,
+    lookup.autoloadRoots
   );
   if (filePath === null) {
     return null;
@@ -3958,7 +4141,7 @@ function superclassCandidatesOf(blocks) {
   return [];
 }
 function methodInAncestry(ancestry, name, read = {}) {
-  for (const entry of ancestry) {
+  for (const [index, entry] of ancestry.entries()) {
     if (entry.type === "root") {
       return { type: "none" };
     }
@@ -3966,7 +4149,8 @@ function methodInAncestry(ancestry, name, read = {}) {
       return {
         type: "unsettled",
         reason: `inherited from ${entry.name}, which this run did not read`,
-        cause: "unreadAncestor"
+        cause: "unreadAncestor",
+        definedLater: definedInProjectAfter(ancestry, index, name, read)
       };
     }
     const found = definitionIn(entry.blocks, name, read);
@@ -3983,6 +4167,18 @@ function methodInAncestry(ancestry, name, read = {}) {
   }
   return { type: "none" };
 }
+function definedInProjectAfter(ancestry, index, name, read) {
+  return ancestry.slice(index + 1).some(
+    (entry) => entry.type !== "root" && entry.type !== "unfollowed" && definitionIn(entry.blocks, name, read).method !== null
+  );
+}
+function methodPastUnreadAncestors(ancestry, name, read = {}) {
+  return methodInAncestry(
+    ancestry.filter((entry) => entry.type !== "unfollowed"),
+    name,
+    read
+  );
+}
 function definitionIn(blocks, name, read) {
   let method = null;
   let block = null;
@@ -4027,12 +4223,12 @@ function inheritedStatements(ancestry, blockConfigures) {
 }
 
 // src/discovery.ts
-var import_behavioral_ir5 = require("@suss/behavioral-ir");
-var import_extractor9 = require("@suss/extractor");
+var import_behavioral_ir6 = require("@suss/behavioral-ir");
+var import_extractor11 = require("@suss/extractor");
 
 // src/clientCalls.ts
-var import_behavioral_ir = require("@suss/behavioral-ir");
-var import_values13 = require("@suss/values");
+var import_behavioral_ir2 = require("@suss/behavioral-ir");
+var import_values14 = require("@suss/values");
 
 // src/paths/effects.ts
 var import_extractor2 = require("@suss/extractor");
@@ -4059,7 +4255,7 @@ function isRaise(node) {
     return false;
   }
   const receiver = field(node, "receiver");
-  const method = field(node, "method") ?? node.namedChildren[0] ?? null;
+  const method = field(node, "method") ?? node.namedChild(0) ?? null;
   return receiver === null && method !== null && RAISE_NAMES.has(method.text);
 }
 function exitOf(node) {
@@ -4071,7 +4267,7 @@ function exitOf(node) {
 function exitKindOf(node) {
   let sawReturn = false;
   const raises2 = (current) => {
-    for (const child of current.namedChildren) {
+    for (const child of children(current)) {
       if (child === null || CAPTURES_RETURN.has(child.type)) {
         continue;
       }
@@ -4105,13 +4301,52 @@ function callHeaderOf(call, block) {
 function blockStatements(block) {
   return block === null ? [] : children(block);
 }
+function attachedBlockOf(call) {
+  return children(call).find(
+    (child) => child !== null && (child.type === "do_block" || child.type === "block")
+  ) ?? null;
+}
+function soleBlockParameter(block) {
+  const names = children(field(block, "parameters")).filter(
+    (child) => child.type === "identifier"
+  );
+  return names.length === 1 ? names[0].text : null;
+}
+function blockBodyStatements(block) {
+  const body = field(block, "body");
+  if (body !== null) {
+    return children(body);
+  }
+  return children(block).filter((child) => child.type !== "block_parameters");
+}
+function armBody(block) {
+  return field(block, "body") ?? block;
+}
+function formatArmOf(statement, parameter) {
+  if (statement.type !== "call") {
+    return null;
+  }
+  const receiver = field(statement, "receiver");
+  const format = field(statement, "method")?.text;
+  if (receiver?.text !== parameter || format === void 0) {
+    return null;
+  }
+  const block = attachedBlockOf(statement);
+  return {
+    format,
+    header: block === null ? statement.text : callHeaderOf(statement, block).sourceText,
+    block
+  };
+}
 var Lowerer = class {
-  constructor(terminals, responseCalls) {
+  constructor(terminals, responseCalls, formatSwitch) {
     this.terminals = terminals;
     this.responseCalls = responseCalls;
+    this.formatSwitch = formatSwitch;
   }
   terminals;
   responseCalls;
+  formatSwitch;
   terminalsByStmt = /* @__PURE__ */ new Map();
   terminalHome = new NodeMap();
   attachTerminals(statement, found) {
@@ -4142,7 +4377,7 @@ var Lowerer = class {
       found.push(own);
       return found;
     }
-    for (const child of node.namedChildren) {
+    for (const child of children(node)) {
       if (child !== null && !OWN_BODY_TYPES.has(child.type)) {
         this.responsesIn(child, found);
       }
@@ -4201,29 +4436,22 @@ var Lowerer = class {
     };
   }
   lowerBegin(node) {
-    const rescues = node.namedChildren.filter(
-      (child) => child !== null && child.type === "rescue"
-    );
-    const ensureClause = node.namedChildren.find(
-      (child) => child !== null && child.type === "ensure"
-    ) ?? null;
-    const tryBody = node.namedChildren.filter(
+    const rescues2 = children(node).filter((child) => child.type === "rescue");
+    const ensureClause = children(node).find((child) => child.type === "ensure") ?? null;
+    const tryBody = children(node).filter(
       (child) => child !== null && child.type !== "rescue" && child.type !== "ensure" && child.type !== "else"
     );
     return {
       kind: "try",
       tryBody: tryBody.map((statement) => this.lower(statement)),
-      catchBody: rescues.length > 0 ? rescues.flatMap((clause) => this.lowerBlock(field(clause, "body"))) : null,
+      catchBody: rescues2.length > 0 ? rescues2.flatMap((clause) => this.lowerBlock(field(clause, "body"))) : null,
       finallyBody: ensureClause === null ? null : this.lowerBlock(ensureClause),
       exitKind: exitKindOf(node)
     };
   }
   lowerCase(node) {
     const groups = [];
-    for (const child of node.namedChildren) {
-      if (child === null) {
-        continue;
-      }
+    for (const child of children(node)) {
       if (child.type === "when") {
         groups.push({
           condition: handleOf(field(child, "pattern")),
@@ -4241,6 +4469,47 @@ var Lowerer = class {
     }
     return { kind: "switch", groups, exitKind: exitKindOf(node) };
   }
+  /**
+   * `respond_to do |format| ... end` runs one arm per request, picked by
+   * the format the request accepts, so it lowers to a switch with an arm
+   * per `format.x`. The arm that accepts every format is the default.
+   * Without one, a request no arm accepts makes the library raise. Null
+   * when the block contains anything besides those arms.
+   */
+  lowerFormatSwitch(node, block) {
+    const declared = this.formatSwitch;
+    if (declared === void 0 || node.type !== "call" || field(node, "receiver") !== null || field(node, "method")?.text !== declared.name) {
+      return null;
+    }
+    const parameter = soleBlockParameter(block);
+    if (parameter === null) {
+      return null;
+    }
+    const arms = blockBodyStatements(block).map(
+      (statement) => formatArmOf(statement, parameter)
+    );
+    if (arms.length === 0 || arms.some((arm) => arm === null)) {
+      return null;
+    }
+    const groups = arms.map(
+      (arm) => ({
+        condition: arm.format === declared.matchesEvery ? null : { sourceText: arm.header, expression: null },
+        hasTrailingBreak: true,
+        body: arm.block === null ? [] : this.lowerBlock(armBody(arm.block))
+      })
+    );
+    const named2 = groups.filter((group) => group.condition !== null);
+    const fallback2 = groups.find((group) => group.condition === null) ?? {
+      condition: null,
+      hasTrailingBreak: true,
+      body: [{ kind: "exit", exit: "throw", exitKind: "throw" }]
+    };
+    return {
+      kind: "switch",
+      groups: [...named2, fallback2],
+      exitKind: exitKindOf(node)
+    };
+  }
   lower(node) {
     const exit = exitOf(node);
     if (exit !== null) {
@@ -4270,10 +4539,12 @@ var Lowerer = class {
         [header]
       );
     }
-    const attachedBlock = node.namedChildren.find(
-      (child) => child !== null && (child.type === "do_block" || child.type === "block")
-    );
-    if (node.type === "call" && attachedBlock !== void 0) {
+    const attachedBlock = attachedBlockOf(node);
+    const formatSwitch = attachedBlock === null ? null : this.lowerFormatSwitch(node, attachedBlock);
+    if (formatSwitch !== null) {
+      return this.attach(formatSwitch, [node]);
+    }
+    if (node.type === "call" && attachedBlock !== null) {
       return this.attach(
         {
           kind: "loop",
@@ -4300,10 +4571,11 @@ var Lowerer = class {
     return this.attach({ kind: "opaque", exitKind: exitKindOf(node) }, [node]);
   }
 };
-function lowerRubyBody(body, terminals, responseCalls = []) {
+function lowerRubyBody(body, terminals, responseCalls = [], formatSwitch) {
   const lowerer = new Lowerer(
     new Map(terminals.map((terminal) => [terminal.id, terminal])),
-    new NodeSet(responseCalls)
+    new NodeSet(responseCalls),
+    formatSwitch
   );
   return {
     statements: lowerer.lowerBlock(body),
@@ -4464,6 +4736,14 @@ function enclosingStatement(call, body) {
   return current;
 }
 function invocationEffects(definitionNode, inherited = NO_INHERITED_METHODS, keepsArglessCall = NO_ARGLESS_CALLS, facts) {
+  return invocationSites(
+    definitionNode,
+    inherited,
+    keepsArglessCall,
+    facts
+  ).map((site) => site.effect);
+}
+function invocationSites(definitionNode, inherited = NO_INHERITED_METHODS, keepsArglessCall = NO_ARGLESS_CALLS, facts) {
   const read = methodBody(definitionNode);
   if (read === null) {
     return [];
@@ -4476,7 +4756,7 @@ function moduleScopeInvocationEffects(root, inherited = NO_INHERITED_METHODS, ke
     inherited,
     keepsArglessCall,
     facts
-  );
+  ).map((site) => site.effect);
 }
 function effectsOfBody(read, inherited, keepsArglessCall, facts) {
   const body = read.body;
@@ -4510,19 +4790,18 @@ function effectsOfBody(read, inherited, keepsArglessCall, facts) {
       statement === void 0 ? void 0 : enumerated.byTerminal.get(statement)
     );
     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 } : {}
+      }
     };
   });
 }
 
-// src/responseStatus.ts
-var import_extractor4 = require("@suss/extractor");
-var import_values12 = require("@suss/values");
-
 // src/paths/predicates.ts
 var OPERATORS = {
   "==": "eq",
@@ -4541,11 +4820,11 @@ var opaqueOf = (node) => ({
 var JOINING = /* @__PURE__ */ new Set(["&&", "||", "and", "or"]);
 function predicateOf(node, inputs) {
   if (node.type === "parenthesized_statements") {
-    const inner = node.namedChildren[0];
+    const inner = node.namedChild(0);
     return inner == null ? opaqueOf(node) : predicateOf(inner, inputs);
   }
   if (node.type === "unary" && field(node, "operator")?.text === "!") {
-    const operand2 = field(node, "operand") ?? node.namedChildren[0];
+    const operand2 = field(node, "operand") ?? node.namedChild(0);
     return operand2 == null ? opaqueOf(node) : { type: "negation", operand: predicateOf(operand2, inputs) };
   }
   if (node.type === "binary") {
@@ -4571,11 +4850,11 @@ function predicateOf(node, inputs) {
 }
 function operandsOf(node) {
   if (node.type === "parenthesized_statements") {
-    const inner = node.namedChildren[0];
+    const inner = node.namedChild(0);
     return inner == null ? [] : operandsOf(inner);
   }
   if (node.type === "unary" && field(node, "operator")?.text === "!") {
-    const operand2 = field(node, "operand") ?? node.namedChildren[0];
+    const operand2 = field(node, "operand") ?? node.namedChild(0);
     return operand2 == null ? [] : operandsOf(operand2);
   }
   if (node.type === "binary") {
@@ -4671,8 +4950,317 @@ function calledMethod(node) {
   return field(node, "method")?.text ?? null;
 }
 
-// src/provenance.ts
+// src/responseHandOff.ts
 var import_extractor3 = require("@suss/extractor");
+
+// src/exceptionClasses.ts
+var ROOT_EXCEPTION = "Exception";
+var RUBY_EXCEPTION_PARENTS = {
+  NoMemoryError: ROOT_EXCEPTION,
+  ScriptError: ROOT_EXCEPTION,
+  LoadError: "ScriptError",
+  NotImplementedError: "ScriptError",
+  SyntaxError: "ScriptError",
+  SecurityError: ROOT_EXCEPTION,
+  SignalException: ROOT_EXCEPTION,
+  Interrupt: "SignalException",
+  StandardError: ROOT_EXCEPTION,
+  SystemExit: ROOT_EXCEPTION,
+  SystemStackError: ROOT_EXCEPTION,
+  ArgumentError: "StandardError",
+  UncaughtThrowError: "ArgumentError",
+  EncodingError: "StandardError",
+  FiberError: "StandardError",
+  IOError: "StandardError",
+  EOFError: "IOError",
+  IndexError: "StandardError",
+  KeyError: "IndexError",
+  StopIteration: "IndexError",
+  ClosedQueueError: "StopIteration",
+  LocalJumpError: "StandardError",
+  NameError: "StandardError",
+  NoMethodError: "NameError",
+  RangeError: "StandardError",
+  FloatDomainError: "RangeError",
+  RegexpError: "StandardError",
+  RuntimeError: "StandardError",
+  FrozenError: "RuntimeError",
+  SystemCallError: "StandardError",
+  ThreadError: "StandardError",
+  TypeError: "StandardError",
+  ZeroDivisionError: "StandardError"
+};
+var MESSAGE_ONLY_EXCEPTION = "RuntimeError";
+var ExceptionReader = class {
+  constructor(lookup, library) {
+    this.library = library;
+    this.walking = {
+      ...lookup,
+      ancestryRootClassNames: [
+        ...Object.keys(library),
+        ...Object.keys(RUBY_EXCEPTION_PARENTS),
+        ROOT_EXCEPTION
+      ]
+    };
+  }
+  library;
+  walking;
+  known = /* @__PURE__ */ new Map();
+  read(ref) {
+    const key = [ref.text, ...ref.candidates].join("\0");
+    let found = this.known.get(key);
+    if (found === void 0) {
+      found = readException(ref, this.walking, this.library);
+      this.known.set(key, found);
+    }
+    return found;
+  }
+};
+function listedException(name, library) {
+  const fromLibrary = library[name];
+  if (fromLibrary !== void 0) {
+    return {
+      name,
+      ancestors: fromLibrary.ancestors,
+      incomplete: false,
+      inheritableByUnread: false
+    };
+  }
+  const fromRuby = rubyAncestors(name);
+  return fromRuby === null ? null : {
+    name,
+    ancestors: fromRuby,
+    incomplete: false,
+    inheritableByUnread: true
+  };
+}
+function unreadException(name) {
+  return {
+    name,
+    ancestors: [ROOT_EXCEPTION],
+    incomplete: true,
+    inheritableByUnread: true
+  };
+}
+function classesOf(exception) {
+  return [exception.name, ...exception.ancestors];
+}
+async function readException(ref, lookup, library) {
+  for (const candidate of ref.candidates) {
+    const known = listedException(candidate, library);
+    if (known !== null) {
+      return known;
+    }
+    const defined = await reachConstant([candidate], lookup);
+    if (defined !== null) {
+      return projectException(defined, lookup, library);
+    }
+  }
+  return unreadException(ref.candidates.at(-1) ?? ref.text);
+}
+async function projectException(defined, lookup, library) {
+  const chain = await ancestryOf(defined.name, defined.blocks, lookup);
+  const ancestors = [];
+  let incomplete = false;
+  for (const entry of chain) {
+    if (entry.type === "bodies" && entry.name === defined.name) {
+      continue;
+    }
+    ancestors.push(entry.name);
+    if (entry.type === "root") {
+      ancestors.push(
+        ...listedException(entry.name, library)?.ancestors ?? []
+      );
+    }
+    if (entry.type === "unfollowed") {
+      incomplete = true;
+    }
+  }
+  if (incomplete && !ancestors.includes(ROOT_EXCEPTION)) {
+    ancestors.push(ROOT_EXCEPTION);
+  }
+  return {
+    name: defined.name,
+    ancestors,
+    incomplete,
+    inheritableByUnread: false
+  };
+}
+function rubyAncestors(name) {
+  if (name === ROOT_EXCEPTION) {
+    return [];
+  }
+  if (RUBY_EXCEPTION_PARENTS[name] === void 0) {
+    return null;
+  }
+  const ancestors = [];
+  for (let parent = RUBY_EXCEPTION_PARENTS[name]; parent !== void 0; parent = RUBY_EXCEPTION_PARENTS[parent]) {
+    ancestors.push(parent);
+  }
+  return ancestors;
+}
+
+// src/raises.ts
+var RESCUING_BODIES = /* @__PURE__ */ new Set(["begin", "body_statement"]);
+var AFTER_CATCH = /* @__PURE__ */ new Set(["rescue", "else", "ensure"]);
+function escapingRaises(method) {
+  const body = field(method, "body");
+  if (body === null) {
+    return [];
+  }
+  const found = [];
+  const visit = (node) => {
+    for (const child of children(node)) {
+      if (child === null || OWN_BODY_TYPES.has(child.type)) {
+        continue;
+      }
+      if (isRaise(child) && !caughtLocally(child, method)) {
+        found.push(child);
+        continue;
+      }
+      visit(child);
+    }
+  };
+  visit(body);
+  return found;
+}
+function caughtLocally(raise, method) {
+  let child = raise;
+  for (let parent = raise.parent; parent !== null && parent.id !== method.id; parent = parent.parent) {
+    if (rescues(parent, child)) {
+      return true;
+    }
+    child = parent;
+  }
+  return false;
+}
+function rescues(parent, child) {
+  if (parent.type === "rescue_modifier") {
+    return field(parent, "body")?.id === child.id;
+  }
+  return RESCUING_BODIES.has(parent.type) && !AFTER_CATCH.has(child.type) && children(parent).some((one) => one?.type === "rescue");
+}
+function raisedClassRef(call, nesting) {
+  const first = readCallArgs(field(call, "arguments")).positional[0];
+  if (first === void 0) {
+    return null;
+  }
+  if (first.type === "string") {
+    return {
+      text: MESSAGE_ONLY_EXCEPTION,
+      candidates: [MESSAGE_ONLY_EXCEPTION]
+    };
+  }
+  const constant2 = constructedClass(first) ?? first;
+  const candidates = constantRefCandidates(constant2, nesting);
+  return candidates.length === 0 ? null : { text: constant2.text, candidates };
+}
+function constructedClass(node) {
+  if (node.type !== "call" || field(node, "method")?.text !== "new") {
+    return null;
+  }
+  return field(node, "receiver");
+}
+
+// src/responseHandOff.ts
+function raiseEndings(method) {
+  return escapingRaises(method).map((call) => ({
+    call,
+    terminal: raiseTerminal(call)
+  }));
+}
+function raiseTerminal(call) {
+  const [first, second] = readCallArgs(field(call, "arguments")).positional;
+  const message = first === void 0 ? null : stringLiteralValue(first);
+  return {
+    kind: "throw",
+    statusCode: null,
+    body: null,
+    exceptionType: raisedClassRef(call, [])?.text ?? null,
+    message: message ?? (second === void 0 ? null : stringLiteralValue(second)),
+    component: null,
+    renderTree: null,
+    delegateTarget: null,
+    emitEvent: null,
+    location: rangeOf(call)
+  };
+}
+function throughResponseHelpers(branches, sites, options) {
+  const handOffs = [];
+  for (const { call, effect } of sites) {
+    const helper = helperBranchesAt(call, options);
+    if (helper !== null) {
+      handOffs.push({
+        helper,
+        preconditions: effect.preconditions,
+        line: rangeOf(call).start,
+        at: rangeOf(call)
+      });
+    }
+  }
+  return handOffs.length === 0 ? [...branches] : branches.flatMap((branch) => (0, import_extractor3.splitAtHandOffs)(branch, handOffs));
+}
+function helperBranchesAt(call, options) {
+  if (call.type !== "call") {
+    return null;
+  }
+  const args = readCallArgs(field(call, "arguments"));
+  const handedAt = args.positional.flatMap(
+    (argument, position) => argument.type === "identifier" && refersToResponse(argument, options) ? [{ position, variable: argument.text }] : []
+  );
+  const handedAs = Object.entries(args.keyword).flatMap(
+    ([name, argument]) => argument.type === "identifier" && refersToResponse(argument, options) ? [{ name, variable: argument.text }] : []
+  );
+  if (handedAt.length === 0 && handedAs.length === 0) {
+    return null;
+  }
+  const helper = calledDefinition(call, options.facts);
+  if (helper === null) {
+    return null;
+  }
+  const passed = /* @__PURE__ */ new Map();
+  const names = parametersOf(helper).map(
+    (parameter) => paramNameOf(parameter)?.text ?? null
+  );
+  for (const { position, variable } of handedAt) {
+    const name = names[position];
+    if (name !== void 0 && name !== null) {
+      passed.set(name, variable);
+    }
+  }
+  for (const { name, variable } of handedAs) {
+    if (names.includes(name)) {
+      passed.set(name, variable);
+    }
+  }
+  return passed.size === 0 ? null : (0, import_extractor3.helperPathsOnVariables)(options.readHelper(helper), passed);
+}
+function refersToResponse(name, options) {
+  const written = writtenNodeOf(name, options.facts);
+  if (written === null) {
+    return false;
+  }
+  if (sameNode(written, options.request)) {
+    return true;
+  }
+  const member = written.type === "call" ? field(written, "method") : null;
+  const receiver = written.type === "call" ? field(written, "receiver") : null;
+  if (member === null || receiver?.type !== "identifier" || !options.bodyMethods.includes(member.text)) {
+    return false;
+  }
+  const parsedFrom = writtenNodeOf(receiver, options.facts);
+  return parsedFrom !== null && sameNode(parsedFrom, options.request);
+}
+function sameNode(a, b) {
+  return a.startIndex === b.startIndex && a.endIndex === b.endIndex && a.tree === b.tree;
+}
+
+// src/responseStatus.ts
+var import_extractor6 = require("@suss/extractor");
+var import_values13 = require("@suss/values");
+
+// src/provenance.ts
+var import_extractor4 = require("@suss/extractor");
 var import_values11 = require("@suss/values");
 
 // src/storage.ts
@@ -4738,7 +5326,7 @@ function pickedSource(call, loader) {
     return null;
   }
   const args = field(pick, "arguments");
-  const given = args === null ? void 0 : args.namedChildren[source.at];
+  const given = args === null ? void 0 : args.namedChild(source.at);
   return given?.type === "constant" || given?.type === "scope_resolution" ? given : null;
 }
 
@@ -5383,10 +5971,7 @@ function recognizeMethodStorage(method, file, options) {
   return { effects, slots };
 }
 function callsUnder(node, found = []) {
-  for (const child of node.namedChildren) {
-    if (child === null) {
-      continue;
-    }
+  for (const child of children(node)) {
     if (child.type === "call") {
       found.push(child);
     }
@@ -5528,7 +6113,7 @@ function valueSources(values, context, question = "wantedSource") {
   const spelling = spellingFor(context);
   const found = new NodeMap();
   for (const [value, key] of keys) {
-    found.set(value, (0, import_extractor3.sourceRefsOf)(leaves.get(key) ?? [], spelling));
+    found.set(value, (0, import_extractor4.sourceRefsOf)(leaves.get(key) ?? [], spelling));
   }
   return found;
 }
@@ -5582,16 +6167,121 @@ function bareMethodOf(node) {
   if (node.type !== "call" || field(node, "arguments") !== null) {
     return null;
   }
-  return field(node, "method")?.text ?? null;
+  return field(node, "method")?.text ?? null;
+}
+function literalAt(key, facts) {
+  const node = nodeOfResolutionKey(key, facts);
+  if (node === null) {
+    return void 0;
+  }
+  const value = evaluatedValue(node, facts);
+  const constant2 = (0, import_values11.constantOf)(value);
+  return constant2 !== void 0 ? constant2 : (0, import_values11.literalOf)(value) ?? void 0;
+}
+
+// src/raisedStatuses.ts
+function rescuedBy(handlers, exception) {
+  if (handlers === "eachRoute") {
+    return true;
+  }
+  const classes = new Set(classesOf(exception));
+  return handlers.some(
+    (caught) => caught.someUnread || caught.classes.some(
+      (one) => classes.has(one.name) || exception.incomplete && one.inheritableByUnread
+    )
+  );
+}
+function raisedTerminal(pattern, exception, handlers, location) {
+  const libraryStatus = exception === null ? void 0 : pattern.libraryExceptions?.[exception.name]?.status;
+  const status = exception === null || rescuedBy(handlers, exception) ? void 0 : libraryStatus;
+  return {
+    kind: status === void 0 ? "throw" : "response",
+    statusCode: status === void 0 ? null : { type: "literal", value: status },
+    body: null,
+    exceptionType: status === void 0 ? exception?.name ?? null : null,
+    ...status === void 0 && exception !== null ? {
+      exceptionAncestry: {
+        ancestors: exception.ancestors,
+        incomplete: exception.incomplete
+      }
+    } : {},
+    ...status === void 0 && libraryStatus !== void 0 ? { statusWhenUncaught: libraryStatus } : {},
+    message: null,
+    component: null,
+    renderTree: null,
+    delegateTarget: null,
+    emitEvent: null,
+    location
+  };
+}
+function raisedStatusBranches(pattern, storage, effects, handlers, location) {
+  const operations = new Set(
+    (effects ?? []).flatMap(
+      (effect) => effect.type === "interaction" && effect.interaction.class === "storage-access" && effect.interaction.operation !== void 0 ? [effect.interaction.operation] : []
+    )
+  );
+  const raised = new Set(
+    storage.flatMap(
+      (one) => (one.raises ?? []).flatMap(
+        (raise) => raise.methods.some((method) => operations.has(method)) ? [raise.exception] : []
+      )
+    )
+  );
+  return [...raised].flatMap((name) => {
+    const exception = listedException(name, pattern.libraryExceptions ?? {}) ?? unreadException(name);
+    const terminal = raisedTerminal(pattern, exception, handlers, location);
+    if (terminal.kind === "throw" && !rescuedBy(handlers, exception)) {
+      return [];
+    }
+    return [
+      {
+        conditions: [
+          {
+            sourceText: `${name} raised`,
+            structured: null,
+            polarity: "positive",
+            source: "earlyThrow"
+          }
+        ],
+        terminal,
+        effects: [],
+        location,
+        isDefault: false
+      }
+    ];
+  });
+}
+
+// src/responseBody.ts
+var import_extractor5 = require("@suss/extractor");
+var import_values12 = require("@suss/values");
+var BODY_KINDS = /* @__PURE__ */ new Set([
+  "record",
+  "sequence",
+  "unbounded"
+]);
+function serializedValue(node, serializers) {
+  const receiver = field(node, "receiver");
+  const method = field(node, "method")?.text;
+  if (node.type !== "call" || receiver === null || method === void 0 || !serializers.has(method) || field(node, "arguments") !== null) {
+    return node;
+  }
+  return serializedValue(receiver, serializers);
 }
-function literalAt(key, facts) {
-  const node = nodeOfResolutionKey(key, facts);
-  if (node === null) {
-    return void 0;
+function bodyReadingOfCall(call, declaration, facts) {
+  if (declaration.bodyKeyword === void 0 || call.type !== "call") {
+    return import_extractor5.absentReading;
   }
-  const value = evaluatedValue(node, facts);
-  const constant2 = (0, import_values11.constantOf)(value);
-  return constant2 !== void 0 ? constant2 : (0, import_values11.literalOf)(value) ?? void 0;
+  const argument = readCallArgs(field(call, "arguments")).keyword[declaration.bodyKeyword];
+  if (argument === void 0) {
+    return import_extractor5.absentReading;
+  }
+  const body = serializedValue(
+    argument,
+    new Set(declaration.bodySerializers ?? [])
+  );
+  const value = evaluatedValue(body, facts);
+  return BODY_KINDS.has(value.kind) ? (0, import_extractor5.writtenReading)((0, import_values12.shapeOfValue)(value), rangeOf(argument)) : import_extractor5.absentReading;
 }
 
 // src/responseStatus.ts
@@ -5606,13 +6296,17 @@ function statusArgumentOf(call, declaration) {
   }
   return args.positional[declaration.statusArgument] ?? null;
 }
-function statusNumberOf(node, names, facts) {
+function statusNumberOf(node, names, facts, bound = /* @__PURE__ */ new Map()) {
+  const passed = node.type === "identifier" ? bound.get(node.text) : void 0;
+  if (passed !== void 0) {
+    return passed;
+  }
   const value = evaluatedValue(node, facts);
-  const constant2 = (0, import_values12.constantOf)(value);
+  const constant2 = (0, import_values13.constantOf)(value);
   if (typeof constant2 === "number") {
     return constant2;
   }
-  const name = (0, import_values12.literalOf)(value);
+  const name = (0, import_values13.literalOf)(value);
   return name === null ? null : names[name] ?? null;
 }
 function declarationsByName(declarations) {
@@ -5630,21 +6324,42 @@ function declarationOf(node, byName, locals) {
   const name = field(node, "method")?.text;
   return name === void 0 ? void 0 : byName.get(name);
 }
-function collectResponseCalls(node, byName, locals, found) {
-  for (const child of node.namedChildren) {
+function responderOf(node, responders) {
+  const declaration = declarationOf(node, responders.byName, responders.locals);
+  if (declaration !== void 0) {
+    return { kind: "declared", declaration };
+  }
+  const name = receiverlessName(node, responders.locals);
+  const reading = name === null || responders.helper === void 0 ? null : responders.helper(name, node);
+  return reading === null ? void 0 : { kind: "helper", reading };
+}
+function receiverlessName(node, locals) {
+  if (node.type === "identifier") {
+    return isBareMethodCall(node, locals) ? node.text : null;
+  }
+  if (node.type !== "call" || field(node, "receiver") !== null) {
+    return null;
+  }
+  return field(node, "method")?.text ?? null;
+}
+function readingOfResponder(call, responder, names, options) {
+  return responder.kind === "helper" ? responder.reading : readingOfCall(call, responder.declaration, names, options);
+}
+function collectResponseCalls(node, responders, found) {
+  for (const child of children(node)) {
     if (child === null || OWN_BODY_TYPES.has(child.type)) {
       continue;
     }
-    if (declarationOf(child, byName, locals) !== void 0) {
+    if (responderOf(child, responders) !== void 0) {
       found.push(child);
       continue;
     }
-    collectResponseCalls(child, byName, locals, found);
+    collectResponseCalls(child, responders, found);
   }
   return found;
 }
 function collectReturns(node, found) {
-  for (const child of node.namedChildren) {
+  for (const child of children(node)) {
     if (child === null || OWN_BODY_TYPES.has(child.type)) {
       continue;
     }
@@ -5656,23 +6371,28 @@ function collectReturns(node, found) {
   }
   return found;
 }
-function readingOfCall(call, declaration, names, facts) {
+function readingOfCall(call, declaration, names, options) {
   const argument = statusArgumentOf(call, declaration);
   if (argument === null) {
-    return declaration.defaultStatusCode === void 0 ? import_extractor4.absentReading : (0, import_extractor4.writtenReading)(declaration.defaultStatusCode, rangeOf(call));
+    return declaration.defaultStatusCode === void 0 ? import_extractor6.absentReading : (0, import_extractor6.writtenReading)(declaration.defaultStatusCode, rangeOf(call));
   }
-  const status = statusNumberOf(argument, names, facts);
+  const status = statusNumberOf(
+    argument,
+    names,
+    options.facts,
+    options.boundStatuses
+  );
   if (status === null) {
-    return (0, import_extractor4.unreadableReading)(
+    return (0, import_extractor6.unreadableReading)(
       "This response writes a status that does not settle on a number here, so this outcome claims none",
       rangeOf(argument)
     );
   }
-  return (0, import_extractor4.writtenReading)(status, rangeOf(argument));
+  return (0, import_extractor6.writtenReading)(status, rangeOf(argument));
 }
 function effectsReaching(effects, conditions) {
   return effects.filter(
-    (effect) => (0, import_extractor4.guardsHoldOn)(
+    (effect) => (0, import_extractor6.guardsHoldOn)(
       effect.type === "invocation" ? effect.preconditions : void 0,
       conditions
     )
@@ -5697,6 +6417,45 @@ function conditionInputs(method, paths, facts) {
   );
   return operands.length === 0 ? void 0 : guardInputs(operands, { facts, unit: method });
 }
+function boundStatusArguments(helper, call, pattern, facts) {
+  const parameters = children(field(helper, "parameters")).filter(
+    (child) => child.type === "identifier"
+  );
+  const args = call.type === "call" ? readCallArgs(field(call, "arguments")).positional : [];
+  const bound = /* @__PURE__ */ new Map();
+  parameters.forEach((parameter, index) => {
+    const arg = args[index];
+    const status = arg === void 0 ? null : statusNumberOf(arg, pattern.statusCodeNames ?? {}, facts);
+    if (status !== null) {
+      bound.set(parameter.text, status);
+    }
+  });
+  return bound;
+}
+function helperResponse(helper, pattern, facts, boundStatuses = /* @__PURE__ */ new Map()) {
+  const branches = responseBranches(helper, pattern, [], void 0, {
+    fallthrough: "handOn",
+    facts,
+    boundStatuses
+  });
+  if (branches === null || branches.some((branch) => branch.terminal.kind !== "response")) {
+    return null;
+  }
+  const statuses = new Set(
+    branches.map((branch) => {
+      const reading = branch.statusCodeReading?.reading;
+      if (reading?.kind === "absent") {
+        return branch.statusCodeReading?.libraryDefault ?? null;
+      }
+      return reading?.kind === "written" ? reading.value : null;
+    })
+  );
+  const [only] = [...statuses];
+  return statuses.size === 1 && typeof only === "number" ? (0, import_extractor6.writtenReading)(only, rangeOf(helper)) : (0, import_extractor6.unreadableReading)(
+    "This response is sent by a helper whose status does not settle on one number here, so this outcome claims none",
+    rangeOf(helper)
+  );
+}
 function branchOf(outcome, pattern, effects, extraEffects, options) {
   if (outcome.fellThrough === true && options.fallthrough === "handOn") {
     return handsOnBranch(outcome, effects, extraEffects);
@@ -5719,6 +6478,7 @@ function branchOf(outcome, pattern, effects, extraEffects, options) {
       reading: outcome.reading,
       libraryDefault: pattern.defaultStatusCode
     },
+    ...outcome.body === void 0 ? {} : { bodyShapeReading: { reading: outcome.body } },
     effects: effectsReaching(effects, outcome.conditions),
     ...extraEffects === void 0 ? {} : { extraEffects },
     location: outcome.location,
@@ -5746,20 +6506,26 @@ function handsOnBranch(outcome, effects, extraEffects) {
     isDefault: outcome.conditions.length === 0
   };
 }
-function returnPathBranches(method, effects, exits = [], facts) {
+function returnPathBranches(method, effects, exits = [], facts, keepsArms, raises2 = []) {
   const body = field(method, "body");
   if (body === null) {
     return null;
   }
   const returns = collectReturns(body, []);
   const exitCalls = exits.map((exit) => exit.call);
-  const lowered = lowerRubyBody(body, [...returns, ...exitCalls], exitCalls);
-  const enumerated = (0, import_extractor4.enumerateOrDegrade)(
+  const terminals = [
+    ...returns,
+    ...exitCalls,
+    ...raises2.map((raise) => raise.call)
+  ];
+  const lowered = lowerRubyBody(body, terminals, exitCalls);
+  const enumerated = (0, import_extractor6.enumerateOrDegrade)(
     {
       statements: lowered.statements,
-      terminalsByStmt: lowered.terminalsByStmt
+      terminalsByStmt: lowered.terminalsByStmt,
+      ...keepsArms === void 0 ? {} : { keepsArms }
     },
-    [...returns, ...exitCalls]
+    terminals
   );
   const inputs = conditionInputs(
     method,
@@ -5787,8 +6553,8 @@ function returnPathBranches(method, effects, exits = [], facts) {
       returnTerminal(rangeOf(statement))
     );
   }
-  for (const exit of exits) {
-    push(enumerated.byTerminal.get(exit.call) ?? [], exit.terminal);
+  for (const ending of [...exits, ...raises2]) {
+    push(enumerated.byTerminal.get(ending.call) ?? [], ending.terminal);
   }
   push(enumerated.fallthrough, returnTerminal(rangeOf(method)));
   return branches.length === 0 ? null : branches;
@@ -5813,21 +6579,30 @@ function responseBranches(method, pattern, effects, extraEffects, options = {})
   if (declarations.length === 0 || body === null) {
     return null;
   }
-  const byName = declarationsByName(declarations);
-  const locals = localNamesIn(method);
-  const responses = collectResponseCalls(body, byName, locals, []);
+  const responders = {
+    byName: declarationsByName(declarations),
+    locals: localNamesIn(method),
+    helper: options.respondingHelper
+  };
+  const responses = collectResponseCalls(body, responders, []);
   const returns = collectReturns(body, []);
-  const lowered = lowerRubyBody(body, returns, responses);
+  const raises2 = options.raises === void 0 ? [] : escapingRaises(method);
+  const lowered = lowerRubyBody(
+    body,
+    [...returns, ...raises2],
+    responses,
+    pattern.formatSwitch
+  );
   const bareReturns = returns.filter(
-    (node) => lowered.terminalHome.has(node) && collectResponseCalls(node, byName, locals, []).length === 0
+    (node) => lowered.terminalHome.has(node) && collectResponseCalls(node, responders, []).length === 0
   );
   const terminals = [...responses, ...bareReturns];
-  const enumerated = (0, import_extractor4.enumerateOrDegrade)(
+  const enumerated = (0, import_extractor6.enumerateOrDegrade)(
     {
       statements: lowered.statements,
       terminalsByStmt: lowered.terminalsByStmt
     },
-    terminals
+    [...terminals, ...raises2]
   );
   const statusNames = pattern.statusCodeNames ?? {};
   const inputs = conditionInputs(
@@ -5838,30 +6613,58 @@ function responseBranches(method, pattern, effects, extraEffects, options = {})
   const conditionsOf = (path7) => path7.map((condition) => conditionOf(condition, inputs));
   const outcomes = [];
   for (const terminal of terminals) {
-    const declaration = declarationOf(terminal, byName, locals);
-    const reading = declaration === void 0 ? import_extractor4.absentReading : readingOfCall(terminal, declaration, statusNames, options.facts);
+    const responder = responderOf(terminal, responders);
+    const reading = responder === void 0 ? import_extractor6.absentReading : readingOfResponder(terminal, responder, statusNames, options);
+    const body2 = responder?.kind === "declared" ? bodyReadingOfCall(terminal, responder.declaration, options.facts) : void 0;
     for (const path7 of enumerated.byTerminal.get(terminal) ?? []) {
       outcomes.push({
         conditions: conditionsOf(path7),
         reading,
-        location: rangeOf(terminal)
+        ...body2 === void 0 ? {} : { body: body2 },
+        location: rangeOf(terminal),
+        // A bare `return` wrote no response, so a filter that takes it
+        // hands the request on the same as one that reaches its end.
+        ...responder === void 0 ? { fellThrough: true } : {}
       });
     }
   }
   for (const path7 of enumerated.fallthrough) {
     outcomes.push({
       conditions: conditionsOf(path7),
-      reading: import_extractor4.absentReading,
+      reading: import_extractor6.absentReading,
       location: rangeOf(method),
       fellThrough: true
     });
   }
-  if (outcomes.length === 0) {
+  const read = options.raises;
+  const raised = raises2.flatMap((call) => {
+    const terminal = raisedTerminal(
+      pattern,
+      read?.classes.get(call) ?? null,
+      read?.handlers ?? [],
+      rangeOf(call)
+    );
+    return (enumerated.byTerminal.get(call) ?? []).map((path7) => {
+      const conditions = conditionsOf(path7);
+      return {
+        conditions,
+        terminal,
+        effects: effectsReaching(effects, conditions),
+        ...extraEffects === void 0 ? {} : { extraEffects },
+        location: terminal.location,
+        isDefault: false
+      };
+    });
+  });
+  if (outcomes.length === 0 && raised.length === 0) {
     return null;
   }
-  return outcomes.map(
-    (outcome) => branchOf(outcome, pattern, effects, extraEffects, options)
-  );
+  return [
+    ...outcomes.map(
+      (outcome) => branchOf(outcome, pattern, effects, extraEffects, options)
+    ),
+    ...raised
+  ];
 }
 
 // src/clientCalls.ts
@@ -5874,7 +6677,16 @@ function clientCallUnits(root, pack, pattern, options) {
     }
     for (const call of callsUnder2(method)) {
       for (const request of requestCalls(call, pattern, options)) {
-        units.push(clientUnit(method, name, request, pattern, pack, options));
+        units.push(
+          clientUnit(
+            method,
+            name,
+            { ...request, call },
+            pattern,
+            pack,
+            options
+          )
+        );
       }
     }
   }
@@ -5932,10 +6744,7 @@ function requestArgument(call, called, pattern) {
   return pattern.requestObject?.attribute === called ? args.positional[0] : void 0;
 }
 function methodDefinitions(node, found = []) {
-  for (const child of node.namedChildren) {
-    if (child === null) {
-      continue;
-    }
+  for (const child of children(node)) {
     if (child.type === "method" || child.type === "singleton_method") {
       found.push(child);
     }
@@ -5944,10 +6753,7 @@ function methodDefinitions(node, found = []) {
   return found;
 }
 function callsUnder2(node, found = []) {
-  for (const child of node.namedChildren) {
-    if (child === null) {
-      continue;
-    }
+  for (const child of children(node)) {
     if (child.type === "call") {
       found.push(child);
     }
@@ -5964,20 +6770,23 @@ function requestCalls(call, pattern, options) {
   const read = (site) => requestCall(
     call,
     called,
-    receiverPrefix(receiver, pattern, options, site),
+    receiverBase(receiver, pattern, options, site),
     pattern,
     options,
     site
   );
   const plain = read();
-  if (plain !== null && !(0, import_behavioral_ir.hasNameHole)(plain.path)) {
+  if (plain !== null && !(0, import_behavioral_ir2.hasNameHole)(plain.path)) {
     return [plain];
   }
   const byBoundary = /* @__PURE__ */ new Map();
   for (const site of constructionSitesOf(call, options.facts)) {
     const stated = read(site);
     if (stated !== null) {
-      byBoundary.set(`${stated.method} ${stated.path}`, stated);
+      byBoundary.set(
+        `${stated.method} ${stated.host ?? ""} ${stated.path}`,
+        stated
+      );
     }
   }
   if (byBoundary.size > 0) {
@@ -5985,12 +6794,12 @@ function requestCalls(call, pattern, options) {
   }
   return plain === null ? [] : [plain];
 }
-function requestCall(call, called, prefix, pattern, options, site) {
+function requestCall(call, called, base, pattern, options, site) {
   const args = readCallArgs(field(call, "arguments"));
   const verb = pattern.verbMethodNames[called];
   if (verb !== void 0) {
-    const path8 = urlIn(args, pattern, options, site);
-    return path8 === null ? null : { method: verb, path: prefix + path8 };
+    const target2 = targetAt(urlNodeIn(args, pattern), options, site);
+    return target2 === null ? null : { method: verb, ...underBase(base, target2) };
   }
   const sent = pattern.requestObject;
   if (sent === void 0 || sent.attribute !== called) {
@@ -6000,8 +6809,14 @@ function requestCall(call, called, prefix, pattern, options, site) {
   if (built === null) {
     return null;
   }
-  const path7 = pathAt(built.url, options, site);
-  return path7 === null ? null : { method: built.method, path: prefix + path7 };
+  const target = targetAt(built.url, options, site);
+  return target === null ? null : { method: built.method, ...underBase(base, target) };
+}
+function underBase(base, target) {
+  if (base === null || target.host !== void 0) {
+    return target;
+  }
+  return { path: base.path + target.path, host: base.host };
 }
 function requestBuilt(argument, sent, options, site) {
   if (argument === void 0) {
@@ -6022,16 +6837,19 @@ function requestBuilt(argument, sent, options, site) {
 function isLibraryReceiver(receiver, pattern, options) {
   return namesConstant2(receiver, pattern.constantName) || builderCallBehind(receiver, pattern, options.facts) !== null;
 }
-function receiverPrefix(receiver, pattern, options, site) {
+function receiverBase(receiver, pattern, options, site) {
   const built = builderCallBehind(receiver, pattern, options.facts);
   if (built === null) {
-    return "";
+    return null;
   }
   const args = readCallArgs(field(built, "arguments"));
   const keyword = pattern.builderUrlKeyword;
   const base = (keyword === void 0 ? void 0 : args.keyword[keyword]) ?? args.positional[0];
-  const path7 = base === void 0 ? null : (0, import_values13.pathOf)(evaluatedValue(base, options.facts, void 0, site));
-  return path7 === void 0 || path7 === null ? "" : trimmed(path7);
+  if (base === void 0) {
+    return null;
+  }
+  const value = evaluatedValue(base, options.facts, void 0, site);
+  return { path: trimmed((0, import_values14.pathOf)(value) ?? ""), host: (0, import_values14.hostOf)(value) };
 }
 function trimmed(path7) {
   return path7 === "/" ? "" : path7.replace(/\/+$/, "");
@@ -6054,22 +6872,32 @@ function builderCallBehind(receiver, pattern, facts) {
   const constant2 = field(written, "receiver");
   return constant2 !== null && namesConstant2(constant2, pattern.constantName) ? written : null;
 }
-function urlIn(args, pattern, options, site) {
-  return pathAt(urlNodeIn(args, pattern), options, site);
-}
 function urlNodeIn(args, pattern) {
   const keyword = pattern.url.keyword;
   return (keyword === void 0 ? void 0 : args.keyword[keyword]) ?? args.positional[pattern.url.position];
 }
-function pathAt(written, options, site) {
+function targetAt(written, options, site) {
   if (written === void 0) {
     return null;
   }
-  const path7 = (0, import_values13.pathOf)(evaluatedValue(written, options.facts, void 0, site));
-  return path7 === void 0 || (0, import_behavioral_ir.namesNothing)(path7) ? null : path7;
+  const value = evaluatedValue(written, options.facts, void 0, site);
+  const path7 = (0, import_values14.pathOf)(value);
+  return path7 === void 0 || (0, import_behavioral_ir2.namesNothing)(path7) ? null : { path: path7, host: (0, import_values14.hostOf)(value) };
 }
 function clientUnit(method, name, request, pattern, pack, options) {
   const range = rangeOf(method);
+  const accessors = responseAccessors(pattern);
+  const statusMembers = (0, import_behavioral_ir2.statusMembersOf)(accessors);
+  const reading = {
+    facts: options.facts,
+    statusMembers,
+    handOff: {
+      request: request.call,
+      bodyMethods: accessors.bodyAccessors ?? [],
+      facts: options.facts,
+      readHelper: (helper) => callerBranches(helper, { facts: options.facts, statusMembers })
+    }
+  };
   return {
     identity: {
       name,
@@ -6081,25 +6909,34 @@ function clientUnit(method, name, request, pattern, pack, options) {
       exportName: name,
       exportPath: [name]
     },
-    boundaryBinding: (0, import_behavioral_ir.restBinding)({
+    boundaryBinding: (0, import_behavioral_ir2.restBinding)({
       transport: pack.protocol,
       method: request.method,
       path: request.path,
+      host: request.host,
       recognition: pack.name
     }),
     parameters: [],
-    branches: callerBranches(method, range, options.facts),
-    ...responseAccessors(pattern),
+    branches: callerBranches(method, reading),
+    ...accessors,
     bodyContent: "statements",
     dependencyCalls: [],
     declaredContract: null
   };
 }
-function callerBranches(method, range, facts) {
-  const effects = invocationEffects(method, void 0, void 0, facts);
-  return returnPathBranches(method, effects, [], facts) ?? [
-    returnBranch(range, effects)
-  ];
+function callerBranches(method, reading) {
+  const sites = invocationSites(method, void 0, void 0, reading.facts);
+  const effects = sites.map((site) => site.effect);
+  const keepsArms = (condition) => (0, import_behavioral_ir2.testsStatus)(predicateOf(condition), reading.statusMembers);
+  const found = returnPathBranches(
+    method,
+    effects,
+    [],
+    reading.facts,
+    keepsArms,
+    raiseEndings(method)
+  ) ?? [returnBranch(rangeOf(method), effects)];
+  return reading.handOff === void 0 ? found : throughResponseHelpers(found, sites, reading.handOff);
 }
 function responseAccessors(pattern) {
   const response = pattern.response;
@@ -6110,7 +6947,8 @@ 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 returnBranch(range, effects) {
@@ -6135,8 +6973,8 @@ function returnBranch(range, effects) {
 }
 
 // src/envReads.ts
-var import_behavioral_ir2 = require("@suss/behavioral-ir");
-var import_extractor5 = require("@suss/extractor");
+var import_behavioral_ir3 = require("@suss/behavioral-ir");
+var import_extractor7 = require("@suss/extractor");
 var import_resolution9 = require("@suss/resolution");
 
 // src/envSpellings.ts
@@ -6161,9 +6999,7 @@ function elementSite(node) {
   if (object === null || !isEnv(object) || isAssignedTo(node)) {
     return null;
   }
-  const index = node.namedChildren.find(
-    (child) => child !== null && child.id !== object.id
-  );
+  const index = children(node).find((child) => child.id !== object.id);
   if (index === void 0) {
     return null;
   }
@@ -6344,7 +7180,7 @@ function followsExitWhenAbsent(parent, child, subject) {
   if (!STATEMENT_LIST_TYPES.has(parent.type)) {
     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)
@@ -6396,7 +7232,7 @@ function continuationRaises(from) {
   let parent = current.parent;
   while (parent !== null) {
     if (STATEMENT_LIST_TYPES.has(parent.type)) {
-      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) {
@@ -6430,20 +7266,13 @@ function firstExit(statements) {
   return null;
 }
 function exitOf2(statement) {
-  if (isRaise3(statement)) {
+  if (isRaiseCall(statement)) {
     return "raise";
   }
   if (LEAVING_TYPES.has(statement.type)) {
     return "leave";
   }
-  return STATEMENT_LIST_TYPES.has(statement.type) ? firstExit(statement.namedChildren) : null;
-}
-var RAISING_METHODS2 = /* @__PURE__ */ new Set(["raise", "fail"]);
-function isRaise3(node) {
-  if (node.type === "identifier") {
-    return RAISING_METHODS2.has(node.text);
-  }
-  return node.type === "call" && field(node, "receiver") === null && RAISING_METHODS2.has(field(node, "method")?.text ?? "");
+  return STATEMENT_LIST_TYPES.has(statement.type) ? firstExit(children(statement)) : null;
 }
 function isPresentWhen(test, outcome, subject) {
   const expression = peelParens(test);
@@ -6511,7 +7340,7 @@ function isNilCheckOn(call, receiver) {
   return call.type === "call" && field(call, "method")?.text === "nil?" && field(call, "receiver")?.id === receiver.id;
 }
 function peelParens(node) {
-  const inner = node.type === "parenthesized_statements" && node.namedChildCount === 1 ? node.namedChildren[0] : null;
+  const inner = node.type === "parenthesized_statements" && node.namedChildCount === 1 ? node.namedChild(0) : null;
   return inner === null || inner === void 0 ? node : peelParens(inner);
 }
 function climbParens(node) {
@@ -6556,7 +7385,7 @@ var DEFERRED_BODY_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method",
 function envReadEffects(root, facts) {
   const helpers = helperFactsOf(facts);
   const slots = [];
-  (0, import_extractor5.walkDescendants)(root, null, {
+  (0, import_extractor7.walkDescendants)(root, null, children, {
     at: (node) => {
       const read = envReadAt(node);
       if (read !== null) {
@@ -6567,7 +7396,7 @@ function envReadEffects(root, facts) {
         slots.push({ call: node });
       }
     },
-    into: (node) => DEFERRED_BODY_TYPES.has(node.type) ? import_extractor5.SKIP_CHILDREN : null
+    into: (node) => DEFERRED_BODY_TYPES.has(node.type) ? import_extractor7.SKIP_CHILDREN : null
   });
   const calls = slots.flatMap((slot) => "call" in slot ? [slot.call] : []);
   const throughHelpers = helpers === null ? new NodeMap() : helperReads(calls, helpers);
@@ -6636,7 +7465,7 @@ function namedParameters(db) {
   return named2;
 }
 function emitEnvFacts(db, file, root) {
-  (0, import_extractor5.walkDescendants)(root, null, {
+  (0, import_extractor7.walkDescendants)(root, null, children, {
     at: (node) => {
       if (isEnv(node) && handsOnward(node)) {
         db.add("environmentObject", [
@@ -6734,7 +7563,7 @@ function readsAtCall(db, call, args) {
 function configReadEffect(read) {
   return {
     type: "interaction",
-    binding: (0, import_behavioral_ir2.runtimeConfigBinding)({ recognition: RUBY_ENV_RECOGNITION }),
+    binding: (0, import_behavioral_ir3.runtimeConfigBinding)({ recognition: RUBY_ENV_RECOGNITION }),
     callee: `ENV["${read.name}"]`,
     interaction: {
       class: "config-read",
@@ -6764,6 +7593,7 @@ function envSiteAt(node) {
 }
 
 // src/filters.ts
+var RESCUES_NOTHING = { refs: [], someUnread: false };
 function controllerFilters(pattern, ancestry, read = {}) {
   const forms = pattern.filters ?? [];
   if (forms.length === 0) {
@@ -6777,18 +7607,29 @@ function controllerFilters(pattern, ancestry, read = {}) {
     }
   }
   let declared = [];
-  for (const { statement } of inheritedStatements(ancestry)) {
+  const inlineSeen = /* @__PURE__ */ new Map();
+  for (const { block, statement } of inheritedStatements(ancestry)) {
     const called = calledName(statement);
     if (called === null) {
       continue;
     }
     const form = byName.get(called);
     if (form !== void 0) {
-      for (const declaration of declarationsOf(statement, form, read.facts)) {
-        declared = [
-          ...declared.filter((earlier) => !sameFilter(earlier, declaration)),
-          declaration
-        ];
+      const inlineKey = `${block.file}\0${block.info.qualifiedName}\0${form.name}`;
+      const ordinal = inlineSeen.get(inlineKey) ?? 0;
+      const declarations = declarationsOf(
+        statement,
+        form,
+        block,
+        read.facts,
+        ordinal
+      );
+      if (declarations.some((one) => one.inline !== void 0)) {
+        inlineSeen.set(inlineKey, ordinal + 1);
+      }
+      for (const declaration of declarations) {
+        const earlier = declaration.filter.onThrow === true ? void 0 : declared.find((one) => sameFilter(one, declaration));
+        declared = [...declared.filter((one) => one !== earlier), declaration];
       }
       continue;
     }
@@ -6799,62 +7640,105 @@ function controllerFilters(pattern, ancestry, read = {}) {
   }
   const resolved = [];
   for (const declaration of declared) {
-    const found = methodInAncestry(ancestry, declaration.methodName, read);
-    if (found.type !== "found") {
+    const written = writtenAt(
+      declaration,
+      filterMethod(ancestry, declaration.methodName, read)
+    );
+    if (written === null) {
       continue;
     }
     resolved.push({
       filter: declaration.filter,
-      methodName: declaration.methodName,
-      method: found.method,
-      file: found.block.file,
-      enclosingQualifiedName: found.block.info.qualifiedName,
+      ...written,
       only: declaration.only,
-      except: declaration.except
+      except: declaration.except,
+      rescues: declaration.rescues
     });
   }
   return [
     ...resolved.filter((one) => one.filter.onThrow !== true),
-    ...resolved.filter((one) => one.filter.onThrow === true)
+    ...resolved.filter((one) => one.filter.onThrow === true).reverse()
   ];
 }
+function writtenAt(declaration, found) {
+  if (found.type === "found") {
+    return {
+      methodName: declaration.methodName,
+      nameKind: "binding",
+      method: found.method,
+      file: found.block.file,
+      enclosingQualifiedName: found.block.info.qualifiedName,
+      nesting: found.block.info.bodyNesting
+    };
+  }
+  const inline = declaration.inline;
+  if (inline === void 0) {
+    return null;
+  }
+  return {
+    methodName: inline.label,
+    nameKind: "label",
+    method: inline.block,
+    file: inline.declaredIn.file,
+    enclosingQualifiedName: inline.declaredIn.info.qualifiedName,
+    nesting: inline.declaredIn.info.bodyNesting
+  };
+}
+function filterMethod(ancestry, name, read) {
+  const found = methodInAncestry(ancestry, name, read);
+  if (found.type === "unsettled" && found.cause === "unreadAncestor") {
+    return methodPastUnreadAncestors(ancestry, name, read);
+  }
+  return found;
+}
 function filterCoversAction(filter, actionName) {
   if (filter.except.has(actionName)) {
     return false;
   }
   return filter.only === null || filter.only.has(actionName);
 }
-function filterReference(filter, displayPath) {
+function filterReference(filter, displayPath, caught) {
   return {
     file: displayPath,
     name: filter.methodName,
-    ...filter.filter.onThrow === true ? { onThrow: true } : {}
+    ...filter.filter.onThrow === true ? { onThrow: true } : {},
+    ...caught === void 0 ? {} : {
+      catches: caught.classes.map((one) => one.name),
+      ...caught.classes.some((one) => one.inheritableByUnread) ? { mayCatchUnreadClasses: true } : {},
+      ...caught.someUnread ? { mayCatchAny: true } : {}
+    }
   };
 }
-function filterUnit(filter, pattern, displayPath, body, facts) {
+function filterUnit(filter, pattern, displayPath, body, reading = {}) {
   const range = rangeOf(filter.method);
+  const { respondingHelper, raises: raises2 } = reading;
   const branches = responseBranches(
     filter.method,
     pattern,
     body.effects ?? [],
     body.extraEffects,
-    { fallthrough: "handOn", facts }
+    {
+      fallthrough: "handOn",
+      facts: reading.facts,
+      ...respondingHelper === void 0 ? {} : { respondingHelper },
+      ...raises2 === void 0 ? {} : { raises: raises2 }
+    }
   );
   return {
     identity: {
       name: filter.methodName,
-      nameKind: "binding",
+      nameKind: filter.nameKind,
       kind: "middleware",
       file: displayPath,
       range,
       span: spanOf(filter.method),
-      exportName: filter.methodName,
+      exportName: filter.nameKind === "binding" ? filter.methodName : null,
       exportPath: [filter.enclosingQualifiedName, filter.methodName]
     },
     boundaryBinding: null,
     parameters: [],
     branches: withSlotSources(
-      branches ?? [handsOn(range, body)],
+      [...branches ?? [handsOn(range, body)], ...reading.raised ?? []],
       body.provenance
     ),
     bodyContent: body.bodyContent ?? "absent",
@@ -6889,25 +7773,92 @@ function calledName(statement) {
   }
   return field(statement, "method")?.text ?? null;
 }
-function declarationsOf(statement, filter, facts) {
+function declarationsOf(statement, filter, declaredIn, facts, inlineOrdinal) {
   const args = readCallArgs(field(statement, "arguments"));
   const keywords = filter.actionKeywords;
   const only = keywords === void 0 ? null : actionsUnder(args.keyword[keywords.include], facts);
   const except = keywords === void 0 ? null : actionsUnder(args.keyword[keywords.exclude], facts);
-  return methodNamesOf(args, filter, facts).map((methodName) => ({
+  const rescues2 = filter.onThrow === true ? rescuedClasses(args, declaredIn.info.bodyNesting, facts) : RESCUES_NOTHING;
+  const inline = inlineHandler(
+    statement,
+    args,
+    filter,
+    declaredIn,
+    inlineOrdinal
+  );
+  return methodNamesOf(args, filter, facts, inline).map((methodName) => ({
     filter,
     methodName,
     only,
-    except: except ?? /* @__PURE__ */ new Set()
+    except: except ?? /* @__PURE__ */ new Set(),
+    rescues: rescues2,
+    ...inline === void 0 ? {} : { inline }
   }));
 }
-function methodNamesOf(args, filter, facts) {
+function inlineHandler(statement, args, filter, declaredIn, ordinal) {
+  const block = blockInPlaceOfMethod(statement, args, filter);
+  if (block === null || blockStatements2(block).length === 0) {
+    return void 0;
+  }
+  return { block, label: `${filter.name}#${ordinal}`, declaredIn };
+}
+function rescuedClasses(args, nesting, facts) {
+  const refs = [];
+  let someUnread = args.positional.length === 0;
+  for (const arg of args.positional) {
+    const candidates = constantRefCandidates(arg, nesting);
+    const named2 = candidates.length === 0 ? stringValueOf(arg, facts) : null;
+    if (candidates.length === 0 && named2 === null) {
+      someUnread = true;
+      continue;
+    }
+    refs.push({
+      text: arg.text,
+      candidates: named2 === null ? candidates : [named2]
+    });
+  }
+  return { refs, someUnread };
+}
+function methodNamesOf(args, filter, facts, inline) {
+  const named2 = filter.methodFrom === "withKeyword" ? withKeywordName(args, facts) : symbolArgumentNames(args, facts);
+  if (named2.length > 0 || inline === void 0) {
+    return named2;
+  }
+  return [blockHandlerName(inline.block) ?? inline.label];
+}
+function withKeywordName(args, facts) {
+  const named2 = args.keyword.with;
+  const value = named2 === void 0 ? null : stringValueOf(named2, facts);
+  return value === null ? [] : [value];
+}
+function blockInPlaceOfMethod(statement, args, filter) {
   if (filter.methodFrom === "withKeyword") {
-    const named2 = args.keyword.with;
-    const value = named2 === void 0 ? null : stringValueOf(named2, facts);
-    return value === null ? [] : [value];
+    return args.keyword.with === void 0 ? field(statement, "block") : null;
+  }
+  const lambda = args.positional.find((arg) => arg.type === "lambda");
+  if (lambda !== void 0) {
+    return field(lambda, "body");
+  }
+  return args.positional.length === 0 ? field(statement, "block") : null;
+}
+function blockStatements2(block) {
+  return children(field(block, "body")).filter(
+    (child) => child.type !== "comment"
+  );
+}
+function blockHandlerName(block) {
+  const statements = blockStatements2(block);
+  const only = statements.length === 1 ? statements[0] : void 0;
+  if (only === void 0) {
+    return null;
+  }
+  const parameters = new Set(
+    children(field(block, "parameters")).map((parameter) => parameter.text)
+  );
+  if (only.type === "identifier") {
+    return parameters.has(only.text) ? null : only.text;
   }
-  return symbolArgumentNames(args, facts);
+  return calledName(only);
 }
 function symbolArgumentNames(args, facts) {
   return args.positional.map((arg) => stringValueOf(arg, facts)).filter((name) => name !== null);
@@ -6918,13 +7869,16 @@ function skipsOf(statement, filterName, facts) {
   return args.positional.map((arg) => stringValueOf(arg, facts)).filter((name) => name !== null).map((methodName) => ({ filterName, methodName, actions }));
 }
 function sameFilter(one, other) {
-  return one.filter.name === other.filter.name && one.methodName === other.methodName;
+  return namedBySymbol(one) && namedBySymbol(other) && one.filter.name === other.filter.name && one.methodName === other.methodName;
+}
+function namedBySymbol(declaration) {
+  return declaration.inline === void 0;
 }
 function applySkips(declared, skips) {
   const left = [];
   for (const declaration of declared) {
     const reaching = skips.filter(
-      (skip) => skip.filterName === declaration.filter.name && skip.methodName === declaration.methodName
+      (skip) => namedBySymbol(declaration) && skip.filterName === declaration.filter.name && skip.methodName === declaration.methodName
     );
     if (reaching.some((skip) => skip.actions === null)) {
       continue;
@@ -6948,8 +7902,8 @@ function actionsUnder(node, facts) {
 }
 
 // src/streamWrites.ts
-var import_behavioral_ir3 = require("@suss/behavioral-ir");
-var import_extractor6 = require("@suss/extractor");
+var import_behavioral_ir4 = require("@suss/behavioral-ir");
+var import_extractor8 = require("@suss/extractor");
 var RUBY_STREAM_RECOGNITION = "ruby-stdlib";
 var KERNEL_WRITES = /* @__PURE__ */ new Map([
   ["puts", "stdout"],
@@ -6967,14 +7921,14 @@ var STREAM_METHODS = /* @__PURE__ */ new Set(["puts", "print", "write", "<<"]);
 var DEFERRED_BODY_TYPES2 = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
 function streamWriteEffects(root) {
   const found = [];
-  (0, import_extractor6.walkDescendants)(root, null, {
+  (0, import_extractor8.walkDescendants)(root, null, children, {
     at: (node) => {
       const write = node.type === "call" ? streamWriteAt(node) : null;
       if (write !== null) {
         found.push(write);
       }
     },
-    into: (node) => DEFERRED_BODY_TYPES2.has(node.type) ? import_extractor6.SKIP_CHILDREN : null
+    into: (node) => DEFERRED_BODY_TYPES2.has(node.type) ? import_extractor8.SKIP_CHILDREN : null
   });
   return found;
 }
@@ -7005,7 +7959,7 @@ function writeEffect(call, target, args) {
   const method = field(call, "method")?.text ?? "";
   return {
     type: "interaction",
-    binding: (0, import_behavioral_ir3.ioBinding)({ recognition: RUBY_STREAM_RECOGNITION, target }),
+    binding: (0, import_behavioral_ir4.ioBinding)({ recognition: RUBY_STREAM_RECOGNITION, target }),
     callee: receiver === null ? method : `${receiver.text}.${method}`,
     groupId: `${call.startPosition.row + 1}:${call.startPosition.column + 1}`,
     interaction: { class: "stream-write", ...payloadOf(args) }
@@ -7058,7 +8012,7 @@ function writtenShapeOf(node) {
     return hashShape(node);
   }
   if (node.type === "array") {
-    const first = node.namedChildren.find((child) => child !== null);
+    const first = children(node).find((child) => child !== null);
     return {
       type: "array",
       items: first ? writtenShapeOf(first) : { type: "unknown" }
@@ -7068,7 +8022,7 @@ function writtenShapeOf(node) {
 }
 function hashShape(node) {
   const properties = {};
-  for (const pair of node.namedChildren) {
+  for (const pair of children(node)) {
     if (pair?.type !== "pair") {
       continue;
     }
@@ -7086,10 +8040,10 @@ function keyName(key) {
 }
 
 // src/testCases.ts
-var import_behavioral_ir4 = require("@suss/behavioral-ir");
-var import_extractor7 = require("@suss/extractor");
+var import_behavioral_ir5 = require("@suss/behavioral-ir");
+var import_extractor9 = require("@suss/extractor");
 var import_resolution10 = require("@suss/resolution");
-var import_values16 = require("@suss/values");
+var import_values17 = require("@suss/values");
 var BLOCK_TYPES6 = /* @__PURE__ */ new Set(["block", "do_block"]);
 function testPatternsIn(packs) {
   return packs.flatMap((pack) => pack.tests ?? []);
@@ -7273,7 +8227,7 @@ function groupStatements(group) {
 }
 function patternForFile(file, patterns) {
   return patterns.find(
-    (pattern) => (0, import_extractor7.matchesTestFileName)(file, pattern.filePatterns) && (0, import_extractor7.isListedTestFile)(file, pattern.files)
+    (pattern) => (0, import_extractor9.matchesTestFileName)(file, pattern.filePatterns) && (0, import_extractor9.isListedTestFile)(file, pattern.files)
   ) ?? null;
 }
 function groupNamesIn(pattern) {
@@ -7431,14 +8385,14 @@ var NodesSeen = class {
 };
 function exampleRun(example, pattern, shared) {
   const byName = /* @__PURE__ */ new Map();
-  const always2 = [];
+  const always3 = [];
   for (const group of withInlineIncludes(example.groups, pattern, shared)) {
     for (const one of groupBlocks(group, pattern)) {
       for (const name of one.names) {
         byName.set(name, one.block);
       }
       if (one.always) {
-        always2.push(one.block);
+        always3.push(one.block);
       }
     }
   }
@@ -7457,7 +8411,7 @@ function exampleRun(example, pattern, shared) {
     }
   };
   include(example.block);
-  for (const block of always2) {
+  for (const block of always3) {
     include(block);
   }
   const valueNames = /* @__PURE__ */ new Set([
@@ -7565,7 +8519,7 @@ function exampleCalls(run, inherited) {
 }
 function testCaseUnits(root, patterns, options) {
   return patterns.flatMap((pattern) => {
-    if (!(0, import_extractor7.matchesTestFileName)(options.absoluteFile, pattern.filePatterns) || !(0, import_extractor7.isListedTestFile)(options.absoluteFile, pattern.files)) {
+    if (!(0, import_extractor9.matchesTestFileName)(options.absoluteFile, pattern.filePatterns) || !(0, import_extractor9.isListedTestFile)(options.absoluteFile, pattern.files)) {
       return [];
     }
     return examplesIn(root, options.absoluteFile, pattern, options.shared).map(
@@ -7638,7 +8592,7 @@ function testUnitOf(parts) {
   const range = rangeOf(anchor);
   return {
     identity: {
-      name: (0, import_behavioral_ir4.testUnitName)(titles.map((title) => title.text)),
+      name: (0, import_behavioral_ir5.testUnitName)(titles.map((title) => title.text)),
       nameKind: "label",
       kind: "test",
       file: options.filePath,
@@ -7684,7 +8638,7 @@ function titleOf(call, facts) {
   if (first.type === "constant" || first.type === "scope_resolution") {
     return { text: first.text, unresolved: false };
   }
-  const read = (0, import_values16.literalOf)(evaluatedValue(first, facts));
+  const read = (0, import_values17.literalOf)(evaluatedValue(first, facts));
   return read === null ? { text: first.text, unresolved: true } : { text: read, unresolved: false };
 }
 function isSkipped(example, pattern) {
@@ -7825,7 +8779,7 @@ function moduleOfConstant(node, options) {
     const key = classBehind(facts, options.absoluteFile, node);
     return key === void 0 ? null : options.displayPathOf((0, import_resolution10.fileOfKey)(key));
   }
-  const name = (0, import_values16.literalOf)(evaluatedValue(node, facts));
+  const name = (0, import_values17.literalOf)(evaluatedValue(node, facts));
   const keys = name === null ? [] : facts.lookup("rbConstantName", 1, name.replace(/^::/, "")).map((row) => String(row[0]));
   const files = [...new Set(keys.map(import_resolution10.fileOfKey))];
   return files.length === 1 ? options.displayPathOf(files[0]) : null;
@@ -7835,8 +8789,8 @@ function oneLine(text2) {
 }
 
 // src/testClasses.ts
-var import_extractor8 = require("@suss/extractor");
-var import_values18 = require("@suss/values");
+var import_extractor10 = require("@suss/extractor");
+var import_values19 = require("@suss/values");
 var BLOCK_TYPES7 = /* @__PURE__ */ new Set(["block", "do_block"]);
 function testClassPatternsIn(packs) {
   return packs.flatMap((pack) => pack.testClasses ?? []);
@@ -7879,7 +8833,7 @@ function testClassUnits(root, patterns, options) {
   });
 }
 function readsFile(file, pattern) {
-  return (0, import_extractor8.matchesTestFileName)(file, pattern.filePatterns) && (0, import_extractor8.isListedTestFile)(file, pattern.files);
+  return (0, import_extractor10.matchesTestFileName)(file, pattern.filePatterns) && (0, import_extractor10.isListedTestFile)(file, pattern.files);
 }
 function testClassesIn(root, file, pattern, facts) {
   const found = [];
@@ -7925,7 +8879,7 @@ function testBlockOf(statement, pattern) {
 }
 function descriptionOf(call, facts) {
   const first = firstArgument(call);
-  return first === null ? null : (0, import_values18.literalOf)(evaluatedValue(first, facts));
+  return first === null ? null : (0, import_values19.literalOf)(evaluatedValue(first, facts));
 }
 function anchorOf2(node) {
   return BLOCK_TYPES7.has(node.type) ? node.parent ?? node : node;
@@ -8102,6 +9056,7 @@ function fieldReadContext(pattern, cache, fileBlocks, bodyRead, facts) {
     },
     lookup: {
       root: pattern.root,
+      autoloadRoots: pattern.autoloadRoots ?? [],
       pathConvention: pattern.pathConvention,
       acronyms: pattern.acronyms ?? [],
       ancestryRootClassNames: pattern.ancestryRootClassNames,
@@ -8210,7 +9165,7 @@ function unitsFor(pattern, pack, info, ownBlocks, fileBlocks, options) {
     graphqlObjectFields: (p) => graphqlObjectFieldUnits(p, pack, info, ownBlocks, fileBlocks, options),
     controllerActions: (p) => controllerActionUnits(p, pack, info, ownBlocks, fileBlocks, options)
   };
-  return (0, import_behavioral_ir5.dispatchByType)(table, pattern);
+  return (0, import_behavioral_ir6.dispatchByType)(table, pattern);
 }
 async function graphqlObjectFieldUnits(pattern, pack, info, ownBlocks, fileBlocks, options) {
   if (info.bodyNode === null || pattern.baseClassNames.includes(info.qualifiedName)) {
@@ -8257,6 +9212,7 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
   }
   const lookup = {
     root: pattern.root,
+    autoloadRoots: pattern.autoloadRoots ?? [],
     pathConvention: pattern.pathConvention,
     acronyms: pattern.acronyms ?? [],
     ancestryRootClassNames: pattern.ancestryRootClassNames,
@@ -8295,15 +9251,41 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
     options.facts,
     options.storage
   );
+  const respondingHelper = respondingHelpersOf(ancestry, pattern, options);
+  const exceptions = new ExceptionReader(
+    lookup,
+    pattern.libraryExceptions ?? {}
+  );
+  const caught = await handlerClasses(filters, exceptions);
+  const handlersAround = (actionName) => filters.filter((filter) => filterCoversAction(filter, actionName)).flatMap((filter) => {
+    const classes = caught.get(filter);
+    return classes === void 0 ? [] : [classes];
+  });
   for (const filter of filters) {
     const displayPath = options.displayPathOf?.(filter.file) ?? filter.file;
-    const raw = filterUnit(
-      filter,
-      pattern,
-      displayPath,
-      bodyOfMethod(filter.method, filter.file, options),
-      options.facts
-    );
+    const body = bodyOfMethod(filter.method, filter.file, options);
+    const handler = filter.filter.onThrow === true;
+    const raw = filterUnit(filter, pattern, displayPath, body, {
+      facts: options.facts,
+      respondingHelper,
+      ...handler ? {} : {
+        raises: {
+          classes: await raisedClasses(
+            filter.method,
+            filter.nesting,
+            exceptions
+          ),
+          handlers: "eachRoute"
+        },
+        raised: raisedStatusBranches(
+          pattern,
+          options.storage?.patterns ?? [],
+          body.extraEffects,
+          "eachRoute",
+          rangeOf(filter.method)
+        )
+      }
+    });
     units.push(raw);
     options.onReachSeed?.(raw, {
       file: filter.file,
@@ -8311,38 +9293,71 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
       enclosingQualifiedName: filter.enclosingQualifiedName
     });
   }
-  const emitAction = (actionName, method, block) => {
+  const emitAction = async (actionName, method, block, routes) => {
     const around = filters.filter((filter) => filterCoversAction(filter, actionName)).map(
       (filter) => filterReference(
         filter,
-        options.displayPathOf?.(filter.file) ?? filter.file
+        options.displayPathOf?.(filter.file) ?? filter.file,
+        caught.get(filter)
       )
     );
-    const raw = buildControllerActionUnit(
-      pack,
-      pattern,
-      info.qualifiedName,
-      actionName,
-      method,
-      {
-        display: block.file === (options.absoluteFile ?? options.filePath) ? options.filePath : options.displayPathOf?.(block.file) ?? block.file,
-        absolute: block.file
-      },
-      options,
-      around
-    );
-    units.push(raw);
-    options.onReachSeed?.(raw, {
-      file: block.file,
-      node: method,
-      enclosingQualifiedName: block.info.qualifiedName
-    });
+    const raises2 = {
+      classes: await raisedClasses(method, block.info.bodyNesting, exceptions),
+      handlers: handlersAround(actionName)
+    };
+    for (const route of routes.length === 0 ? [null] : routes) {
+      const raw = buildControllerActionUnit(
+        pack,
+        pattern,
+        info.qualifiedName,
+        actionName,
+        route,
+        method,
+        {
+          display: block.file === (options.absoluteFile ?? options.filePath) ? options.filePath : options.displayPathOf?.(block.file) ?? block.file,
+          absolute: block.file
+        },
+        options,
+        around,
+        respondingHelper,
+        raises2
+      );
+      units.push(raw);
+      options.onReachSeed?.(raw, {
+        file: block.file,
+        node: method,
+        enclosingQualifiedName: block.info.qualifiedName
+      });
+    }
   };
   for (const [actionName, method, block] of actions) {
-    emitAction(actionName, method, block);
+    const routes = pattern.routesFor(info.qualifiedName, actionName);
+    await emitAction(actionName, method, block, routes);
   }
   return units;
 }
+async function handlerClasses(filters, exceptions) {
+  const caught = /* @__PURE__ */ new Map();
+  for (const filter of filters) {
+    if (filter.filter.onThrow !== true) {
+      continue;
+    }
+    const classes = [];
+    for (const ref of filter.rescues.refs) {
+      classes.push(await exceptions.read(ref));
+    }
+    caught.set(filter, { classes, someUnread: filter.rescues.someUnread });
+  }
+  return caught;
+}
+async function raisedClasses(method, nesting, exceptions) {
+  const classes = new NodeMap();
+  for (const call of escapingRaises(method)) {
+    const ref = raisedClassRef(call, nesting);
+    classes.set(call, ref === null ? null : await exceptions.read(ref));
+  }
+  return classes;
+}
 function controllerActions(pattern, info, ownBlocks, ancestry, options) {
   const actions = publicInstanceMethods(ownBlocks, options.bodyBlocks);
   const seen = new Set(actions.map(([actionName]) => actionName));
@@ -8359,7 +9374,7 @@ function controllerActions(pattern, info, ownBlocks, ancestry, options) {
         continue;
       }
       seen.add(actionName);
-      if (pattern.routeFor(info.qualifiedName, actionName) !== null) {
+      if (pattern.routesFor(info.qualifiedName, actionName).length > 0) {
         actions.push(action);
       }
     }
@@ -8384,16 +9399,52 @@ function publicInstanceMethods(blocks, bodyBlocks) {
   }
   return found;
 }
-function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actionName, method, file, bodyRead, wrappers = []) {
+function respondingHelpersOf(ancestry, pattern, options) {
+  const methods = /* @__PURE__ */ new Map();
+  const known = /* @__PURE__ */ new Map();
+  const declared = new Set(
+    (pattern.responseStatusCalls ?? []).map((call) => call.name)
+  );
+  const methodNamed = (name) => {
+    if (!methods.has(name)) {
+      const found = methodInAncestry(ancestry, name, {
+        facts: options.facts,
+        bodyBlocks: options.bodyBlocks,
+        dynamicNames: options.dynamicNames
+      });
+      methods.set(name, found.type === "found" ? found.method : null);
+    }
+    return methods.get(name) ?? null;
+  };
+  return (name, call) => {
+    const method = declared.has(name) ? null : methodNamed(name);
+    if (method === null) {
+      return null;
+    }
+    const bound = boundStatusArguments(method, call, pattern, options.facts);
+    const key = `${name}(${[...bound].join(",")})`;
+    if (!known.has(key)) {
+      known.set(key, helperResponse(method, pattern, options.facts, bound));
+    }
+    return known.get(key) ?? null;
+  };
+}
+function servesFormat(pattern, route) {
+  return pattern.optionalFormat === true && route.formatless !== true && !route.path.endsWith("/");
+}
+function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actionName, route, method, file, bodyRead, wrappers, respondingHelper, raises2) {
   const range = rangeOf(method);
-  const route = pattern.routeFor(controllerQualifiedName, actionName);
   const body = bodyOfMethod(method, file.absolute, bodyRead);
   const perResponse = responseBranches(
     method,
     pattern,
     body.effects ?? [],
     body.extraEffects,
-    { facts: bodyRead.facts }
+    {
+      facts: bodyRead.facts,
+      respondingHelper,
+      raises: raises2
+    }
   );
   return {
     identity: {
@@ -8406,11 +9457,12 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
       exportName: actionName,
       exportPath: [controllerQualifiedName, actionName]
     },
-    boundaryBinding: route === null ? null : (0, import_behavioral_ir5.restBinding)({
+    boundaryBinding: route === null ? null : (0, import_behavioral_ir6.restBinding)({
       transport: pack.protocol,
       method: route.method,
       path: route.path,
-      recognition: pack.name
+      recognition: pack.name,
+      optionalFormat: servesFormat(pattern, route)
     }),
     parameters: [],
     branches: withSlotSources(
@@ -8430,7 +9482,7 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
             location: range
           },
           statusCodeReading: {
-            reading: import_extractor9.absentReading,
+            reading: import_extractor11.absentReading,
             libraryDefault: pattern.defaultStatusCode
           },
           effects: body.effects ?? [],
@@ -8440,6 +9492,14 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
         }
       ],
       body.provenance
+    ).concat(
+      raisedStatusBranches(
+        pattern,
+        bodyRead.storage?.patterns ?? [],
+        body.extraEffects,
+        raises2.handlers,
+        range
+      )
     ),
     bodyContent: body.bodyContent ?? "absent",
     dependencyCalls: [],
@@ -8481,7 +9541,7 @@ function routingGapUnit(pattern, gaps) {
         isDefault: true
       }
     ],
-    readings: gaps.map((gap) => (0, import_extractor9.unreadableReading)(gap, range)),
+    readings: gaps.map((gap) => (0, import_extractor11.unreadableReading)(gap, range)),
     dependencyCalls: [],
     declaredContract: null
   };
@@ -8554,7 +9614,7 @@ var NO_METHOD_BEHIND_IT = {
   readings: []
 };
 function methodNotSettled(reason, range) {
-  return { readings: [(0, import_extractor9.unreadableReading)(reason, range)] };
+  return { readings: [(0, import_extractor11.unreadableReading)(reason, range)] };
 }
 function bodyFromLookup(found, range, subject, nothingThere, bodyRead) {
   const table = {
@@ -8572,7 +9632,7 @@ function bodyFromLookup(found, range, subject, nothingThere, bodyRead) {
     ),
     none: () => nothingThere
   };
-  return (0, import_behavioral_ir5.dispatchByType)(table, found);
+  return (0, import_behavioral_ir6.dispatchByType)(table, found);
 }
 async function readFieldCall(stmt, scope, ctx, ancestry) {
   if (stmt.type !== "call" || field(stmt, "receiver") !== null) {
@@ -8615,7 +9675,7 @@ function computedNameDeclaration(stmt, nameArg) {
     contract: null,
     body: {
       readings: [
-        (0, import_extractor9.unreadableReading)(
+        (0, import_extractor11.unreadableReading)(
           `This field is named by ${nameArg.text}, which is worked out when the class body runs, so the name the schema exposes it under was not read here`,
           range
         )
@@ -8846,7 +9906,7 @@ function buildFieldUnit(pack, typeName, decl, filePath) {
       exportName: null,
       exportPath: null
     },
-    boundaryBinding: decl.namedOnTheWire ? (0, import_behavioral_ir5.graphqlResolverBinding)({
+    boundaryBinding: decl.namedOnTheWire ? (0, import_behavioral_ir6.graphqlResolverBinding)({
       transport: pack.protocol,
       recognition: pack.name,
       typeName,
@@ -9262,15 +10322,15 @@ function parseWith(language, source) {
 // src/project.ts
 var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
-var import_behavioral_ir8 = require("@suss/behavioral-ir");
+var import_behavioral_ir9 = require("@suss/behavioral-ir");
 var import_datalog3 = require("@suss/datalog");
-var import_extractor17 = require("@suss/extractor");
+var import_extractor19 = require("@suss/extractor");
 var import_resolution16 = require("@suss/resolution");
 
 // src/diagnostics.ts
-var import_extractor10 = require("@suss/extractor");
+var import_extractor12 = require("@suss/extractor");
 function buildRubyExtractionReport(args) {
-  return (0, import_extractor10.buildUngatedExtractionReport)({
+  return (0, import_extractor12.buildUngatedExtractionReport)({
     packs: args.packs.map((pack) => ({
       name: pack.name,
       version: pack.version ?? null,
@@ -9283,9 +10343,9 @@ function buildRubyExtractionReport(args) {
 }
 
 // src/exits.ts
-var import_extractor11 = require("@suss/extractor");
+var import_extractor13 = require("@suss/extractor");
 var import_resolution11 = require("@suss/resolution");
-var import_values21 = require("@suss/values");
+var import_values22 = require("@suss/values");
 var EXIT_METHODS = /* @__PURE__ */ new Map([
   ["exit", 0],
   ["exit!", 1],
@@ -9294,14 +10354,14 @@ var EXIT_METHODS = /* @__PURE__ */ new Map([
 var DEFERRED_BODY_TYPES3 = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
 function exitSites(root) {
   const found = [];
-  (0, import_extractor11.walkDescendants)(root, null, {
+  (0, import_extractor13.walkDescendants)(root, null, children, {
     at: (node) => {
       const site = node.type === "call" ? exitSiteAt(node) : null;
       if (site !== null) {
         found.push(site);
       }
     },
-    into: (node) => DEFERRED_BODY_TYPES3.has(node.type) ? import_extractor11.SKIP_CHILDREN : null
+    into: (node) => DEFERRED_BODY_TYPES3.has(node.type) ? import_extractor13.SKIP_CHILDREN : null
   });
   return found;
 }
@@ -9338,7 +10398,7 @@ function exitCodeOf(site, facts) {
   if (written !== void 0) {
     return { type: "literal", value: written };
   }
-  const value = (0, import_values21.constantOf)(evaluatedValue(code, facts));
+  const value = (0, import_values22.constantOf)(evaluatedValue(code, facts));
   return typeof value === "number" ? { type: "literal", value } : { type: "dynamic", sourceText: code.text };
 }
 function exitingBranches(method, effects, facts) {
@@ -9359,7 +10419,7 @@ function markExitCodeFunctions(summaries, exits, facts, workspaceRoot) {
       (site) => site.code === null ? [] : [nodeId(file, site.code)]
     )
   );
-  (0, import_extractor11.markReturnsAsExitCode)(
+  (0, import_extractor13.markReturnsAsExitCode)(
     summaries,
     (0, import_resolution11.exitCodeFunctions)(facts, sinks),
     workspaceRoot
@@ -9409,9 +10469,9 @@ function eventsOf(args, called, callbacks, db) {
 
 // src/facts.ts
 var import_node_path3 = __toESM(require("path"), 1);
-var import_extractor12 = require("@suss/extractor");
+var import_extractor14 = require("@suss/extractor");
 function emitRequireFacts(db, filePath, root, known) {
-  (0, import_extractor12.walkDescendants)(root, null, {
+  (0, import_extractor14.walkDescendants)(root, null, children, {
     at: (node) => {
       const target = requiredRelativePath(node);
       if (target === null) {
@@ -9425,7 +10485,7 @@ function emitRequireFacts(db, filePath, root, known) {
         db.add("importsFile", [filePath, resolved]);
       }
     },
-    into: (node) => node.type === "argument_list" ? import_extractor12.SKIP_CHILDREN : null
+    into: (node) => node.type === "argument_list" ? import_extractor14.SKIP_CHILDREN : null
   });
 }
 function requiredRelativePath(node) {
@@ -9437,17 +10497,17 @@ function requiredRelativePath(node) {
 }
 
 // src/moduleSurface.ts
-var import_behavioral_ir7 = require("@suss/behavioral-ir");
-var import_extractor15 = require("@suss/extractor");
+var import_behavioral_ir8 = require("@suss/behavioral-ir");
+var import_extractor17 = require("@suss/extractor");
 
 // src/reach/closure.ts
-var import_behavioral_ir6 = require("@suss/behavioral-ir");
+var import_behavioral_ir7 = require("@suss/behavioral-ir");
 var import_datalog2 = require("@suss/datalog");
-var import_extractor14 = require("@suss/extractor");
+var import_extractor16 = require("@suss/extractor");
 var import_resolution13 = require("@suss/resolution");
 
 // src/flags.ts
-var import_extractor13 = require("@suss/extractor");
+var import_extractor15 = require("@suss/extractor");
 var PARSE_METHODS = /* @__PURE__ */ new Set(["parse", "parse!", "permute", "permute!"]);
 var DEFERRED_BODY_TYPES4 = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
 function optionParserFlagReads(method, parameterNames3) {
@@ -9476,9 +10536,9 @@ function optionParserFlagReads(method, parameterNames3) {
   return reads;
 }
 function walkBody2(body, at) {
-  (0, import_extractor13.walkDescendants)(body, null, {
+  (0, import_extractor15.walkDescendants)(body, null, children, {
     at,
-    into: (node) => DEFERRED_BODY_TYPES4.has(node.type) ? import_extractor13.SKIP_CHILDREN : null
+    into: (node) => DEFERRED_BODY_TYPES4.has(node.type) ? import_extractor15.SKIP_CHILDREN : null
   });
 }
 var OPTION_PARSER_SPELLINGS = /* @__PURE__ */ new Set(["OptionParser", "::OptionParser"]);
@@ -9492,7 +10552,7 @@ function flagsDeclaredIn(construction) {
     return [];
   }
   const flags = [];
-  (0, import_extractor13.walkDescendants)(block, null, {
+  (0, import_extractor15.walkDescendants)(block, null, children, {
     at: (node) => {
       if (node.type !== "call" || field(node, "method")?.text !== "on") {
         return;
@@ -9564,6 +10624,11 @@ var UNSETTLED_ON_SELF = {
   reason: "noDeclaration",
   matchByName: true
 };
+var SELF_CALL_IN_MIXIN = {
+  kind: "stopped",
+  reason: "selfCallInMixin",
+  matchByName: true
+};
 function followed(target) {
   return { kind: "followed", target };
 }
@@ -9752,22 +10817,27 @@ function leavesRoomForATopLevelMethod(reason) {
   return reason === "noDeclaration" || reason === "outsideRun";
 }
 function resolveImplicitSelf(methodName, site, ctx) {
-  if (site.enclosingQualifiedName !== null) {
-    const onClass = methodOnSelf(
-      site,
-      site.enclosingQualifiedName,
-      methodName,
-      ctx
-    );
-    if (onClass.kind === "followed" || !leavesRoomForATopLevelMethod(onClass.reason)) {
-      return onClass;
-    }
+  const onClass = site.enclosingQualifiedName === null ? null : methodOnSelf(site, site.enclosingQualifiedName, methodName, ctx);
+  if (onClass !== null && (onClass.kind === "followed" || !leavesRoomForATopLevelMethod(onClass.reason))) {
+    return onClass;
   }
+  const readWholeAncestry = onClass?.kind === "stopped" && onClass.reason === "noDeclaration";
   const topLevel = resolveTopLevelName(methodName, ctx);
   if (topLevel.kind === "followed" || topLevel.reason !== "noDeclaration") {
     return topLevel;
   }
-  return declaredForTheOtherSelf(site, methodName, ctx) ? NO_DECLARATION : UNSETTLED_ON_SELF;
+  if (declaredForTheOtherSelf(site, methodName, ctx)) {
+    return NO_DECLARATION;
+  }
+  return readWholeAncestry && !OBJECT_METHODS.has(methodName) && inModuleInstanceMethod(site, ctx) ? SELF_CALL_IN_MIXIN : UNSETTLED_ON_SELF;
+}
+function inModuleInstanceMethod(site, ctx) {
+  const qualifiedName = site.enclosingQualifiedName;
+  if (qualifiedName === null || site.method === null || inClassMethod(site, ctx)) {
+    return false;
+  }
+  const own = ctx.ancestries.get(qualifiedName)?.[0];
+  return own?.type === "bodies" && own.blocks.every((block) => block.info.kind === "module");
 }
 function declaredForTheOtherSelf(site, methodName, ctx) {
   const qualifiedName = site.enclosingQualifiedName;
@@ -9810,12 +10880,16 @@ function methodOnAncestryOf(qualifiedName, methodName, ctx) {
     return followed(reachedMethod(found.method, found.block, methodName));
   }
   if (found.type === "unsettled") {
-    return stop(
-      found.cause === "dynamicDefine" ? "definedAtLoadTime" : "outsideRun"
-    );
+    return stop(unsettledReason(found));
   }
   return NO_DECLARATION;
 }
+function unsettledReason(found) {
+  if (found.cause === "dynamicDefine") {
+    return "definedAtLoadTime";
+  }
+  return found.definedLater === true ? "behindUnreadAncestor" : "outsideRun";
+}
 function reachedMethod(node, block, name) {
   return {
     file: block.file,
@@ -9975,15 +11049,15 @@ async function reachedFunctions(seeds, options) {
     const build = () => {
       const raw = libraryUnit(target, options);
       dropPropertyReads(raw, propertyReadsByKey.get(key));
-      const summary2 = (0, import_extractor14.assembleSummary)(raw, { gapHandling });
+      const summary2 = (0, import_extractor16.assembleSummary)(raw, { gapHandling });
       if (gapHandling !== "silent") {
         summary2.gaps.push(
-          ...(stopsByKey.get(key) ?? []).map(import_behavioral_ir6.unfollowedCallGap)
+          ...(stopsByKey.get(key) ?? []).map(import_behavioral_ir7.unfollowedCallGap)
         );
       }
-      (0, import_behavioral_ir6.placeCalls)(summary2, targetsByKey.get(key));
-      (0, import_behavioral_ir6.placeArgTargets)(summary2, argTargetsByKey.get(key));
-      (0, import_behavioral_ir6.placeCalleeParameters)(summary2, parameterCallsByKey.get(key));
+      (0, import_behavioral_ir7.placeCalls)(summary2, targetsByKey.get(key));
+      (0, import_behavioral_ir7.placeArgTargets)(summary2, argTargetsByKey.get(key));
+      (0, import_behavioral_ir7.placeCalleeParameters)(summary2, parameterCallsByKey.get(key));
       return summary2;
     };
     const summary = ledger === void 0 ? build() : ledger.charging(chargeOf(charges, key), () => {
@@ -9998,7 +11072,7 @@ async function reachedFunctions(seeds, options) {
     summaries.push(summary);
   }
   if (gapHandling !== "silent") {
-    (0, import_behavioral_ir6.recordParameterGaps)(parameterCallsByKey, summariesByKey, passedPositions);
+    (0, import_behavioral_ir7.recordParameterGaps)(parameterCallsByKey, summariesByKey, passedPositions);
   }
   return {
     summaries,
@@ -10211,9 +11285,9 @@ function scanBody(source, ctx, options, read) {
   );
   const ownParameters = positionalParameters(source.node).map((p) => p.name);
   const followed2 = [];
-  const stops = [];
-  const placements = new import_behavioral_ir6.TargetPlacements();
-  const receiverClasses = new import_behavioral_ir6.ReceiverClasses();
+  const stops = new import_behavioral_ir7.StopList();
+  const placements = new import_behavioral_ir7.TargetPlacements();
+  const receiverClasses = new import_behavioral_ir7.ReceiverClasses();
   const parameterCalls = [];
   const passedPositions = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
@@ -10295,11 +11369,13 @@ function scanBody(source, ctx, options, read) {
       outcome.kind === "followed" ? keyOf(outcome.target) : null
     );
     if (outcome.kind === "stopped") {
-      const stopKey = `${outcome.reason}:${callee}`;
       const claimed = options.storage !== void 0 && storageClaims(call, callSite.file, options.storage, callSite.method);
-      if (!seen.has(stopKey) && !claimed && (0, import_behavioral_ir6.worthRecording)(outcome.reason)) {
-        seen.add(stopKey);
-        stops.push({ callee, reason: outcome.reason });
+      if (!claimed && (0, import_behavioral_ir7.worthRecording)(outcome.reason)) {
+        stops.add({
+          callee,
+          reason: outcome.reason,
+          ...resultUsedAsValue(call) ? { usedAsValue: true } : {}
+        });
       }
       if (outcome.reason === "callerSupplied" && !parameterCallsSeen.has(callee)) {
         const receiverName = field(call, "receiver")?.text;
@@ -10322,7 +11398,7 @@ function scanBody(source, ctx, options, read) {
   }
   return {
     followed: followed2,
-    stops,
+    stops: stops.stops,
     targets: placements.targets,
     argTargets: placements.argTargets,
     parameterCalls,
@@ -10363,7 +11439,7 @@ function propertyReadsAmong(argless, made, keptArgless) {
   }
   return reads;
 }
-function libraryUnit(target, options, binding = (0, import_behavioral_ir6.functionCallBinding)({
+function libraryUnit(target, options, binding = (0, import_behavioral_ir7.functionCallBinding)({
   transport: "in-process",
   recognition: "reachable"
 })) {
@@ -10448,10 +11524,10 @@ function parameterName(param) {
 
 // src/moduleSurface.ts
 function settleRubyModules(modules) {
-  return (0, import_extractor15.settleModules)(modules, ["{name}.rb", "../{name}.rb"]);
+  return (0, import_extractor17.settleModules)(modules, ["{name}.rb", "../{name}.rb"]);
 }
 function moduleExportUnits(root, file, options) {
-  const module2 = (0, import_extractor15.moduleOfFile)(options.modules, file);
+  const module2 = (0, import_extractor17.moduleOfFile)(options.modules, file);
   if (module2 === void 0 || !module2.public.includes(file)) {
     return [];
   }
@@ -10478,8 +11554,8 @@ function moduleExportUnits(root, file, options) {
           exportPath: [info.qualifiedName, method]
         },
         options,
-        (0, import_behavioral_ir7.moduleExportBinding)({
-          recognition: import_extractor15.MODULE_SURFACE_RECOGNITION,
+        (0, import_behavioral_ir8.moduleExportBinding)({
+          recognition: import_extractor17.MODULE_SURFACE_RECOGNITION,
           module: module2.name,
           exportName: name
         })
@@ -10787,11 +11863,11 @@ var WalkReplay = class {
 };
 
 // src/testFactories.ts
-var import_values28 = require("@suss/values");
+var import_values29 = require("@suss/values");
 function factoriesIn(packs) {
   return packs.flatMap((pack) => pack.factories ?? []);
 }
-function emitFactoryFacts(db, files, isTestFile, patterns, inflections) {
+function emitFactoryFacts(db, files, isTestFile2, patterns, inflections) {
   for (const pattern of patterns) {
     const definitions = /* @__PURE__ */ new Map();
     for (const { file, root } of files) {
@@ -10799,7 +11875,7 @@ function emitFactoryFacts(db, files, isTestFile, patterns, inflections) {
     }
     const classes = new FactoryClasses(db, definitions, inflections);
     for (const { file, root } of files) {
-      if (!isTestFile(file)) {
+      if (!isTestFile2(file)) {
         continue;
       }
       for (const [call, name] of buildsIn(db, root, pattern)) {
@@ -10849,7 +11925,7 @@ function classRefOf(db, file, node) {
   if (node.type === "constant" || node.type === "scope_resolution") {
     return { key: readKey(file, node, null) };
   }
-  const written = (0, import_values28.literalOf)(evaluatedValue(node, db));
+  const written = (0, import_values29.literalOf)(evaluatedValue(node, db));
   if (written === null) {
     return null;
   }
@@ -10858,7 +11934,7 @@ function classRefOf(db, file, node) {
   };
 }
 function nameOf(db, node) {
-  return symbolValue(node) ?? (0, import_values28.literalOf)(evaluatedValue(node, db));
+  return symbolValue(node) ?? (0, import_values29.literalOf)(evaluatedValue(node, db));
 }
 var FactoryClasses = class {
   constructor(db, definitions, inflections) {
@@ -10930,7 +12006,7 @@ function builtAt(db, call, pattern) {
 
 // src/testSharedGroups.ts
 var import_resolution15 = require("@suss/resolution");
-var import_values30 = require("@suss/values");
+var import_values31 = require("@suss/values");
 var ByNode = class {
   byTree = /* @__PURE__ */ new WeakMap();
   set(node, value) {
@@ -11034,7 +12110,7 @@ var SharedGroupIndex = class {
   }
   nameOf(call) {
     const first = firstArgument(call);
-    return first === null ? null : (0, import_values30.literalOf)(evaluatedValue(first, this.db));
+    return first === null ? null : (0, import_values31.literalOf)(evaluatedValue(first, this.db));
   }
   noteRead(definition) {
     if (definition !== null) {
@@ -11111,16 +12187,16 @@ function visibleAt(index, site, pattern) {
 }
 
 // src/version.ts
-var import_extractor16 = require("@suss/extractor");
+var import_extractor18 = require("@suss/extractor");
 var ADAPTER_VERSION = "0.1.0";
-var adapterStamp = (0, import_extractor16.createAdapterStamp)({
+var adapterStamp = (0, import_extractor18.createAdapterStamp)({
   moduleUrl: importMetaUrl,
   version: ADAPTER_VERSION
 });
 
 // src/project.ts
 function keptRubyParses() {
-  return new import_extractor17.KeptParses((root) => root.tree.delete());
+  return new import_extractor19.KeptParses((root) => root.tree.delete());
 }
 async function parseRubyAhead(files, kept) {
   for (const file of files) {
@@ -11225,7 +12301,7 @@ var RunFacts = class {
         ...this.testFiles.map(({ file }) => file),
         ...this.parsed.map(({ file }) => file).filter(
           (file) => classTests.some(
-            (one) => (0, import_extractor17.matchesTestFileName)(file, one.filePatterns)
+            (one) => (0, import_extractor19.matchesTestFileName)(file, one.filePatterns)
           )
         )
       ]);
@@ -11260,7 +12336,7 @@ function factsForFile(options) {
   return facts.db;
 }
 function moduleInitUnit(options) {
-  const raw = (0, import_extractor17.moduleInitStructure)({
+  const raw = (0, import_extractor19.moduleInitStructure)({
     name: options.name,
     file: options.file,
     range: options.range,
@@ -11274,7 +12350,7 @@ function moduleInitUnit(options) {
 }
 function discoveredAs(raw) {
   const reported = raw.identity.exportPath?.join(".") ?? raw.identity.name;
-  const boundary = raw.boundaryBinding === null ? "" : (0, import_behavioral_ir8.boundaryKey)(raw.boundaryBinding) ?? "";
+  const boundary = raw.boundaryBinding === null ? "" : (0, import_behavioral_ir9.boundaryKey)(raw.boundaryBinding) ?? "";
   return `${raw.identity.file}::${reported}::${raw.identity.range.start}::${boundary}`;
 }
 function replaysCleanly(units, discovered) {
@@ -11291,16 +12367,16 @@ function replaysCleanly(units, discovered) {
   return true;
 }
 async function extractRubyProject(options) {
-  const timer = options.onTiming !== void 0 ? (0, import_extractor17.createTimer)() : (0, import_extractor17.noopTimer)();
+  const timer = options.onTiming !== void 0 ? (0, import_extractor19.createTimer)() : (0, import_extractor19.noopTimer)();
   const cacheDir = adapterStamp.declineWhenRunFromSource(
     options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? import_node_path4.default.join(options.projectRoot, ".suss", "cache") : null)
   );
-  const layer = (0, import_extractor17.createCacheLayer)(cacheDir);
+  const layer = (0, import_extractor19.createCacheLayer)(cacheDir);
   const packsDigest = `${adapterStamp.packsDigest(
     options.packs.map(
       (pack) => pack.version !== void 0 ? { name: pack.name, version: pack.version } : { name: pack.name }
     )
-  )}|${(0, import_extractor17.extractionConfigStamp)({
+  )}|${(0, import_extractor19.extractionConfigStamp)({
     gapHandling: options.gapHandling,
     workspaceRoot: options.workspaceRoot,
     projectRoot: options.projectRoot,
@@ -11308,7 +12384,7 @@ async function extractRubyProject(options) {
   })}`;
   const input = {
     files: cacheDir === null ? [] : options.files,
-    adapterPacksDigest: cacheDir === null ? packsDigest : (0, import_extractor17.runDigest)(packsDigest, options.packs, options.files)
+    adapterPacksDigest: cacheDir === null ? packsDigest : (0, import_extractor19.runDigest)(packsDigest, options.packs, options.files)
   };
   const lookup = await timer.timeAsync(
     "cache.lookup",
@@ -11363,7 +12439,7 @@ async function runRuby(options, cache, previous) {
   const db = new import_datalog3.Database();
   const summaries = [];
   const gapHandling = options.gapHandling ?? "permissive";
-  const tallies = (0, import_extractor10.createPackTallies)(options.packs);
+  const tallies = (0, import_extractor12.createPackTallies)(options.packs);
   const ledger = cacheDir === null ? null : new import_resolution16.DependencyLedger(options.files);
   const log = ledger === null ? null : new import_resolution16.FactLog(db, ledger);
   if (ledger !== null) {
@@ -11465,7 +12541,7 @@ async function runRuby(options, cache, previous) {
           continue;
         }
         discovered.add(unit.dedup);
-        (0, import_extractor10.tallyUnit)(tallies, unit.recognition);
+        (0, import_extractor12.tallyUnit)(tallies, unit.recognition);
         found.push({
           replayed: unit.summary ?? null,
           seedKey: unit.seed?.key ?? null
@@ -11546,7 +12622,7 @@ async function runRuby(options, cache, previous) {
         continue;
       }
       discovered.add(dedup);
-      (0, import_extractor10.tallyUnit)(tallies, recognition);
+      (0, import_extractor12.tallyUnit)(tallies, recognition);
       found.push({ raw, seedKey, draft: units[units.length - 1] });
       if (seed !== void 0 && seedKey !== null && !seedKeys.has(seedKey)) {
         seedKeys.add(seedKey);
@@ -11609,7 +12685,7 @@ async function runRuby(options, cache, previous) {
       }
       const summary = timer.time(
         "summarize",
-        () => (0, import_extractor17.assembleSummary)(routingGapUnit(pattern, gaps), { gapHandling })
+        () => (0, import_extractor19.assembleSummary)(routingGapUnit(pattern, gaps), { gapHandling })
       );
       summary.confidence = { source: "inferred_static", level: "low" };
       found.push({ summary });
@@ -11665,7 +12741,7 @@ async function runRuby(options, cache, previous) {
     }
     const summary = timer.time(
       "summarize",
-      () => (0, import_extractor17.assembleSummary)(raw, { gapHandling })
+      () => (0, import_extractor19.assembleSummary)(raw, { gapHandling })
     );
     summaries.push(summary);
     assembledHere.add(summary);
@@ -11683,13 +12759,13 @@ async function runRuby(options, cache, previous) {
       }
       if (gapHandling !== "silent") {
         summary.gaps.push(
-          ...(reached.stopsByKey.get(key) ?? []).map(import_behavioral_ir8.unfollowedCallGap)
+          ...(reached.stopsByKey.get(key) ?? []).map(import_behavioral_ir9.unfollowedCallGap)
         );
       }
-      (0, import_behavioral_ir8.placeCalls)(summary, reached.targetsByKey.get(key));
-      (0, import_behavioral_ir8.placeArgTargets)(summary, reached.argTargetsByKey.get(key));
-      (0, import_behavioral_ir8.placeCalleeParameters)(summary, reached.parameterCallsByKey.get(key));
-      (0, import_behavioral_ir8.placeReceiverClasses)(summary, reached.receiverClassesByKey.get(key));
+      (0, import_behavioral_ir9.placeCalls)(summary, reached.targetsByKey.get(key));
+      (0, import_behavioral_ir9.placeArgTargets)(summary, reached.argTargetsByKey.get(key));
+      (0, import_behavioral_ir9.placeCalleeParameters)(summary, reached.parameterCallsByKey.get(key));
+      (0, import_behavioral_ir9.placeReceiverClasses)(summary, reached.receiverClassesByKey.get(key));
     }
   }
   if (ledger !== null) {
@@ -11698,7 +12774,7 @@ async function runRuby(options, cache, previous) {
     }
   }
   if (gapHandling !== "silent") {
-    (0, import_behavioral_ir8.recordParameterGaps)(
+    (0, import_behavioral_ir9.recordParameterGaps)(
       reached.parameterCallsByKey,
       summariesBySeed,
       reached.passedPositions
@@ -11711,20 +12787,20 @@ async function runRuby(options, cache, previous) {
     throw new ReplayFailed("");
   }
   const dependencies = (0, import_resolution16.importedFilesByFile)(db, displayPathOf);
-  (0, import_extractor17.stampModuleImports)(summaries, (file) => dependencies.get(file) ?? []);
-  (0, import_extractor17.stampModules)(summaries, declaredModules, options.workspaceRoot);
+  (0, import_extractor19.stampModuleImports)(summaries, (file) => dependencies.get(file) ?? []);
+  (0, import_extractor19.stampModules)(summaries, declaredModules, options.workspaceRoot);
   const idRoot = options.projectRoot ?? options.workspaceRoot;
   for (const summary of summaries) {
     const absoluteFile = options.workspaceRoot === void 0 ? summary.location.file : import_node_path4.default.resolve(options.workspaceRoot, summary.location.file);
-    summary.identity.id = (0, import_behavioral_ir8.summaryIdFromParts)({
+    summary.identity.id = (0, import_behavioral_ir9.summaryIdFromParts)({
       workspace: void 0,
       file: idRoot === void 0 ? absoluteFile : import_node_path4.default.relative(idRoot, absoluteFile),
       name: summary.identity.name,
       exportPath: summary.identity.exportPath
     });
   }
-  (0, import_behavioral_ir8.disambiguateSummaryIds)(summaries);
-  (0, import_behavioral_ir8.linkCallsToSummaries)(summaries);
+  (0, import_behavioral_ir9.disambiguateSummaryIds)(summaries);
+  (0, import_behavioral_ir9.linkCallsToSummaries)(summaries);
   const composed = timer.time("summarize", () => {
     markExitCodeFunctions(
       summaries,
@@ -11732,7 +12808,7 @@ async function runRuby(options, cache, previous) {
       db,
       options.workspaceRoot
     );
-    return (0, import_extractor17.composeWrappers)(summaries, { gapHandling });
+    return (0, import_extractor19.composeWrappers)(summaries, { gapHandling });
   });
   await timer.timeAsync("cache.write", async () => {
     if (cacheDir === null || composed.length === 0) {
@@ -12011,7 +13087,7 @@ var RubyWhySession = class {
 // src/stubEvidence.ts
 var import_node_fs5 = __toESM(require("fs"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
-var import_extractor18 = require("@suss/extractor");
+var import_extractor20 = require("@suss/extractor");
 function bareLetters(name) {
   return name.replaceAll(/[-_]/g, "").toLowerCase();
 }
@@ -12035,14 +13111,14 @@ function requireTarget(node) {
 }
 function requireSitesIn(root, file) {
   const found = [];
-  (0, import_extractor18.walkDescendants)(root, null, {
+  (0, import_extractor20.walkDescendants)(root, null, children, {
     at: (node) => {
       const target = requireTarget(node);
       if (target !== null) {
         found.push({ target, file, line: rangeOf(node).start });
       }
     },
-    into: (node) => node.type === "argument_list" ? import_extractor18.SKIP_CHILDREN : null
+    into: (node) => node.type === "argument_list" ? import_extractor20.SKIP_CHILDREN : null
   });
   return found;
 }
@@ -12086,6 +13162,7 @@ async function rubyStubEvidence(options) {
   bindEvaluator,
   bodyStatements,
   booleanLiteralValue,
+  children,
   collectFileConstants,
   createConstantFileCache,
   createFileCache,