@suss/adapter-ruby 0.34.0 → 0.35.0

package/dist/index.js

@@ -19,7 +19,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);
@@ -81,6 +103,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);
 }
@@ -156,7 +185,7 @@ function runStatements(body, blockConfigures = () => false) {
     }
     return !(node.type === "call" && blockConfigures(node));
   };
-  walkDescendants(body, null, {
+  walkDescendants(body, null, children, {
     at: (node) => {
       found.push(node);
     },
@@ -242,8 +271,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") {
@@ -443,6 +472,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 IdSet {
 };
 var NodeMap = class extends IdMap {
@@ -468,8 +542,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
@@ -477,19 +551,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 = path.join(candidate, relative);
     if (fs.existsSync(file)) {
       return file;
@@ -528,7 +606,7 @@ function isDirectory(directory) {
 }
 
 // src/defineMethod.ts
-import { nodeOfKey as nodeOfKey2 } from "@suss/resolution";
+import { nodeOfKey as nodeOfKey2, spanOfKey } from "@suss/resolution";
 import { hole as hole2, literalOf as literalOf3, piecesOf } from "@suss/values";
 
 // src/values/evaluator.ts
@@ -536,10 +614,12 @@ import { nodeOfKey, noteKeyRead, writtenValuesByKey } from "@suss/resolution";
 import { Evaluator, force, literalOf, text } from "@suss/values";
 
 // src/facts/resolve.ts
+import { isTestFile } from "@suss/behavioral-ir";
 import { constant, lit, rule, variable as v } from "@suss/datalog";
 import {
   allocationSitesOf,
   alsoSteps,
+  answersFromTestsLeftOut,
   askResolution,
   askResolutionUnder,
   askSources,
@@ -565,6 +645,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
@@ -612,7 +766,13 @@ function resolveEnvObjects(db, objects) {
 }
 function writtenValueOf(db, key) {
   resolveValues(db, [key]);
-  return sharedWrittenValueOf(db, key, (keys) => resolveValues(db, keys));
+  return sharedWrittenValueOf(
+    db,
+    key,
+    (keys) => resolveValues(db, keys),
+    void 0,
+    answersFromTestsLeftOut(key, isTestFile)
+  );
 }
 function writtenValueUnder(db, key, site) {
   const program = resolutionUnderProgram(RUBY_RULES);
@@ -630,12 +790,16 @@ function constructionSites(db, classKey) {
 
 // src/facts/values.ts
 import {
+  addEntryRows,
   addPackWords,
+  addTemplateRows,
   classMemberName,
   NAMED_STORE_NAME,
   RECEIVER_STORE_NAME,
+  SPREAD_ENTRY,
   startsAtName,
   UNPLACED_STORE_NAME,
+  VALUE_ENTRY,
   valueLeftByWrites
 } from "@suss/resolution";
 
@@ -652,7 +816,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 = {
@@ -667,14 +831,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) {
@@ -1168,6 +1332,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);
 }
@@ -1251,6 +1418,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;
@@ -1324,7 +1582,6 @@ var SELF_READS = {
 function classSpelling(name) {
   return name === CONSTRUCTOR ? name : classMemberName(name);
 }
-var INVOKE_METHOD = "call";
 function invokedValueOf(call) {
   if (call.type !== "call") {
     return null;
@@ -1370,6 +1627,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,
@@ -1379,12 +1637,24 @@ function emitArray(emitter, array) {
       valueKey(emitter, element, array)
     );
     position += 1;
+    entries.push(writtenEntry(emitter, element, array));
   }
+  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: VALUE_ENTRY } : { key: valueKey(emitter, unpacked, entry), form: 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;
     }
@@ -1393,6 +1663,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));
@@ -1406,32 +1677,66 @@ function emitHash(emitter, hash) {
       valueKey(emitter, value, pair)
     );
   }
+  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;
@@ -1440,33 +1745,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([
@@ -1480,22 +1768,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);
@@ -1536,27 +1825,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);
@@ -1597,6 +1886,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) {
+    addTemplateRows(rowsOf(emitter), nodeId(emitter.filePath, child), pieces);
   }
   for (const branch of BRANCHES_OF[type]?.(child) ?? []) {
     add(
@@ -1616,6 +1910,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) {
@@ -2038,11 +2355,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
   );
@@ -2502,9 +2818,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;
     }
@@ -2706,8 +3020,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;
@@ -3382,6 +3713,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;
@@ -3444,7 +3779,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);
       }
@@ -3507,7 +3842,7 @@ function contextOver(db, nodes) {
 }
 
 // src/values/literals.ts
-import { force as force2, literalOf as literalOf2 } from "@suss/values";
+import { force as force2, literalOf as literalOf2, sequence, text as text2 } from "@suss/values";
 function literalElementsIn(value) {
   if (value.kind !== "sequence") {
     return null;
@@ -3522,8 +3857,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(force2(item.value)));
+  }
+  if (value.kind === "record" && !value.open) {
+    return [...value.fields].map(([key, item]) => {
+      const parts = [text2(key), force2(item.value)];
+      return { whole: sequence(parts), parts };
+    });
+  }
+  return null;
+}
+function elementOfList(whole) {
+  return {
+    whole,
+    parts: whole.kind === "sequence" ? whole.items.map((item) => force2(item.value)) : [whole]
+  };
 }
 function namesOf(node, db) {
   const value = evaluatedValue(node, db);
@@ -3545,13 +3896,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)
       )
     );
   }
