@suss/adapter-ruby 0.35.0 → 0.36.0

package/dist/index.js

@@ -627,6 +627,8 @@ import {
   readUses,
   resolutionProgram,
   resolutionUnderProgram,
+  SELF_AS_CLASS,
+  SELF_AS_INSTANCE,
   writtenValueOf as sharedWrittenValueOf,
   writtenValueUnder as sharedWrittenValueUnder,
   USES_QUESTION
@@ -720,6 +722,8 @@ var INVOKE_METHOD = "call";
 var BLOCK_WRAPPERS = /* @__PURE__ */ new Set(["proc", "lambda"]);
 var PROC_CLASS = "Proc";
 var CONSTRUCTOR = "new";
+var INITIALIZE_METHOD = "initialize";
+var CLASS_OF_INSTANCE = "class";
 
 // src/facts/resolve.ts
 import { resolvedFunctions, settledFunction } from "@suss/resolution";
@@ -747,6 +751,26 @@ var RUBY_RULES = alsoSteps([
       lit("readsProperty", v("c"), v("o"), constant(CONSTRUCTOR)),
       lit("call", v("r"), v("c"))
     ]
+  ),
+  // `new` in a class method makes one of the class the method runs on,
+  // and `self.class` in an instance method is that class.
+  rule(
+    "selfBehind",
+    [v("r"), v("s"), SELF_AS_INSTANCE],
+    [
+      lit("call", v("r"), v("c")),
+      lit("readsProperty", v("c"), v("o"), constant(CONSTRUCTOR)),
+      lit("selfBehind", v("o"), v("s"), SELF_AS_CLASS)
+    ]
+  ),
+  rule(
+    "selfBehind",
+    [v("r"), v("s"), SELF_AS_CLASS],
+    [
+      lit("call", v("r"), v("c")),
+      lit("readsProperty", v("c"), v("o"), constant(CLASS_OF_INSTANCE)),
+      lit("selfBehind", v("o"), v("s"), SELF_AS_INSTANCE)
+    ]
   )
 ]);
 var RUBY_PROGRAM = resolutionProgram(RUBY_RULES);
@@ -796,6 +820,8 @@ import {
   classMemberName,
   NAMED_STORE_NAME,
   RECEIVER_STORE_NAME,
+  SELF_AS_CLASS_NAME,
+  SELF_AS_INSTANCE_NAME,
   SPREAD_ENTRY,
   startsAtName,
   UNPLACED_STORE_NAME,
@@ -2488,9 +2514,8 @@ function emitCandidates(emitter, key, group) {
     add(emitter, "writesAllStated", key);
   }
 }
