@suss/adapter-ruby 0.34.0 → 0.34.1

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);
     },
@@ -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 {
@@ -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;
@@ -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,71 @@ var CONVERTING_FUNCTIONS = /* @__PURE__ */ new Set([
   "String",
   "Float"
 ]);
+var OBJECT_METHODS = /* @__PURE__ */ new Set([
+  "Array",
+  "Float",
+  "Hash",
+  "Integer",
+  "String",
+  "abort",
+  "binding",
+  "block_given?",
+  "caller",
+  "catch",
+  "class",
+  "clone",
+  "define_singleton_method",
+  "dup",
+  "eql?",
+  "equal?",
+  "eval",
+  "exit",
+  "extend",
+  "fail",
+  "format",
+  "freeze",
+  "frozen?",
+  "hash",
+  "inspect",
+  "instance_of?",
+  "instance_variable_defined?",
+  "instance_variable_get",
+  "instance_variable_set",
+  "instance_variables",
+  "is_a?",
+  "itself",
+  "kind_of?",
+  "lambda",
+  "loop",
+  "method",
+  "methods",
+  "nil?",
+  "object_id",
+  "p",
+  "pp",
+  "print",
+  "printf",
+  "proc",
+  "public_send",
+  "puts",
+  "raise",
+  "rand",
+  "require",
+  "require_relative",
+  "respond_to?",
+  "send",
+  "singleton_class",
+  "sleep",
+  "sprintf",
+  "srand",
+  "system",
+  "tap",
+  "then",
+  "throw",
+  "to_s",
+  "warn",
+  "yield_self"
+]);
 var CONSTRUCTOR = "new";
 
 // src/facts/resolve.ts
@@ -612,7 +757,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);
@@ -652,7 +803,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 +818,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) {
@@ -1493,9 +1644,7 @@ function emitKeyedElement(emitter, node, parent) {
   if (object === null || isWriteTarget(node, parent)) {
     return;
   }
-  const index = node.namedChildren.find(
-    (child) => child !== null && child.id !== object.id
-  );
+  const index = children(node).find((child) => child.id !== object.id);
   if (index !== void 0) {
     emitKeyedRead(emitter, node, object, index, node);
     emitWrittenKeyRead(emitter, node, object, index);
@@ -1536,17 +1685,17 @@ function fallbackBranchesOf(node, type, enclosing) {
   }
   return [left, right].filter((side) => !raises(side, enclosing));
 }
-var RAISING_METHODS = /* @__PURE__ */ new Set(["raise", "fail"]);
+var RAISING_METHODS2 = /* @__PURE__ */ new Set(["raise", "fail"]);
 function raises(written, enclosing) {
   const node = readThrough(written);
   if (node.type === "identifier") {
-    return RAISING_METHODS.has(node.text) && isBareCall(node, enclosing);
+    return RAISING_METHODS2.has(node.text) && isBareCall(node, enclosing);
   }
   if (node.type !== "call") {
     return false;
   }
   const receiver = field(node, "receiver");
-  return RAISING_METHODS.has(field(node, "method")?.text ?? "") && (receiver === null || receiver.text === "Kernel");
+  return RAISING_METHODS2.has(field(node, "method")?.text ?? "") && (receiver === null || receiver.text === "Kernel");
 }
 function emitExpressionFacts(emitter, node) {
   emitDynamicDefinition(emitter, node, node.type, []);
@@ -2502,9 +2651,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 +2853,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 +3546,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 +3612,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);
       }
@@ -3770,12 +3938,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 +4103,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 +4111,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 +4129,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 +4190,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 +4227,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 +4239,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 +4273,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 +4349,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 +4408,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 +4441,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 +4511,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 +4543,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),
@@ -4430,6 +4708,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 +4728,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 +4762,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 +4792,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 +4822,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 +4922,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 +5304,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 +5949,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 +6157,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 +6274,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 +6302,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 +6349,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 +6395,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 +6456,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 +6484,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 +6531,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 +6557,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 +6580,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 +6591,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 +6655,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 +6722,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 +6731,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 +6748,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 +6761,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 +6772,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 +6787,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 +6815,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 +6850,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 +6891,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 +6925,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 +6977,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 +7158,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 +7210,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 +7244,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 +7318,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 +7363,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 +7443,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,6 +7571,7 @@ function envSiteAt(node) {
 }
 
 // src/filters.ts