@@ -3572,11 +3926,11 @@ function foldReading(soFar, reading) {
     unreadable: soFar.unreadable
   };
 }
-function readOne(db, rootsByFile, nameKey2) {
+function readOne(db, rootsByFile, nameKey2, loops) {
   const node = nodeOfKey2(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 ? hole2(nameKey2) : evaluatedValue(node, db, bindings.size === 0 ? void 0 : bindings);
     const name = literalOf3(value);
     if (name !== null) {
@@ -3609,38 +3963,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 = nodeOfKey2(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) => literalOf3(element.whole),
+  part: (element, _, takes) => {
+    const part = takes.kind === "part" ? element.parts[takes.part] : void 0;
+    return part === void 0 ? null : literalOf3(part);
+  },
+  position: (_, position) => String(position)
+};
+function collectionNode(rootsByFile, loop) {
+  const written = nodeOfKey2(rootsByFile, loop.over);
+  if (written !== null) {
+    return written;
+  }
+  const call = nodeOfKey2(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 : 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 = spanOfKey(classKey);
+  const name = 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
@@ -3770,12 +4191,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;
@@ -3920,7 +4356,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" };
     }
@@ -3928,7 +4364,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);
@@ -3945,6 +4382,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;
@@ -3994,11 +4443,17 @@ import {
   graphqlResolverBinding,
   restBinding as restBinding2
 } from "@suss/behavioral-ir";
-import { absentReading as absentReading2, unreadableReading as unreadableReading2 } from "@suss/extractor";
+import { absentReading as absentReading3, unreadableReading as unreadableReading2 } from "@suss/extractor";
 
 // src/clientCalls.ts
-import { hasNameHole, namesNothing, restBinding } from "@suss/behavioral-ir";
-import { pathOf } from "@suss/values";
+import {
+  hasNameHole,
+  namesNothing,
+  restBinding,
+  statusMembersOf,
+  testsStatus
+} from "@suss/behavioral-ir";
+import { hostOf, pathOf } from "@suss/values";
 
 // src/paths/effects.ts
 import { enumerateOrDegrade, sharedGatingConditions } from "@suss/extractor";
@@ -4025,7 +4480,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) {
@@ -4037,7 +4492,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;
       }
@@ -4071,13 +4526,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) {
@@ -4108,7 +4602,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);
       }