-var INITIALIZE_METHOD = "initialize";
-function receiverKeyOf(emitter, method, classKey) {
-  return definesClassMethod(method, emitter.bodyBlocks) ? classKey : `${nodeId(emitter.filePath, method)}#self`;
+function receiverKeyOf(file, method) {
+  return `${nodeId(file, method)}#self`;
 }
 var CONSTANT_REF_TYPES = /* @__PURE__ */ new Set(["constant", "scope_resolution"]);
 function mixedInConstants(body, callName, statements) {
@@ -2510,11 +2535,20 @@ function emitMixinFacts(emitter, classKey, body) {
 }
 function emitMethodOfClass(within, classKey, method, offeredOnClass) {
   const stored = /* @__PURE__ */ new Map();
-  const receiverKey = receiverKeyOf(within, method, classKey);
-  const onInstance = receiverKey !== classKey;
+  const receiverKey = receiverKeyOf(within.filePath, method);
+  const onInstance = !definesClassMethod(method, within.bodyBlocks);
   if (onInstance) {
     add(within, "instanceOf", receiverKey, classKey);
+  } else {
+    add(within, "binds", receiverKey, classKey);
   }
+  add(
+    within,
+    "selfReceiver",
+    nodeId(within.filePath, method),
+    receiverKey,
+    onInstance ? SELF_AS_INSTANCE_NAME : SELF_AS_CLASS_NAME
+  );
   const funcKey = emitMethodFacts(
     {
       ...within,
@@ -4216,7 +4250,10 @@ async function definedInFileOf(fileConstant, qualifiedName, lookup) {
   if (filePath === null) {
     return null;
   }
-  const fileRoot = await lookup.parsedFile(filePath);
+  return blocksDefinedIn(filePath, qualifiedName, lookup.parsedFile);
+}
+async function blocksDefinedIn(filePath, qualifiedName, parsedFile) {
+  const fileRoot = await parsedFile(filePath);
   if (fileRoot === null) {
     return null;
   }
@@ -4296,9 +4333,16 @@ function unreadConstant(candidates) {
   const bare = candidates.at(-1);
   return bare === void 0 ? [] : [{ type: "unfollowed", name: bare }];
 }
-function definitionOf(qualifiedName, lookup) {
+async function definitionOf(qualifiedName, lookup) {
   const local = lookup.localDefinition?.(qualifiedName);
-  return local !== void 0 && local !== null ? Promise.resolve(local) : reachDefinition(qualifiedName, lookup);
+  if (local !== void 0 && local !== null) {
+    return local;
+  }
+  const inRun = await lookup.definedInRun?.(qualifiedName);
+  if (inRun !== void 0 && inRun !== null) {
+    return inRun;
+  }
+  return reachDefinition(qualifiedName, lookup);
 }
 async function mixinChain(self, callName, lookup, active, present) {
   let chain = [];
@@ -4443,7 +4487,69 @@ import {
   graphqlResolverBinding,
   restBinding as restBinding2
 } from "@suss/behavioral-ir";
-import { absentReading as absentReading3, unreadableReading as unreadableReading2 } from "@suss/extractor";
+import { absentReading as absentReading3, unreadableReading as unreadableReading3 } from "@suss/extractor";
+
+// src/baseClass.ts
+import { answersFor, askResolution as askResolution2, spanOfKey as spanOfKey2 } from "@suss/resolution";
+function classBehind(facts, file, constant2) {
+  const key = constant2.type === "constant" ? `${file}#${constant2.text}` : nodeId(file, constant2);
+  const bound = new Set(
+    facts.lookup("binds", 0, key).map((row) => String(row[1]))
+  );
+  return bound.size === 1 ? [...bound][0] : void 0;
+}
+function classSettledOn(facts, key) {
+  askResolution2(facts, [key], "wanted", RUBY_PROGRAM);
+  const objects = answersFor(facts, "wantedObjectOf", key);
+  return objects.length === 1 ? objects[0] : void 0;
+}
+function declaredName(facts, classKey) {
+  const names = new Set(
+    facts.lookup("rbConstantName", 0, classKey).map((row) => String(row[1]))
+  );
+  return names.size === 1 ? [...names][0] : void 0;
+}
+function classesDeclaredInRun(facts, parsedFile) {
+  const known = /* @__PURE__ */ new Map();
+  const read = async (qualifiedName) => {
+    const files = /* @__PURE__ */ new Set();
+    for (const row of facts.lookup("rbConstantName", 1, qualifiedName)) {
+      const span = spanOfKey2(String(row[0]));
+      if (span !== null) {
+        files.add(span.file);
+      }
+    }
+    const blocks = [];
+    for (const file of files) {
+      blocks.push(
+        ...await blocksDefinedIn(file, qualifiedName, parsedFile) ?? []
+      );
+    }
+    return blocks.length === 0 ? null : blocks;
+  };
+  return (qualifiedName) => {
+    let found = known.get(qualifiedName);
+    if (found === void 0) {
+      found = read(qualifiedName);
+      known.set(qualifiedName, found);
+    }
+    return found;
+  };
+}
+function reachesBase(facts, classKey, bases) {
+  askResolution2(facts, [classKey], "wantedAncestry", RUBY_PROGRAM);
+  return facts.lookup("wantedBaseName", 0, classKey).some((row) => bases.includes(String(row[1])));
+}
+function enclosingClassKey(node, file) {
+  let current = node.parent;
+  while (current !== null) {
+    if (NESTING_TYPES.has(current.type)) {
+      return nodeId(file, current);
+    }
+    current = current.parent;
+  }
+  return null;
+}
 
 // src/clientCalls.ts
 import {
@@ -4456,7 +4562,7 @@ import {
 import { hostOf, pathOf } from "@suss/values";
 
 // src/paths/effects.ts
-import { enumerateOrDegrade, sharedGatingConditions } from "@suss/extractor";
+import { sharedGatingConditions, statementSites } from "@suss/extractor";
 import { constantOf, literalOf as literalOf4 } from "@suss/values";
 
 // src/paths/lowering.ts
@@ -4668,6 +4774,7 @@ var Lowerer = class {
     );
     return {
       kind: "try",
+      lines: rangeOf(node),
       tryBody: tryBody.map((statement) => this.lower(statement)),
       catchBody: rescues2.length > 0 ? rescues2.flatMap((clause) => this.lowerBlock(field(clause, "body"))) : null,
       finallyBody: ensureClause === null ? null : this.lowerBlock(ensureClause),
@@ -4759,7 +4866,8 @@ var Lowerer = class {
           kind: "loop",
           condition: handleOf(header),
           body: this.lowerBlock(field(node, "body")),
-          exitKind: exitKindOf(node)
+          exitKind: exitKindOf(node),
+          lines: rangeOf(node)
         },
         [header]
       );
@@ -4775,7 +4883,8 @@ var Lowerer = class {
           kind: "loop",
           condition: callHeaderOf(node, attachedBlock),
           body: this.lowerBlock(field(attachedBlock, "body") ?? attachedBlock),
-          exitKind: exitKindOf(node)
+          exitKind: exitKindOf(node),
+          lines: rangeOf(node)
         },
         [node]
       );
@@ -4819,6 +4928,9 @@ var BLOCK_TYPES5 = /* @__PURE__ */ new Set([
   "block"
 ]);
 function literalArgOf(node, facts) {
+  if (node.type === "nil") {
+    return { kind: "null" };
+  }
   const value = evaluatedValue(node, facts);
   const text3 = literalOf4(value);
   if (text3 !== null) {
@@ -4956,13 +5068,21 @@ function argsOf(call, facts) {
 function enclosingStatement(call, body) {
   let current = call;
   while (current.parent !== null) {
-    if (BLOCK_TYPES5.has(current.parent.type) || current.parent.id === body.id) {
+    if (listsStatements(current.parent, body)) {
       return current;
     }
     current = current.parent;
   }
   return current;
 }
+function listsStatements(node, body) {
+  if (BLOCK_TYPES5.has(node.type) || node.id === body.id) {
+    return true;
+  }
+  const begin = node.type === "ensure" ? node.parent : node;
+  const around = begin?.type === "begin" ? begin.parent : null;
+  return around !== null && around !== void 0 && (BLOCK_TYPES5.has(around.type) || around.id === body.id);
+}
 function invocationEffects(definitionNode, inherited = NO_INHERITED_METHODS, keepsArglessCall = NO_ARGLESS_CALLS, facts) {
   return invocationSites(
     definitionNode,
@@ -4987,36 +5107,13 @@ function moduleScopeInvocationEffects(root, inherited = NO_INHERITED_METHODS, ke
   ).map((site) => site.effect);
 }
 function effectsOfBody(read, inherited, keepsArglessCall, facts) {
-  const body = read.body;
   const calls = callsReported(bodyCalls(read, inherited), keepsArglessCall);
   if (calls.length === 0) {
     return [];
   }
-  const statementOf2 = /* @__PURE__ */ new Map();
-  const byStatement = new NodeMap();
-  const statements = [];
-  for (const call of calls) {
-    const written = enclosingStatement(call, body);
-    const statement = byStatement.get(written);
-    if (statement === void 0) {
-      byStatement.set(written, written);
-      statements.push(written);
-    }
-    statementOf2.set(call.id, statement ?? written);
-  }
-  const lowered = lowerRubyBody(body, statements);
-  const enumerated = enumerateOrDegrade(
-    {
-      statements: lowered.statements,
-      terminalsByStmt: lowered.terminalsByStmt
-    },
-    statements
-  );
+  const sites = sitesIn(read.body, calls);
   return calls.map((call) => {
-    const statement = statementOf2.get(call.id);
-    const conditions = sharedGatingConditions(
-      statement === void 0 ? void 0 : enumerated.byTerminal.get(statement)
-    );
+    const conditions = sharedGatingConditions(sites.pathsTo(call));
     return {
       call,
       effect: {
@@ -5024,11 +5121,26 @@ function effectsOfBody(read, inherited, keepsArglessCall, facts) {
         callee: calleeText(call),
         args: argsOf(call, facts),
         async: false,
-        ...conditions.length > 0 ? { preconditions: conditions } : {}
-      }
+        ...conditions.length > 0 ? { preconditions: conditions } : {},
+        location: rangeOf(call)
+      },
+      site: sites.siteOf(call, conditions)
     };
   });
 }
+function sitesIn(body, nodes) {
+  return statementSites(nodes, {
+    statementOf: (node) => enclosingStatement(node, body),
+    lower: (statements) => lowerRubyBody(body, statements),
+    firstLine: (node) => rangeOf(node).start
+  });
+}
+function effectSitesIn(read, nodes) {
+  if (read === null || nodes.length === 0) {
+    return (node) => ({ line: rangeOf(node).start });
+  }
+  return sitesIn(read.body, nodes).plainSiteOf;
+}
 
 // src/paths/predicates.ts
 var OPERATORS = {
@@ -5415,15 +5527,10 @@ function raiseTerminal(call) {
 }
 function throughResponseHelpers(branches, sites, options) {
   const handOffs = [];
-  for (const { call, effect } of sites) {
+  for (const { call, site } of sites) {
     const helper = helperBranchesAt(call, options);
     if (helper !== null) {
-      handOffs.push({
-        helper,
-        preconditions: effect.preconditions,
-        line: rangeOf(call).start,
-        at: rangeOf(call)
-      });
+      handOffs.push({ ...site, helper, at: rangeOf(call) });
     }
   }
   return handOffs.length === 0 ? [...branches] : branches.flatMap((branch) => splitAtHandOffs(branch, handOffs));
@@ -5486,8 +5593,8 @@ function sameNode(a, b) {
 // src/responseStatus.ts
 import {
   absentReading as absentReading2,
-  enumerateOrDegrade as enumerateOrDegrade2,
-  guardsHoldOn,
+  effectsFiringOn,
+  enumerateOrDegrade,
   unreadableReading,
   writtenReading as writtenReading2
 } from "@suss/extractor";
@@ -5499,31 +5606,7 @@ import { constantOf as constantOf2, literalOf as literalOf6 } from "@suss/values
 
 // src/storage.ts
 import { storageBinding as storageBinding2 } from "@suss/ir-core";
-import { answersFor, askResolution as askResolution3, classMemberName as classMemberName2 } from "@suss/resolution";
-
-// src/baseClass.ts
-import { askResolution as askResolution2 } from "@suss/resolution";
-function classBehind(facts, file, constant2) {
-  const key = constant2.type === "constant" ? `${file}#${constant2.text}` : nodeId(file, constant2);
-  const bound = new Set(
-    facts.lookup("binds", 0, key).map((row) => String(row[1]))
-  );
-  return bound.size === 1 ? [...bound][0] : void 0;
-}
-function reachesBase(facts, classKey, bases) {
-  askResolution2(facts, [classKey], "wantedAncestry", RUBY_PROGRAM);
-  return facts.lookup("wantedBaseName", 0, classKey).some((row) => bases.includes(String(row[1])));
-}
-function enclosingClassKey(node, file) {
-  let current = node.parent;
-  while (current !== null) {
-    if (NESTING_TYPES.has(current.type)) {
-      return nodeId(file, current);
-    }
-    current = current.parent;
-  }
-  return null;
-}
+import { askResolution as askResolution3, classMemberName as classMemberName2 } from "@suss/resolution";
 
 // src/loaders.ts
 function receiverOf(node) {
@@ -5668,7 +5751,8 @@ function effectOf(call, store, address, access) {
       fields: access.fields,
       operation,
       ...access.selector.length > 0 ? { selector: access.selector } : {}
-    }
+    },
+    location: rangeOf(call)
   };
 }
 function addressBehind(receiver, pattern, options, hops) {
@@ -5979,20 +6063,10 @@ function storageEffect(call, container, pattern, kind, selector, fields) {
       fields,
       operation,
       ...selector.length > 0 ? { selector } : {}
-    }
+    },
+    location: rangeOf(call)
   };
 }
-function classSettledOn(facts, key) {
-  askResolution3(facts, [key], "wanted", RUBY_PROGRAM);
-  const objects = answersFor(facts, "wantedObjectOf", key);
-  return objects.length === 1 ? objects[0] : void 0;
-}
-function declaredName(facts, classKey) {
-  const names = new Set(
-    facts.lookup("rbConstantName", 0, classKey).map((row) => String(row[1]))
-  );
-  return names.size === 1 ? [...names][0] : void 0;
-}
 function projectDeclares(facts, classKey, method) {
   const spellings = /* @__PURE__ */ new Set([method, classMemberName2(method)]);
   return facts.lookup("wantedDeclaredName", 0, classKey).some((row) => spellings.has(String(row[1])));
@@ -6049,12 +6123,13 @@ function callbacksRunBy(facts, classKey, pattern, writeMethod) {
   }
   return [...found.values()];
 }
-function callbackEffect(callback) {
+function callbackEffect(callback, write) {
   return {
     type: "invocation",
     callee: callback.name,
     args: [],
-    async: false
+    async: false,
+    location: rangeOf(write)
   };
 }
 function modelCallEffects(call, file, options, enclosing) {
@@ -6093,7 +6168,7 @@ function modelCallEffects(call, file, options, enclosing) {
         options.statesSlots(access, slots);
       }
     }
-    return [access, ...ran.map(callbackEffect)];
+    return [access, ...ran.map((callback) => callbackEffect(callback, worked))];
   }
   return [];
 }
@@ -6231,11 +6306,12 @@ function storageEffects(calls, file, options, enclosing = null) {
     "wanted",
     RUBY_PROGRAM
   );
-  const effects = [];
-  for (const call of chains) {
-    effects.push(...effectsOfCall(call, file, options, enclosing));
-  }
-  return effects;
+  return chains.flatMap(
+    (call) => effectsOfCall(call, file, options, enclosing).map((effect) => ({
+      effect,
+      at: call
+    }))
+  );
 }
 
 // src/provenance.ts
@@ -6624,13 +6700,13 @@ function readingOfCall(call, declaration, names, options) {
   }
   return writtenReading2(status, rangeOf(argument));
 }
-function effectsReaching(effects, conditions) {
-  return effects.filter(
-    (effect) => guardsHoldOn(
-      effect.type === "invocation" ? effect.preconditions : void 0,
-      conditions
-    )
-  );
+function withEffectsThatRun(branch, body) {
+  const extra = effectsFiringOn(body.extraEffects ?? [], branch);
+  return {
+    ...branch,
+    effects: effectsFiringOn(body.effects, branch),
+    ...extra.length === 0 ? {} : { extraEffects: extra }
+  };
 }
 function conditionOf(condition, inputs) {
   return {
@@ -6690,57 +6766,66 @@ function helperResponse(helper, pattern, facts, boundStatuses = /* @__PURE__ */
     rangeOf(helper)
   );
 }
-function branchOf(outcome, pattern, effects, extraEffects, options) {
+function branchOf(outcome, pattern, body, options) {
   if (outcome.fellThrough === true && options.fallthrough === "handOn") {
-    return handsOnBranch(outcome, effects, extraEffects);
+    return handsOnBranch(outcome, body);
   }
-  return {
-    conditions: outcome.conditions,
-    terminal: {
-      kind: "response",
-      statusCode: null,
-      body: null,
-      exceptionType: null,
-      message: null,
-      component: null,
-      renderTree: null,
-      delegateTarget: null,
-      emitEvent: null,
-      location: outcome.location
-    },
-    statusCodeReading: {
-      reading: outcome.reading,
-      libraryDefault: pattern.defaultStatusCode
+  return withEffectsThatRun(
+    {
+      conditions: outcome.conditions,
+      terminal: {
+        kind: "response",
+        statusCode: null,
+        body: null,
+        exceptionType: null,
+        message: null,
+        component: null,
+        renderTree: null,
+        delegateTarget: null,
+        emitEvent: null,
+        location: outcome.location
+      },
+      statusCodeReading: {
+        reading: outcome.reading,
+        libraryDefault: pattern.defaultStatusCode
+      },
+      ...outcome.body === void 0 ? {} : { bodyShapeReading: { reading: outcome.body } },
+      effects: [],
+      location: outcome.location,
+      ...loopAroundOf(outcome),
+      isDefault: outcome.conditions.length === 0
     },
-    ...outcome.body === void 0 ? {} : { bodyShapeReading: { reading: outcome.body } },
-    effects: effectsReaching(effects, outcome.conditions),
-    ...extraEffects === void 0 ? {} : { extraEffects },
-    location: outcome.location,
-    isDefault: outcome.conditions.length === 0
-  };
+    body
+  );
 }
-function handsOnBranch(outcome, effects, extraEffects) {
-  return {
-    conditions: outcome.conditions,
-    terminal: {
-      kind: "delegate",
-      statusCode: null,
-      body: null,
-      exceptionType: null,
-      message: null,
-      component: null,
-      renderTree: null,
-      delegateTarget: null,
-      emitEvent: null,
-      location: outcome.location
+function handsOnBranch(outcome, body) {
+  return withEffectsThatRun(
+    {
+      conditions: outcome.conditions,
+      terminal: {
+        kind: "delegate",
+        statusCode: null,
+        body: null,
+        exceptionType: null,
+        message: null,
+        component: null,
+        renderTree: null,
+        delegateTarget: null,
+        emitEvent: null,
+        location: outcome.location
+      },
+      effects: [],
+      location: outcome.location,
+      ...loopAroundOf(outcome),
+      isDefault: outcome.conditions.length === 0
     },
-    effects: effectsReaching(effects, outcome.conditions),
-    ...extraEffects === void 0 ? {} : { extraEffects },
-    location: outcome.location,
-    isDefault: outcome.conditions.length === 0
-  };
+    body
+  );
+}
+function loopAroundOf(placed) {
+  return placed.loopAround === void 0 ? {} : { loopAround: placed.loopAround };
 }
-function returnPathBranches(method, effects, exits = [], facts, keepsArms, raises2 = []) {
+function returnPathBranches(method, effects, exits = [], facts, keepsArms, raises2 = [], endingOfReturn = (_statement, location) => returnTerminal(location)) {
   const body = field(method, "body");
   if (body === null) {
     return null;
@@ -6753,7 +6838,7 @@ function returnPathBranches(method, effects, exits = [], facts, keepsArms, raise
     ...raises2.map((raise) => raise.call)
   ];
   const lowered = lowerRubyBody(body, terminals, exitCalls);
-  const enumerated = enumerateOrDegrade2(
+  const enumerated = enumerateOrDegrade(
     {
       statements: lowered.statements,
       terminalsByStmt: lowered.terminalsByStmt,
@@ -6767,30 +6852,42 @@ function returnPathBranches(method, effects, exits = [], facts, keepsArms, raise
     facts
   );
   const branches = [];
-  const push = (paths, terminal) => {
+  const push = (paths, terminal, at) => {
+    const placement = at === null ? void 0 : enumerated.placement.get(at);
     for (const path7 of paths) {
       const conditions = path7.map(
         (condition) => conditionOf(condition, inputs)
       );
-      branches.push({
-        conditions,
-        terminal,
-        effects: effectsReaching(effects, conditions),
-        location: terminal.location,
-        isDefault: conditions.length === 0
-      });
+      branches.push(
+        withEffectsThatRun(
+          {
+            conditions,
+            terminal,
+            effects: [],
+            location: terminal.location,
+            ...loopAroundOf({ loopAround: placement?.loopAround }),
+            isDefault: conditions.length === 0
+          },
+          { effects }
+        )
+      );
     }
   };
   for (const statement of returns) {
     push(
       enumerated.byTerminal.get(statement) ?? [],
-      returnTerminal(rangeOf(statement))
+      endingOfReturn(statement, rangeOf(statement)),
+      statement
     );
   }
   for (const ending of [...exits, ...raises2]) {
-    push(enumerated.byTerminal.get(ending.call) ?? [], ending.terminal);
+    push(
+      enumerated.byTerminal.get(ending.call) ?? [],
+      ending.terminal,
+      ending.call
+    );
   }
-  push(enumerated.fallthrough, returnTerminal(rangeOf(method)));
+  push(enumerated.fallthrough, endingOfReturn(null, rangeOf(method)), null);
   return branches.length === 0 ? null : branches;
 }
 function returnTerminal(location) {
@@ -6831,7 +6928,7 @@ function responseBranches(method, pattern, effects, extraEffects, options = {})
     (node) => lowered.terminalHome.has(node) && collectResponseCalls(node, responders, []).length === 0
   );
   const terminals = [...responses, ...bareReturns];
-  const enumerated = enumerateOrDegrade2(
+  const enumerated = enumerateOrDegrade(
     {
       statements: lowered.statements,
       terminalsByStmt: lowered.terminalsByStmt
@@ -6850,12 +6947,14 @@ function responseBranches(method, pattern, effects, extraEffects, options = {})
     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;
+    const loopAround = enumerated.placement.get(terminal)?.loopAround;
     for (const path7 of enumerated.byTerminal.get(terminal) ?? []) {
       outcomes.push({
         conditions: conditionsOf(path7),
         reading,
         ...body2 === void 0 ? {} : { body: body2 },
         location: rangeOf(terminal),
+        loopAround,
         // 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 } : {}
@@ -6871,6 +6970,7 @@ function responseBranches(method, pattern, effects, extraEffects, options = {})
     });
   }
   const read = options.raises;
+  const placed = { effects, extraEffects };
   const raised = raises2.flatMap((call) => {
     const terminal = raisedTerminal(
       pattern,
@@ -6878,25 +6978,26 @@ function responseBranches(method, pattern, effects, extraEffects, options = {})
       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
-      };
-    });
+    const loopAround = enumerated.placement.get(call)?.loopAround;
+    return (enumerated.byTerminal.get(call) ?? []).map(
+      (path7) => withEffectsThatRun(
+        {
+          conditions: conditionsOf(path7),
+          terminal,
+          effects: [],
+          location: terminal.location,
+          ...loopAroundOf({ loopAround }),
+          isDefault: false
+        },
+        placed
+      )
+    );
   });
   if (outcomes.length === 0 && raised.length === 0) {
     return null;
   }
   return [
-    ...outcomes.map(
-      (outcome) => branchOf(outcome, pattern, effects, extraEffects, options)
-    ),
+    ...outcomes.map((outcome) => branchOf(outcome, pattern, placed, options)),
     ...raised
   ];
 }
@@ -7164,7 +7265,7 @@ function callerBranches(method, reading) {
   const keepsArms = (condition) => testsStatus(predicateOf(condition), reading.statusMembers);
   const found = returnPathBranches(
     method,
-    effects,
+    sites,
     [],
     reading.facts,
     keepsArms,
@@ -7623,7 +7724,7 @@ function envReadEffects(root, facts) {
     at: (node) => {
       const read = envReadAt(node);
       if (read !== null) {
-        slots.push({ read });
+        slots.push({ read, at: node });
         return;
       }
       if (helpers !== null && node.type === "call") {
@@ -7636,9 +7737,12 @@ function envReadEffects(root, facts) {
   const throughHelpers = helpers === null ? new NodeMap() : helperReads(calls, helpers);
   return slots.flatMap((slot) => {
     if ("read" in slot) {
-      return [configReadEffect(slot.read)];
+      return [{ effect: configReadEffect(slot.read, slot.at), at: slot.at }];
     }
-    return (throughHelpers.get(slot.call) ?? []).map(configReadEffect);
+    return (throughHelpers.get(slot.call) ?? []).map((read) => ({
+      effect: configReadEffect(read, slot.call),
+      at: slot.call
+    }));
   });
 }
 function helperFactsOf(facts) {
@@ -7794,16 +7898,17 @@ function readsAtCall(db, call, args) {
   }
   return [...byName].map(([name, defaulted]) => ({ name, defaulted }));
 }
-function configReadEffect(read) {
+function configReadEffect(read, at) {
   return {
     type: "interaction",
     binding: runtimeConfigBinding({ recognition: RUBY_ENV_RECOGNITION }),
-    callee: `ENV["${read.name}"]`,
+    callee: read.name === null ? at.text : `ENV["${read.name}"]`,
     interaction: {
       class: "config-read",
       name: read.name,
       defaulted: read.defaulted
-    }
+    },
+    location: rangeOf(at)
   };
 }
 function envReadAt(node) {
@@ -7811,8 +7916,7 @@ function envReadAt(node) {
   if (site === null) {
     return null;
   }
-  const name = stringLiteralValue(site.name);
-  return name === null ? null : { name, defaulted: site.defaulted };
+  return { name: stringLiteralValue(site.name), defaulted: site.defaulted };
 }
 function envSiteAt(node) {
   const spelling = envSpellingAt(node);
@@ -8008,25 +8112,27 @@ function filterUnit(filter, pattern, displayPath, body, reading = {}) {
   };
 }
 function handsOn(range, body) {
-  return {
-    conditions: [],
-    terminal: {
-      kind: "delegate",
-      statusCode: null,
-      body: null,
-      exceptionType: null,
-      message: null,
-      component: null,
-      renderTree: null,
-      delegateTarget: null,
-      emitEvent: null,
-      location: range
+  return withEffectsThatRun(
+    {
+      conditions: [],
+      terminal: {
+        kind: "delegate",
+        statusCode: null,
+        body: null,
+        exceptionType: null,
+        message: null,
+        component: null,
+        renderTree: null,
+        delegateTarget: null,
+        emitEvent: null,
+        location: range
+      },
+      effects: [],
+      location: range,
+      isDefault: true
     },
-    effects: body.effects ?? [],
-    ...body.extraEffects === void 0 ? {} : { extraEffects: body.extraEffects },
-    location: range,
-    isDefault: true
-  };
+    { effects: body.effects ?? [], extraEffects: body.extraEffects }
+  );
 }
 function calledName(statement) {
   if (statement.type !== "call" || field(statement, "receiver") !== null) {
@@ -8163,34 +8269,214 @@ function actionsUnder(node, facts) {
   return found === null ? null : new Set(found);
 }
 
-// src/streamWrites.ts
-import { ioBinding } from "@suss/behavioral-ir";
-import { SKIP_CHILDREN as SKIP_CHILDREN3, walkDescendants as walkDescendants3 } from "@suss/extractor";
-var RUBY_STREAM_RECOGNITION = "ruby-stdlib";
-var KERNEL_WRITES = /* @__PURE__ */ new Map([
-  ["puts", "stdout"],
-  ["print", "stdout"],
-  ["warn", "stderr"],
-  ["abort", "stderr"]
-]);
-var STREAM_RECEIVERS = /* @__PURE__ */ new Map([
-  ["$stdout", "stdout"],
-  ["STDOUT", "stdout"],
-  ["$stderr", "stderr"],
-  ["STDERR", "stderr"]
-]);
-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, children, {
-    at: (node) => {
-      const write = node.type === "call" ? streamWriteAt(node) : null;
-      if (write !== null) {
-        found.push(write);
-      }
-    },
-    into: (node) => DEFERRED_BODY_TYPES2.has(node.type) ? SKIP_CHILDREN3 : null
+// src/resolverHooks.ts
+import {
+  SKIP_CHILDREN as SKIP_CHILDREN3,
+  unreadableReading as unreadableReading2,
+  walkDescendants as walkDescendants3
+} from "@suss/extractor";
+import { constantOf as constantOf4 } from "@suss/values";
+function hooksRun(ancestry, hooks, read) {
+  const definitions = [];
+  const unsettled = [];
+  for (const name of hooks.methods) {
+    const found = definitionsRun(ancestry, name, read);
+    definitions.push(...found.definitions);
+    if (found.unsettled !== null) {
+      unsettled.push({ name, reason: found.unsettled });
+    }
+  }
+  return { definitions, unsettled };
+}
+function definitionsRun(ancestry, name, read) {
+  const definitions = [];
+  let rest = ancestry;
+  while (rest.length > 0) {
+    const lookup = methodInAncestry(rest, name, read);
+    if (lookup.type !== "found") {
+      return { definitions, unsettled: unsettledReason(lookup) };
+    }
+    definitions.push({ name, method: lookup.method, block: lookup.block });
+    if (!callsSuper(lookup.method)) {
+      break;
+    }
+    const at = rest.findIndex(
+      (entry) => entry.type === "bodies" && entry.blocks.includes(lookup.block)
+    );
+    rest = rest.slice(Math.max(at, 0) + 1);
+  }
+  return { definitions, unsettled: null };
+}
+function unsettledReason(lookup) {
+  if (lookup.type !== "unsettled") {
+    return null;
+  }
+  return lookup.cause === "dynamicDefine" || lookup.definedLater === true ? lookup.reason : null;
+}
+function callsSuper(method) {
+  let found = false;
+  walkDescendants3(method, null, children, {
+    at: (node) => {
+      found ||= isSuper(node);
+    },
+    into: (node) => node !== method && METHOD_TYPES.has(node.type) ? SKIP_CHILDREN3 : null
+  });
+  return found;
+}
+function isSuper(node) {
+  return node.type === "super" || node.type === "call" && field(node, "method")?.type === "super";
+}
+function hookUnit(hook, input) {
+  const { body, facts } = input;
+  const range = rangeOf(hook.method);
+  const effects = body.effects ?? [];
+  const branches = (returnPathBranches(
+    hook.method,
+    effects,
+    [],
+    facts,
+    void 0,
+    raiseEndings(hook.method),
+    (statement, location) => hookEnding(hook.method, statement, location, input)
+  ) ?? [emptyBodyBranch(range)]).map(
+    (branch) => withEffectsThatRun(branch, {
+      effects,
+      extraEffects: body.extraEffects
+    })
+  );
+  return {
+    identity: {
+      name: hook.name,
+      nameKind: "binding",
+      kind: "middleware",
+      file: input.displayPath,
+      range,
+      span: spanOf(hook.method),
+      exportName: hook.name,
+      exportPath: [hook.block.info.qualifiedName, hook.name]
+    },
+    boundaryBinding: null,
+    parameters: [],
+    branches: withSlotSources(branches, body.provenance),
+    bodyContent: body.bodyContent ?? "absent",
+    dependencyCalls: [],
+    declaredContract: null
+  };
+}
+function hookReference(hook, displayPath) {
+  return {
+    file: displayPath,
+    name: hook.name,
+    line: rangeOf(hook.method).start
+  };
+}
+function unsettledHookReading(className, unsettled, range) {
+  return unreadableReading2(
+    `This field's ${className} could be stopped by a ${unsettled.name} hook ${unsettled.reason}, so whether one runs was not settled here`,
+    range
+  );
+}
+function hookEnding(method, statement, location, input) {
+  const values = statement === null ? lastStatement(method) : returnedValues(statement);
+  return stopsTheField(values, input) ? endingTerminal("return", location) : goOn(location);
+}
+function lastStatement(method) {
+  const body = field(method, "body");
+  const last = body === null ? void 0 : bodyStatements(body).at(-1);
+  return last === void 0 ? [] : [last];
+}
+function returnedValues(statement) {
+  const list = children(statement)[0];
+  if (list === void 0) {
+    return [];
+  }
+  return list.type === "argument_list" ? children(list) : [list];
+}
+function stopsTheField(values, input) {
+  const first = values[0];
+  if (first === void 0) {
+    return true;
+  }
+  const listHead = input.hooks.answerIsListHead === true;
+  if (values.length > 1) {
+    return listHead && isFalsy(evaluatedValue(first, input.facts));
+  }
+  const value = evaluatedValue(first, input.facts);
+  if (value.kind !== "sequence") {
+    return isFalsy(value);
+  }
+  const head = value.items[0];
+  return listHead && head !== void 0 && isFalsy(head.value);
+}
+function isFalsy(value) {
+  const settled = constantOf4(value);
+  return settled === false || settled === null;
+}
+function emptyBodyBranch(location) {
+  return {
+    conditions: [],
+    terminal: endingTerminal("return", location),
+    effects: [],
+    location,
+    isDefault: true
+  };
+}
+function goOn(location) {
+  return endingTerminal("delegate", location);
+}
+function endingTerminal(kind, location) {
+  return {
+    kind,
+    statusCode: null,
+    body: null,
+    exceptionType: null,
+    message: null,
+    component: null,
+    renderTree: null,
+    delegateTarget: null,
+    emitEvent: null,
+    location
+  };
+}
+
+// src/streamWrites.ts
+import { ioBinding } from "@suss/behavioral-ir";
+import {
+  callSiteKey,
+  numberRepeatedCallSites,
+  SKIP_CHILDREN as SKIP_CHILDREN4,
+  walkDescendants as walkDescendants4
+} from "@suss/extractor";
+var RUBY_STREAM_RECOGNITION = "ruby-stdlib";
+var KERNEL_WRITES = /* @__PURE__ */ new Map([
+  ["puts", "stdout"],
+  ["print", "stdout"],
+  ["warn", "stderr"],
+  ["abort", "stderr"]
+]);
+var STREAM_RECEIVERS = /* @__PURE__ */ new Map([
+  ["$stdout", "stdout"],
+  ["STDOUT", "stdout"],
+  ["$stderr", "stderr"],
+  ["STDERR", "stderr"]
+]);
+var STREAM_METHODS = /* @__PURE__ */ new Set(["puts", "print", "write", "<<"]);
+var DEFERRED_BODY_TYPES2 = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
+function streamWriteEffects(root) {
+  return numberRepeatedCallSites(
+    writesUnder2(root).map((write) => [write])
+  ).flat();
+}
+function writesUnder2(root) {
+  const found = [];
+  walkDescendants4(root, null, children, {
+    at: (node) => {
+      const write = node.type === "call" ? streamWriteAt(node) : null;
+      if (write !== null) {
+        found.push({ effect: write, at: node });
+      }
+    },
+    into: (node) => DEFERRED_BODY_TYPES2.has(node.type) ? SKIP_CHILDREN4 : null
   });
   return found;
 }
@@ -8219,13 +8505,14 @@ function streamWriteAt(call) {
 function writeEffect(call, target, args) {
   const receiver = field(call, "receiver");
   const method = field(call, "method")?.text ?? "";
-  return {
+  const effect = {
     type: "interaction",
     binding: ioBinding({ recognition: RUBY_STREAM_RECOGNITION, target }),
     callee: receiver === null ? method : `${receiver.text}.${method}`,
-    groupId: `${call.startPosition.row + 1}:${call.startPosition.column + 1}`,
-    interaction: { class: "stream-write", ...payloadOf(args) }
+    interaction: { class: "stream-write", ...payloadOf(args) },
+    location: rangeOf(call)
   };
+  return { ...effect, groupId: callSiteKey(effect) };
 }
 function payloadOf(args) {
   const only = args[0];
@@ -9305,16 +9592,19 @@ function createFileCache(parse, readFile) {
     }
   };
 }
-function fieldReadContext(pattern, cache, fileBlocks, bodyRead, facts) {
+function fieldReadContext(pattern, cache, fileBlocks, options) {
+  const facts = options.facts;
+  const parsedFile = (absPath) => cache.get(absPath);
   return {
     pattern,
     cache,
-    bodyRead,
+    bodyRead: options,
     facts,
+    file: options.absoluteFile ?? options.filePath,
     read: {
       facts,
-      bodyBlocks: bodyRead.bodyBlocks,
-      dynamicNames: bodyRead.dynamicNames
+      bodyBlocks: options.bodyBlocks,
+      dynamicNames: options.dynamicNames
     },
     lookup: {
       root: pattern.root,
@@ -9323,8 +9613,9 @@ function fieldReadContext(pattern, cache, fileBlocks, bodyRead, facts) {
       acronyms: pattern.acronyms ?? [],
       ancestryRootClassNames: pattern.ancestryRootClassNames,
       constantFiles: cache.constantFiles,
-      parsedFile: (absPath) => cache.get(absPath),
-      localDefinition: (name) => sameFileBlocks(name, fileBlocks)
+      parsedFile,
+      localDefinition: (name) => sameFileBlocks(name, fileBlocks),
+      ...facts === void 0 ? {} : { definedInRun: classesDeclaredInRun(facts, parsedFile) }
     }
   };
 }
@@ -9433,13 +9724,7 @@ async function graphqlObjectFieldUnits(pattern, pack, info, ownBlocks, fileBlock
   if (info.bodyNode === null || pattern.baseClassNames.includes(info.qualifiedName)) {
     return [];
   }
-  const ctx = fieldReadContext(
-    pattern,
-    options.cache,
-    fileBlocks,
-    options,
-    options.facts
-  );
+  const ctx = fieldReadContext(pattern, options.cache, fileBlocks, options);
   const ancestry = await ancestryOf(info.qualifiedName, ownBlocks, ctx.lookup);
   if (!reachesConfiguredBase(ancestry, info.qualifiedName, pattern.baseClassNames)) {
     return [];
@@ -9460,13 +9745,47 @@ async function graphqlObjectFieldUnits(pattern, pack, info, ownBlocks, fileBlock
       declsByName.set(decl.fieldName, decl);
     }
   }
-  return [...declsByName.values()].map((decl) => {
-    const raw = buildFieldUnit(pack, typeName, decl, options.filePath);
+  const decls = [...declsByName.values()];
+  const fields = decls.map((decl) => {
+    const raw = buildFieldUnit(pack, typeName, decl, options);
     if (decl.body.reachSeed !== void 0) {
       options.onReachSeed?.(raw, decl.body.reachSeed);
     }
     return raw;
   });
+  return [...fields, ...hookUnitsOf(decls, pattern, options)];
+}
+function hookUnitsOf(decls, pattern, options) {
+  const hooks = pattern.resolverHooks;
+  if (hooks === void 0) {
+    return [];
+  }
+  const units = /* @__PURE__ */ new Map();
+  for (const hook of decls.flatMap((decl) => decl.hooks)) {
+    const key = nodeId(hook.block.file, hook.method);
+    if (units.has(key)) {
+      continue;
+    }
+    const raw = hookUnit(hook, {
+      hooks,
+      body: bodyOfMethod(hook.method, hook.block.file, options),
+      displayPath: displayPathIn(options, hook.block.file),
+      facts: options.facts
+    });
+    units.set(key, raw);
+    options.onReachSeed?.(raw, {
+      file: hook.block.file,
+      node: hook.method,
+      enclosingQualifiedName: hook.block.info.qualifiedName
+    });
+  }
+  return [...units.values()];
+}
+function displayPathIn(options, file) {
+  if (file === (options.absoluteFile ?? options.filePath)) {
+    return options.filePath;
+  }
+  return options.displayPathOf?.(file) ?? file;
 }
 async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks, options) {
   if (info.bodyNode === null || pattern.baseClassNames.includes(info.qualifiedName)) {
@@ -9543,7 +9862,7 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
         raised: raisedStatusBranches(
           pattern,
           options.storage?.patterns ?? [],
-          body.extraEffects,
+          everyEffect(body.extraEffects),
           "eachRoute",
           rangeOf(filter.method)
         )
@@ -9576,10 +9895,7 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
         actionName,
         route,
         method,
-        {
-          display: block.file === (options.absoluteFile ?? options.filePath) ? options.filePath : options.displayPathOf?.(block.file) ?? block.file,
-          absolute: block.file
-        },
+        { display: displayPathIn(options, block.file), absolute: block.file },
         options,
         around,
         respondingHelper,
@@ -9748,8 +10064,8 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
             reading: absentReading3,
             libraryDefault: pattern.defaultStatusCode
           },
-          effects: body.effects ?? [],
-          ...body.extraEffects === void 0 ? {} : { extraEffects: body.extraEffects },
+          effects: everyEffect(body.effects),
+          ...body.extraEffects === void 0 ? {} : { extraEffects: everyEffect(body.extraEffects) },
           location: range,
           isDefault: true
         }
@@ -9759,7 +10075,7 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
       raisedStatusBranches(
         pattern,
         bodyRead.storage?.patterns ?? [],
-        body.extraEffects,
+        everyEffect(body.extraEffects),
         raises2.handlers,
         range
       )
@@ -9804,7 +10120,7 @@ function routingGapUnit(pattern, gaps) {
         isDefault: true
       }
     ],
-    readings: gaps.map((gap) => unreadableReading2(gap, range)),
+    readings: gaps.map((gap) => unreadableReading3(gap, range)),
     dependencyCalls: [],
     declaredContract: null
   };
@@ -9838,15 +10154,18 @@ function branchesFor(body, range) {
       emitEvent: null,
       location: range
     },
-    effects: body.effects ?? [],
-    ...body.extraEffects === void 0 ? {} : { extraEffects: body.extraEffects },
+    effects: everyEffect(body.effects),
+    ...body.extraEffects === void 0 ? {} : { extraEffects: everyEffect(body.extraEffects) },
     location: range,
     isDefault: true
   };
   return withSlotSources([branch], body.provenance);
 }
+function everyEffect(placed) {
+  return (placed ?? []).map((one) => one.effect);
+}
 function bodyOfMethod(method, file, bodyRead = {}) {
-  const effects = invocationEffects(
+  const effects = invocationSites(
     method,
     bodyRead.inheritedMethods,
     EVERY_ARGLESS_CALL,
@@ -9855,7 +10174,7 @@ function bodyOfMethod(method, file, bodyRead = {}) {
   const storage = bodyRead.storage;
   const facts = bodyRead.facts;
   const database = storage === void 0 ? { effects: [], slots: [] } : methodStorage(method, file, storage);
-  const extra = [
+  const found = [
     ...envReadEffects(
       method,
       facts === void 0 ? void 0 : { db: facts, file }
@@ -9863,6 +10182,11 @@ function bodyOfMethod(method, file, bodyRead = {}) {
     ...database.effects,
     ...streamWriteEffects(method)
   ];
+  const siteOf3 = effectSitesIn(
+    methodBody(method),
+    found.map((one) => one.at)
+  );
+  const extra = found.map(({ effect, at }) => ({ effect, site: siteOf3(at) }));
   const provenance = database.slots.length === 0 || storage === void 0 ? [] : slotProvenance(database.slots, { facts: storage.facts, unit: method });
   return {
     bodyContent: methodHasStatements(method) ? "statements" : "empty",
@@ -9877,7 +10201,7 @@ var NO_METHOD_BEHIND_IT = {
   readings: []
 };
 function methodNotSettled(reason, range) {
-  return { readings: [unreadableReading2(reason, range)] };
+  return { readings: [unreadableReading3(reason, range)] };
 }
 function bodyFromLookup(found, range, subject, nothingThere, bodyRead) {
   const table = {
@@ -9926,7 +10250,8 @@ async function readFieldCall(stmt, scope, ctx, ancestry) {
     namedOnTheWire: true,
     node: stmt,
     contract: read.contract,
-    body: read.body
+    body: read.body,
+    hooks: read.hooks ?? []
   };
 }
 function computedNameDeclaration(stmt, nameArg) {
@@ -9936,9 +10261,10 @@ function computedNameDeclaration(stmt, nameArg) {
     namedOnTheWire: false,
     node: stmt,
     contract: null,
+    hooks: [],
     body: {
       readings: [
-        unreadableReading2(
+        unreadableReading3(
           `This field is named by ${nameArg.text}, which is worked out when the class body runs, so the name the schema exposes it under was not read here`,
           range
         )
@@ -9962,14 +10288,38 @@ async function readFieldShape(symbol, callArgs, scope, ctx, ancestry, range) {
   }
   return {
     contract: literalContract(callArgs, scope, ctx),
-    body: bodyFromLookup(
+    body: methodBehindField(symbol, callArgs, ctx, ancestry, range)
+  };
+}
+function methodBehindField(symbol, callArgs, ctx, ancestry, range) {
+  const keyword = ctx.pattern.resolverMethodKeyword;
+  const written = keyword === void 0 ? void 0 : callArgs.keyword[keyword];
+  if (written === void 0) {
+    return bodyFromLookup(
       methodInAncestry(ancestry, symbol, ctx.read),
       range,
       "This field",
       NO_METHOD_BEHIND_IT,
       ctx.bodyRead
-    )
-  };
+    );
+  }
+  const name = stringValueOf(written, ctx.facts);
+  if (name === null) {
+    return methodNotSettled(
+      `This field is resolved by the method ${written.text}, which is worked out at run time, so nothing about what it does was read here`,
+      range
+    );
+  }
+  return bodyFromLookup(
+    methodInAncestry(ancestry, name, ctx.read),
+    range,
+    "This field",
+    methodNotSettled(
+      `This field is resolved by ${name}, which nothing in its type's ancestry defines, so nothing about what it does was read here`,
+      range
+    ),
+    ctx.bodyRead
+  );
 }
 function literalContract(callArgs, scope, ctx) {
   const typeArg = callArgs.positional[1];
@@ -9985,21 +10335,12 @@ function literalContract(callArgs, scope, ctx) {
 async function readWiredClass(ref, scope, ctx) {
   const range = rangeOf(ref);
   const candidates = constantRefCandidates(ref, scope.nesting);
-  if (candidates.length === 0) {
-    return {
-      contract: null,
-      body: methodNotSettled(
-        `This field is wired to ${ref.text}, which is not a constant path this reader follows, so nothing about what it does was read here`,
-        range
-      )
-    };
-  }
-  const reached = await reachConstant(candidates, ctx.lookup);
+  const reached = await wiredClassInRun(ref, ctx) ?? (candidates.length === 0 ? null : await reachConstant(candidates, ctx.lookup));
   if (reached === null) {
     return {
       contract: null,
       body: methodNotSettled(
-        `This field is wired to ${ref.text}, which this run did not read, so nothing about what it does was read here`,
+        candidates.length === 0 ? `This field is wired to ${ref.text}, which is not a constant path this reader follows, so nothing about what it does was read here` : `This field is wired to ${ref.text}, which this run did not read, so nothing about what it does was read here`,
         range
       )
     };
@@ -10010,20 +10351,44 @@ async function readWiredClass(ref, scope, ctx) {
     reached.blocks,
     ctx.lookup
   );
+  const body = bodyFromLookup(
+    methodInAncestry(ancestry, ctx.pattern.resolverMethodName, ctx.read),
+    range,
+    `This field's ${targetQualifiedName}`,
+    methodNotSettled(
+      `This field is wired to ${targetQualifiedName}, which defines no ${ctx.pattern.resolverMethodName} method anywhere in its ancestry, so nothing about what it does was read here`,
+      range
+    ),
+    ctx.bodyRead
+  );
+  const hooks = ctx.pattern.resolverHooks === void 0 ? { definitions: [], unsettled: [] } : hooksRun(ancestry, ctx.pattern.resolverHooks, ctx.read);
   return {
     contract: readClassContract(ancestry, ctx.pattern),
-    body: bodyFromLookup(
-      methodInAncestry(ancestry, ctx.pattern.resolverMethodName, ctx.read),
-      range,
-      `This field's ${targetQualifiedName}`,
-      methodNotSettled(
-        `This field is wired to ${targetQualifiedName}, which defines no ${ctx.pattern.resolverMethodName} method anywhere in its ancestry, so nothing about what it does was read here`,
-        range
-      ),
-      ctx.bodyRead
-    )
+    body: {
+      ...body,
+      readings: [
+        ...body.readings,
+        ...hooks.unsettled.map(
+          (one) => unsettledHookReading(targetQualifiedName, one, range)
+        )
+      ]
+    },
+    hooks: hooks.definitions
   };
 }
+async function wiredClassInRun(ref, ctx) {
+  const inRun = ctx.lookup.definedInRun;
+  if (ctx.facts === void 0 || inRun === void 0) {
+    return null;
+  }
+  const classKey = classSettledOn(ctx.facts, readKey(ctx.file, ref, null));
+  const name = classKey === void 0 ? void 0 : declaredName(ctx.facts, classKey);
+  if (name === void 0) {
+    return null;
+  }
+  const blocks = await inRun(name);
+  return blocks === null ? null : { name, blocks };
+}
 function readTypeCall(callArgs, scope, pattern, out) {
   const typeArg = callArgs.positional[0];
   if (typeArg !== void 0) {
@@ -10141,7 +10506,11 @@ function toCamelCase(name) {
     ...rest.map((part) => part.charAt(0).toUpperCase() + part.slice(1))
   ].join("");
 }
-function buildFieldUnit(pack, typeName, decl, filePath) {
+function buildFieldUnit(pack, typeName, decl, options) {
+  const filePath = options.filePath;
+  const wrappers = decl.hooks.map(
+    (hook) => hookReference(hook, displayPathIn(options, hook.block.file))
+  );
   const parameters = (decl.contract?.methodArgs ?? decl.contract?.args ?? []).map((arg, position) => ({
     name: arg.name,
     position,
@@ -10181,7 +10550,8 @@ function buildFieldUnit(pack, typeName, decl, filePath) {
     dependencyCalls: [],
     declaredContract: null,
     ...decl.body.readings.length > 0 ? { readings: decl.body.readings } : {},
-    ...graphqlDeclaredContract !== void 0 ? { graphqlDeclaredContract } : {}
+    ...graphqlDeclaredContract !== void 0 ? { graphqlDeclaredContract } : {},
+    ...wrappers.length > 0 ? { wrappers } : {}
   };
 }
 
@@ -10649,14 +11019,39 @@ function buildRubyExtractionReport(args) {
   });
 }
 
+// src/reach/closure.ts
+import {
+  functionCallBinding,
+  placeArgTargets,
+  placeCalleeParameters,
+  placeCalls,
+  placePossibleCalls,
+  ReceiverClasses,
+  recordParameterGaps,
+  StopList,
+  sameDeclarations,
+  TargetPlacements,
+  unfollowedCallGap,
+  worthRecording
+} from "@suss/behavioral-ir";
+import { Database, evaluate, lit as lit2, rule as rule2, variable as v2 } from "@suss/datalog";
+import { assembleSummary } from "@suss/extractor";
+import {
+  fileOfKey as fileOfKey2,
+  keptVariants,
+  noDependencies,
+  plainKeyOf,
+  variantKey
+} from "@suss/resolution";
+
 // src/exits.ts
 import {
   markReturnsAsExitCode,
-  SKIP_CHILDREN as SKIP_CHILDREN4,
-  walkDescendants as walkDescendants4
+  SKIP_CHILDREN as SKIP_CHILDREN5,
+  walkDescendants as walkDescendants5
 } from "@suss/extractor";
 import { exitCodeFunctions } from "@suss/resolution";
-import { constantOf as constantOf4 } from "@suss/values";
+import { constantOf as constantOf5 } from "@suss/values";
 var EXIT_METHODS = /* @__PURE__ */ new Map([
   ["exit", 0],
   ["exit!", 1],
@@ -10665,14 +11060,14 @@ 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, children, {
+  walkDescendants5(root, null, children, {
     at: (node) => {
       const site = node.type === "call" ? exitSiteAt(node) : null;
       if (site !== null) {
         found.push(site);
       }
     },
-    into: (node) => DEFERRED_BODY_TYPES3.has(node.type) ? SKIP_CHILDREN4 : null
+    into: (node) => DEFERRED_BODY_TYPES3.has(node.type) ? SKIP_CHILDREN5 : null
   });
   return found;
 }
@@ -10709,7 +11104,7 @@ function exitCodeOf(site, facts) {
   if (written !== void 0) {
     return { type: "literal", value: written };
   }
-  const value = constantOf4(evaluatedValue(code, facts));
+  const value = constantOf5(evaluatedValue(code, facts));
   return typeof value === "number" ? { type: "literal", value } : { type: "dynamic", sourceText: code.text };
 }
 function exitingBranches(method, effects, facts) {
@@ -10737,105 +11132,6 @@ function markExitCodeFunctions(summaries, exits, facts, workspaceRoot) {
   );
 }
 
-// src/facts/callbacks.ts
-function callbacksIn(patterns) {
-  return patterns.flatMap(
-    (pattern) => pattern.callbacks === void 0 ? [] : [pattern.callbacks]
-  );
-}
-function emitClassCallbacks(db, file, classNode, declared) {
-  const body = field(classNode, "body");
-  if (body === null || declared.length === 0) {
-    return;
-  }
-  const classKey = nodeId(file, classNode);
-  for (const statement of runStatements(body)) {
-    if (statement.type !== "call" || field(statement, "receiver") !== null) {
-      continue;
-    }
-    const called = field(statement, "method")?.text ?? "";
-    const args = readCallArgs(field(statement, "arguments"));
-    for (const callbacks of declared) {
-      const events = eventsOf(args, called, callbacks, db);
-      for (const event of events) {
-        for (const method of symbolArgumentNames(args, db)) {
-          db.add("classCallback", [classKey, event, method]);
-        }
-      }
-    }
-  }
-}
-function eventsOf(args, called, callbacks, db) {
-  const covered = callbacks.registeredBy[called];
-  if (covered === void 0) {
-    return [];
-  }
-  const written = args.keyword[callbacks.eventKeyword];
-  const narrowed = written === void 0 ? null : stringValueOf(written, db);
-  if (narrowed === null) {
-    return covered;
-  }
-  return covered.filter((event) => event === narrowed);
-}
-
-// src/facts.ts
-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, children, {
-    at: (node) => {
-      const target = requiredRelativePath(node);
-      if (target === null) {
-        return;
-      }
-      const resolved = path3.resolve(
-        path3.dirname(filePath),
-        target.endsWith(".rb") ? target : `${target}.rb`
-      );
-      if (known.has(resolved)) {
-        db.add("importsFile", [filePath, resolved]);
-      }
-    },
-    into: (node) => node.type === "argument_list" ? SKIP_CHILDREN5 : null
-  });
-}
-function requiredRelativePath(node) {
-  if (node.type !== "call" || field(node, "receiver") !== null || field(node, "method")?.text !== "require_relative") {
-    return null;
-  }
-  const { positional } = readCallArgs(field(node, "arguments"));
-  return positional[0] === void 0 ? null : stringLiteralValue(positional[0]);
-}
-
-// src/moduleSurface.ts
-import { moduleExportBinding } from "@suss/behavioral-ir";
-import {
-  MODULE_SURFACE_RECOGNITION,
-  moduleOfFile,
-  settleModules
-} from "@suss/extractor";
-
-// src/reach/closure.ts
-import {
-  functionCallBinding,
-  placeArgTargets,
-  placeCalleeParameters,
-  placeCalls,
-  placePossibleCalls,
-  ReceiverClasses,
-  recordParameterGaps,
-  StopList,
-  TargetPlacements,
-  unfollowedCallGap,
-  worthRecording
-} from "@suss/behavioral-ir";
-import { Database, evaluate, lit as lit2, rule as rule2, variable as v2 } from "@suss/datalog";
-import { assembleSummary } from "@suss/extractor";
-import {
-  fileOfKey as fileOfKey2,
-  noDependencies
-} from "@suss/resolution";
-
 // src/flags.ts
 import { SKIP_CHILDREN as SKIP_CHILDREN6, walkDescendants as walkDescendants6 } from "@suss/extractor";
 var PARSE_METHODS = /* @__PURE__ */ new Set(["parse", "parse!", "permute", "permute!"]);
@@ -10941,8 +11237,14 @@ import {
   calleeOutcomes,
   classMemberName as classMemberName3,
   couldBeSettled,
-  dispatchOutcomes
+  dispatchOutcomes,
+  SELF_AS_CLASS_NAME as SELF_AS_CLASS_NAME2,
+  selfFormOf,
+  selfResultOf
 } from "@suss/resolution";
+function selfClassOf(site) {
+  return site.receiverClass?.name ?? site.enclosingQualifiedName;
+}
 var STOP_FOR = {
   severalSources: "multipleSources",
   outsideRun: "outsideRun",
@@ -11139,6 +11441,24 @@ function asCallee(spelling, outcome, site, ctx) {
   if (objects.length > 1) {
     return stop("multipleSources");
   }
+  const fromSelf = ownReceiverForm(spelling.key, site, ctx);
+  const selfClass = selfClassOf(site);
+  if (fromSelf !== null && selfClass !== null) {
+    return methodOfClass(
+      { ...spelling, onClassItself: fromSelf === SELF_AS_CLASS_NAME2 },
+      selfClass,
+      ctx
+    );
+  }
+  const returned = selfResultOf(ctx.facts, spelling.key);
+  const sentTo = returned === null ? null : classSentTo(returned.receiver, site, ctx);
+  if (returned !== null && sentTo !== null) {
+    return methodOfClass(
+      { ...spelling, onClassItself: returned.form === SELF_AS_CLASS_NAME2 },
+      sentTo,
+      ctx
+    );
+  }
   const objectKey = objects[0] ?? (outcome.kind === "object" ? outcome.key : void 0);
   if (objectKey !== void 0) {
     return methodOnObject(spelling, objectKey, ctx);
@@ -11148,6 +11468,17 @@ function asCallee(spelling, outcome, site, ctx) {
   }
   return stop(STOP_FOR[outcome.kind] ?? "noDeclaration");
 }
+function ownReceiverForm(key, site, ctx) {
+  return site.method === null ? null : selfFormOf(ctx.facts, key, receiverKeyOf(site.file, site.method));
+}
+function classSentTo(receiver, site, ctx) {
+  resolveValues(ctx.facts, [receiver]);
+  if (ownReceiverForm(receiver, site, ctx) !== null) {
+    return selfClassOf(site);
+  }
+  const [only, ...more] = objectsBehind(ctx.facts, receiver);
+  return only === void 0 || more.length > 0 ? null : ctx.classNames.get(only) ?? null;
+}
 function objectsBehind(facts, key) {
   return answersFor2(facts, "wantedObjectOf", key);
 }
@@ -11165,11 +11496,18 @@ function methodOfClass(spelling, qualifiedName, ctx) {
   if (!spelling.onClassItself) {
     return methodOnAncestryOf(qualifiedName, spelling.method, ctx);
   }
-  if (spelling.method === "new") {
-    return methodOnAncestryOf(qualifiedName, "initialize", ctx);
+  if (spelling.method === CONSTRUCTOR) {
+    return methodOnAncestryOf(qualifiedName, INITIALIZE_METHOD, ctx);
+  }
+  return classMethodOn(qualifiedName, spelling.method, ctx);
+}
+function classMethodOn(qualifiedName, method, ctx) {
+  const written = singletonMethodOn(qualifiedName, method, ctx);
+  if (written.kind === "followed") {
+    return written;
   }
-  const written = singletonMethodOn(qualifiedName, spelling.method, ctx);
-  return written.kind === "followed" ? written : scopeOn(qualifiedName, spelling.method, ctx) ?? written;
+  const inherited = scopeOn(qualifiedName, method, ctx);
+  return inherited === null ? written : followed(runningOn(qualifiedName, inherited, ctx));
 }
 function scopeOn(qualifiedName, method, ctx) {
   const spelled = classMemberName3(method);
@@ -11181,7 +11519,7 @@ function scopeOn(qualifiedName, method, ctx) {
     for (const row of ctx.facts.lookup("holdsProperty", 0, classKey)) {
       const target = row[1] === spelled ? ctx.definitions.get(String(row[2])) : void 0;
       if (target !== void 0) {
-        return followed(target);
+        return target;
       }
     }
   }
@@ -11205,7 +11543,8 @@ function leavesRoomForATopLevelMethod(reason) {
   return reason === "noDeclaration" || reason === "outsideRun";
 }
 function resolveImplicitSelf(methodName, site, ctx) {
-  const onClass = site.enclosingQualifiedName === null ? null : methodOnSelf(site, site.enclosingQualifiedName, methodName, ctx);
+  const selfClass = selfClassOf(site);
+  const onClass = selfClass === null ? null : methodOnSelf(site, selfClass, methodName, ctx);
   if (onClass !== null && (onClass.kind === "followed" || !leavesRoomForATopLevelMethod(onClass.reason))) {
     return onClass;
   }
@@ -11220,7 +11559,7 @@ function resolveImplicitSelf(methodName, site, ctx) {
   return readWholeAncestry && !OBJECT_METHODS.has(methodName) && inModuleInstanceMethod(site, ctx) ? SELF_CALL_IN_MIXIN : UNSETTLED_ON_SELF;
 }
 function inModuleInstanceMethod(site, ctx) {
-  const qualifiedName = site.enclosingQualifiedName;
+  const qualifiedName = selfClassOf(site);
   if (qualifiedName === null || site.method === null || inClassMethod(site, ctx)) {
     return false;
   }
@@ -11228,7 +11567,7 @@ function inModuleInstanceMethod(site, ctx) {
   return own?.type === "bodies" && own.blocks.every((block) => block.info.kind === "module");
 }
 function declaredForTheOtherSelf(site, methodName, ctx) {
-  const qualifiedName = site.enclosingQualifiedName;
+  const qualifiedName = selfClassOf(site);
   if (qualifiedName === null) {
     return false;
   }
@@ -11239,10 +11578,10 @@ function inClassMethod(site, ctx) {
   return site.method !== null && definesClassMethod(site.method, ctx.bodyBlocks);
 }
 function methodOnSelf(site, qualifiedName, methodName, ctx) {
-  if (inClassMethod(site, ctx)) {
-    return singletonMethodOn(qualifiedName, methodName, ctx);
+  if (!inClassMethod(site, ctx)) {
+    return methodOnAncestryOf(qualifiedName, methodName, ctx);
   }
-  return methodOnAncestryOf(qualifiedName, methodName, ctx);
+  return methodName === CONSTRUCTOR ? methodOnAncestryOf(qualifiedName, INITIALIZE_METHOD, ctx) : classMethodOn(qualifiedName, methodName, ctx);
 }
 function resolveTopLevelName(methodName, ctx) {
   const candidates = ctx.topLevelMethods.get(methodName);
@@ -11265,14 +11604,37 @@ function methodOnAncestryOf(qualifiedName, methodName, ctx) {
     dynamicNames: ctx.dynamicNames
   });
   if (found.type === "found") {
-    return followed(reachedMethod(found.method, found.block, methodName));
+    return followed(
+      runningOn(
+        qualifiedName,
+        reachedMethod(found.method, found.block, methodName),
+        ctx
+      )
+    );
   }
   if (found.type === "unsettled") {
-    return stop(unsettledReason(found));
+    return stop(unsettledReason2(found));
   }
   return NO_DECLARATION;
 }
-function unsettledReason(found) {
+function runningOn(qualifiedName, target, ctx) {
+  if (target.enclosingQualifiedName === qualifiedName) {
+    return target;
+  }
+  const own = (ctx.ancestries.get(qualifiedName) ?? []).find(
+    (entry) => entry.type === "bodies" && entry.name === qualifiedName
+  );
+  const file = own?.type === "bodies" ? own.blocks[0]?.file : void 0;
+  if (file === void 0) {
+    return target;
+  }
+  return {
+    ...target,
+    exportPath: [qualifiedName, target.name],
+    receiverClass: { name: qualifiedName, file }
+  };
+}
+function unsettledReason2(found) {
   if (found.cause === "dynamicDefine") {
     return "definedAtLoadTime";
   }
@@ -11335,11 +11697,12 @@ async function reachedFunctions(seeds, options) {
   const charges = /* @__PURE__ */ new Map();
   const beforeGaps = /* @__PURE__ */ new Map();
   const functionFor = (target) => {
-    const node = replay?.nodeOf(target.key) ?? null;
-    if (node === null) {
+    const node = replay?.nodeOf(plainKeyOf(target.key)) ?? null;
+    const found = node === null ? null : { ...target, node };
+    if (found === null || keyOf(found) !== target.key) {
       throw new ReplayFailed(target.key);
     }
-    return { ...target, node };
+    return found;
   };
   for (const seed of seeds) {
     seedKeys.add(seed.key);
@@ -11399,7 +11762,10 @@ async function reachedFunctions(seeds, options) {
       if (scan.followed.length > 0) {
         followedKeys.add(key);
       }
-      for (const target of scan.followed) {
+      const calledHere = scan.followed.flatMap(
+        (target) => target.receiverClass === void 0 ? [target] : [plainOf(target), target]
+      );
+      for (const target of calledHere) {
         const calleeKey = keyOf(target);
         if (!functionByKey.has(calleeKey)) {
           functionByKey.set(calleeKey, target);
@@ -11420,12 +11786,22 @@ async function reachedFunctions(seeds, options) {
       options.storage
     );
   }
+  const placementsOf = (key) => ({
+    targets: targetsByKey.get(key),
+    argTargets: argTargetsByKey.get(key),
+    possibleTargets: possibleTargetsByKey.get(key)
+  });
+  const onSubclass = keptVariants(
+    [...functionByKey].flatMap(
+      ([key, target]) => target.receiverClass === void 0 ? [] : [variantOf(key, scans, placementsOf)]
+    )
+  );
   const summaries = [];
   const summariesByKey = /* @__PURE__ */ new Map();
   for (const [keyAtom] of db.facts("reachable")) {
     const key = String(keyAtom);
     const target = functionByKey.get(key);
-    if (seedKeys.has(key) || target === void 0) {
+    if (seedKeys.has(key) || target === void 0 || target.receiverClass !== void 0 && !onSubclass.has(key)) {
       continue;
     }
     const kept = replay?.summaryOf(key);
@@ -11440,6 +11816,12 @@ async function reachedFunctions(seeds, options) {
       const raw = libraryUnit(target, options);
       dropPropertyReads(raw, propertyReadsByKey.get(key));
       const summary2 = assembleSummary(raw, { gapHandling });
+      if (target.receiverClass !== void 0) {
+        summary2.receiverClass = subclassAt(
+          target.receiverClass,
+          options.displayPathOf
+        );
+      }
       if (gapHandling !== "silent") {
         summary2.gaps.push(
           ...(stopsByKey.get(key) ?? []).map(unfollowedCallGap)
@@ -11481,6 +11863,16 @@ async function reachedFunctions(seeds, options) {
     beforeGaps
   };
 }
+function variantOf(key, scans, placementsOf) {
+  return {
+    key,
+    differs: !sameDeclarations(
+      placementsOf(key),
+      placementsOf(plainKeyOf(key))
+    ),
+    calls: scans.get(key)?.followed.map((target) => target.key) ?? []
+  };
+}
 var ReplayFailed = class extends Error {
   constructor(key) {
     super(`The cache stored a method at ${key}, and nothing is there now.`);
@@ -11571,7 +11963,8 @@ function storedScan(scan) {
       file: target.file,
       name: target.name,
       exportPath: target.exportPath,
-      enclosingQualifiedName: target.enclosingQualifiedName
+      enclosingQualifiedName: target.enclosingQualifiedName,
+      ...target.receiverClass === void 0 ? {} : { receiverClass: target.receiverClass }
     })),
     stops: scan.stops,
     targets: [...scan.targets],
@@ -11608,7 +12001,25 @@ function scanFromStored(stored, functionFor) {
   };
 }
 function keyOf(target) {
-  return nodeId(target.file, target.node);
+  const key = nodeId(target.file, target.node);
+  return target.receiverClass === void 0 ? key : variantKey(key, target.receiverClass);
+}
+function plainOf(target) {
+  const { receiverClass: _, ...plain } = target;
+  return plain.enclosingQualifiedName === null ? plain : { ...plain, exportPath: [plain.enclosingQualifiedName, plain.name] };
+}
+function placeOf(target, displayPathOf) {
+  const place = {
+    file: displayPathOf(target.file),
+    span: spanOf(target.node)
+  };
+  return target.receiverClass === void 0 ? place : {
+    ...place,
+    receiverClass: subclassAt(target.receiverClass, displayPathOf)
+  };
+}
+function subclassAt(subclass, displayPathOf) {
+  return { name: subclass.name, file: displayPathOf(subclass.file) };
 }
 function dropPropertyReads(raw, callees) {
   if (callees === void 0) {
@@ -11681,8 +12092,9 @@ function siteOf2(source) {
   return {
     file: source.file,
     method: localsOwnerOf(source.node),
-    owner: keyOf(source),
-    enclosingQualifiedName: source.enclosingQualifiedName
+    owner: nodeId(source.file, source.node),
+    enclosingQualifiedName: source.enclosingQualifiedName,
+    receiverClass: source.receiverClass
   };
 }
 function localsOwnerOf(node) {
@@ -11725,17 +12137,21 @@ function scanBody(source, ctx, options, read) {
   const seen = /* @__PURE__ */ new Set();
   const parameterCallsSeen = /* @__PURE__ */ new Set();
   const keptArgless = /* @__PURE__ */ new Set();
-  const recordPassedArgs = (call, callee, calleeKey) => {
+  const recordPassedArgs = (call, callee, target) => {
     const args = field(call, "arguments");
     if (args === null) {
       return;
     }
+    const calleeKeys = target === null ? [] : [keyOf(target), keyOf(plainOf(target))];
+    const passes = (position) => {
+      for (const calleeKey of calleeKeys) {
+        passedPositions.add(`${calleeKey}#${position}`);
+      }
+    };
     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}`);
-        }
+        passes(position);
         continue;
       }
       const symbol = methodReferenceSymbol(argNodes[position]);
@@ -11751,13 +12167,8 @@ function scanBody(source, ctx, options, read) {
         seen.add(key);
         followed2.push(resolved);
       }
-      placements.placeArg(callee, position, {
-        file: displayPathOf(resolved.file),
-        span: spanOf(resolved.node)
-      });
-      if (calleeKey !== null) {
-        passedPositions.add(`${calleeKey}#${position}`);
-      }
+      placements.placeArg(callee, position, placeOf(resolved, displayPathOf));
+      passes(position);
     }
   };
   const followCallback = (name, key) => {
@@ -11793,10 +12204,7 @@ function scanBody(source, ctx, options, read) {
       dispatched.targets.forEach(follow);
       placements.placePossible(
         callee,
-        dispatched.targets.map((target) => ({
-          file: displayPathOf(target.file),
-          span: spanOf(target.node)
-        }))
+        dispatched.targets.map((target) => placeOf(target, displayPathOf))
       );
       if (dispatched.unresolved > 0) {
         stops.add({ callee, reason: "unsettledValue" });
@@ -11828,7 +12236,7 @@ function scanBody(source, ctx, options, read) {
     recordPassedArgs(
       call,
       callee,
-      outcome.kind === "followed" ? keyOf(outcome.target) : null
+      outcome.kind === "followed" ? outcome.target : null
     );
     if (outcome.kind === "stopped") {
       const claimed = options.storage !== void 0 && storageClaims(call, callSite.file, options.storage, callSite.method);
@@ -11869,10 +12277,7 @@ function scanBody(source, ctx, options, read) {
 function placeCallee(placements, outcome, call, where) {
   const callee = calleeText(call);
   if (outcome.kind === "followed") {
-    placements.place(callee, {
-      file: where.displayPathOf(outcome.target.file),
-      span: spanOf(outcome.target.node)
-    });
+    placements.place(callee, placeOf(outcome.target, where.displayPathOf));
     return;
   }
   if (outcome.matchByName === true) {
@@ -11926,7 +12331,7 @@ function libraryUnit(target, options, binding = functionCallBinding({
         emitEvent: null,
         location: range
       },
-      effects,
+      effects: [],
       location: range,
       isDefault: true
     }
@@ -11946,7 +12351,10 @@ function libraryUnit(target, options, binding = functionCallBinding({
     parameters,
     branches: withSlotSources(
       branches.map(
-        (branch) => body.extraEffects === void 0 ? branch : { ...branch, extraEffects: body.extraEffects }
+        (branch) => withEffectsThatRun(branch, {
+          effects,
+          extraEffects: body.extraEffects
+        })
       ),
       body.provenance
     ),
@@ -11981,7 +12389,204 @@ function parameterName(param) {
   return named2 !== null && named2.type === "identifier" ? named2.text : null;
 }
 
+// src/entryPoints.ts
+function declaredEntryUnits(root, file, options) {
+  const units = [];
+  for (const pack of options.packs) {
+    for (const entry of pack.entryPoints?.(file) ?? []) {
+      const method = entryMethod(root, entry.name, options);
+      if (method === null) {
+        continue;
+      }
+      for (const declared of entry.units) {
+        const raw = libraryUnit(
+          {
+            file,
+            node: method.node,
+            name: declared.name,
+            exportPath: method.exportPath
+          },
+          options,
+          declared.binding
+        );
+        const unit = {
+          ...raw,
+          identity: { ...raw.identity, kind: declared.kind },
+          deployableUnit: declared.deployableUnit,
+          ...declared.metadata !== void 0 ? { packMetadata: declared.metadata } : {}
+        };
+        units.push(unit);
+        options.onReachSeed(unit, {
+          file,
+          node: method.node,
+          enclosingQualifiedName: method.enclosingQualifiedName
+        });
+      }
+    }
+  }
+  return units;
+}
+function entryMethod(root, name, options) {
+  const dot = name.lastIndexOf(".");
+  if (dot === -1) {
+    const node = instanceMethodsByName(root, options.bodyBlocks).get(name);
+    return node === void 0 ? null : { node, exportPath: [name], enclosingQualifiedName: null };
+  }
+  const className = name.slice(0, dot);
+  const methodName = name.slice(dot + 1);
+  let found = null;
+  walkDefinitions(root, (info) => {
+    if (found !== null || info.qualifiedName !== className) {
+      return;
+    }
+    const node = info.bodyNode === null ? void 0 : singletonMethodsByName(info.bodyNode, options.bodyBlocks).get(
+      methodName
+    );
+    if (node !== void 0) {
+      found = {
+        node,
+        exportPath: [className, methodName],
+        enclosingQualifiedName: className
+      };
+    }
+  });
+  return found;
+}
+
+// src/erbTemplate.ts
+var OPEN = "<%";
+var CLOSE = "%>";
+var LITERAL_OPEN = "<%%";
+var COMMENT_MARK = "#";
+var OUTPUT_MARK = "=";
+var TRIM_OPEN_MARK = "-";
+var TRIM_CLOSE_MARK = "-";
+var CODE_CLOSE = "; ";
+var OUTPUT_CLOSE = "];";
+var OUTPUT_OPEN = "[";
+function rubyInErbTemplate(template) {
+  const parts = [];
+  let at = 0;
+  while (at < template.length) {
+    const open = template.indexOf(OPEN, at);
+    if (open === -1) {
+      parts.push(blanked(template.slice(at)));
+      break;
+    }
+    parts.push(blanked(template.slice(at, open)));
+    if (template.startsWith(LITERAL_OPEN, open)) {
+      parts.push(blanked(LITERAL_OPEN));
+      at = open + LITERAL_OPEN.length;
+      continue;
+    }
+    const close = template.indexOf(CLOSE, open + OPEN.length);
+    if (close === -1) {
+      parts.push(blanked(template.slice(open)));
+      break;
+    }
+    parts.push(tagAsRuby(template.slice(open, close + CLOSE.length)));
+    at = close + CLOSE.length;
+  }
+  return parts.join("");
+}
+function tagAsRuby(tag) {
+  const mark = tag.charAt(OPEN.length);
+  if (mark === COMMENT_MARK) {
+    return blanked(tag);
+  }
+  const prints = mark === OUTPUT_MARK;
+  const codeStart = OPEN.length + (prints || mark === TRIM_OPEN_MARK ? mark.length : 0);
+  const beforeClose = tag.length - CLOSE.length;
+  const codeEnd = beforeClose > codeStart && tag.charAt(beforeClose - 1) === TRIM_CLOSE_MARK ? beforeClose - 1 : beforeClose;
+  const opening = blanked(tag.slice(0, codeStart));
+  return [
+    prints ? `${OUTPUT_OPEN}${opening.slice(OUTPUT_OPEN.length)}` : opening,
+    tag.slice(codeStart, codeEnd),
+    blanked(tag.slice(codeEnd, beforeClose)),
+    prints ? OUTPUT_CLOSE : CODE_CLOSE
+  ].join("");
+}
+function blanked(text3) {
+  return text3.replace(/[^\r\n]/g, " ");
+}
+
+// src/facts/callbacks.ts
+function callbacksIn(patterns) {
+  return patterns.flatMap(
+    (pattern) => pattern.callbacks === void 0 ? [] : [pattern.callbacks]
+  );
+}
+function emitClassCallbacks(db, file, classNode, declared) {
+  const body = field(classNode, "body");
+  if (body === null || declared.length === 0) {
+    return;
+  }
+  const classKey = nodeId(file, classNode);
+  for (const statement of runStatements(body)) {
+    if (statement.type !== "call" || field(statement, "receiver") !== null) {
+      continue;
+    }
+    const called = field(statement, "method")?.text ?? "";
+    const args = readCallArgs(field(statement, "arguments"));
+    for (const callbacks of declared) {
+      const events = eventsOf(args, called, callbacks, db);
+      for (const event of events) {
+        for (const method of symbolArgumentNames(args, db)) {
+          db.add("classCallback", [classKey, event, method]);
+        }
+      }
+    }
+  }
+}
+function eventsOf(args, called, callbacks, db) {
+  const covered = callbacks.registeredBy[called];
+  if (covered === void 0) {
+    return [];
+  }
+  const written = args.keyword[callbacks.eventKeyword];
+  const narrowed = written === void 0 ? null : stringValueOf(written, db);
+  if (narrowed === null) {
+    return covered;
+  }
+  return covered.filter((event) => event === narrowed);
+}
+
+// src/facts.ts
+import path3 from "path";
+import { SKIP_CHILDREN as SKIP_CHILDREN7, walkDescendants as walkDescendants7 } from "@suss/extractor";
+function emitRequireFacts(db, filePath, root, known) {
+  walkDescendants7(root, null, children, {
+    at: (node) => {
+      const target = requiredRelativePath(node);
+      if (target === null) {
+        return;
+      }
+      const resolved = path3.resolve(
+        path3.dirname(filePath),
+        target.endsWith(".rb") ? target : `${target}.rb`
+      );
+      if (known.has(resolved)) {
+        db.add("importsFile", [filePath, resolved]);
+      }
+    },
+    into: (node) => node.type === "argument_list" ? SKIP_CHILDREN7 : null
+  });
+}
+function requiredRelativePath(node) {
+  if (node.type !== "call" || field(node, "receiver") !== null || field(node, "method")?.text !== "require_relative") {
+    return null;
+  }
+  const { positional } = readCallArgs(field(node, "arguments"));
+  return positional[0] === void 0 ? null : stringLiteralValue(positional[0]);
+}
+
 // src/moduleSurface.ts
+import { moduleExportBinding } from "@suss/behavioral-ir";
+import {
+  MODULE_SURFACE_RECOGNITION,
+  moduleOfFile,
+  settleModules
+} from "@suss/extractor";
 function settleRubyModules(modules) {
   return settleModules(modules, ["{name}.rb", "../{name}.rb"]);
 }
@@ -12584,12 +13189,12 @@ var SharedGroupIndex = class {
 };
 function emitSharedGroupBinds(db, index, files) {
   for (const at of files) {
-    for (const site of sitesIn(index, at)) {
+    for (const site of sitesIn2(index, at)) {
       emitSiteBinds(db, index, site, at.pattern);
     }
   }
 }
-function sitesIn(index, at) {
+function sitesIn2(index, at) {
   const found = [];
   const visit = (node) => {
     for (const child of children(node)) {
@@ -12830,7 +13435,25 @@ function replaysCleanly(units, discovered) {
   }
   return true;
 }
+function walkedFilesOf(options) {
+  const given = new Set(options.files);
+  const templates = [
+    ...new Set(options.packs.flatMap((pack) => pack.bootTemplates?.() ?? []))
+  ].filter((file) => !given.has(file)).sort();
+  return {
+    files: [...options.files, ...templates],
+    templates: new Set(templates)
+  };
+}
+function rubySourceOf(absPath, templates) {
+  if (!fs3.existsSync(absPath)) {
+    return null;
+  }
+  const text3 = fs3.readFileSync(absPath, "utf8");
+  return templates.has(absPath) ? rubyInErbTemplate(text3) : text3;
+}
 async function extractRubyProject(options) {
+  const walked = walkedFilesOf(options);
   const timer = options.onTiming !== void 0 ? createTimer() : noopTimer();
   const cacheDir = adapterStamp.declineWhenRunFromSource(
     options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? extractionCacheDirFor(options.projectRoot) : null)
@@ -12847,8 +13470,8 @@ async function extractRubyProject(options) {
     modules: settleRubyModules(options.modules)
   })}`;
   const input = {
-    files: cacheDir === null ? [] : options.files,
-    adapterPacksDigest: cacheDir === null ? packsDigest : runDigest(packsDigest, options.packs, options.files)
+    files: cacheDir === null ? [] : walked.files,
+    adapterPacksDigest: cacheDir === null ? packsDigest : runDigest(packsDigest, options.packs, walked.files)
   };
   const lookup = await timer.timeAsync(
     "cache.lookup",
@@ -12876,7 +13499,7 @@ async function extractRubyProject(options) {
   const records = plan === null ? null : recordsToReplay(plan.roots, plan.changed, plan.removed);
   if (plan !== null && records !== null) {
     try {
-      return await runRuby(options, cache, { plan, records });
+      return await runRuby(options, walked, cache, { plan, records });
     } catch (error) {
       if (!(error instanceof ReplayFailed)) {
         throw error;
@@ -12884,7 +13507,7 @@ async function extractRubyProject(options) {
     }
   }
   options.onCacheDiagnostic?.(lookup.diagnostic);
-  return runRuby(options, cache, null);
+  return runRuby(options, walked, cache, null);
 }
 function seedFromStored(seed, nodeOf) {
   const node = nodeOf(seed.key);
@@ -12901,13 +13524,13 @@ function seedFromStored(seed, nodeOf) {
 function addForSeed(bySeed, seedKey, summary) {
   bySeed.set(seedKey, [...bySeed.get(seedKey) ?? [], summary]);
 }
-async function runRuby(options, cache, previous) {
+async function runRuby(options, walked, cache, previous) {
   const { timer, cacheDir } = cache;
   const db = new Database2();
   const summaries = [];
   const gapHandling = options.gapHandling ?? "permissive";
   const tallies = createPackTallies(options.packs);
-  const ledger = cacheDir === null ? null : new DependencyLedger(options.files);
+  const ledger = cacheDir === null ? null : new DependencyLedger(walked.files);
   const log = ledger === null ? null : new FactLog(db, ledger);
   if (ledger !== null) {
     observeDemand(db, ledger);
@@ -12915,12 +13538,12 @@ async function runRuby(options, cache, previous) {
   const parses = options.keptParses ?? keptRubyParses();
   const trees = createFileCache(
     (source, absPath) => parses.parse(absPath, source, parseRubyRoot),
-    (absPath) => fs3.existsSync(absPath) ? fs3.readFileSync(absPath, "utf8") : null
+    (absPath) => rubySourceOf(absPath, walked.templates)
   );
   const fileCache = ledger === null ? trees : watchFileCache(trees, ledger);
   const facts = new RunFacts(db, options.packs);
   const { parsed, bodyBlocks, scopeCalls } = facts;
-  for (const file of options.files) {
+  for (const file of walked.files) {
     await timer.timeAsync("parse", async () => {
       const root = await trees.get(file);
       if (root !== null) {
@@ -12930,7 +13553,7 @@ async function runRuby(options, cache, previous) {
       }
     });
   }
-  options.keptParses?.keepOnly(options.files);
+  options.keptParses?.keepOnly(walked.files);
   const rootsByFile = new Map(parsed.map(({ file, root }) => [file, root]));
   const dynamicNames = timer.time("discover", () => {
     log?.startJoined();
@@ -13056,6 +13679,16 @@ async function runRuby(options, cache, previous) {
         displayPathOf,
         facts: db,
         onReachSeed
+      }),
+      ...declaredEntryUnits(root, file, {
+        packs: options.packs,
+        ...storage === void 0 ? {} : { storage },
+        inheritedMethods,
+        bodyBlocks,
+        dynamicNames: watchedNames,
+        displayPathOf,
+        facts: db,
+        onReachSeed
       })
     ];
     const rawUnits = await timer.timeAsync(
@@ -13104,7 +13737,7 @@ async function runRuby(options, cache, previous) {
     seedKeys.add(moduleKey);
     seeds.push(moduleSeed);
     const readLoadTime = () => ({
-      reads: envReadEffects(root, { db, file }),
+      reads: envReadEffects(root, { db, file }).map((one) => one.effect),
       calls: moduleScopeInvocationEffects(
         root,
         inheritedMethods,
@@ -13336,7 +13969,7 @@ async function runRuby(options, cache, previous) {
     buildRubyExtractionReport({
       packs: options.packs,
       tallies,
-      filesWalked: options.files.length,
+      filesWalked: walked.files.length,
       summaries: composed
     })
   );
@@ -13562,7 +14195,7 @@ var RubyWhySession = class {
 // src/stubEvidence.ts
 import fs5 from "fs";
 import path6 from "path";
-import { SKIP_CHILDREN as SKIP_CHILDREN7, walkDescendants as walkDescendants7 } from "@suss/extractor";
+import { SKIP_CHILDREN as SKIP_CHILDREN8, walkDescendants as walkDescendants8 } from "@suss/extractor";
 function bareLetters(name) {
   return name.replaceAll(/[-_]/g, "").toLowerCase();
 }
@@ -13586,14 +14219,14 @@ function requireTarget(node) {
 }
 function requireSitesIn(root, file) {
   const found = [];
-  walkDescendants7(root, null, children, {
+  walkDescendants8(root, null, children, {
     at: (node) => {
       const target = requireTarget(node);
       if (target !== null) {
         found.push({ target, file, line: rangeOf(node).start });
       }
     },
-    into: (node) => node.type === "argument_list" ? SKIP_CHILDREN7 : null
+    into: (node) => node.type === "argument_list" ? SKIP_CHILDREN8 : null
   });
   return found;
 }