@suss/adapter-ruby 0.35.1 → 0.36.0

package/dist/index.cjs

@@ -785,6 +785,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
 var import_resolution2 = require("@suss/resolution");
@@ -812,6 +814,26 @@ var RUBY_RULES = (0, import_resolution.alsoSteps)([
       (0, import_datalog.lit)("readsProperty", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("o"), (0, import_datalog.constant)(CONSTRUCTOR)),
       (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("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.
+  (0, import_datalog.rule)(
+    "selfBehind",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("s"), import_resolution.SELF_AS_INSTANCE],
+    [
+      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
+      (0, import_datalog.lit)("readsProperty", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("o"), (0, import_datalog.constant)(CONSTRUCTOR)),
+      (0, import_datalog.lit)("selfBehind", (0, import_datalog.variable)("o"), (0, import_datalog.variable)("s"), import_resolution.SELF_AS_CLASS)
+    ]
+  ),
+  (0, import_datalog.rule)(
+    "selfBehind",
+    [(0, import_datalog.variable)("r"), (0, import_datalog.variable)("s"), import_resolution.SELF_AS_CLASS],
+    [
+      (0, import_datalog.lit)("call", (0, import_datalog.variable)("r"), (0, import_datalog.variable)("c")),
+      (0, import_datalog.lit)("readsProperty", (0, import_datalog.variable)("c"), (0, import_datalog.variable)("o"), (0, import_datalog.constant)(CLASS_OF_INSTANCE)),
+      (0, import_datalog.lit)("selfBehind", (0, import_datalog.variable)("o"), (0, import_datalog.variable)("s"), import_resolution.SELF_AS_INSTANCE)
+    ]
   )
 ]);
 var RUBY_PROGRAM = (0, import_resolution.resolutionProgram)(RUBY_RULES);
@@ -2541,9 +2563,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) {
@@ -2563,11 +2584,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 ? import_resolution4.SELF_AS_INSTANCE_NAME : import_resolution4.SELF_AS_CLASS_NAME
+  );
   const funcKey = emitMethodFacts(
     {
       ...within,
@@ -4250,7 +4280,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;
   }
@@ -4330,9 +4363,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 = [];
@@ -4473,7 +4513,69 @@ function inheritedStatements(ancestry, blockConfigures) {
 
 // src/discovery.ts
 var import_behavioral_ir6 = require("@suss/behavioral-ir");
-var import_extractor11 = require("@suss/extractor");
+var import_extractor12 = require("@suss/extractor");
+
+// src/baseClass.ts
+var import_resolution7 = require("@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) {
+  (0, import_resolution7.askResolution)(facts, [key], "wanted", RUBY_PROGRAM);
+  const objects = (0, import_resolution7.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 = (0, import_resolution7.spanOfKey)(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) {
+  (0, import_resolution7.askResolution)(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
 var import_behavioral_ir2 = require("@suss/behavioral-ir");
@@ -4481,7 +4583,7 @@ var import_values14 = require("@suss/values");
 
 // src/paths/effects.ts
 var import_extractor2 = require("@suss/extractor");
-var import_values7 = require("@suss/values");
+var import_values8 = require("@suss/values");
 
 // src/paths/lowering.ts
 var RAISE_NAMES = /* @__PURE__ */ new Set(["raise", "fail"]);
@@ -4692,6 +4794,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),
@@ -4783,7 +4886,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]
       );
@@ -4799,7 +4903,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]
       );
@@ -4843,12 +4948,15 @@ 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 = (0, import_values7.literalOf)(value);
+  const text3 = (0, import_values8.literalOf)(value);
   if (text3 !== null) {
     return { kind: "string", value: text3 };
   }
-  const constant2 = (0, import_values7.constantOf)(value);
+  const constant2 = (0, import_values8.constantOf)(value);
   if (typeof constant2 === "number") {
     return { kind: "number", value: constant2 };
   }
@@ -4980,13 +5088,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,
@@ -5011,36 +5127,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 = (0, import_extractor2.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 = (0, import_extractor2.sharedGatingConditions)(
-      statement === void 0 ? void 0 : enumerated.byTerminal.get(statement)
-    );
+    const conditions = (0, import_extractor2.sharedGatingConditions)(sites.pathsTo(call));
     return {
       call,
       effect: {
@@ -5048,11 +5141,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 (0, import_extractor2.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 = {
@@ -5439,15 +5547,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) => (0, import_extractor3.splitAtHandOffs)(branch, handOffs));
@@ -5519,30 +5622,6 @@ var import_values11 = require("@suss/values");
 var import_ir_core2 = require("@suss/ir-core");
 var import_resolution8 = require("@suss/resolution");
 
-// src/baseClass.ts
-var import_resolution7 = require("@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) {
-  (0, import_resolution7.askResolution)(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/loaders.ts
 function receiverOf(node) {
   return node.type === "call" ? field(node, "receiver") : null;
@@ -5686,7 +5765,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) {
@@ -5997,20 +6077,10 @@ function storageEffect(call, container, pattern, kind, selector, fields) {
       fields,
       operation,
       ...selector.length > 0 ? { selector } : {}
-    }
+    },
+    location: rangeOf(call)
   };
 }
-function classSettledOn(facts, key) {
-  (0, import_resolution8.askResolution)(facts, [key], "wanted", RUBY_PROGRAM);
-  const objects = (0, import_resolution8.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, (0, import_resolution8.classMemberName)(method)]);
   return facts.lookup("wantedDeclaredName", 0, classKey).some((row) => spellings.has(String(row[1])));
@@ -6067,12 +6137,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) {
@@ -6111,7 +6182,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 [];
 }
@@ -6249,11 +6320,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
@@ -6642,13 +6714,13 @@ function readingOfCall(call, declaration, names, options) {
   }
   return (0, import_extractor6.writtenReading)(status, rangeOf(argument));
 }
-function effectsReaching(effects, conditions) {
-  return effects.filter(
-    (effect) => (0, import_extractor6.guardsHoldOn)(
-      effect.type === "invocation" ? effect.preconditions : void 0,
-      conditions
-    )
-  );
+function withEffectsThatRun(branch, body) {
+  const extra = (0, import_extractor6.effectsFiringOn)(body.extraEffects ?? [], branch);
+  return {
+    ...branch,
+    effects: (0, import_extractor6.effectsFiringOn)(body.effects, branch),
+    ...extra.length === 0 ? {} : { extraEffects: extra }
+  };
 }
 function conditionOf(condition, inputs) {
   return {
@@ -6708,57 +6780,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 returnPathBranches(method, effects, exits = [], facts, keepsArms, raises2 = []) {
+function loopAroundOf(placed) {
+  return placed.loopAround === void 0 ? {} : { loopAround: placed.loopAround };
+}
+function returnPathBranches(method, effects, exits = [], facts, keepsArms, raises2 = [], endingOfReturn = (_statement, location) => returnTerminal(location)) {
   const body = field(method, "body");
   if (body === null) {
     return null;
@@ -6785,30 +6866,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) {
@@ -6868,12 +6961,14 @@ function responseBranches(method, pattern, effects, extraEffects, options = {})
     const responder = responderOf(terminal, responders);
     const reading = responder === void 0 ? import_extractor6.absentReading : readingOfResponder(terminal, responder, statusNames, options);
     const body2 = responder?.kind === "declared" ? bodyReadingOfCall(terminal, responder.declaration, options.facts) : void 0;
+    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 } : {}
@@ -6889,6 +6984,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,
@@ -6896,25 +6992,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
   ];
 }
@@ -7182,7 +7279,7 @@ function callerBranches(method, reading) {
   const keepsArms = (condition) => (0, import_behavioral_ir2.testsStatus)(predicateOf(condition), reading.statusMembers);
   const found = returnPathBranches(
     method,
-    effects,
+    sites,
     [],
     reading.facts,
     keepsArms,
@@ -7641,7 +7738,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") {
@@ -7654,9 +7751,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) {
@@ -7812,16 +7912,17 @@ function readsAtCall(db, call, args) {
   }
   return [...byName].map(([name, defaulted]) => ({ name, defaulted }));
 }
-function configReadEffect(read) {
+function configReadEffect(read, at) {
   return {
     type: "interaction",
     binding: (0, import_behavioral_ir3.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) {
@@ -7829,8 +7930,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);
@@ -8026,25 +8126,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) {
@@ -8181,35 +8283,206 @@ function actionsUnder(node, facts) {
   return found === null ? null : new Set(found);
 }
 
-// src/streamWrites.ts
-var import_behavioral_ir4 = require("@suss/behavioral-ir");
+// src/resolverHooks.ts
 var import_extractor8 = require("@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 = [];
-  (0, import_extractor8.walkDescendants)(root, null, children, {
-    at: (node) => {
-      const write = node.type === "call" ? streamWriteAt(node) : null;
-      if (write !== null) {
-        found.push(write);
-      }
-    },
-    into: (node) => DEFERRED_BODY_TYPES2.has(node.type) ? import_extractor8.SKIP_CHILDREN : null
-  });
+var import_values17 = require("@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;
+  (0, import_extractor8.walkDescendants)(method, null, children, {
+    at: (node) => {
+      found ||= isSuper(node);
+    },
+    into: (node) => node !== method && METHOD_TYPES.has(node.type) ? import_extractor8.SKIP_CHILDREN : 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 (0, import_extractor8.unreadableReading)(
+    `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 = (0, import_values17.constantOf)(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
+var import_behavioral_ir4 = require("@suss/behavioral-ir");
+var import_extractor9 = require("@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 (0, import_extractor9.numberRepeatedCallSites)(
+    writesUnder2(root).map((write) => [write])
+  ).flat();
+}
+function writesUnder2(root) {
+  const found = [];
+  (0, import_extractor9.walkDescendants)(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) ? import_extractor9.SKIP_CHILDREN : null
+  });
   return found;
 }
 function streamWrittenBy(call) {
@@ -8237,13 +8510,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: (0, import_behavioral_ir4.ioBinding)({ recognition: RUBY_STREAM_RECOGNITION, target }),
     callee: receiver === null ? method : `${receiver.text}.${method}`,
-    groupId: `${call.startPosition.row + 1}:${call.startPosition.column + 1}`,
-    interaction: { class: "stream-write", ...payloadOf(args) }
+    interaction: { class: "stream-write", ...payloadOf(args) },
+    location: rangeOf(call)
   };
+  return { ...effect, groupId: (0, import_extractor9.callSiteKey)(effect) };
 }
 function payloadOf(args) {
   const only = args[0];
@@ -8321,9 +8595,9 @@ function keyName(key) {
 
 // src/testCases.ts
 var import_behavioral_ir5 = require("@suss/behavioral-ir");
-var import_extractor9 = require("@suss/extractor");
+var import_extractor10 = require("@suss/extractor");
 var import_resolution10 = require("@suss/resolution");
-var import_values17 = require("@suss/values");
+var import_values18 = require("@suss/values");
 var BLOCK_TYPES6 = /* @__PURE__ */ new Set(["block", "do_block"]);
 function testPatternsIn(packs) {
   return packs.flatMap((pack) => pack.tests ?? []);
@@ -8507,7 +8781,7 @@ function groupStatements(group) {
 }
 function patternForFile(file, patterns) {
   return patterns.find(
-    (pattern) => (0, import_extractor9.matchesTestFileName)(file, pattern.filePatterns) && (0, import_extractor9.isListedTestFile)(file, pattern.files)
+    (pattern) => (0, import_extractor10.matchesTestFileName)(file, pattern.filePatterns) && (0, import_extractor10.isListedTestFile)(file, pattern.files)
   ) ?? null;
 }
 function groupNamesIn(pattern) {
@@ -8799,7 +9073,7 @@ function exampleCalls(run, inherited) {
 }
 function testCaseUnits(root, patterns, options) {
   return patterns.flatMap((pattern) => {
-    if (!(0, import_extractor9.matchesTestFileName)(options.absoluteFile, pattern.filePatterns) || !(0, import_extractor9.isListedTestFile)(options.absoluteFile, pattern.files)) {
+    if (!(0, import_extractor10.matchesTestFileName)(options.absoluteFile, pattern.filePatterns) || !(0, import_extractor10.isListedTestFile)(options.absoluteFile, pattern.files)) {
       return [];
     }
     return examplesIn(root, options.absoluteFile, pattern, options.shared).map(
@@ -8918,7 +9192,7 @@ function titleOf(call, facts) {
   if (first.type === "constant" || first.type === "scope_resolution") {
     return { text: first.text, unresolved: false };
   }
-  const read = (0, import_values17.literalOf)(evaluatedValue(first, facts));
+  const read = (0, import_values18.literalOf)(evaluatedValue(first, facts));
   return read === null ? { text: first.text, unresolved: true } : { text: read, unresolved: false };
 }
 function isSkipped(example, pattern) {
@@ -9059,7 +9333,7 @@ function moduleOfConstant(node, options) {
     const key = classBehind(facts, options.absoluteFile, node);
     return key === void 0 ? null : options.displayPathOf((0, import_resolution10.fileOfKey)(key));
   }
-  const name = (0, import_values17.literalOf)(evaluatedValue(node, facts));
+  const name = (0, import_values18.literalOf)(evaluatedValue(node, facts));
   const keys = name === null ? [] : facts.lookup("rbConstantName", 1, name.replace(/^::/, "")).map((row) => String(row[0]));
   const files = [...new Set(keys.map(import_resolution10.fileOfKey))];
   return files.length === 1 ? options.displayPathOf(files[0]) : null;
@@ -9069,8 +9343,8 @@ function oneLine(text3) {
 }
 
 // src/testClasses.ts
-var import_extractor10 = require("@suss/extractor");
-var import_values19 = require("@suss/values");
+var import_extractor11 = require("@suss/extractor");
+var import_values20 = require("@suss/values");
 var BLOCK_TYPES7 = /* @__PURE__ */ new Set(["block", "do_block"]);
 function testClassPatternsIn(packs) {
   return packs.flatMap((pack) => pack.testClasses ?? []);
@@ -9113,7 +9387,7 @@ function testClassUnits(root, patterns, options) {
   });
 }
 function readsFile(file, pattern) {
-  return (0, import_extractor10.matchesTestFileName)(file, pattern.filePatterns) && (0, import_extractor10.isListedTestFile)(file, pattern.files);
+  return (0, import_extractor11.matchesTestFileName)(file, pattern.filePatterns) && (0, import_extractor11.isListedTestFile)(file, pattern.files);
 }
 function testClassesIn(root, file, pattern, facts) {
   const found = [];
@@ -9159,7 +9433,7 @@ function testBlockOf(statement, pattern) {
 }
 function descriptionOf(call, facts) {
   const first = firstArgument(call);
-  return first === null ? null : (0, import_values19.literalOf)(evaluatedValue(first, facts));
+  return first === null ? null : (0, import_values20.literalOf)(evaluatedValue(first, facts));
 }
 function anchorOf2(node) {
   return BLOCK_TYPES7.has(node.type) ? node.parent ?? node : node;
@@ -9323,16 +9597,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,
@@ -9341,8 +9618,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) }
     }
   };
 }
@@ -9451,13 +9729,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 [];
@@ -9478,13 +9750,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)) {
@@ -9561,7 +9867,7 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
         raised: raisedStatusBranches(
           pattern,
           options.storage?.patterns ?? [],
-          body.extraEffects,
+          everyEffect(body.extraEffects),
           "eachRoute",
           rangeOf(filter.method)
         )
@@ -9594,10 +9900,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,
@@ -9763,11 +10066,11 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
             location: range
           },
           statusCodeReading: {
-            reading: import_extractor11.absentReading,
+            reading: import_extractor12.absentReading,
             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
         }
@@ -9777,7 +10080,7 @@ function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actio
       raisedStatusBranches(
         pattern,
         bodyRead.storage?.patterns ?? [],
-        body.extraEffects,
+        everyEffect(body.extraEffects),
         raises2.handlers,
         range
       )
@@ -9822,7 +10125,7 @@ function routingGapUnit(pattern, gaps) {
         isDefault: true
       }
     ],
-    readings: gaps.map((gap) => (0, import_extractor11.unreadableReading)(gap, range)),
+    readings: gaps.map((gap) => (0, import_extractor12.unreadableReading)(gap, range)),
     dependencyCalls: [],
     declaredContract: null
   };
@@ -9856,15 +10159,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,
@@ -9873,7 +10179,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 }
@@ -9881,6 +10187,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",
@@ -9895,7 +10206,7 @@ var NO_METHOD_BEHIND_IT = {
   readings: []
 };
 function methodNotSettled(reason, range) {
-  return { readings: [(0, import_extractor11.unreadableReading)(reason, range)] };
+  return { readings: [(0, import_extractor12.unreadableReading)(reason, range)] };
 }
 function bodyFromLookup(found, range, subject, nothingThere, bodyRead) {
   const table = {
@@ -9944,7 +10255,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) {
@@ -9954,9 +10266,10 @@ function computedNameDeclaration(stmt, nameArg) {
     namedOnTheWire: false,
     node: stmt,
     contract: null,
+    hooks: [],
     body: {
       readings: [
-        (0, import_extractor11.unreadableReading)(
+        (0, import_extractor12.unreadableReading)(
           `This field is named by ${nameArg.text}, which is worked out when the class body runs, so the name the schema exposes it under was not read here`,
           range
         )
@@ -9980,14 +10293,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];
@@ -10003,21 +10340,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
       )
     };
@@ -10028,20 +10356,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) {
@@ -10159,7 +10511,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,
@@ -10199,7 +10555,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 } : {}
   };
 }
 
@@ -10605,13 +10962,13 @@ var import_node_fs3 = __toESM(require("fs"), 1);
 var import_node_path4 = __toESM(require("path"), 1);
 var import_behavioral_ir9 = require("@suss/behavioral-ir");
 var import_datalog3 = require("@suss/datalog");
-var import_extractor19 = require("@suss/extractor");
+var import_extractor20 = require("@suss/extractor");
 var import_resolution16 = require("@suss/resolution");
 
 // src/diagnostics.ts
-var import_extractor12 = require("@suss/extractor");
+var import_extractor13 = require("@suss/extractor");
 function buildRubyExtractionReport(args) {
-  return (0, import_extractor12.buildUngatedExtractionReport)({
+  return (0, import_extractor13.buildUngatedExtractionReport)({
     packs: args.packs.map((pack) => ({
       name: pack.name,
       version: pack.version ?? null,
@@ -10623,10 +10980,16 @@ function buildRubyExtractionReport(args) {
   });
 }
 
+// src/reach/closure.ts
+var import_behavioral_ir7 = require("@suss/behavioral-ir");
+var import_datalog2 = require("@suss/datalog");
+var import_extractor16 = require("@suss/extractor");
+var import_resolution13 = require("@suss/resolution");
+
 // src/exits.ts
-var import_extractor13 = require("@suss/extractor");
+var import_extractor14 = require("@suss/extractor");
 var import_resolution11 = require("@suss/resolution");
-var import_values22 = require("@suss/values");
+var import_values24 = require("@suss/values");
 var EXIT_METHODS = /* @__PURE__ */ new Map([
   ["exit", 0],
   ["exit!", 1],
@@ -10635,14 +10998,14 @@ var EXIT_METHODS = /* @__PURE__ */ new Map([
 var DEFERRED_BODY_TYPES3 = /* @__PURE__ */ new Set(["method", "singleton_method", "lambda"]);
 function exitSites(root) {
   const found = [];
-  (0, import_extractor13.walkDescendants)(root, null, children, {
+  (0, import_extractor14.walkDescendants)(root, null, children, {
     at: (node) => {
       const site = node.type === "call" ? exitSiteAt(node) : null;
       if (site !== null) {
         found.push(site);
       }
     },
-    into: (node) => DEFERRED_BODY_TYPES3.has(node.type) ? import_extractor13.SKIP_CHILDREN : null
+    into: (node) => DEFERRED_BODY_TYPES3.has(node.type) ? import_extractor14.SKIP_CHILDREN : null
   });
   return found;
 }
@@ -10679,7 +11042,7 @@ function exitCodeOf(site, facts) {
   if (written !== void 0) {
     return { type: "literal", value: written };
   }
-  const value = (0, import_values22.constantOf)(evaluatedValue(code, facts));
+  const value = (0, import_values24.constantOf)(evaluatedValue(code, facts));
   return typeof value === "number" ? { type: "literal", value } : { type: "dynamic", sourceText: code.text };
 }
 function exitingBranches(method, effects, facts) {
@@ -10700,93 +11063,13 @@ function markExitCodeFunctions(summaries, exits, facts, workspaceRoot) {
       (site) => site.code === null ? [] : [nodeId(file, site.code)]
     )
   );
-  (0, import_extractor13.markReturnsAsExitCode)(
+  (0, import_extractor14.markReturnsAsExitCode)(
     summaries,
     (0, import_resolution11.exitCodeFunctions)(facts, sinks),
     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
-var import_node_path3 = __toESM(require("path"), 1);
-var import_extractor14 = require("@suss/extractor");
-function emitRequireFacts(db, filePath, root, known) {
-  (0, import_extractor14.walkDescendants)(root, null, children, {
-    at: (node) => {
-      const target = requiredRelativePath(node);
-      if (target === null) {
-        return;
-      }
-      const resolved = import_node_path3.default.resolve(
-        import_node_path3.default.dirname(filePath),
-        target.endsWith(".rb") ? target : `${target}.rb`
-      );
-      if (known.has(resolved)) {
-        db.add("importsFile", [filePath, resolved]);
-      }
-    },
-    into: (node) => node.type === "argument_list" ? import_extractor14.SKIP_CHILDREN : 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
-var import_behavioral_ir8 = require("@suss/behavioral-ir");
-var import_extractor17 = require("@suss/extractor");
-
-// src/reach/closure.ts
-var import_behavioral_ir7 = require("@suss/behavioral-ir");
-var import_datalog2 = require("@suss/datalog");
-var import_extractor16 = require("@suss/extractor");
-var import_resolution13 = require("@suss/resolution");
-
 // src/flags.ts
 var import_extractor15 = require("@suss/extractor");
 var PARSE_METHODS = /* @__PURE__ */ new Set(["parse", "parse!", "permute", "permute!"]);
@@ -10887,6 +11170,9 @@ function parserCalledOn(receiver, parserNamed) {
 
 // src/reach/resolveCallee.ts
 var import_resolution12 = require("@suss/resolution");
+function selfClassOf(site) {
+  return site.receiverClass?.name ?? site.enclosingQualifiedName;
+}
 var STOP_FOR = {
   severalSources: "multipleSources",
   outsideRun: "outsideRun",
@@ -11083,6 +11369,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 === import_resolution12.SELF_AS_CLASS_NAME },
+      selfClass,
+      ctx
+    );
+  }
+  const returned = (0, import_resolution12.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 === import_resolution12.SELF_AS_CLASS_NAME },
+      sentTo,
+      ctx
+    );
+  }
   const objectKey = objects[0] ?? (outcome.kind === "object" ? outcome.key : void 0);
   if (objectKey !== void 0) {
     return methodOnObject(spelling, objectKey, ctx);
@@ -11092,6 +11396,17 @@ function asCallee(spelling, outcome, site, ctx) {
   }
   return stop(STOP_FOR[outcome.kind] ?? "noDeclaration");
 }
+function ownReceiverForm(key, site, ctx) {
+  return site.method === null ? null : (0, import_resolution12.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 (0, import_resolution12.answersFor)(facts, "wantedObjectOf", key);
 }
@@ -11109,11 +11424,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 = (0, import_resolution12.classMemberName)(method);
@@ -11125,7 +11447,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;
       }
     }
   }
@@ -11149,7 +11471,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;
   }
@@ -11164,7 +11487,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;
   }
@@ -11172,7 +11495,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;
   }
@@ -11183,10 +11506,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);
@@ -11209,14 +11532,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";
   }
@@ -11279,11 +11625,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((0, import_resolution13.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);
@@ -11343,7 +11690,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);
@@ -11364,12 +11714,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 = (0, import_resolution13.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);
@@ -11384,6 +11744,12 @@ async function reachedFunctions(seeds, options) {
       const raw = libraryUnit(target, options);
       dropPropertyReads(raw, propertyReadsByKey.get(key));
       const summary2 = (0, import_extractor16.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(import_behavioral_ir7.unfollowedCallGap)
@@ -11425,6 +11791,16 @@ async function reachedFunctions(seeds, options) {
     beforeGaps
   };
 }
+function variantOf(key, scans, placementsOf) {
+  return {
+    key,
+    differs: !(0, import_behavioral_ir7.sameDeclarations)(
+      placementsOf(key),
+      placementsOf((0, import_resolution13.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.`);
@@ -11515,7 +11891,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],
@@ -11552,7 +11929,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 : (0, import_resolution13.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) {
@@ -11625,8 +12020,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) {
@@ -11669,17 +12065,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]);
@@ -11695,13 +12095,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) => {
@@ -11737,10 +12132,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" });
@@ -11772,7 +12164,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);
@@ -11813,10 +12205,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) {
@@ -11870,7 +12259,7 @@ function libraryUnit(target, options, binding = (0, import_behavioral_ir7.functi
         emitEvent: null,
         location: range
       },
-      effects,
+      effects: [],
       location: range,
       isDefault: true
     }
@@ -11890,7 +12279,10 @@ function libraryUnit(target, options, binding = (0, import_behavioral_ir7.functi
     parameters,
     branches: withSlotSources(
       branches.map(
-        (branch) => body.extraEffects === void 0 ? branch : { ...branch, extraEffects: body.extraEffects }
+        (branch) => withEffectsThatRun(branch, {
+          effects,
+          extraEffects: body.extraEffects
+        })
       ),
       body.provenance
     ),
@@ -11925,12 +12317,205 @@ 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
+var import_node_path3 = __toESM(require("path"), 1);
+var import_extractor17 = require("@suss/extractor");
+function emitRequireFacts(db, filePath, root, known) {
+  (0, import_extractor17.walkDescendants)(root, null, children, {
+    at: (node) => {
+      const target = requiredRelativePath(node);
+      if (target === null) {
+        return;
+      }
+      const resolved = import_node_path3.default.resolve(
+        import_node_path3.default.dirname(filePath),
+        target.endsWith(".rb") ? target : `${target}.rb`
+      );
+      if (known.has(resolved)) {
+        db.add("importsFile", [filePath, resolved]);
+      }
+    },
+    into: (node) => node.type === "argument_list" ? import_extractor17.SKIP_CHILDREN : 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
+var import_behavioral_ir8 = require("@suss/behavioral-ir");
+var import_extractor18 = require("@suss/extractor");
 function settleRubyModules(modules) {
-  return (0, import_extractor17.settleModules)(modules, ["{name}.rb", "../{name}.rb"]);
+  return (0, import_extractor18.settleModules)(modules, ["{name}.rb", "../{name}.rb"]);
 }
 function moduleExportUnits(root, file, options) {
-  const module2 = (0, import_extractor17.moduleOfFile)(options.modules, file);
+  const module2 = (0, import_extractor18.moduleOfFile)(options.modules, file);
   if (module2 === void 0 || !module2.public.includes(file)) {
     return [];
   }
@@ -11958,7 +12543,7 @@ function moduleExportUnits(root, file, options) {
         },
         options,
         (0, import_behavioral_ir8.moduleExportBinding)({
-          recognition: import_extractor17.MODULE_SURFACE_RECOGNITION,
+          recognition: import_extractor18.MODULE_SURFACE_RECOGNITION,
           module: module2.name,
           exportName: name
         })
@@ -12266,7 +12851,7 @@ var WalkReplay = class {
 };
 
 // src/testFactories.ts
-var import_values29 = require("@suss/values");
+var import_values31 = require("@suss/values");
 function factoriesIn(packs) {
   return packs.flatMap((pack) => pack.factories ?? []);
 }
@@ -12328,7 +12913,7 @@ function classRefOf(db, file, node) {
   if (node.type === "constant" || node.type === "scope_resolution") {
     return { key: readKey(file, node, null) };
   }
-  const written = (0, import_values29.literalOf)(evaluatedValue(node, db));
+  const written = (0, import_values31.literalOf)(evaluatedValue(node, db));
   if (written === null) {
     return null;
   }
@@ -12337,7 +12922,7 @@ function classRefOf(db, file, node) {
   };
 }
 function nameOf(db, node) {
-  return symbolValue(node) ?? (0, import_values29.literalOf)(evaluatedValue(node, db));
+  return symbolValue(node) ?? (0, import_values31.literalOf)(evaluatedValue(node, db));
 }
 var FactoryClasses = class {
   constructor(db, definitions, inflections) {
@@ -12409,7 +12994,7 @@ function builtAt(db, call, pattern) {
 
 // src/testSharedGroups.ts
 var import_resolution15 = require("@suss/resolution");
-var import_values31 = require("@suss/values");
+var import_values33 = require("@suss/values");
 var ByNode = class {
   byTree = /* @__PURE__ */ new WeakMap();
   set(node, value) {
@@ -12513,7 +13098,7 @@ var SharedGroupIndex = class {
   }
   nameOf(call) {
     const first = firstArgument(call);
-    return first === null ? null : (0, import_values31.literalOf)(evaluatedValue(first, this.db));
+    return first === null ? null : (0, import_values33.literalOf)(evaluatedValue(first, this.db));
   }
   noteRead(definition) {
     if (definition !== null) {
@@ -12523,12 +13108,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)) {
@@ -12590,16 +13175,16 @@ function visibleAt(index, site, pattern) {
 }
 
 // src/version.ts
-var import_extractor18 = require("@suss/extractor");
+var import_extractor19 = require("@suss/extractor");
 var ADAPTER_VERSION = "0.1.0";
-var adapterStamp = (0, import_extractor18.createAdapterStamp)({
+var adapterStamp = (0, import_extractor19.createAdapterStamp)({
   moduleUrl: importMetaUrl,
   version: ADAPTER_VERSION
 });
 
 // src/project.ts
 function keptRubyParses() {
-  return new import_extractor19.KeptParses((root) => root.tree.delete());
+  return new import_extractor20.KeptParses((root) => root.tree.delete());
 }
 async function parseRubyAhead(files, kept) {
   for (const file of files) {
@@ -12704,7 +13289,7 @@ var RunFacts = class {
         ...this.testFiles.map(({ file }) => file),
         ...this.parsed.map(({ file }) => file).filter(
           (file) => classTests.some(
-            (one) => (0, import_extractor19.matchesTestFileName)(file, one.filePatterns)
+            (one) => (0, import_extractor20.matchesTestFileName)(file, one.filePatterns)
           )
         )
       ]);
@@ -12739,7 +13324,7 @@ function factsForFile(options) {
   return facts.db;
 }
 function moduleInitUnit(options) {
-  const raw = (0, import_extractor19.moduleInitStructure)({
+  const raw = (0, import_extractor20.moduleInitStructure)({
     name: options.name,
     file: options.file,
     range: options.range,
@@ -12769,31 +13354,49 @@ 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 (!import_node_fs3.default.existsSync(absPath)) {
+    return null;
+  }
+  const text3 = import_node_fs3.default.readFileSync(absPath, "utf8");
+  return templates.has(absPath) ? rubyInErbTemplate(text3) : text3;
+}
 async function extractRubyProject(options) {
-  const timer = options.onTiming !== void 0 ? (0, import_extractor19.createTimer)() : (0, import_extractor19.noopTimer)();
+  const walked = walkedFilesOf(options);
+  const timer = options.onTiming !== void 0 ? (0, import_extractor20.createTimer)() : (0, import_extractor20.noopTimer)();
   const cacheDir = adapterStamp.declineWhenRunFromSource(
-    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? (0, import_extractor19.extractionCacheDirFor)(options.projectRoot) : null)
+    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? (0, import_extractor20.extractionCacheDirFor)(options.projectRoot) : null)
   );
-  const layer = (0, import_extractor19.createCacheLayer)(cacheDir);
+  const layer = (0, import_extractor20.createCacheLayer)(cacheDir);
   const packsDigest = `${adapterStamp.packsDigest(
     options.packs.map(
       (pack) => pack.version !== void 0 ? { name: pack.name, version: pack.version } : { name: pack.name }
     )
-  )}|${(0, import_extractor19.extractionConfigStamp)({
+  )}|${(0, import_extractor20.extractionConfigStamp)({
     gapHandling: options.gapHandling,
     workspaceRoot: options.workspaceRoot,
     projectRoot: options.projectRoot,
     modules: settleRubyModules(options.modules)
   })}`;
   const input = {
-    files: cacheDir === null ? [] : options.files,
-    adapterPacksDigest: cacheDir === null ? packsDigest : (0, import_extractor19.runDigest)(packsDigest, options.packs, options.files)
+    files: cacheDir === null ? [] : walked.files,
+    adapterPacksDigest: cacheDir === null ? packsDigest : (0, import_extractor20.runDigest)(packsDigest, options.packs, walked.files)
   };
   const lookup = await timer.timeAsync(
     "cache.lookup",
     () => layer.lookup(input)
   );
-  const composed = (stored) => (0, import_extractor19.composeWrappers)(stored, {
+  const composed = (stored) => (0, import_extractor20.composeWrappers)(stored, {
     gapHandling: options.gapHandling ?? "permissive"
   });
   if (lookup.kind === "hit") {
@@ -12815,7 +13418,7 @@ async function extractRubyProject(options) {
   const records = plan === null ? null : (0, import_resolution16.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;
@@ -12823,7 +13426,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);
@@ -12840,13 +13443,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 import_datalog3.Database();
   const summaries = [];
   const gapHandling = options.gapHandling ?? "permissive";
-  const tallies = (0, import_extractor12.createPackTallies)(options.packs);
-  const ledger = cacheDir === null ? null : new import_resolution16.DependencyLedger(options.files);
+  const tallies = (0, import_extractor13.createPackTallies)(options.packs);
+  const ledger = cacheDir === null ? null : new import_resolution16.DependencyLedger(walked.files);
   const log = ledger === null ? null : new import_resolution16.FactLog(db, ledger);
   if (ledger !== null) {
     (0, import_resolution16.observeDemand)(db, ledger);
@@ -12854,12 +13457,12 @@ async function runRuby(options, cache, previous) {
   const parses = options.keptParses ?? keptRubyParses();
   const trees = createFileCache(
     (source, absPath) => parses.parse(absPath, source, parseRubyRoot),
-    (absPath) => import_node_fs3.default.existsSync(absPath) ? import_node_fs3.default.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) {
@@ -12869,7 +13472,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();
@@ -12947,7 +13550,7 @@ async function runRuby(options, cache, previous) {
           continue;
         }
         discovered.add(unit.dedup);
-        (0, import_extractor12.tallyUnit)(tallies, unit.recognition);
+        (0, import_extractor13.tallyUnit)(tallies, unit.recognition);
         found.push({
           replayed: unit.summary ?? null,
           seedKey: unit.seed?.key ?? null
@@ -12995,6 +13598,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(
@@ -13028,7 +13641,7 @@ async function runRuby(options, cache, previous) {
         continue;
       }
       discovered.add(dedup);
-      (0, import_extractor12.tallyUnit)(tallies, recognition);
+      (0, import_extractor13.tallyUnit)(tallies, recognition);
       found.push({ raw, seedKey, draft: units[units.length - 1] });
       if (seed !== void 0 && seedKey !== null && !seedKeys.has(seedKey)) {
         seedKeys.add(seedKey);
@@ -13043,7 +13656,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,
@@ -13091,7 +13704,7 @@ async function runRuby(options, cache, previous) {
       }
       const summary = timer.time(
         "summarize",
-        () => (0, import_extractor19.assembleSummary)(routingGapUnit(pattern, gaps), { gapHandling })
+        () => (0, import_extractor20.assembleSummary)(routingGapUnit(pattern, gaps), { gapHandling })
       );
       summary.confidence = { source: "inferred_static", level: "low" };
       found.push({ summary });
@@ -13147,7 +13760,7 @@ async function runRuby(options, cache, previous) {
     }
     const summary = timer.time(
       "summarize",
-      () => (0, import_extractor19.assembleSummary)(raw, { gapHandling })
+      () => (0, import_extractor20.assembleSummary)(raw, { gapHandling })
     );
     summaries.push(summary);
     assembledHere.add(summary);
@@ -13194,8 +13807,8 @@ async function runRuby(options, cache, previous) {
     throw new ReplayFailed("");
   }
   const dependencies = (0, import_resolution16.importedFilesByFile)(db, displayPathOf);
-  (0, import_extractor19.stampModuleImports)(summaries, (file) => dependencies.get(file) ?? []);
-  (0, import_extractor19.stampModules)(summaries, declaredModules, options.workspaceRoot);
+  (0, import_extractor20.stampModuleImports)(summaries, (file) => dependencies.get(file) ?? []);
+  (0, import_extractor20.stampModules)(summaries, declaredModules, options.workspaceRoot);
   const idRoot = options.projectRoot ?? options.workspaceRoot;
   for (const summary of summaries) {
     const absoluteFile = options.workspaceRoot === void 0 ? summary.location.file : import_node_path4.default.resolve(options.workspaceRoot, summary.location.file);
@@ -13215,7 +13828,7 @@ async function runRuby(options, cache, previous) {
       db,
       options.workspaceRoot
     );
-    return (0, import_extractor19.composeWrappers)(summaries, { gapHandling });
+    return (0, import_extractor20.composeWrappers)(summaries, { gapHandling });
   });
   const walkedFiles = new Map(
     parsed.map(({ file }) => [displayPathOf(file), file])
@@ -13275,7 +13888,7 @@ async function runRuby(options, cache, previous) {
     buildRubyExtractionReport({
       packs: options.packs,
       tallies,
-      filesWalked: options.files.length,
+      filesWalked: walked.files.length,
       summaries: composed
     })
   );
@@ -13307,7 +13920,7 @@ function rubyAttribution(args) {
   }));
   return {
     roots,
-    owners: (0, import_extractor19.ownersWhereWritten)(args.summaries, args.walkedFileOf)
+    owners: (0, import_extractor20.ownersWhereWritten)(args.summaries, args.walkedFileOf)
   };
 }
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["vendor", "node_modules", "tmp", ".git"]);
@@ -13501,7 +14114,7 @@ var RubyWhySession = class {
 // src/stubEvidence.ts
 var import_node_fs5 = __toESM(require("fs"), 1);
 var import_node_path6 = __toESM(require("path"), 1);
-var import_extractor20 = require("@suss/extractor");
+var import_extractor21 = require("@suss/extractor");
 function bareLetters(name) {
   return name.replaceAll(/[-_]/g, "").toLowerCase();
 }
@@ -13525,14 +14138,14 @@ function requireTarget(node) {
 }
 function requireSitesIn(root, file) {
   const found = [];
-  (0, import_extractor20.walkDescendants)(root, null, children, {
+  (0, import_extractor21.walkDescendants)(root, null, children, {
     at: (node) => {
       const target = requireTarget(node);
       if (target !== null) {
         found.push({ target, file, line: rangeOf(node).start });
       }
     },
-    into: (node) => node.type === "argument_list" ? import_extractor20.SKIP_CHILDREN : null
+    into: (node) => node.type === "argument_list" ? import_extractor21.SKIP_CHILDREN : null
   });
   return found;
 }