@@ -4167,29 +4661,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")),
@@ -4207,6 +4694,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) {
@@ -4236,10 +4764,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",
@@ -4266,10 +4796,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),
@@ -4289,9 +4820,9 @@ var BLOCK_TYPES5 = /* @__PURE__ */ new Set([
 ]);
 function literalArgOf(node, facts) {
   const value = evaluatedValue(node, facts);
-  const text2 = literalOf4(value);
-  if (text2 !== null) {
-    return { kind: "string", value: text2 };
+  const text3 = literalOf4(value);
+  if (text3 !== null) {
+    return { kind: "string", value: text3 };
   }
   const constant2 = constantOf(value);
   if (typeof constant2 === "number") {
@@ -4357,7 +4888,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)) {
@@ -4367,6 +4898,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) {
@@ -4430,6 +4964,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 [];
@@ -4442,7 +4984,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;
@@ -4476,25 +5018,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
-import {
-  absentReading,
-  enumerateOrDegrade as enumerateOrDegrade2,
-  guardsHoldOn,
-  unreadableReading,
-  writtenReading
-} from "@suss/extractor";
-import { constantOf as constantOf3, literalOf as literalOf7 } from "@suss/values";
-
 // src/paths/predicates.ts
 var OPERATORS = {
   "==": "eq",
@@ -4513,11 +5048,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") {
@@ -4543,11 +5078,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") {
@@ -4643,6 +5178,321 @@ function calledMethod(node) {
   return field(node, "method")?.text ?? null;
 }
 
+// src/responseHandOff.ts
+import { helperPathsOnVariables, splitAtHandOffs } from "@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) => 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 : 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
+import {
+  absentReading as absentReading2,
+  enumerateOrDegrade as enumerateOrDegrade2,
+  guardsHoldOn,
+  unreadableReading,
+  writtenReading as writtenReading2
+} from "@suss/extractor";
+import { constantOf as constantOf3, literalOf as literalOf7 } from "@suss/values";
+
 // src/provenance.ts
 import { sourceRefsOf } from "@suss/extractor";
 import { constantOf as constantOf2, literalOf as literalOf6 } from "@suss/values";
@@ -4710,7 +5560,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;
 }
 
@@ -5355,10 +6205,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);
     }
@@ -5566,6 +6413,111 @@ function literalAt(key, facts) {
   return constant2 !== void 0 ? constant2 : literalOf6(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
+import { absentReading, writtenReading } from "@suss/extractor";
+import { shapeOfValue } from "@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 absentReading;
+  }
+  const argument = readCallArgs(field(call, "arguments")).keyword[declaration.bodyKeyword];
+  if (argument === void 0) {
+    return absentReading;
+  }
+  const body = serializedValue(
+    argument,
+    new Set(declaration.bodySerializers ?? [])
+  );
+  const value = evaluatedValue(body, facts);
+  return BODY_KINDS.has(value.kind) ? writtenReading(shapeOfValue(value), rangeOf(argument)) : absentReading;
+}
+
 // src/responseStatus.ts
 function statusArgumentOf(call, declaration) {
   const args = readCallArgs(field(call, "arguments"));
@@ -5578,7 +6530,11 @@ 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 = constantOf3(value);
   if (typeof constant2 === "number") {
@@ -5602,21 +6558,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;
     }
@@ -5628,19 +6605,24 @@ 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 ? absentReading : writtenReading(declaration.defaultStatusCode, rangeOf(call));
+    return declaration.defaultStatusCode === void 0 ? absentReading2 : writtenReading2(declaration.defaultStatusCode, rangeOf(call));
   }
-  const status = statusNumberOf(argument, names, facts);
+  const status = statusNumberOf(
+    argument,
+    names,
+    options.facts,
+    options.boundStatuses
+  );
   if (status === null) {
     return unreadableReading(
       "This response writes a status that does not settle on a number here, so this outcome claims none",
       rangeOf(argument)
     );
   }
