@suss/adapter-ruby 0.34.0 → 0.35.0

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);
     },
@@ -320,8 +350,8 @@ var VISIBILITY_KEYWORDS = /* @__PURE__ */ new Set([
   "protected",
   "public"
 ]);
-function visibilityKeyword(text2) {
-  return VISIBILITY_KEYWORDS.has(text2) ? text2 : null;
+function visibilityKeyword(text3) {
+  return VISIBILITY_KEYWORDS.has(text3) ? text3 : null;
 }
 function setVisibility(visibility, name, keyword) {
   if (keyword === "public") {
@@ -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 {
@@ -546,8 +621,8 @@ function lowerAcronyms(word, acronyms) {
     (_match, before, acronym) => `${before === void 0 ? "" : "_"}${acronym.toLowerCase()}`
   );
 }
-function escapeRegExp(text2) {
-  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegExp(text3) {
+  return text3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var PATH_CONVENTIONS = {
   railsUnderscore: underscoreConstantPath
@@ -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,80 @@ 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 SENDING_METHODS = /* @__PURE__ */ new Set([
+  "send",
+  "public_send",
+  "__send__"
+]);
+var METHOD_REFERENCE = "method";
+var INVOKE_METHOD = "call";
+var BLOCK_WRAPPERS = /* @__PURE__ */ new Set(["proc", "lambda"]);
+var PROC_CLASS = "Proc";
 var CONSTRUCTOR = "new";
 
 // src/facts/resolve.ts
@@ -677,7 +831,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 +869,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 +884,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) {
@@ -1225,6 +1385,9 @@ function add(emitter, relation, ...tuple) {
   }
   emitter.db.add(relation, tuple);
 }
+function rowsOf(emitter) {
+  return (relation, row) => add(emitter, relation, ...row);
+}
 function valueKey(emitter, written, parent) {
   return readKey(emitter.filePath, written, emitter.enclosing, parent);
 }
@@ -1308,6 +1471,97 @@ function emitCall(emitter, site) {
   }
   emitCallArguments(emitter, site);
   emitConversion(emitter, site);
+  emitSentChoice(emitter, site);
+  emitMethodReference(emitter, site);
+  emitBlockAsProc(emitter, site);
+}
+function emitBlockAsProc(emitter, site) {
+  const { method, receiver, node } = site;
+  const name = method?.text;
+  const wraps = receiver === null ? name !== void 0 && BLOCK_WRAPPERS.has(name) : name === CONSTRUCTOR && receiver.text === PROC_CLASS;
+  const block = field(node, "block");
+  if (!wraps || block === null) {
+    return;
+  }
+  const blockKey = nodeId(emitter.filePath, block);
+  add(emitter, "func", blockKey);
+  add(emitter, "binds", site.key, blockKey);
+  for (const call of callsWrittenIn(block)) {
+    add(emitter, "makesCall", blockKey, nodeId(emitter.filePath, call));
+  }
+}
+function callsWrittenIn(node, found = []) {
+  for (const child of children(node)) {
+    if (OWN_BODY_TYPES.has(child.type)) {
+      continue;
+    }
+    if (child.type === "call") {
+      found.push(child);
+    }
+    callsWrittenIn(child, found);
+  }
+  return found;
+}
+function emitSentChoice(emitter, site) {
+  const { method, receiver, node } = site;
+  if (method === null || !SENDING_METHODS.has(method.text)) {
+    return;
+  }
+  const objectKey = receiver === null ? emitter.selfKey : valueKey(emitter, receiver, node);
+  const [name] = readCallArgs(field(node, "arguments")).positional;
+  if (objectKey === null || name === void 0) {
+    return;
+  }
+  add(emitter, "callsChosenEntry", site.key);
+  const written = symbolValue(name) ?? stringLiteralValue(name);
+  if (written !== null) {
+    for (const spelled of namesReadAs(emitter, receiver, objectKey, written)) {
+      add(emitter, "choosesNamedEntry", site.key, objectKey, spelled);
+    }
+    return;
+  }
+  const ends = writtenEnds(name);
+  if (ends === null) {
+    add(emitter, "choosesEntry", site.key, objectKey);
+    return;
+  }
+  for (const start of namesReadAs(emitter, receiver, objectKey, ends.start)) {
+    add(emitter, "choosesEntryLike", site.key, objectKey, start, ends.end);
+  }
+}
+function writtenEnds(node) {
+  if (node.type !== "string" && node.type !== "delimited_symbol") {
+    return null;
+  }
+  const parts = children(node);
+  const written = (part) => part.type === "string_content";
+  const firstComputed = parts.findIndex((part) => !written(part));
+  if (firstComputed === -1) {
+    return null;
+  }
+  const lastComputed = parts.length - 1 - [...parts].reverse().findIndex((part) => !written(part));
+  const start = parts.slice(0, firstComputed).map((part) => part.text).join("");
+  const end = parts.slice(lastComputed + 1).map((part) => part.text).join("");
+  return start === "" && end === "" ? null : { start, end };
+}
+function emitMethodReference(emitter, site) {
+  const { method, receiver, node } = site;
+  if (method?.text !== METHOD_REFERENCE || receiver !== null || emitter.selfKey === null) {
+    return;
+  }
+  const [name] = readCallArgs(field(node, "arguments")).positional;
+  const written = name === void 0 ? null : symbolValue(name) ?? stringLiteralValue(name);
+  if (written === null) {
+    return;
+  }
+  for (const spelled of namesReadAs(
+    emitter,
+    receiver,
+    emitter.selfKey,
+    written
+  )) {
+    add(emitter, "readsProperty", site.key, emitter.selfKey, spelled);
+  }
 }
 function emitConversion(emitter, site) {
   const { method, receiver, node } = site;
@@ -1381,7 +1635,6 @@ var SELF_READS = {
 function classSpelling(name) {
   return name === CONSTRUCTOR ? name : (0, import_resolution4.classMemberName)(name);
 }
-var INVOKE_METHOD = "call";
 function invokedValueOf(call) {
   if (call.type !== "call") {
     return null;
@@ -1427,6 +1680,7 @@ function emitArray(emitter, array) {
   const objectKey = nodeId(emitter.filePath, array);
   add(emitter, "objectValue", objectKey);
   let position = 0;
+  const entries = [];
   for (const element of children(array)) {
     add(
       emitter,
@@ -1436,12 +1690,24 @@ function emitArray(emitter, array) {
       valueKey(emitter, element, array)
     );
     position += 1;
+    entries.push(writtenEntry(emitter, element, array));
   }
+  (0, import_resolution4.addEntryRows)(rowsOf(emitter), objectKey, entries);
+}
+var SPREAD_TYPES = /* @__PURE__ */ new Set(["splat_argument", "hash_splat_argument"]);
+function writtenEntry(emitter, entry, parent) {
+  const unpacked = SPREAD_TYPES.has(entry.type) ? children(entry)[0] : void 0;
+  return unpacked === void 0 ? { key: valueKey(emitter, entry, parent), form: import_resolution4.VALUE_ENTRY } : { key: valueKey(emitter, unpacked, entry), form: import_resolution4.SPREAD_ENTRY };
 }
 function emitHash(emitter, hash) {
   const objectKey = nodeId(emitter.filePath, hash);
   add(emitter, "objectValue", objectKey);
+  const entries = [];
   for (const pair of children(hash)) {
+    if (SPREAD_TYPES.has(pair.type)) {
+      entries.push(writtenEntry(emitter, pair, hash));
+      continue;
+    }
     if (pair.type !== "pair") {
       continue;
     }
@@ -1450,6 +1716,7 @@ function emitHash(emitter, hash) {
     if (key === null || value === null) {
       continue;
     }
+    entries.push(writtenEntry(emitter, value, pair));
     const keyText = pairKeyText(key);
     if (keyText === null) {
       add(emitter, "holdsUnderKey", objectKey, valueKey(emitter, value, pair));
@@ -1463,32 +1730,66 @@ function emitHash(emitter, hash) {
       valueKey(emitter, value, pair)
     );
   }
+  (0, import_resolution4.addEntryRows)(rowsOf(emitter), objectKey, entries);
 }
 var BLOCK_TYPES3 = /* @__PURE__ */ new Set(["block", "do_block"]);
 var LOOP_METHODS = /* @__PURE__ */ new Set(["each", "each_with_index", "map"]);
-var DEFINE_METHOD_CALL = "define_method";
-function loopTurnAt(emitter, block, call) {
-  if (call.type !== "call") {
-    return null;
-  }
-  const receiver = field(call, "receiver");
-  const method = field(call, "method");
+var COUNTING_LOOP = "each_with_index";
+function emitLoopVariables(emitter, block, call) {
+  const receiver = call.type === "call" ? field(call, "receiver") : null;
+  const method = receiver === null ? null : field(call, "method");
   if (receiver === null || method === null || !LOOP_METHODS.has(method.text)) {
-    return null;
+    return;
   }
-  const parameters = field(block, "parameters");
-  const names = parameters === null ? [] : children(parameters).map((p) => p.text);
-  const element = names[0];
-  if (element === void 0) {
-    return null;
+  const variables = children(field(block, "parameters")).filter(
+    (variable) => variable.type !== "block_parameter"
+  );
+  const counting = method.text === COUNTING_LOOP;
+  const [first, position] = variables;
+  if (first === void 0 || counting && variables.length > 2) {
+    return;
   }
-  return {
-    element,
-    index: names[1] ?? "",
-    overKey: nodeId(emitter.filePath, receiver)
-  };
+  const taken = counting || variables.length === 1 ? elementTakenBy(first) : partsTakenBy(variables);
+  const blockKey = nodeId(emitter.filePath, block);
+  const over = valueKey(emitter, receiver, call);
+  for (const variable of taken) {
+    const key = `${blockKey}#${variable.name}`;
+    if (variable.part === null) {
+      add(emitter, "elementOf", key, over);
+      continue;
+    }
+    add(emitter, "elementPartOf", key, over, variable.part);
+  }
+  const [anchor] = taken;
+  if (counting && position?.type === "identifier" && anchor !== void 0) {
+    add(
+      emitter,
+      "positionOf",
+      `${blockKey}#${position.text}`,
+      `${blockKey}#${anchor.name}`
+    );
+  }
+}
+function elementTakenBy(variable) {
+  if (variable.type === "identifier") {
+    return [{ name: variable.text, part: null }];
+  }
+  return variable.type === "destructured_parameter" ? partsTakenBy(children(variable)) : [];
+}
+function partsTakenBy(variables) {
+  const parts = [];
+  for (const [position, variable] of variables.entries()) {
+    if (variable.type === "splat_parameter") {
+      break;
+    }
+    if (variable.type === "identifier") {
+      parts.push({ name: variable.text, part: String(position) });
+    }
+  }
+  return parts;
 }
-function emitDynamicDefinition(emitter, call, type, turns) {
+var DEFINE_METHOD_CALL = "define_method";
+function emitDynamicDefinition(emitter, call, type) {
   if (emitter.selfKey === null || // A call inside a method runs when the method runs, not when the class loads.
   emitter.enclosing !== null || type !== "call" || field(call, "receiver") !== null || field(call, "method")?.text !== DEFINE_METHOD_CALL) {
     return;
@@ -1497,33 +1798,16 @@ function emitDynamicDefinition(emitter, call, type, turns) {
   const first = args === null ? void 0 : children(args)[0];
   const nameKey2 = nodeId(emitter.filePath, first ?? call);
   add(emitter, "definesMethodFrom", emitter.selfKey, nameKey2);
-  for (const turn of turns) {
-    add(
-      emitter,
-      "nameTurnsOn",
-      nameKey2,
-      turn.element,
-      turn.index,
-      turn.overKey
-    );
-  }
 }
-function walkExpressions(node, emitter, visit, nested = null, turns = []) {
+function walkExpressions(node, visit, nested = null) {
   for (const child of children(node)) {
     const type = child.type;
     if (OWN_BODY_TYPES.has(type)) {
       nested?.push(child);
       continue;
     }
-    visit(child, type, node, turns);
-    const opened = BLOCK_TYPES3.has(type) ? loopTurnAt(emitter, child, node) : null;
-    walkExpressions(
-      child,
-      emitter,
-      visit,
-      nested,
-      opened === null ? turns : [...turns, opened]
-    );
+    visit(child, type, node);
+    walkExpressions(child, visit, nested);
   }
 }
 var WRITTEN_KEY_TYPES = /* @__PURE__ */ new Set([
@@ -1537,22 +1821,23 @@ function emitKeyedRead(emitter, site, container, key, keyParent) {
   if (WRITTEN_KEY_TYPES.has(key.type)) {
     return;
   }
+  const siteKey = nodeId(emitter.filePath, site);
+  const containerKey = valueKey(emitter, container, site);
   add(
     emitter,
     "readsKeyed",
-    nodeId(emitter.filePath, site),
-    valueKey(emitter, container, site),
+    siteKey,
+    containerKey,
     valueKey(emitter, key, keyParent)
   );
+  add(emitter, "choosesEntry", siteKey, containerKey);
 }
 function emitKeyedElement(emitter, node, parent) {
   const object = field(node, "object");
   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,27 +1878,27 @@ 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, []);
-  walkExpressions(node, emitter, (child, type, parent, turns) => {
+  emitDynamicDefinition(emitter, node, node.type);
+  walkExpressions(node, (child, type, parent) => {
     const site = callSiteAt(emitter, child, type, parent);
-    emitExpressionFact(emitter, child, type, parent, turns, site);
+    emitExpressionFact(emitter, child, type, parent, site);
   });
 }
-function emitExpressionFact(emitter, child, type, parent, turns, site) {
-  emitDynamicDefinition(emitter, child, type, turns);
+function emitExpressionFact(emitter, child, type, parent, site) {
+  emitDynamicDefinition(emitter, child, type);
   if (site !== null) {
     emitCall(emitter, site);
     emitKeyedFetch(emitter, site);
@@ -1654,6 +1939,11 @@ function emitExpressionFact(emitter, child, type, parent, turns, site) {
   }
   if (BLOCK_TYPES3.has(type)) {
     emitBlockValue(emitter, child);
+    emitLoopVariables(emitter, child, parent);
+  }
+  const pieces = TEMPLATE_PIECES[type]?.(emitter, child) ?? [];
+  if (pieces.length > 0) {
+    (0, import_resolution4.addTemplateRows)(rowsOf(emitter), nodeId(emitter.filePath, child), pieces);
   }
   for (const branch of BRANCHES_OF[type]?.(child) ?? []) {
     add(
@@ -1673,6 +1963,29 @@ function emitExpressionFact(emitter, child, type, parent, turns, site) {
     emitParameterDefault(emitter, child);
   }
 }
+function interpolatedPieces(emitter, string) {
+  const parts = children(string);
+  if (!parts.some((part) => part.type === "interpolation")) {
+    return [];
+  }
+  return parts.flatMap((part) => {
+    if (part.type === "string_content") {
+      return [{ text: part.text }];
+    }
+    const expression = part.type === "interpolation" ? children(part)[0] : void 0;
+    return expression === void 0 ? [] : [{ hole: valueKey(emitter, expression, part) }];
+  });
+}
+function adjacentPieces(emitter, joined2) {
+  return children(joined2).map((part) => ({
+    hole: valueKey(emitter, part, joined2)
+  }));
+}
+var TEMPLATE_PIECES = {
+  string: interpolatedPieces,
+  delimited_symbol: interpolatedPieces,
+  chained_string: adjacentPieces
+};
 function emitBlockArgument(emitter, argument) {
   const [handed] = children(argument);
   if (handed !== void 0) {
@@ -2095,11 +2408,10 @@ function emitMethodFacts(emitter, method) {
   const collecting = { ...inside, heldRows: expressionFacts };
   walkExpressions(
     body,
-    inside,
-    (child, type, parent, turns) => {
+    (child, type, parent) => {
       const site = callSiteAt(inside, child, type, parent);
       emitBodyFact(bodyFacts, inside, funcKey, child, type, site);
-      emitExpressionFact(collecting, child, type, parent, turns, site);
+      emitExpressionFact(collecting, child, type, parent, site);
     },
     nested
   );
@@ -2559,9 +2871,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 +3073,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 +3747,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 +3813,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);
       }
@@ -3560,8 +3891,24 @@ function literalElementsIn(value) {
   }
   return elements;
 }
-function literalElementsOf(node, db) {
-  return literalElementsIn(evaluatedValue(node, db));
+function loopElementsOf(node, db) {
+  const value = evaluatedValue(node, db);
+  if (value.kind === "sequence") {
+    return value.items.map((item) => elementOfList((0, import_values4.force)(item.value)));
+  }
+  if (value.kind === "record" && !value.open) {
+    return [...value.fields].map(([key, item]) => {
+      const parts = [(0, import_values4.text)(key), (0, import_values4.force)(item.value)];
+      return { whole: (0, import_values4.sequence)(parts), parts };
+    });
+  }
+  return null;
+}
+function elementOfList(whole) {
+  return {
+    whole,
+    parts: whole.kind === "sequence" ? whole.items.map((item) => (0, import_values4.force)(item.value)) : [whole]
+  };
 }
 function namesOf(node, db) {
   const value = evaluatedValue(node, db);
@@ -3583,13 +3930,16 @@ function definedNamesOf(dynamic, classKey) {
 }
 function readDynamicNames(db, rootsByFile) {
   const byClass = /* @__PURE__ */ new Map();
-  for (const [classKey, nameKey2] of db.facts("definesMethodFrom")) {
+  const definitions = db.facts("definesMethodFrom");
+  const loops = definitions.length === 0 ? /* @__PURE__ */ new Map() : loopsByFile(db);
+  for (const [classKey, nameKey2] of definitions) {
     const key = String(classKey);
+    const around = loopsAround(loops, key, String(nameKey2));
     byClass.set(
       key,
       foldReading(
         byClass.get(key) ?? NOTHING,
-        readOne(db, rootsByFile, String(nameKey2))
+        readOne(db, rootsByFile, String(nameKey2), around)
       )
     );
   }
@@ -3610,11 +3960,11 @@ function foldReading(soFar, reading) {
     unreadable: soFar.unreadable
   };
 }
-function readOne(db, rootsByFile, nameKey2) {
+function readOne(db, rootsByFile, nameKey2, loops) {
   const node = (0, import_resolution6.nodeOfKey)(rootsByFile, nameKey2);
   const names = [];
   const patterns = [];
-  for (const bindings of loopTurns(db, rootsByFile, nameKey2)) {
+  for (const bindings of loopTurns(db, rootsByFile, loops)) {
     const value = node === null ? (0, import_values5.hole)(nameKey2) : evaluatedValue(node, db, bindings.size === 0 ? void 0 : bindings);
     const name = (0, import_values5.literalOf)(value);
     if (name !== null) {
@@ -3647,38 +3997,105 @@ function patternOf(value) {
   }
   return readSomething ? new RegExp(`${source}$`) : null;
 }
-function escapeForPattern(text2) {
-  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeForPattern(text3) {
+  return text3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function loopTurns(db, rootsByFile, nameKey2) {
+function loopTurns(db, rootsByFile, loops) {
   let turns = [/* @__PURE__ */ new Map()];
-  for (const over of listsBehind(db, rootsByFile, nameKey2)) {
+  for (const loop of loops) {
+    const bindings = bindingsOf(db, rootsByFile, loop);
+    if (bindings === null) {
+      continue;
+    }
     turns = turns.flatMap(
-      (base) => over.elements.map((value, position) => {
-        const binding = new Map([...base, [over.element, value]]);
-        if (over.index !== "") {
-          binding.set(over.index, String(position));
-        }
-        return binding;
-      })
+      (base) => bindings.map((binding) => new Map([...base, ...binding]))
     );
   }
   return turns;
 }
-function listsBehind(db, rootsByFile, nameKey2) {
-  const found = [];
-  for (const [, element, index, overKey] of db.lookup(
-    "nameTurnsOn",
-    0,
-    nameKey2
-  )) {
-    const node = (0, import_resolution6.nodeOfKey)(rootsByFile, String(overKey));
-    const elements = node === null ? null : literalElementsOf(node, db);
-    if (elements !== null) {
-      found.push({ element: String(element), index: String(index), elements });
+function bindingsOf(db, rootsByFile, loop) {
+  const node = collectionNode(rootsByFile, loop);
+  const elements = node === null ? null : loopElementsOf(node, db);
+  if (elements === null) {
+    return null;
+  }
+  const bound = [...loop.variables].flatMap(([name, takes]) => {
+    const values = elements.map(
+      (element, position) => GIVEN[takes.kind](element, position, takes)
+    );
+    return values.every((value) => value !== null) ? [{ name, values }] : [];
+  });
+  if (bound.length === 0) {
+    return null;
+  }
+  return elements.map(
+    (_, position) => new Map(bound.map(({ name, values }) => [name, values[position] ?? ""]))
+  );
+}
+var GIVEN = {
+  element: (element) => (0, import_values5.literalOf)(element.whole),
+  part: (element, _, takes) => {
+    const part = takes.kind === "part" ? element.parts[takes.part] : void 0;
+    return part === void 0 ? null : (0, import_values5.literalOf)(part);
+  },
+  position: (_, position) => String(position)
+};
+function collectionNode(rootsByFile, loop) {
+  const written = (0, import_resolution6.nodeOfKey)(rootsByFile, loop.over);
+  if (written !== null) {
+    return written;
+  }
+  const call = (0, import_resolution6.nodeOfKey)(rootsByFile, loop.block.key)?.parent ?? null;
+  return call === null ? null : field(call, "receiver");
+}
+function blockVariableOf(key) {
+  const at = key.lastIndexOf("#");
+  const span = at < 0 ? null : (0, import_resolution6.spanOfKey)(key.slice(0, at));
+  return span === null ? null : { block: { ...span, key: key.slice(0, at) }, name: key.slice(at + 1) };
+}
+function loopsByFile(db) {
+  const blocks = /* @__PURE__ */ new Map();
+  const note = (key, over, takes) => {
+    const variable = blockVariableOf(String(key));
+    if (variable === null) {
+      return;
     }
+    const known = blocks.get(variable.block.key);
+    const loop = known ?? {
+      block: variable.block,
+      over: String(over),
+      variables: /* @__PURE__ */ new Map()
+    };
+    loop.variables.set(variable.name, takes);
+    blocks.set(variable.block.key, loop);
+  };
+  for (const [element, over] of db.facts("elementOf")) {
+    note(element, over, { kind: "element" });
   }
-  return found;
+  for (const [element, over, part] of db.facts("elementPartOf")) {
+    note(element, over, { kind: "part", part: Number(part) });
+  }
+  for (const [position, element] of db.facts("positionOf")) {
+    const block = blockVariableOf(String(element))?.block.key;
+    if (block !== void 0 && blocks.has(block)) {
+      note(position, blocks.get(block)?.over, { kind: "position" });
+    }
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const loop of blocks.values()) {
+    byFile.set(loop.block.file, [...byFile.get(loop.block.file) ?? [], loop]);
+  }
+  return byFile;
+}
+function loopsAround(loops, classKey, nameKey2) {
+  const cls = (0, import_resolution6.spanOfKey)(classKey);
+  const name = (0, import_resolution6.spanOfKey)(nameKey2);
+  if (cls === null || name === null) {
+    return [];
+  }
+  return (loops.get(name.file) ?? []).filter(
+    ({ block }) => cls.start <= block.start && block.end <= cls.end && block.start <= name.start && name.end <= block.end
+  ).sort((a, b) => a.block.start - b.block.start);
 }
 
 // src/scope.ts
@@ -3808,12 +4225,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 +4390,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 +4398,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 +4416,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 +4472,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 +4504,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 +4516,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 +4550,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 +4626,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 +4685,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 +4718,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 +4788,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 +4820,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),
@@ -4323,9 +4844,9 @@ var BLOCK_TYPES5 = /* @__PURE__ */ new Set([
 ]);
 function literalArgOf(node, facts) {
   const value = evaluatedValue(node, facts);
-  const text2 = (0, import_values7.literalOf)(value);
-  if (text2 !== null) {
-    return { kind: "string", value: text2 };
+  const text3 = (0, import_values7.literalOf)(value);
+  if (text3 !== null) {
+    return { kind: "string", value: text3 };
   }
   const constant2 = (0, import_values7.constantOf)(value);
   if (typeof constant2 === "number") {
@@ -4391,7 +4912,7 @@ function isCall(node, locals, inherited) {
 }
 function collectCalls(node, read, inherited, found) {
   for (const child of children(node)) {
-    if (read.stops.has(child.type)) {
+    if (read.stops.has(child.type) && !isLambdaArgument(child)) {
       continue;
     }
     if (isCall(child, read.locals, inherited)) {
@@ -4401,6 +4922,9 @@ function collectCalls(node, read, inherited, found) {
   }
   return found;
 }
+function isLambdaArgument(node) {
+  return node.type === LAMBDA_TYPE && node.parent?.type === "argument_list";
+}
 function methodBody(definitionNode) {
   const body = field(definitionNode, "body");
   if (body === null) {
@@ -4464,6 +4988,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 +5008,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 +5042,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 +5072,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 +5102,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 +5202,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 +5578,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 +6223,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 +6365,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;
 }
@@ -5594,6 +6431,111 @@ function literalAt(key, facts) {
   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 bodyReadingOfCall(call, declaration, facts) {
+  if (declaration.bodyKeyword === void 0 || call.type !== "call") {
+    return import_extractor5.absentReading;
+  }
+  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
 function statusArgumentOf(call, declaration) {
   const args = readCallArgs(field(call, "arguments"));
@@ -5606,13 +6548,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 +6576,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 +6623,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 +6669,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 +6730,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 +6758,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 +6805,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 +6831,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 +6865,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 +6929,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 +6996,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 +7005,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 +7022,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 +7046,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 +7061,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 +7089,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 +7124,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 +7161,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 +7199,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 +7225,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 +7251,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 +7432,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 +7484,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 +7518,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 +7592,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 +7637,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 +7648,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 +7717,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 +7815,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,7 +7845,8 @@ function envSiteAt(node) {
 }
 
 // src/filters.ts
-function controllerFilters(pattern, ancestry, read = {}) {
+var RESCUES_NOTHING = { refs: [], someUnread: false };
+function controllerFilterChain(pattern, ancestry, read = {}) {
   const forms = pattern.filters ?? [];
   if (forms.length === 0) {
     return [];
@@ -6777,18 +7859,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;
     }
@@ -6797,26 +7890,78 @@ function controllerFilters(pattern, ancestry, read = {}) {
       declared = applySkips(declared, skipsOf(statement, skipped, read.facts));
     }
   }
-  const resolved = [];
-  for (const declaration of declared) {
-    const found = methodInAncestry(ancestry, declaration.methodName, read);
-    if (found.type !== "found") {
-      continue;
-    }
-    resolved.push({
+  const resolved = declared.map(
+    (declaration) => linkFor(
+      declaration,
+      writtenAt(
+        declaration,
+        filterMethod(ancestry, declaration.methodName, read)
+      )
+    )
+  );
+  return [
+    ...resolved.filter((one) => !runsAfterARaise(one)),
+    ...resolved.filter(runsAfterARaise).reverse()
+  ];
+}
+function linkFor(declaration, written) {
+  if (written === null) {
+    return {
+      unread: {
+        filter: declaration.filter,
+        methodName: declaration.methodName,
+        declaredIn: declaration.declaredIn,
+        only: declaration.only,
+        except: declaration.except
+      }
+    };
+  }
+  return {
+    read: {
       filter: declaration.filter,
+      ...written,
+      only: declaration.only,
+      except: declaration.except,
+      rescues: declaration.rescues
+    }
+  };
+}
+function filterOf(link) {
+  return "read" in link ? link.read : link.unread;
+}
+function runsAfterARaise(link) {
+  return filterOf(link).filter.onThrow === true;
+}
+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,
-      only: declaration.only,
-      except: declaration.except
-    });
+      nesting: found.block.info.bodyNesting
+    };
   }
-  return [
-    ...resolved.filter((one) => one.filter.onThrow !== true),
-    ...resolved.filter((one) => one.filter.onThrow === true)
-  ];
+  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)) {
@@ -6824,37 +7969,55 @@ function filterCoversAction(filter, actionName) {
   }
   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 } : {},
+    ...caught === void 0 ? {} : {
+      catches: caught.classes.map((one) => one.name),
+      ...caught.classes.some((one) => one.inheritableByUnread) ? { mayCatchUnreadClasses: true } : {},
+      ...caught.someUnread ? { mayCatchAny: true } : {}
+    }
+  };
+}
+function unreadFilterReference(filter, displayPath) {
   return {
     file: displayPath,
     name: filter.methodName,
     ...filter.filter.onThrow === true ? { onThrow: 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 +8052,93 @@ 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,
+    declaredIn: declaredIn.file,
+    ...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 +8149,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 +8182,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 +8201,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 +8239,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 +8292,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 +8302,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 +8320,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 +8507,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 +8665,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 +8691,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 +8799,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 +8872,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 +8918,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,18 +9059,18 @@ 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;
 }
-function oneLine(text2) {
-  return text2.replace(/\s*\n\s*/g, " ").trim();
+function oneLine(text3) {
+  return text3.replace(/\s*\n\s*/g, " ").trim();
 }
 
 // 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 +9113,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 +9159,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 +9336,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 +9445,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 +9492,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,
@@ -8271,11 +9507,12 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
   ])) {
     return [];
   }
-  const filters = controllerFilters(pattern, ancestry, {
+  const chain = controllerFilterChain(pattern, ancestry, {
     facts: options.facts,
     bodyBlocks: options.bodyBlocks,
     dynamicNames: options.dynamicNames
   });
+  const filters = chain.flatMap((link) => "read" in link ? [link.read] : []);
   const units = [];
   const actions = controllerActions(
     pattern,
@@ -8295,15 +9532,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 displayPath2 = options.displayPathOf?.(filter.file) ?? filter.file;
+    const body = bodyOfMethod(filter.method, filter.file, options);
+    const handler = filter.filter.onThrow === true;
+    const raw = filterUnit(filter, pattern, displayPath2, 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 +9574,71 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
       enclosingQualifiedName: filter.enclosingQualifiedName
     });
   }
-  const emitAction = (actionName, method, block) => {
-    const around = filters.filter((filter) => filterCoversAction(filter, actionName)).map(
-      (filter) => filterReference(
-        filter,
-        options.displayPathOf?.(filter.file) ?? filter.file
-      )
-    );
-    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 displayPath = (file) => options.displayPathOf?.(file) ?? file;
+  const referenceTo = (link) => "read" in link ? filterReference(
+    link.read,
+    displayPath(link.read.file),
+    caught.get(link.read)
+  ) : unreadFilterReference(link.unread, displayPath(link.unread.declaredIn));
+  const emitAction = async (actionName, method, block, routes) => {
+    const around = chain.filter((link) => filterCoversAction(filterOf(link), actionName)).map((link) => referenceTo(link));
+    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 +9655,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 +9680,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 +9738,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 +9763,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 +9773,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 +9822,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 +9895,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 +9913,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 +9956,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 +10187,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 +10603,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 +10624,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 +10635,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 +10679,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 +10700,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 +10750,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 +10766,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 +10778,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 +10817,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 +10833,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;
@@ -9507,8 +10848,8 @@ function flagsDeclaredIn(construction) {
   return flags;
 }
 function flagOf(args) {
-  const written = args.map((arg) => stringLiteralValue(arg)).filter((text2) => text2 !== null && text2.startsWith("-"));
-  const chosen = written.find((text2) => text2.startsWith("--")) ?? written[0] ?? null;
+  const written = args.map((arg) => stringLiteralValue(arg)).filter((text3) => text3 !== null && text3.startsWith("-"));
+  const chosen = written.find((text3) => text3.startsWith("--")) ?? written[0] ?? null;
   if (chosen === null) {
     return null;
   }
@@ -9546,8 +10887,6 @@ function parserCalledOn(receiver, parserNamed) {
 
 // src/reach/resolveCallee.ts
 var import_resolution12 = require("@suss/resolution");
-var DYNAMIC_SEND_NAMES = /* @__PURE__ */ new Set(["send", "public_send", "__send__"]);
-var INVOKES_RECEIVER = "call";
 var STOP_FOR = {
   severalSources: "multipleSources",
   outsideRun: "outsideRun",
@@ -9564,6 +10903,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 };
 }
@@ -9625,6 +10969,57 @@ function loaderSourceCallee(call, site, ctx) {
   }
   return null;
 }
+function dispatchedCalls(calls, ctx) {
+  const byKey = new Map(
+    calls.map((one) => [nodeId(one.site.file, one.call), one])
+  );
+  const found = /* @__PURE__ */ new Map();
+  const outcomes = (0, import_resolution12.dispatchOutcomes)(ctx.facts, [...byKey.keys()], RUBY_PROGRAM);
+  for (const [key, outcome] of outcomes) {
+    const asked = byKey.get(key);
+    if (asked === void 0) {
+      continue;
+    }
+    const fits = sendFits(asked.call, asked.site, ctx);
+    const targets = /* @__PURE__ */ new Map();
+    for (const fn of outcome.functions) {
+      for (const target of reachedThrough(fn, outcome.through, ctx)) {
+        if (fits(target)) {
+          targets.set(nodeId(target.file, target.node), target);
+        }
+      }
+    }
+    found.set(asked.call.id, {
+      targets: [...targets.values()],
+      certain: outcome.certain && outcome.functions.every((fn) => ctx.definitions.has(fn)),
+      unresolved: outcome.unresolved
+    });
+  }
+  return found;
+}
+function reachedThrough(key, through, ctx) {
+  const own = ctx.definitions.get(key);
+  if (own !== void 0) {
+    return [own];
+  }
+  return (through.get(key) ?? []).flatMap((inner) => {
+    const target = ctx.definitions.get(inner);
+    return target === void 0 ? [] : [target];
+  });
+}
+function sendFits(call, site, ctx) {
+  const method = calleeMethodName(call);
+  if (method === void 0 || !SENDING_METHODS.has(method)) {
+    return () => true;
+  }
+  const receiver = field(call, "receiver");
+  const toClass = receiver === null || receiver.type === "self" ? inClassMethod(site, ctx) : readsOffClassItself(
+    receiver,
+    readKey(site.file, receiver, site.method),
+    classLocalsFor(call, site)
+  );
+  return (target) => definesClassMethod(target.node, ctx.bodyBlocks) === toClass;
+}
 function outcomeFor(key, ctx, read) {
   return read?.outcomes.get(key) ?? (0, import_resolution12.calleeOutcomeOf)(ctx.facts, key, RUBY_PROGRAM);
 }
@@ -9638,14 +11033,16 @@ function readsAsACall(call, site, ctx, read) {
     return false;
   }
   const outcome = outcomeFor(spelling.key, ctx, read);
-  return outcome.kind === "function" || outcome.kind === "object";
+  return outcome.kind === "function" || outcome.kind === "object" || objectsBehind(ctx.facts, spelling.key).some(
+    (key) => ctx.classNames.has(key)
+  );
 }
 function spellingFor2(call, site) {
   const methodName = calleeMethodName(call);
   if (methodName === void 0) {
     return { kind: "stopped", reason: "noDeclaration" };
   }
-  if (DYNAMIC_SEND_NAMES.has(methodName)) {
+  if (SENDING_METHODS.has(methodName)) {
     return { kind: "stopped", reason: "unsettledValue" };
   }
   const receiver = field(call, "receiver");
@@ -9691,7 +11088,7 @@ function asCallee(spelling, outcome, site, ctx) {
     return methodOnObject(spelling, objectKey, ctx);
   }
   if (outcome.kind === "function") {
-    return spelling.method === INVOKES_RECEIVER ? functionCallee(outcome.key, ctx) : NO_DECLARATION;
+    return spelling.method === INVOKE_METHOD ? functionCallee(outcome.key, ctx) : NO_DECLARATION;
   }
   return stop(STOP_FOR[outcome.kind] ?? "noDeclaration");
 }
@@ -9735,7 +11132,7 @@ function scopeOn(qualifiedName, method, ctx) {
   return null;
 }
 function fromCaller(spelling, parameterKey, site) {
-  if (!parameterKey.startsWith(`${site.owner}#`) || spelling.method !== INVOKES_RECEIVER) {
+  if (!parameterKey.startsWith(`${site.owner}#`) || spelling.method !== INVOKE_METHOD) {
     return stop("unsettledValue");
   }
   return stop("callerSupplied");
@@ -9752,22 +11149,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 +11212,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,
@@ -9862,6 +11268,7 @@ async function reachedFunctions(seeds, options) {
   const targetsByKey = /* @__PURE__ */ new Map();
   const stopsByKey = /* @__PURE__ */ new Map();
   const argTargetsByKey = /* @__PURE__ */ new Map();
+  const possibleTargetsByKey = /* @__PURE__ */ new Map();
   const parameterCallsByKey = /* @__PURE__ */ new Map();
   const propertyReadsByKey = /* @__PURE__ */ new Map();
   const receiverClassesByKey = /* @__PURE__ */ new Map();
@@ -9920,6 +11327,7 @@ async function reachedFunctions(seeds, options) {
       }
       targetsByKey.set(key, scan.targets);
       argTargetsByKey.set(key, scan.argTargets);
+      possibleTargetsByKey.set(key, scan.possibleTargets);
       if (scan.propertyReads.size > 0) {
         propertyReadsByKey.set(key, scan.propertyReads);
       }
@@ -9975,15 +11383,16 @@ 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.placePossibleCalls)(summary2, possibleTargetsByKey.get(key));
+      (0, import_behavioral_ir7.placeCalleeParameters)(summary2, parameterCallsByKey.get(key));
       return summary2;
     };
     const summary = ledger === void 0 ? build() : ledger.charging(chargeOf(charges, key), () => {
@@ -9998,13 +11407,14 @@ 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,
     targetsByKey,
     stopsByKey,
     argTargetsByKey,
+    possibleTargetsByKey,
     parameterCallsByKey,
     propertyReadsByKey,
     receiverClassesByKey,
@@ -10034,36 +11444,70 @@ function batchedReads(round, options) {
   const bodies = round.flatMap(
     (entry) => "source" in entry ? [{ key: entry.key, ...bodyOf2(entry.source, options) }] : []
   );
-  const spellings = calleeSpellings(
-    bodies.flatMap((body) => body.written),
-    options.context
+  const written = bodies.flatMap((body) => body.written);
+  const spellings = calleeSpellings(written, options.context);
+  const dispatched = dispatchedAmong(written, spellings, options.context);
+  return new Map(
+    bodies.map((body) => [body.key, { ...body, spellings, dispatched }])
+  );
+}
+function dispatchedAmong(written, spellings, ctx) {
+  return dispatchedCalls(
+    written.filter(({ call, site }) => {
+      if (!mayRunAnEntry(call)) {
+        return false;
+      }
+      const outcome = resolveCallee(call, site, ctx, spellings);
+      return outcome.kind === "stopped" && outcome.reason !== "callerSupplied";
+    }),
+    ctx
   );
-  return new Map(bodies.map((body) => [body.key, { ...body, spellings }]));
+}
+function mayRunAnEntry(call) {
+  const sent = calleeMethodName(call);
+  if (sent !== void 0 && SENDING_METHODS.has(sent)) {
+    return true;
+  }
+  if (call.type !== "call" || field(call, "receiver") === null) {
+    return false;
+  }
+  const method = field(call, "method");
+  return method === null || method.text === INVOKE_METHOD;
 }
 function scanOnce(source, key, options, read, charges) {
   const ledger = options.ledger;
   if (ledger === void 0) {
-    const body = read ?? {
-      ...bodyOf2(source, options),
-      spellings: { spellingOf: /* @__PURE__ */ new Map(), outcomes: /* @__PURE__ */ new Map() }
-    };
-    return scanBody(source, options.context, options, body);
+    return scanBody(
+      source,
+      options.context,
+      options,
+      read ?? ownReads(source, options)
+    );
   }
   return ledger.charging(chargeOf(charges, key), () => {
     forgetEvaluations(options.context.facts);
     ledger.readFile(source.file);
-    const body = bodyOf2(source, options);
-    const spellings = calleeSpellings(body.written, options.context);
-    const scan = scanBody(source, options.context, options, {
-      ...body,
-      spellings
-    });
+    const scan = scanBody(
+      source,
+      options.context,
+      options,
+      ownReads(source, options)
+    );
     for (const target of scan.followed) {
       ledger.touchKey(keyOf(target));
     }
     return scan;
   });
 }
+function ownReads(source, options) {
+  const body = bodyOf2(source, options);
+  const spellings = calleeSpellings(body.written, options.context);
+  return {
+    ...body,
+    spellings,
+    dispatched: dispatchedAmong(body.written, spellings, options.context)
+  };
+}
 function storedScan(scan) {
   return {
     followed: scan.followed.map((target) => ({
@@ -10079,6 +11523,10 @@ function storedScan(scan) {
       callee,
       [...byPosition]
     ]),
+    possibleTargets: [...scan.possibleTargets].map(([callee, places]) => [
+      callee,
+      [...places]
+    ]),
     parameterCalls: [...scan.parameterCalls],
     passedPositions: [...scan.passedPositions],
     propertyReads: [...scan.propertyReads],
@@ -10096,6 +11544,7 @@ function scanFromStored(stored, functionFor) {
         new Map(byPosition)
       ])
     ),
+    possibleTargets: new Map(stored.possibleTargets),
     parameterCalls: stored.parameterCalls,
     passedPositions: new Set(stored.passedPositions),
     propertyReads: new Set(stored.propertyReads),
@@ -10124,6 +11573,7 @@ var EMPTY_SCAN = {
   stops: [],
   targets: /* @__PURE__ */ new Map(),
   argTargets: /* @__PURE__ */ new Map(),
+  possibleTargets: /* @__PURE__ */ new Map(),
   parameterCalls: [],
   passedPositions: /* @__PURE__ */ new Set(),
   propertyReads: /* @__PURE__ */ new Set(),
@@ -10145,7 +11595,7 @@ function bodyOf2(source, options) {
     const file = run?.fileOf(call) ?? source.file;
     return file === source.file ? site : { ...site, file, method: enclosingDefinition(call) };
   };
-  const written = callsWrittenIn(source.node, run, options);
+  const written = callsWrittenIn2(source.node, run, options);
   const calls = callsReported(
     written,
     (call) => mightReadAsACall(call, siteFor(call), options.context)
@@ -10159,7 +11609,7 @@ function bodyOf2(source, options) {
     written: calls.map((call) => ({ call, site: siteFor(call) }))
   };
 }
-function callsWrittenIn(node, run, options) {
+function callsWrittenIn2(node, run, options) {
   if (run !== null) {
     return exampleCalls(run, options.inheritedMethods).filter(
       (call) => !run.isRunnerCall(call)
@@ -10211,9 +11661,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();
@@ -10226,6 +11676,12 @@ function scanBody(source, ctx, options, read) {
     }
     const argNodes = bodyStatements(args);
     for (let position = 0; position < argNodes.length; position += 1) {
+      if (argNodes[position]?.type === LAMBDA_TYPE) {
+        if (calleeKey !== null) {
+          passedPositions.add(`${calleeKey}#${position}`);
+        }
+        continue;
+      }
       const symbol = methodReferenceSymbol(argNodes[position]);
       if (symbol === null) {
         continue;
@@ -10263,11 +11719,35 @@ function scanBody(source, ctx, options, read) {
       span: spanOf(target.node)
     });
   };
+  const follow = (target) => {
+    const key = keyOf(target);
+    if (!seen.has(key)) {
+      seen.add(key);
+      followed2.push(target);
+    }
+  };
   for (const call of calls) {
     const callee = calleeText(call);
     const callSite = read.siteFor(call);
     const predicate = read.predicateOf(call);
-    const outcome = predicate === null ? resolveCallee(call, callSite, ctx, read.spellings) : resolveMethodOn(predicate.target, predicate.method, callSite, ctx);
+    const settled = predicate === null ? resolveCallee(call, callSite, ctx, read.spellings) : resolveMethodOn(predicate.target, predicate.method, callSite, ctx);
+    const dispatched = settled.kind === "stopped" ? read.dispatched.get(call.id) : void 0;
+    const [only] = dispatched?.targets ?? [];
+    if (dispatched !== void 0 && only !== void 0 && !dispatched.certain) {
+      dispatched.targets.forEach(follow);
+      placements.placePossible(
+        callee,
+        dispatched.targets.map((target) => ({
+          file: displayPathOf(target.file),
+          span: spanOf(target.node)
+        }))
+      );
+      if (dispatched.unresolved > 0) {
+        stops.add({ callee, reason: "unsettledValue" });
+      }
+      continue;
+    }
+    const outcome = only === void 0 ? settled : { kind: "followed", target: only };
     if (options.storage !== void 0) {
       for (const callback of callbacksReached(
         call,
@@ -10295,11 +11775,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;
@@ -10314,17 +11796,14 @@ function scanBody(source, ctx, options, read) {
     if (isArglessReceiverCall(call)) {
       keptArgless.add(call.id);
     }
-    const key = keyOf(outcome.target);
-    if (!seen.has(key)) {
-      seen.add(key);
-      followed2.push(outcome.target);
-    }
+    follow(outcome.target);
   }
   return {
     followed: followed2,
-    stops,
+    stops: stops.stops,
     targets: placements.targets,
     argTargets: placements.argTargets,
+    possibleTargets: placements.possibleTargets,
     parameterCalls,
     passedPositions,
     propertyReads: propertyReadsAmong(read.argless, calls, keptArgless),
@@ -10356,14 +11835,14 @@ function propertyReadsAmong(argless, made, keptArgless) {
   );
   const reads = /* @__PURE__ */ new Set();
   for (const call of argless) {
-    const text2 = calleeText(call);
-    if (!kept.has(text2)) {
-      reads.add(text2);
+    const text3 = calleeText(call);
+    if (!kept.has(text3)) {
+      reads.add(text3);
     }
   }
   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 +11927,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 +11957,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 +12266,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 +12278,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 +12328,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 +12337,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 +12409,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 +12513,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 +12590,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 +12704,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 +12739,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 +12753,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 +12770,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)
+    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? (0, import_extractor19.extractionCacheDirFor)(options.projectRoot) : 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,16 +12787,19 @@ 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",
     () => layer.lookup(input)
   );
+  const composed = (stored) => (0, import_extractor19.composeWrappers)(stored, {
+    gapHandling: options.gapHandling ?? "permissive"
+  });
   if (lookup.kind === "hit") {
     options.onCacheDiagnostic?.(lookup.diagnostic);
     options.onTiming?.(timer.report());
-    return { summaries: lookup.summaries, facts: new import_datalog3.Database() };
+    return { summaries: composed(lookup.summaries), facts: new import_datalog3.Database() };
   }
   const plan = lookup.diagnostic.missReason === "files-changed" ? await timer.timeAsync("cache.plan", () => layer.plan(input)) : null;
   if (plan !== null && plan.changed.size === 0 && plan.removed.size === 0) {
@@ -11327,7 +12809,7 @@ async function extractRubyProject(options) {
     }
     options.onCacheDiagnostic?.({ kind: "hit" });
     options.onTiming?.(timer.report());
-    return { summaries: plan.allSummaries(), facts: new import_datalog3.Database() };
+    return { summaries: composed(plan.allSummaries()), facts: new import_datalog3.Database() };
   }
   const cache = { timer, cacheDir, layer, input };
   const records = plan === null ? null : (0, import_resolution16.recordsToReplay)(plan.roots, plan.changed, plan.removed);
@@ -11363,7 +12845,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 +12947,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 +13028,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 +13091,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 +13147,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 +13165,14 @@ 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.placePossibleCalls)(summary, reached.possibleTargetsByKey.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 +13181,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 +13194,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,18 +13215,22 @@ async function runRuby(options, cache, previous) {
       db,
       options.workspaceRoot
     );
-    return (0, import_extractor17.composeWrappers)(summaries, { gapHandling });
+    return (0, import_extractor19.composeWrappers)(summaries, { gapHandling });
   });
+  const walkedFiles = new Map(
+    parsed.map(({ file }) => [displayPathOf(file), file])
+  );
   await timer.timeAsync("cache.write", async () => {
-    if (cacheDir === null || composed.length === 0) {
+    if (cacheDir === null || summaries.length === 0) {
       return;
     }
     try {
       await cache.layer.write(
         cache.input,
-        composed,
+        summaries,
         log === null || ledger === null || overBudget ? void 0 : rubyAttribution({
-          composed,
+          summaries,
+          walkedFileOf: (locationFile) => walkedFiles.get(locationFile),
           discoveries,
           reached,
           reuse,
@@ -11818,7 +13305,10 @@ function rubyAttribution(args) {
       facts: args.facts.get(file) ?? { own: "", joined: "" }
     }
   }));
-  return { roots, owners: args.composed.map(() => []) };
+  return {
+    roots,
+    owners: (0, import_extractor19.ownersWhereWritten)(args.summaries, args.walkedFileOf)
+  };
 }
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["vendor", "node_modules", "tmp", ".git"]);
 function findRubyFiles(root) {
@@ -11892,8 +13382,8 @@ function displayNameOf(node) {
   if (node.type === "class" || node.type === "module") {
     return field(node, "name")?.text ?? node.text;
   }
-  const text2 = node.text.split("\n")[0].trim();
-  return text2.length > 40 ? `${text2.slice(0, 40)}...` : text2;
+  const text3 = node.text.split("\n")[0].trim();
+  return text3.length > 40 ? `${text3.slice(0, 40)}...` : text3;
 }
 function width(node) {
   return node.endIndex - node.startIndex;
@@ -11923,14 +13413,14 @@ var RubyWhySession = class {
    * The smallest expression on `line` of `file` whose text is exactly
    * `text`, or null.
    */
-  findExpression(file, line, text2) {
+  findExpression(file, line, text3) {
     const root = this.rootOf(file);
     if (root === null) {
       return null;
     }
     let found = null;
     const visit = (node) => {
-      if (node.startPosition.row + 1 === line && node.text === text2) {
+      if (node.startPosition.row + 1 === line && node.text === text3) {
         if (found === null || width(node) <= width(found)) {
           found = node;
         }
@@ -12011,7 +13501,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 +13525,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 +13576,7 @@ async function rubyStubEvidence(options) {
   bindEvaluator,
   bodyStatements,
   booleanLiteralValue,
+  children,
   collectFileConstants,
   createConstantFileCache,
   createFileCache,