+var RESCUES_NOTHING = { refs: [], someUnread: false };
 function controllerFilters(pattern, ancestry, read = {}) {
   const forms = pattern.filters ?? [];
   if (forms.length === 0) {
@@ -6749,18 +7585,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;
     }
@@ -6771,62 +7618,105 @@ function controllerFilters(pattern, ancestry, read = {}) {
   }
   const resolved = [];
   for (const declaration of declared) {
-    const found = methodInAncestry(ancestry, declaration.methodName, read);
-    if (found.type !== "found") {
+    const written = writtenAt(
+      declaration,
+      filterMethod(ancestry, declaration.methodName, read)
+    );
+    if (written === null) {
       continue;
     }
     resolved.push({
       filter: declaration.filter,
-      methodName: declaration.methodName,
-      method: found.method,
-      file: found.block.file,
-      enclosingQualifiedName: found.block.info.qualifiedName,
+      ...written,
       only: declaration.only,
-      except: declaration.except
+      except: declaration.except,
+      rescues: declaration.rescues
     });
   }
   return [
     ...resolved.filter((one) => one.filter.onThrow !== true),
-    ...resolved.filter((one) => one.filter.onThrow === true)
+    ...resolved.filter((one) => one.filter.onThrow === true).reverse()
   ];
 }
+function writtenAt(declaration, found) {
+  if (found.type === "found") {
+    return {
+      methodName: declaration.methodName,
+      nameKind: "binding",
+      method: found.method,
+      file: found.block.file,
+      enclosingQualifiedName: found.block.info.qualifiedName,
+      nesting: found.block.info.bodyNesting
+    };
+  }
+  const inline = declaration.inline;
+  if (inline === void 0) {
+    return null;
+  }
+  return {
+    methodName: inline.label,
+    nameKind: "label",
+    method: inline.block,
+    file: inline.declaredIn.file,
+    enclosingQualifiedName: inline.declaredIn.info.qualifiedName,
+    nesting: inline.declaredIn.info.bodyNesting
+  };
+}
+function filterMethod(ancestry, name, read) {
+  const found = methodInAncestry(ancestry, name, read);
+  if (found.type === "unsettled" && found.cause === "unreadAncestor") {
+    return methodPastUnreadAncestors(ancestry, name, read);
+  }
+  return found;
+}
 function filterCoversAction(filter, actionName) {
   if (filter.except.has(actionName)) {
     return false;
   }
   return filter.only === null || filter.only.has(actionName);
 }
-function filterReference(filter, displayPath) {
+function filterReference(filter, displayPath, caught) {
   return {
     file: displayPath,
     name: filter.methodName,
-    ...filter.filter.onThrow === true ? { onThrow: true } : {}
+    ...filter.filter.onThrow === true ? { onThrow: true } : {},
+    ...caught === void 0 ? {} : {
+      catches: caught.classes.map((one) => one.name),
+      ...caught.classes.some((one) => one.inheritableByUnread) ? { mayCatchUnreadClasses: true } : {},
+      ...caught.someUnread ? { mayCatchAny: true } : {}
+    }
   };
 }
-function filterUnit(filter, pattern, displayPath, body, facts) {
+function filterUnit(filter, pattern, displayPath, body, reading = {}) {
   const range = rangeOf(filter.method);
+  const { respondingHelper, raises: raises2 } = reading;
   const branches = responseBranches(
     filter.method,
     pattern,
     body.effects ?? [],
     body.extraEffects,
-    { fallthrough: "handOn", facts }
+    {
+      fallthrough: "handOn",
+      facts: reading.facts,
+      ...respondingHelper === void 0 ? {} : { respondingHelper },
+      ...raises2 === void 0 ? {} : { raises: raises2 }
+    }
   );
   return {
     identity: {
       name: filter.methodName,
-      nameKind: "binding",
+      nameKind: filter.nameKind,
       kind: "middleware",
       file: displayPath,
       range,
       span: spanOf(filter.method),
-      exportName: filter.methodName,
+      exportName: filter.nameKind === "binding" ? filter.methodName : null,
       exportPath: [filter.enclosingQualifiedName, filter.methodName]
     },
     boundaryBinding: null,
     parameters: [],
     branches: withSlotSources(
-      branches ?? [handsOn(range, body)],
+      [...branches ?? [handsOn(range, body)], ...reading.raised ?? []],
       body.provenance
     ),
     bodyContent: body.bodyContent ?? "absent",
@@ -6861,25 +7751,92 @@ function calledName(statement) {
   }
   return field(statement, "method")?.text ?? null;
 }
-function declarationsOf(statement, filter, facts) {
+function declarationsOf(statement, filter, declaredIn, facts, inlineOrdinal) {
   const args = readCallArgs(field(statement, "arguments"));
   const keywords = filter.actionKeywords;
   const only = keywords === void 0 ? null : actionsUnder(args.keyword[keywords.include], facts);
   const except = keywords === void 0 ? null : actionsUnder(args.keyword[keywords.exclude], facts);
-  return methodNamesOf(args, filter, facts).map((methodName) => ({
+  const rescues2 = filter.onThrow === true ? rescuedClasses(args, declaredIn.info.bodyNesting, facts) : RESCUES_NOTHING;
+  const inline = inlineHandler(
+    statement,
+    args,
+    filter,
+    declaredIn,
+    inlineOrdinal
+  );
+  return methodNamesOf(args, filter, facts, inline).map((methodName) => ({
     filter,
     methodName,
     only,
-    except: except ?? /* @__PURE__ */ new Set()
+    except: except ?? /* @__PURE__ */ new Set(),
+    rescues: rescues2,
+    ...inline === void 0 ? {} : { inline }
   }));
 }
-function methodNamesOf(args, filter, facts) {
+function inlineHandler(statement, args, filter, declaredIn, ordinal) {
+  const block = blockInPlaceOfMethod(statement, args, filter);
+  if (block === null || blockStatements2(block).length === 0) {
+    return void 0;
+  }
+  return { block, label: `${filter.name}#${ordinal}`, declaredIn };
+}
+function rescuedClasses(args, nesting, facts) {
+  const refs = [];
+  let someUnread = args.positional.length === 0;
+  for (const arg of args.positional) {
+    const candidates = constantRefCandidates(arg, nesting);
+    const named2 = candidates.length === 0 ? stringValueOf(arg, facts) : null;
+    if (candidates.length === 0 && named2 === null) {
+      someUnread = true;
+      continue;
+    }
+    refs.push({
+      text: arg.text,
+      candidates: named2 === null ? candidates : [named2]
+    });
+  }
+  return { refs, someUnread };
+}
+function methodNamesOf(args, filter, facts, inline) {
+  const named2 = filter.methodFrom === "withKeyword" ? withKeywordName(args, facts) : symbolArgumentNames(args, facts);
+  if (named2.length > 0 || inline === void 0) {
+    return named2;
+  }
+  return [blockHandlerName(inline.block) ?? inline.label];
+}
+function withKeywordName(args, facts) {
+  const named2 = args.keyword.with;
+  const value = named2 === void 0 ? null : stringValueOf(named2, facts);
+  return value === null ? [] : [value];
+}
+function blockInPlaceOfMethod(statement, args, filter) {
   if (filter.methodFrom === "withKeyword") {
-    const named2 = args.keyword.with;
-    const value = named2 === void 0 ? null : stringValueOf(named2, facts);
-    return value === null ? [] : [value];
+    return args.keyword.with === void 0 ? field(statement, "block") : null;
+  }
+  const lambda = args.positional.find((arg) => arg.type === "lambda");
+  if (lambda !== void 0) {
+    return field(lambda, "body");
   }
-  return symbolArgumentNames(args, facts);
+  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 calledName(only);
 }
 function symbolArgumentNames(args, facts) {
   return args.positional.map((arg) => stringValueOf(arg, facts)).filter((name) => name !== null);
@@ -6890,13 +7847,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 +7899,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 +7990,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 +8000,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 +8363,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 +8389,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([
@@ -8074,6 +9034,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 +9190,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,
@@ -8267,15 +9229,41 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
     options.facts,
     options.storage
   );
+  const respondingHelper = respondingHelpersOf(ancestry, pattern, options);
+  const exceptions = new ExceptionReader(
+    lookup,
+    pattern.libraryExceptions ?? {}
+  );
+  const caught = await handlerClasses(filters, exceptions);
+  const handlersAround = (actionName) => filters.filter((filter) => filterCoversAction(filter, actionName)).flatMap((filter) => {
+    const classes = caught.get(filter);
+    return classes === void 0 ? [] : [classes];
+  });
   for (const filter of filters) {
     const displayPath = options.displayPathOf?.(filter.file) ?? filter.file;
-    const raw = filterUnit(
-      filter,
-      pattern,
-      displayPath,
-      bodyOfMethod(filter.method, filter.file, options),
-      options.facts
-    );
+    const body = bodyOfMethod(filter.method, filter.file, options);
+    const handler = filter.filter.onThrow === true;
+    const raw = filterUnit(filter, pattern, displayPath, body, {
+      facts: options.facts,
+      respondingHelper,
+      ...handler ? {} : {
+        raises: {
+          classes: await raisedClasses(
+            filter.method,
+            filter.nesting,
+            exceptions
+          ),
+          handlers: "eachRoute"
+        },
+        raised: raisedStatusBranches(
+          pattern,
+          options.storage?.patterns ?? [],
+          body.extraEffects,
+          "eachRoute",
+          rangeOf(filter.method)
+        )
+      }
+    });
     units.push(raw);
     options.onReachSeed?.(raw, {
       file: filter.file,
@@ -8283,38 +9271,71 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
       enclosingQualifiedName: filter.enclosingQualifiedName
     });
   }
-  const emitAction = (actionName, method, block) => {
+  const emitAction = async (actionName, method, block, routes) => {
     const around = filters.filter((filter) => filterCoversAction(filter, actionName)).map(
       (filter) => filterReference(
         filter,
-        options.displayPathOf?.(filter.file) ?? filter.file
+        options.displayPathOf?.(filter.file) ?? filter.file,
+        caught.get(filter)
       )
     );
-    const raw = buildControllerActionUnit(
-      pack,
-      pattern,
-      info.qualifiedName,
-      actionName,
-      method,
-      {
-        display: block.file === (options.absoluteFile ?? options.filePath) ? options.filePath : options.displayPathOf?.(block.file) ?? block.file,
-        absolute: block.file
-      },
-      options,
-      around
-    );
-    units.push(raw);
-    options.onReachSeed?.(raw, {
-      file: block.file,
-      node: method,
-      enclosingQualifiedName: block.info.qualifiedName
-    });
+    const raises2 = {
+      classes: await raisedClasses(method, block.info.bodyNesting, exceptions),
+      handlers: handlersAround(actionName)
+    };
+    for (const route of routes.length === 0 ? [null] : routes) {
+      const raw = buildControllerActionUnit(
+        pack,
+        pattern,
+        info.qualifiedName,
+        actionName,
+        route,
+        method,
+        {
+          display: block.file === (options.absoluteFile ?? options.filePath) ? options.filePath : options.displayPathOf?.(block.file) ?? block.file,
+          absolute: block.file
+        },
+        options,
+        around,
+        respondingHelper,
+        raises2
+      );
+      units.push(raw);
+      options.onReachSeed?.(raw, {
+        file: block.file,
+        node: method,
+        enclosingQualifiedName: block.info.qualifiedName
+      });
+    }
   };
   for (const [actionName, method, block] of actions) {
-    emitAction(actionName, method, block);
+    const routes = pattern.routesFor(info.qualifiedName, actionName);
+    await emitAction(actionName, method, block, routes);
   }
   return units;
 }
+async function handlerClasses(filters, exceptions) {
+  const caught = /* @__PURE__ */ new Map();
+  for (const filter of filters) {
+    if (filter.filter.onThrow !== true) {
+      continue;
+    }
+    const classes = [];
+    for (const ref of filter.rescues.refs) {
+      classes.push(await exceptions.read(ref));
+    }
+    caught.set(filter, { classes, someUnread: filter.rescues.someUnread });
+  }
+  return caught;
+}
+async function raisedClasses(method, nesting, exceptions) {
+  const classes = new NodeMap();
+  for (const call of escapingRaises(method)) {
+    const ref = raisedClassRef(call, nesting);
+    classes.set(call, ref === null ? null : await exceptions.read(ref));
+  }
+  return classes;
+}
 function controllerActions(pattern, info, ownBlocks, ancestry, options) {
   const actions = publicInstanceMethods(ownBlocks, options.bodyBlocks);
   const seen = new Set(actions.map(([actionName]) => actionName));
@@ -8331,7 +9352,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 +9377,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 +9439,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 +9460,7 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
             location: range
           },
           statusCodeReading: {
-            reading: absentReading2,
+            reading: absentReading3,
             libraryDefault: pattern.defaultStatusCode
           },
           effects: body.effects ?? [],
@@ -8412,6 +9470,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: [],
@@ -9311,7 +10377,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 +10494,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) {
@@ -9469,6 +10535,7 @@ import {
   placeCalls,
   ReceiverClasses,
   recordParameterGaps,
+  StopList,
   TargetPlacements,
   unfollowedCallGap,
   worthRecording
@@ -9510,7 +10577,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 +10593,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;
@@ -9604,6 +10671,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 };
 }
@@ -9792,22 +10864,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 +10927,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,
@@ -10251,7 +11332,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 = [];
@@ -10335,11 +11416,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;
@@ -10362,7 +11445,7 @@ function scanBody(source, ctx, options, read) {
   }
   return {
     followed: followed2,
-    stops,
+    stops: stops.stops,
     targets: placements.targets,
     argTargets: placements.argTargets,
     parameterCalls,
@@ -10836,7 +11919,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 +11927,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)) {
@@ -12080,7 +13163,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 +13213,7 @@ export {
   bindEvaluator,
   bodyStatements,
   booleanLiteralValue,
+  children,
   collectFileConstants,
   createConstantFileCache,
   createFileCache,