-  return writtenReading(status, rangeOf(argument));
+  return writtenReading2(status, rangeOf(argument));
 }
 function effectsReaching(effects, conditions) {
   return effects.filter(
@@ -5669,6 +6651,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" ? writtenReading2(only, rangeOf(helper)) : 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);
@@ -5691,6 +6712,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,
@@ -5718,20 +6740,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 terminals = [
+    ...returns,
+    ...exitCalls,
+    ...raises2.map((raise) => raise.call)
+  ];
+  const lowered = lowerRubyBody(body, terminals, exitCalls);
   const enumerated = enumerateOrDegrade2(
     {
       statements: lowered.statements,
-      terminalsByStmt: lowered.terminalsByStmt
+      terminalsByStmt: lowered.terminalsByStmt,
+      ...keepsArms === void 0 ? {} : { keepsArms }
     },
-    [...returns, ...exitCalls]
+    terminals
   );
   const inputs = conditionInputs(
     method,
@@ -5759,8 +6787,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;
@@ -5785,13 +6813,22 @@ 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 = enumerateOrDegrade2(
@@ -5799,7 +6836,7 @@ function responseBranches(method, pattern, effects, extraEffects, options = {})
       statements: lowered.statements,
       terminalsByStmt: lowered.terminalsByStmt
     },
-    terminals
+    [...terminals, ...raises2]
   );
   const statusNames = pattern.statusCodeNames ?? {};
   const inputs = conditionInputs(
@@ -5810,30 +6847,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 ? absentReading : readingOfCall(terminal, declaration, statusNames, options.facts);
+    const responder = responderOf(terminal, responders);
+    const reading = responder === void 0 ? absentReading2 : 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: absentReading,
+      reading: absentReading2,
       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
@@ -5846,7 +6911,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
+          )
+        );
       }
     }
   }
@@ -5904,10 +6978,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);
     }
@@ -5916,10 +6987,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);
     }
@@ -5936,7 +7004,7 @@ function requestCalls(call, pattern, options) {
   const read = (site) => requestCall(
     call,
     called,
-    receiverPrefix(receiver, pattern, options, site),
+    receiverBase(receiver, pattern, options, site),
     pattern,
     options,
     site
@@ -5949,7 +7017,10 @@ function requestCalls(call, pattern, options) {
   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) {
@@ -5957,12 +7028,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) {
@@ -5972,8 +7043,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) {
@@ -5994,16 +7071,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 : 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(pathOf(value) ?? ""), host: hostOf(value) };
 }
 function trimmed(path7) {
   return path7 === "/" ? "" : path7.replace(/\/+$/, "");
@@ -6026,22 +7106,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 = pathOf(evaluatedValue(written, options.facts, void 0, site));
-  return path7 === void 0 || namesNothing(path7) ? null : path7;
+  const value = evaluatedValue(written, options.facts, void 0, site);
+  const path7 = pathOf(value);
+  return path7 === void 0 || namesNothing(path7) ? null : { path: path7, host: hostOf(value) };
 }
 function clientUnit(method, name, request, pattern, pack, options) {
   const range = rangeOf(method);
+  const accessors = responseAccessors(pattern);
+  const statusMembers = 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,
@@ -6057,21 +7147,30 @@ function clientUnit(method, name, request, pattern, pack, options) {
       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) => 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;
@@ -6082,7 +7181,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) {
@@ -6133,9 +7233,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;
   }
@@ -6316,7 +7414,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)
@@ -6368,7 +7466,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) {
@@ -6402,20 +7500,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);
@@ -6483,7 +7574,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) {
@@ -6528,7 +7619,7 @@ var DEFERRED_BODY_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method",
 function envReadEffects(root, facts) {
   const helpers = helperFactsOf(facts);
   const slots = [];
-  walkDescendants2(root, null, {
+  walkDescendants2(root, null, children, {
     at: (node) => {
       const read = envReadAt(node);
       if (read !== null) {
@@ -6608,7 +7699,7 @@ function namedParameters(db) {
   return named2;
 }
 function emitEnvFacts(db, file, root) {
-  walkDescendants2(root, null, {
+  walkDescendants2(root, null, children, {
     at: (node) => {
       if (isEnv(node) && handsOnward(node)) {
         db.add("environmentObject", [
@@ -6736,7 +7827,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 [];
@@ -6749,18 +7841,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;
     }
@@ -6769,26 +7872,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)) {
@@ -6796,37 +7951,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",
@@ -6861,25 +8034,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);
@@ -6890,13 +8131,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;
@@ -6939,7 +8183,7 @@ 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 = [];
-  walkDescendants3(root, null, {
+  walkDescendants3(root, null, children, {
     at: (node) => {
       const write = node.type === "call" ? streamWriteAt(node) : null;
       if (write !== null) {
@@ -7030,7 +8274,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" }
@@ -7040,7 +8284,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;
     }
@@ -7403,14 +8647,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);
       }
     }
   }
@@ -7429,7 +8673,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([
@@ -7802,8 +9046,8 @@ function moduleOfConstant(node, options) {
   const files = [...new Set(keys.map(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
@@ -8074,6 +9318,7 @@ function fieldReadContext(pattern, cache, fileBlocks, bodyRead, facts) {
     },
     lookup: {
       root: pattern.root,
+      autoloadRoots: pattern.autoloadRoots ?? [],
       pathConvention: pattern.pathConvention,
       acronyms: pattern.acronyms ?? [],
       ancestryRootClassNames: pattern.ancestryRootClassNames,
@@ -8229,6 +9474,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,
@@ -8243,11 +9489,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,
@@ -8267,15 +9514,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,
@@ -8283,38 +9556,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));
@@ -8331,7 +9637,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);
       }
     }
@@ -8356,16 +9662,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: {
@@ -8382,7 +9724,8 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
       transport: pack.protocol,
       method: route.method,
       path: route.path,
-      recognition: pack.name
+      recognition: pack.name,
+      optionalFormat: servesFormat(pattern, route)
     }),
     parameters: [],
     branches: withSlotSources(
@@ -8402,7 +9745,7 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
             location: range
           },
           statusCodeReading: {
-            reading: absentReading2,
+            reading: absentReading3,
             libraryDefault: pattern.defaultStatusCode
           },
           effects: body.effects ?? [],
@@ -8412,6 +9755,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: [],
@@ -9241,6 +10592,7 @@ import {
   placeArgTargets as placeArgTargets2,
   placeCalleeParameters as placeCalleeParameters2,
   placeCalls as placeCalls2,
+  placePossibleCalls as placePossibleCalls2,
   placeReceiverClasses,
   recordParameterGaps as recordParameterGaps2,
   summaryIdFromParts,
@@ -9252,11 +10604,13 @@ import {
   composeWrappers,
   createCacheLayer,
   createTimer,
+  extractionCacheDirFor,
   extractionConfigStamp,
   KeptParses,
   matchesTestFileName as matchesTestFileName3,
   moduleInitStructure,
   noopTimer,
+  ownersWhereWritten,
   runDigest,
   stampModuleImports,
   stampModules
@@ -9311,7 +10665,7 @@ var EXIT_METHODS = /* @__PURE__ */ new Map([
 var DEFERRED_BODY_TYPES3 = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
 function exitSites(root) {
   const found = [];
-  walkDescendants4(root, null, {
+  walkDescendants4(root, null, children, {
     at: (node) => {
       const site = node.type === "call" ? exitSiteAt(node) : null;
       if (site !== null) {
@@ -9428,7 +10782,7 @@ function eventsOf(args, called, callbacks, db) {
 import path3 from "path";
 import { SKIP_CHILDREN as SKIP_CHILDREN5, walkDescendants as walkDescendants5 } from "@suss/extractor";
 function emitRequireFacts(db, filePath, root, known) {
-  walkDescendants5(root, null, {
+  walkDescendants5(root, null, children, {
     at: (node) => {
       const target = requiredRelativePath(node);
       if (target === null) {
@@ -9467,8 +10821,10 @@ import {
   placeArgTargets,
   placeCalleeParameters,
   placeCalls,
+  placePossibleCalls,
   ReceiverClasses,
   recordParameterGaps,
+  StopList,
   TargetPlacements,
   unfollowedCallGap,
   worthRecording
@@ -9510,7 +10866,7 @@ function optionParserFlagReads(method, parameterNames3) {
   return reads;
 }
 function walkBody2(body, at) {
-  walkDescendants6(body, null, {
+  walkDescendants6(body, null, children, {
     at,
     into: (node) => DEFERRED_BODY_TYPES4.has(node.type) ? SKIP_CHILDREN6 : null
   });
@@ -9526,7 +10882,7 @@ function flagsDeclaredIn(construction) {
     return [];
   }
   const flags = [];
-  walkDescendants6(block, null, {
+  walkDescendants6(block, null, children, {
     at: (node) => {
       if (node.type !== "call" || field(node, "method")?.text !== "on") {
         return;
@@ -9541,8 +10897,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;
   }
@@ -9584,10 +10940,9 @@ import {
   calleeOutcomeOf,
   calleeOutcomes,
   classMemberName as classMemberName3,
-  couldBeSettled
+  couldBeSettled,
+  dispatchOutcomes
 } from "@suss/resolution";
-var DYNAMIC_SEND_NAMES = /* @__PURE__ */ new Set(["send", "public_send", "__send__"]);
-var INVOKES_RECEIVER = "call";
 var STOP_FOR = {
   severalSources: "multipleSources",
   outsideRun: "outsideRun",
@@ -9604,6 +10959,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 };
 }
@@ -9665,6 +11025,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 = 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) ?? calleeOutcomeOf(ctx.facts, key, RUBY_PROGRAM);
 }
@@ -9678,14 +11089,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");
@@ -9731,7 +11144,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");
 }
@@ -9775,7 +11188,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");
@@ -9792,22 +11205,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;
@@ -9850,12 +11268,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,
@@ -9902,6 +11324,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();
@@ -9960,6 +11383,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);
       }
@@ -10023,6 +11447,7 @@ async function reachedFunctions(seeds, options) {
       }
       placeCalls(summary2, targetsByKey.get(key));
       placeArgTargets(summary2, argTargetsByKey.get(key));
+      placePossibleCalls(summary2, possibleTargetsByKey.get(key));
       placeCalleeParameters(summary2, parameterCallsByKey.get(key));
       return summary2;
     };
@@ -10045,6 +11470,7 @@ async function reachedFunctions(seeds, options) {
     targetsByKey,
     stopsByKey,
     argTargetsByKey,
+    possibleTargetsByKey,
     parameterCallsByKey,
     propertyReadsByKey,
     receiverClassesByKey,
@@ -10074,36 +11500,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) => ({
@@ -10119,6 +11579,10 @@ function storedScan(scan) {
       callee,
       [...byPosition]
     ]),
+    possibleTargets: [...scan.possibleTargets].map(([callee, places]) => [
+      callee,
+      [...places]
+    ]),
     parameterCalls: [...scan.parameterCalls],
     passedPositions: [...scan.passedPositions],
     propertyReads: [...scan.propertyReads],
@@ -10136,6 +11600,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),
@@ -10164,6 +11629,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(),
@@ -10185,7 +11651,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)
@@ -10199,7 +11665,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)
@@ -10251,7 +11717,7 @@ function scanBody(source, ctx, options, read) {
   );
   const ownParameters = positionalParameters(source.node).map((p) => p.name);
   const followed2 = [];
-  const stops = [];
+  const stops = new StopList();
   const placements = new TargetPlacements();
   const receiverClasses = new ReceiverClasses();
   const parameterCalls = [];
@@ -10266,6 +11732,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;
@@ -10303,11 +11775,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,
@@ -10335,11 +11831,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 && worthRecording(outcome.reason)) {
-        seen.add(stopKey);
-        stops.push({ callee, reason: outcome.reason });
+      if (!claimed && 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;
@@ -10354,17 +11852,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),
@@ -10396,9 +11891,9 @@ 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;
@@ -10836,7 +12331,7 @@ import { literalOf as literalOf10 } from "@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) {
@@ -10844,7 +12339,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)) {
@@ -11338,7 +12833,7 @@ function replaysCleanly(units, discovered) {
 async function extractRubyProject(options) {
   const timer = options.onTiming !== void 0 ? createTimer() : noopTimer();
   const cacheDir = adapterStamp.declineWhenRunFromSource(
-    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? path4.join(options.projectRoot, ".suss", "cache") : null)
+    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? extractionCacheDirFor(options.projectRoot) : null)
   );
   const layer = createCacheLayer(cacheDir);
   const packsDigest = `${adapterStamp.packsDigest(
@@ -11359,10 +12854,13 @@ async function extractRubyProject(options) {
     "cache.lookup",
     () => layer.lookup(input)
   );
+  const composed = (stored) => composeWrappers(stored, {
+    gapHandling: options.gapHandling ?? "permissive"
+  });
   if (lookup.kind === "hit") {
     options.onCacheDiagnostic?.(lookup.diagnostic);
     options.onTiming?.(timer.report());
-    return { summaries: lookup.summaries, facts: new Database2() };
+    return { summaries: composed(lookup.summaries), facts: new Database2() };
   }
   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) {
@@ -11372,7 +12870,7 @@ async function extractRubyProject(options) {
     }
     options.onCacheDiagnostic?.({ kind: "hit" });
     options.onTiming?.(timer.report());
-    return { summaries: plan.allSummaries(), facts: new Database2() };
+    return { summaries: composed(plan.allSummaries()), facts: new Database2() };
   }
   const cache = { timer, cacheDir, layer, input };
   const records = plan === null ? null : recordsToReplay(plan.roots, plan.changed, plan.removed);
@@ -11733,6 +13231,7 @@ async function runRuby(options, cache, previous) {
       }
       placeCalls2(summary, reached.targetsByKey.get(key));
       placeArgTargets2(summary, reached.argTargetsByKey.get(key));
+      placePossibleCalls2(summary, reached.possibleTargetsByKey.get(key));
       placeCalleeParameters2(summary, reached.parameterCallsByKey.get(key));
       placeReceiverClasses(summary, reached.receiverClassesByKey.get(key));
     }
@@ -11779,16 +13278,20 @@ async function runRuby(options, cache, previous) {
     );
     return 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,
@@ -11863,7 +13366,10 @@ function rubyAttribution(args) {
       facts: args.facts.get(file) ?? { own: "", joined: "" }
     }
   }));
-  return { roots, owners: args.composed.map(() => []) };
+  return {
+    roots,
+    owners: ownersWhereWritten(args.summaries, args.walkedFileOf)
+  };
 }
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["vendor", "node_modules", "tmp", ".git"]);
 function findRubyFiles(root) {
@@ -11937,8 +13443,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;
@@ -11968,14 +13474,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;
         }
@@ -12080,7 +13586,7 @@ function requireTarget(node) {
 }
 function requireSitesIn(root, file) {
   const found = [];
-  walkDescendants7(root, null, {
+  walkDescendants7(root, null, children, {
     at: (node) => {
       const target = requireTarget(node);
       if (target !== null) {
@@ -12130,6 +13636,7 @@ export {
   bindEvaluator,
   bodyStatements,
   booleanLiteralValue,
+  children,
   collectFileConstants,
   createConstantFileCache,
   createFileCache,