@suss/adapter-ruby 0.34.1 → 0.35.1

package/dist/index.js

@@ -271,8 +271,8 @@ var VISIBILITY_KEYWORDS = /* @__PURE__ */ new Set([
   "protected",
   "public"
 ]);
-function visibilityKeyword(text2) {
-  return VISIBILITY_KEYWORDS.has(text2) ? text2 : null;
+function visibilityKeyword(text3) {
+  return VISIBILITY_KEYWORDS.has(text3) ? text3 : null;
 }
 function setVisibility(visibility, name, keyword) {
   if (keyword === "public") {
@@ -542,8 +542,8 @@ function lowerAcronyms(word, acronyms) {
     (_match, before, acronym) => `${before === void 0 ? "" : "_"}${acronym.toLowerCase()}`
   );
 }
-function escapeRegExp(text2) {
-  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegExp(text3) {
+  return text3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var PATH_CONVENTIONS = {
   railsUnderscore: underscoreConstantPath
@@ -606,7 +606,7 @@ function isDirectory(directory) {
 }
 
 // src/defineMethod.ts
-import { nodeOfKey as nodeOfKey2 } from "@suss/resolution";
+import { nodeOfKey as nodeOfKey2, spanOfKey } from "@suss/resolution";
 import { hole as hole2, literalOf as literalOf3, piecesOf } from "@suss/values";
 
 // src/values/evaluator.ts
@@ -710,6 +710,15 @@ var OBJECT_METHODS = /* @__PURE__ */ new Set([
   "warn",
   "yield_self"
 ]);
+var SENDING_METHODS = /* @__PURE__ */ new Set([
+  "send",
+  "public_send",
+  "__send__"
+]);
+var METHOD_REFERENCE = "method";
+var INVOKE_METHOD = "call";
+var BLOCK_WRAPPERS = /* @__PURE__ */ new Set(["proc", "lambda"]);
+var PROC_CLASS = "Proc";
 var CONSTRUCTOR = "new";
 
 // src/facts/resolve.ts
@@ -781,12 +790,16 @@ function constructionSites(db, classKey) {
 
 // src/facts/values.ts
 import {
+  addEntryRows,
   addPackWords,
+  addTemplateRows,
   classMemberName,
   NAMED_STORE_NAME,
   RECEIVER_STORE_NAME,
+  SPREAD_ENTRY,
   startsAtName,
   UNPLACED_STORE_NAME,
+  VALUE_ENTRY,
   valueLeftByWrites
 } from "@suss/resolution";
 
@@ -1319,6 +1332,9 @@ function add(emitter, relation, ...tuple) {
   }
   emitter.db.add(relation, tuple);
 }
+function rowsOf(emitter) {
+  return (relation, row) => add(emitter, relation, ...row);
+}
 function valueKey(emitter, written, parent) {
   return readKey(emitter.filePath, written, emitter.enclosing, parent);
 }
@@ -1402,6 +1418,97 @@ function emitCall(emitter, site) {
   }
   emitCallArguments(emitter, site);
   emitConversion(emitter, site);
+  emitSentChoice(emitter, site);
+  emitMethodReference(emitter, site);
+  emitBlockAsProc(emitter, site);
+}
+function emitBlockAsProc(emitter, site) {
+  const { method, receiver, node } = site;
+  const name = method?.text;
+  const wraps = receiver === null ? name !== void 0 && BLOCK_WRAPPERS.has(name) : name === CONSTRUCTOR && receiver.text === PROC_CLASS;
+  const block = field(node, "block");
+  if (!wraps || block === null) {
+    return;
+  }
+  const blockKey = nodeId(emitter.filePath, block);
+  add(emitter, "func", blockKey);
+  add(emitter, "binds", site.key, blockKey);
+  for (const call of callsWrittenIn(block)) {
+    add(emitter, "makesCall", blockKey, nodeId(emitter.filePath, call));
+  }
+}
+function callsWrittenIn(node, found = []) {
+  for (const child of children(node)) {
+    if (OWN_BODY_TYPES.has(child.type)) {
+      continue;
+    }
+    if (child.type === "call") {
+      found.push(child);
+    }
+    callsWrittenIn(child, found);
+  }
+  return found;
+}
+function emitSentChoice(emitter, site) {
+  const { method, receiver, node } = site;
+  if (method === null || !SENDING_METHODS.has(method.text)) {
+    return;
+  }
+  const objectKey = receiver === null ? emitter.selfKey : valueKey(emitter, receiver, node);
+  const [name] = readCallArgs(field(node, "arguments")).positional;
+  if (objectKey === null || name === void 0) {
+    return;
+  }
+  add(emitter, "callsChosenEntry", site.key);
+  const written = symbolValue(name) ?? stringLiteralValue(name);
+  if (written !== null) {
+    for (const spelled of namesReadAs(emitter, receiver, objectKey, written)) {
+      add(emitter, "choosesNamedEntry", site.key, objectKey, spelled);
+    }
+    return;
+  }
+  const ends = writtenEnds(name);
+  if (ends === null) {
+    add(emitter, "choosesEntry", site.key, objectKey);
+    return;
+  }
+  for (const start of namesReadAs(emitter, receiver, objectKey, ends.start)) {
+    add(emitter, "choosesEntryLike", site.key, objectKey, start, ends.end);
+  }
+}
+function writtenEnds(node) {
+  if (node.type !== "string" && node.type !== "delimited_symbol") {
+    return null;
+  }
+  const parts = children(node);
+  const written = (part) => part.type === "string_content";
+  const firstComputed = parts.findIndex((part) => !written(part));
+  if (firstComputed === -1) {
+    return null;
+  }
+  const lastComputed = parts.length - 1 - [...parts].reverse().findIndex((part) => !written(part));
+  const start = parts.slice(0, firstComputed).map((part) => part.text).join("");
+  const end = parts.slice(lastComputed + 1).map((part) => part.text).join("");
+  return start === "" && end === "" ? null : { start, end };
+}
+function emitMethodReference(emitter, site) {
+  const { method, receiver, node } = site;
+  if (method?.text !== METHOD_REFERENCE || receiver !== null || emitter.selfKey === null) {
+    return;
+  }
+  const [name] = readCallArgs(field(node, "arguments")).positional;
+  const written = name === void 0 ? null : symbolValue(name) ?? stringLiteralValue(name);
+  if (written === null) {
+    return;
+  }
+  for (const spelled of namesReadAs(
+    emitter,
+    receiver,
+    emitter.selfKey,
+    written
+  )) {
+    add(emitter, "readsProperty", site.key, emitter.selfKey, spelled);
+  }
 }
 function emitConversion(emitter, site) {
   const { method, receiver, node } = site;
@@ -1475,7 +1582,6 @@ var SELF_READS = {
 function classSpelling(name) {
   return name === CONSTRUCTOR ? name : classMemberName(name);
 }
-var INVOKE_METHOD = "call";
 function invokedValueOf(call) {
   if (call.type !== "call") {
     return null;
@@ -1521,6 +1627,7 @@ function emitArray(emitter, array) {
   const objectKey = nodeId(emitter.filePath, array);
   add(emitter, "objectValue", objectKey);
   let position = 0;
+  const entries = [];
   for (const element of children(array)) {
     add(
       emitter,
@@ -1530,12 +1637,24 @@ function emitArray(emitter, array) {
       valueKey(emitter, element, array)
     );
     position += 1;
+    entries.push(writtenEntry(emitter, element, array));
   }
+  addEntryRows(rowsOf(emitter), objectKey, entries);
+}
+var SPREAD_TYPES = /* @__PURE__ */ new Set(["splat_argument", "hash_splat_argument"]);
+function writtenEntry(emitter, entry, parent) {
+  const unpacked = SPREAD_TYPES.has(entry.type) ? children(entry)[0] : void 0;
+  return unpacked === void 0 ? { key: valueKey(emitter, entry, parent), form: VALUE_ENTRY } : { key: valueKey(emitter, unpacked, entry), form: SPREAD_ENTRY };
 }
 function emitHash(emitter, hash) {
   const objectKey = nodeId(emitter.filePath, hash);
   add(emitter, "objectValue", objectKey);
+  const entries = [];
   for (const pair of children(hash)) {
+    if (SPREAD_TYPES.has(pair.type)) {
+      entries.push(writtenEntry(emitter, pair, hash));
+      continue;
+    }
     if (pair.type !== "pair") {
       continue;
     }
@@ -1544,6 +1663,7 @@ function emitHash(emitter, hash) {
     if (key === null || value === null) {
       continue;
     }
+    entries.push(writtenEntry(emitter, value, pair));
     const keyText = pairKeyText(key);
     if (keyText === null) {
       add(emitter, "holdsUnderKey", objectKey, valueKey(emitter, value, pair));
@@ -1557,32 +1677,66 @@ function emitHash(emitter, hash) {
       valueKey(emitter, value, pair)
     );
   }
+  addEntryRows(rowsOf(emitter), objectKey, entries);
 }
 var BLOCK_TYPES3 = /* @__PURE__ */ new Set(["block", "do_block"]);
 var LOOP_METHODS = /* @__PURE__ */ new Set(["each", "each_with_index", "map"]);
-var DEFINE_METHOD_CALL = "define_method";
-function loopTurnAt(emitter, block, call) {
-  if (call.type !== "call") {
-    return null;
-  }
-  const receiver = field(call, "receiver");
-  const method = field(call, "method");
+var COUNTING_LOOP = "each_with_index";
+function emitLoopVariables(emitter, block, call) {
+  const receiver = call.type === "call" ? field(call, "receiver") : null;
+  const method = receiver === null ? null : field(call, "method");
   if (receiver === null || method === null || !LOOP_METHODS.has(method.text)) {
-    return null;
+    return;
   }
-  const parameters = field(block, "parameters");
-  const names = parameters === null ? [] : children(parameters).map((p) => p.text);
-  const element = names[0];
-  if (element === void 0) {
-    return null;
+  const variables = children(field(block, "parameters")).filter(
+    (variable) => variable.type !== "block_parameter"
+  );
+  const counting = method.text === COUNTING_LOOP;
+  const [first, position] = variables;
+  if (first === void 0 || counting && variables.length > 2) {
+    return;
+  }
+  const taken = counting || variables.length === 1 ? elementTakenBy(first) : partsTakenBy(variables);
+  const blockKey = nodeId(emitter.filePath, block);
+  const over = valueKey(emitter, receiver, call);
+  for (const variable of taken) {
+    const key = `${blockKey}#${variable.name}`;
+    if (variable.part === null) {
+      add(emitter, "elementOf", key, over);
+      continue;
+    }
+    add(emitter, "elementPartOf", key, over, variable.part);
+  }
+  const [anchor] = taken;
+  if (counting && position?.type === "identifier" && anchor !== void 0) {
+    add(
+      emitter,
+      "positionOf",
+      `${blockKey}#${position.text}`,
+      `${blockKey}#${anchor.name}`
+    );
   }
-  return {
-    element,
-    index: names[1] ?? "",
-    overKey: nodeId(emitter.filePath, receiver)
-  };
 }
-function emitDynamicDefinition(emitter, call, type, turns) {
+function elementTakenBy(variable) {
+  if (variable.type === "identifier") {
+    return [{ name: variable.text, part: null }];
+  }
+  return variable.type === "destructured_parameter" ? partsTakenBy(children(variable)) : [];
+}
+function partsTakenBy(variables) {
+  const parts = [];
+  for (const [position, variable] of variables.entries()) {
+    if (variable.type === "splat_parameter") {
+      break;
+    }
+    if (variable.type === "identifier") {
+      parts.push({ name: variable.text, part: String(position) });
+    }
+  }
+  return parts;
+}
+var DEFINE_METHOD_CALL = "define_method";
+function emitDynamicDefinition(emitter, call, type) {
   if (emitter.selfKey === null || // A call inside a method runs when the method runs, not when the class loads.
   emitter.enclosing !== null || type !== "call" || field(call, "receiver") !== null || field(call, "method")?.text !== DEFINE_METHOD_CALL) {
     return;
@@ -1591,33 +1745,16 @@ function emitDynamicDefinition(emitter, call, type, turns) {
   const first = args === null ? void 0 : children(args)[0];
   const nameKey2 = nodeId(emitter.filePath, first ?? call);
   add(emitter, "definesMethodFrom", emitter.selfKey, nameKey2);
-  for (const turn of turns) {
-    add(
-      emitter,
-      "nameTurnsOn",
-      nameKey2,
-      turn.element,
-      turn.index,
-      turn.overKey
-    );
-  }
 }
-function walkExpressions(node, emitter, visit, nested = null, turns = []) {
+function walkExpressions(node, visit, nested = null) {
   for (const child of children(node)) {
     const type = child.type;
     if (OWN_BODY_TYPES.has(type)) {
       nested?.push(child);
       continue;
     }
-    visit(child, type, node, turns);
-    const opened = BLOCK_TYPES3.has(type) ? loopTurnAt(emitter, child, node) : null;
-    walkExpressions(
-      child,
-      emitter,
-      visit,
-      nested,
-      opened === null ? turns : [...turns, opened]
-    );
+    visit(child, type, node);
+    walkExpressions(child, visit, nested);
   }
 }
 var WRITTEN_KEY_TYPES = /* @__PURE__ */ new Set([
@@ -1631,13 +1768,16 @@ function emitKeyedRead(emitter, site, container, key, keyParent) {
   if (WRITTEN_KEY_TYPES.has(key.type)) {
     return;
   }
+  const siteKey = nodeId(emitter.filePath, site);
+  const containerKey = valueKey(emitter, container, site);
   add(
     emitter,
     "readsKeyed",
-    nodeId(emitter.filePath, site),
-    valueKey(emitter, container, site),
+    siteKey,
+    containerKey,
     valueKey(emitter, key, keyParent)
   );
+  add(emitter, "choosesEntry", siteKey, containerKey);
 }
 function emitKeyedElement(emitter, node, parent) {
   const object = field(node, "object");
@@ -1698,14 +1838,14 @@ function raises(written, enclosing) {
   return RAISING_METHODS2.has(field(node, "method")?.text ?? "") && (receiver === null || receiver.text === "Kernel");
 }
 function emitExpressionFacts(emitter, node) {
-  emitDynamicDefinition(emitter, node, node.type, []);
-  walkExpressions(node, emitter, (child, type, parent, turns) => {
+  emitDynamicDefinition(emitter, node, node.type);
+  walkExpressions(node, (child, type, parent) => {
     const site = callSiteAt(emitter, child, type, parent);
-    emitExpressionFact(emitter, child, type, parent, turns, site);
+    emitExpressionFact(emitter, child, type, parent, site);
   });
 }
-function emitExpressionFact(emitter, child, type, parent, turns, site) {
-  emitDynamicDefinition(emitter, child, type, turns);
+function emitExpressionFact(emitter, child, type, parent, site) {
+  emitDynamicDefinition(emitter, child, type);
   if (site !== null) {
     emitCall(emitter, site);
     emitKeyedFetch(emitter, site);
@@ -1746,6 +1886,11 @@ function emitExpressionFact(emitter, child, type, parent, turns, site) {
   }
   if (BLOCK_TYPES3.has(type)) {
     emitBlockValue(emitter, child);
+    emitLoopVariables(emitter, child, parent);
+  }
+  const pieces = TEMPLATE_PIECES[type]?.(emitter, child) ?? [];
+  if (pieces.length > 0) {
+    addTemplateRows(rowsOf(emitter), nodeId(emitter.filePath, child), pieces);
   }
   for (const branch of BRANCHES_OF[type]?.(child) ?? []) {
     add(
@@ -1765,6 +1910,29 @@ function emitExpressionFact(emitter, child, type, parent, turns, site) {
     emitParameterDefault(emitter, child);
   }
 }
+function interpolatedPieces(emitter, string) {
+  const parts = children(string);
+  if (!parts.some((part) => part.type === "interpolation")) {
+    return [];
+  }
+  return parts.flatMap((part) => {
+    if (part.type === "string_content") {
+      return [{ text: part.text }];
+    }
+    const expression = part.type === "interpolation" ? children(part)[0] : void 0;
+    return expression === void 0 ? [] : [{ hole: valueKey(emitter, expression, part) }];
+  });
+}
+function adjacentPieces(emitter, joined2) {
+  return children(joined2).map((part) => ({
+    hole: valueKey(emitter, part, joined2)
+  }));
+}
+var TEMPLATE_PIECES = {
+  string: interpolatedPieces,
+  delimited_symbol: interpolatedPieces,
+  chained_string: adjacentPieces
+};
 function emitBlockArgument(emitter, argument) {
   const [handed] = children(argument);
   if (handed !== void 0) {
@@ -2187,11 +2355,10 @@ function emitMethodFacts(emitter, method) {
   const collecting = { ...inside, heldRows: expressionFacts };
   walkExpressions(
     body,
-    inside,
-    (child, type, parent, turns) => {
+    (child, type, parent) => {
       const site = callSiteAt(inside, child, type, parent);
       emitBodyFact(bodyFacts, inside, funcKey, child, type, site);
-      emitExpressionFact(collecting, child, type, parent, turns, site);
+      emitExpressionFact(collecting, child, type, parent, site);
     },
     nested
   );
@@ -3675,7 +3842,7 @@ function contextOver(db, nodes) {
 }
 
 // src/values/literals.ts
-import { force as force2, literalOf as literalOf2 } from "@suss/values";
+import { force as force2, literalOf as literalOf2, sequence, text as text2 } from "@suss/values";
 function literalElementsIn(value) {
   if (value.kind !== "sequence") {
     return null;
@@ -3690,8 +3857,24 @@ function literalElementsIn(value) {
   }
   return elements;
 }
-function literalElementsOf(node, db) {
-  return literalElementsIn(evaluatedValue(node, db));
+function loopElementsOf(node, db) {
+  const value = evaluatedValue(node, db);
+  if (value.kind === "sequence") {
+    return value.items.map((item) => elementOfList(force2(item.value)));
+  }
+  if (value.kind === "record" && !value.open) {
+    return [...value.fields].map(([key, item]) => {
+      const parts = [text2(key), force2(item.value)];
+      return { whole: sequence(parts), parts };
+    });
+  }
+  return null;
+}
+function elementOfList(whole) {
+  return {
+    whole,
+    parts: whole.kind === "sequence" ? whole.items.map((item) => force2(item.value)) : [whole]
+  };
 }
 function namesOf(node, db) {
   const value = evaluatedValue(node, db);
@@ -3713,13 +3896,16 @@ function definedNamesOf(dynamic, classKey) {
 }
 function readDynamicNames(db, rootsByFile) {
   const byClass = /* @__PURE__ */ new Map();
-  for (const [classKey, nameKey2] of db.facts("definesMethodFrom")) {
+  const definitions = db.facts("definesMethodFrom");
+  const loops = definitions.length === 0 ? /* @__PURE__ */ new Map() : loopsByFile(db);
+  for (const [classKey, nameKey2] of definitions) {
     const key = String(classKey);
+    const around = loopsAround(loops, key, String(nameKey2));
     byClass.set(
       key,
       foldReading(
         byClass.get(key) ?? NOTHING,
-        readOne(db, rootsByFile, String(nameKey2))
+        readOne(db, rootsByFile, String(nameKey2), around)
       )
     );
   }
@@ -3740,11 +3926,11 @@ function foldReading(soFar, reading) {
     unreadable: soFar.unreadable
   };
 }
-function readOne(db, rootsByFile, nameKey2) {
+function readOne(db, rootsByFile, nameKey2, loops) {
   const node = nodeOfKey2(rootsByFile, nameKey2);
   const names = [];
   const patterns = [];
-  for (const bindings of loopTurns(db, rootsByFile, nameKey2)) {
+  for (const bindings of loopTurns(db, rootsByFile, loops)) {
     const value = node === null ? hole2(nameKey2) : evaluatedValue(node, db, bindings.size === 0 ? void 0 : bindings);
     const name = literalOf3(value);
     if (name !== null) {
@@ -3777,38 +3963,105 @@ function patternOf(value) {
   }
   return readSomething ? new RegExp(`${source}$`) : null;
 }
-function escapeForPattern(text2) {
-  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeForPattern(text3) {
+  return text3.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function loopTurns(db, rootsByFile, nameKey2) {
+function loopTurns(db, rootsByFile, loops) {
   let turns = [/* @__PURE__ */ new Map()];
-  for (const over of listsBehind(db, rootsByFile, nameKey2)) {
+  for (const loop of loops) {
+    const bindings = bindingsOf(db, rootsByFile, loop);
+    if (bindings === null) {
+      continue;
+    }
     turns = turns.flatMap(
-      (base) => over.elements.map((value, position) => {
-        const binding = new Map([...base, [over.element, value]]);
-        if (over.index !== "") {
-          binding.set(over.index, String(position));
-        }
-        return binding;
-      })
+      (base) => bindings.map((binding) => new Map([...base, ...binding]))
     );
   }
   return turns;
 }
-function listsBehind(db, rootsByFile, nameKey2) {
-  const found = [];
-  for (const [, element, index, overKey] of db.lookup(
-    "nameTurnsOn",
-    0,
-    nameKey2
-  )) {
-    const node = nodeOfKey2(rootsByFile, String(overKey));
-    const elements = node === null ? null : literalElementsOf(node, db);
-    if (elements !== null) {
-      found.push({ element: String(element), index: String(index), elements });
+function bindingsOf(db, rootsByFile, loop) {
+  const node = collectionNode(rootsByFile, loop);
+  const elements = node === null ? null : loopElementsOf(node, db);
+  if (elements === null) {
+    return null;
+  }
+  const bound = [...loop.variables].flatMap(([name, takes]) => {
+    const values = elements.map(
+      (element, position) => GIVEN[takes.kind](element, position, takes)
+    );
+    return values.every((value) => value !== null) ? [{ name, values }] : [];
+  });
+  if (bound.length === 0) {
+    return null;
+  }
+  return elements.map(
+    (_, position) => new Map(bound.map(({ name, values }) => [name, values[position] ?? ""]))
+  );
+}
+var GIVEN = {
+  element: (element) => literalOf3(element.whole),
+  part: (element, _, takes) => {
+    const part = takes.kind === "part" ? element.parts[takes.part] : void 0;
+    return part === void 0 ? null : literalOf3(part);
+  },
+  position: (_, position) => String(position)
+};
+function collectionNode(rootsByFile, loop) {
+  const written = nodeOfKey2(rootsByFile, loop.over);
+  if (written !== null) {
+    return written;
+  }
+  const call = nodeOfKey2(rootsByFile, loop.block.key)?.parent ?? null;
+  return call === null ? null : field(call, "receiver");
+}
+function blockVariableOf(key) {
+  const at = key.lastIndexOf("#");
+  const span = at < 0 ? null : spanOfKey(key.slice(0, at));
+  return span === null ? null : { block: { ...span, key: key.slice(0, at) }, name: key.slice(at + 1) };
+}
+function loopsByFile(db) {
+  const blocks = /* @__PURE__ */ new Map();
+  const note = (key, over, takes) => {
+    const variable = blockVariableOf(String(key));
+    if (variable === null) {
+      return;
     }
+    const known = blocks.get(variable.block.key);
+    const loop = known ?? {
+      block: variable.block,
+      over: String(over),
+      variables: /* @__PURE__ */ new Map()
+    };
+    loop.variables.set(variable.name, takes);
+    blocks.set(variable.block.key, loop);
+  };
+  for (const [element, over] of db.facts("elementOf")) {
+    note(element, over, { kind: "element" });
   }
-  return found;
+  for (const [element, over, part] of db.facts("elementPartOf")) {
+    note(element, over, { kind: "part", part: Number(part) });
+  }
+  for (const [position, element] of db.facts("positionOf")) {
+    const block = blockVariableOf(String(element))?.block.key;
+    if (block !== void 0 && blocks.has(block)) {
+      note(position, blocks.get(block)?.over, { kind: "position" });
+    }
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const loop of blocks.values()) {
+    byFile.set(loop.block.file, [...byFile.get(loop.block.file) ?? [], loop]);
+  }
+  return byFile;
+}
+function loopsAround(loops, classKey, nameKey2) {
+  const cls = spanOfKey(classKey);
+  const name = spanOfKey(nameKey2);
+  if (cls === null || name === null) {
+    return [];
+  }
+  return (loops.get(name.file) ?? []).filter(
+    ({ block }) => cls.start <= block.start && block.end <= cls.end && block.start <= name.start && name.end <= block.end
+  ).sort((a, b) => a.block.start - b.block.start);
 }
 
 // src/scope.ts
@@ -4567,9 +4820,9 @@ var BLOCK_TYPES5 = /* @__PURE__ */ new Set([
 ]);
 function literalArgOf(node, facts) {
   const value = evaluatedValue(node, facts);
-  const text2 = literalOf4(value);
-  if (text2 !== null) {
-    return { kind: "string", value: text2 };
+  const text3 = literalOf4(value);
+  if (text3 !== null) {
+    return { kind: "string", value: text3 };
   }
   const constant2 = constantOf(value);
   if (typeof constant2 === "number") {
@@ -4635,7 +4888,7 @@ function isCall(node, locals, inherited) {
 }
 function collectCalls(node, read, inherited, found) {
   for (const child of children(node)) {
-    if (read.stops.has(child.type)) {
+    if (read.stops.has(child.type) && !isLambdaArgument(child)) {
       continue;
     }
     if (isCall(child, read.locals, inherited)) {
@@ -4645,6 +4898,9 @@ function collectCalls(node, read, inherited, found) {
   }
   return found;
 }
+function isLambdaArgument(node) {
+  return node.type === LAMBDA_TYPE && node.parent?.type === "argument_list";
+}
 function methodBody(definitionNode) {
   const body = field(definitionNode, "body");
   if (body === null) {
@@ -7572,7 +7828,7 @@ function envSiteAt(node) {
 
 // src/filters.ts
 var RESCUES_NOTHING = { refs: [], someUnread: false };
-function controllerFilters(pattern, ancestry, read = {}) {
+function controllerFilterChain(pattern, ancestry, read = {}) {
   const forms = pattern.filters ?? [];
   if (forms.length === 0) {
     return [];
@@ -7616,27 +7872,47 @@ function controllerFilters(pattern, ancestry, read = {}) {
       declared = applySkips(declared, skipsOf(statement, skipped, read.facts));
     }
   }
-  const resolved = [];
-  for (const declaration of declared) {
-    const written = writtenAt(
+  const resolved = declared.map(
+    (declaration) => linkFor(
       declaration,
-      filterMethod(ancestry, declaration.methodName, read)
-    );
-    if (written === null) {
-      continue;
-    }
-    resolved.push({
+      writtenAt(
+        declaration,
+        filterMethod(ancestry, declaration.methodName, read)
+      )
+    )
+  );
+  return [
+    ...resolved.filter((one) => !runsAfterARaise(one)),
+    ...resolved.filter(runsAfterARaise).reverse()
+  ];
+}
+function linkFor(declaration, written) {
+  if (written === null) {
+    return {
+      unread: {
+        filter: declaration.filter,
+        methodName: declaration.methodName,
+        declaredIn: declaration.declaredIn,
+        only: declaration.only,
+        except: declaration.except
+      }
+    };
+  }
+  return {
+    read: {
       filter: declaration.filter,
       ...written,
       only: declaration.only,
       except: declaration.except,
       rescues: declaration.rescues
-    });
-  }
-  return [
-    ...resolved.filter((one) => one.filter.onThrow !== true),
-    ...resolved.filter((one) => one.filter.onThrow === true).reverse()
-  ];
+    }
+  };
+}
+function filterOf(link) {
+  return "read" in link ? link.read : link.unread;
+}
+function runsAfterARaise(link) {
+  return filterOf(link).filter.onThrow === true;
 }
 function writtenAt(declaration, found) {
   if (found.type === "found") {
@@ -7687,6 +7963,13 @@ function filterReference(filter, displayPath, caught) {
     }
   };
 }
+function unreadFilterReference(filter, displayPath) {
+  return {
+    file: displayPath,
+    name: filter.methodName,
+    ...filter.filter.onThrow === true ? { onThrow: true } : {}
+  };
+}
 function filterUnit(filter, pattern, displayPath, body, reading = {}) {
   const range = rangeOf(filter.method);
   const { respondingHelper, raises: raises2 } = reading;
@@ -7770,6 +8053,7 @@ function declarationsOf(statement, filter, declaredIn, facts, inlineOrdinal) {
     only,
     except: except ?? /* @__PURE__ */ new Set(),
     rescues: rescues2,
+    declaredIn: declaredIn.file,
     ...inline === void 0 ? {} : { inline }
   }));
 }
@@ -8762,8 +9046,8 @@ function moduleOfConstant(node, options) {
   const files = [...new Set(keys.map(fileOfKey))];
   return files.length === 1 ? options.displayPathOf(files[0]) : null;
 }
-function oneLine(text2) {
-  return text2.replace(/\s*\n\s*/g, " ").trim();
+function oneLine(text3) {
+  return text3.replace(/\s*\n\s*/g, " ").trim();
 }
 
 // src/testClasses.ts
@@ -9205,11 +9489,12 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
   ])) {
     return [];
   }
-  const filters = controllerFilters(pattern, ancestry, {
+  const chain = controllerFilterChain(pattern, ancestry, {
     facts: options.facts,
     bodyBlocks: options.bodyBlocks,
     dynamicNames: options.dynamicNames
   });
+  const filters = chain.flatMap((link) => "read" in link ? [link.read] : []);
   const units = [];
   const actions = controllerActions(
     pattern,
@@ -9240,10 +9525,10 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
     return classes === void 0 ? [] : [classes];
   });
   for (const filter of filters) {
-    const displayPath = options.displayPathOf?.(filter.file) ?? filter.file;
+    const displayPath2 = options.displayPathOf?.(filter.file) ?? filter.file;
     const body = bodyOfMethod(filter.method, filter.file, options);
     const handler = filter.filter.onThrow === true;
-    const raw = filterUnit(filter, pattern, displayPath, body, {
+    const raw = filterUnit(filter, pattern, displayPath2, body, {
       facts: options.facts,
       respondingHelper,
       ...handler ? {} : {
@@ -9271,14 +9556,14 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
       enclosingQualifiedName: filter.enclosingQualifiedName
     });
   }
+  const displayPath = (file) => options.displayPathOf?.(file) ?? file;
+  const referenceTo = (link) => "read" in link ? filterReference(
+    link.read,
+    displayPath(link.read.file),
+    caught.get(link.read)
+  ) : unreadFilterReference(link.unread, displayPath(link.unread.declaredIn));
   const emitAction = async (actionName, method, block, routes) => {
-    const around = filters.filter((filter) => filterCoversAction(filter, actionName)).map(
-      (filter) => filterReference(
-        filter,
-        options.displayPathOf?.(filter.file) ?? filter.file,
-        caught.get(filter)
-      )
-    );
+    const around = chain.filter((link) => filterCoversAction(filterOf(link), actionName)).map((link) => referenceTo(link));
     const raises2 = {
       classes: await raisedClasses(method, block.info.bodyNesting, exceptions),
       handlers: handlersAround(actionName)
@@ -10307,6 +10592,7 @@ import {
   placeArgTargets as placeArgTargets2,
   placeCalleeParameters as placeCalleeParameters2,
   placeCalls as placeCalls2,
+  placePossibleCalls as placePossibleCalls2,
   placeReceiverClasses,
   recordParameterGaps as recordParameterGaps2,
   summaryIdFromParts,
@@ -10318,11 +10604,13 @@ import {
   composeWrappers,
   createCacheLayer,
   createTimer,
+  extractionCacheDirFor,
   extractionConfigStamp,
   KeptParses,
   matchesTestFileName as matchesTestFileName3,
   moduleInitStructure,
   noopTimer,
+  ownersWhereWritten,
   runDigest,
   stampModuleImports,
   stampModules
@@ -10533,6 +10821,7 @@ import {
   placeArgTargets,
   placeCalleeParameters,
   placeCalls,
+  placePossibleCalls,
   ReceiverClasses,
   recordParameterGaps,
   StopList,
@@ -10608,8 +10897,8 @@ function flagsDeclaredIn(construction) {
   return flags;
 }
 function flagOf(args) {
-  const written = args.map((arg) => stringLiteralValue(arg)).filter((text2) => text2 !== null && text2.startsWith("-"));
-  const chosen = written.find((text2) => text2.startsWith("--")) ?? written[0] ?? null;
+  const written = args.map((arg) => stringLiteralValue(arg)).filter((text3) => text3 !== null && text3.startsWith("-"));
+  const chosen = written.find((text3) => text3.startsWith("--")) ?? written[0] ?? null;
   if (chosen === null) {
     return null;
   }
@@ -10651,10 +10940,9 @@ import {
   calleeOutcomeOf,
   calleeOutcomes,
   classMemberName as classMemberName3,
-  couldBeSettled
+  couldBeSettled,
+  dispatchOutcomes
 } from "@suss/resolution";
-var DYNAMIC_SEND_NAMES = /* @__PURE__ */ new Set(["send", "public_send", "__send__"]);
-var INVOKES_RECEIVER = "call";
 var STOP_FOR = {
   severalSources: "multipleSources",
   outsideRun: "outsideRun",
@@ -10737,6 +11025,57 @@ function loaderSourceCallee(call, site, ctx) {
   }
   return null;
 }
+function dispatchedCalls(calls, ctx) {
+  const byKey = new Map(
+    calls.map((one) => [nodeId(one.site.file, one.call), one])
+  );
+  const found = /* @__PURE__ */ new Map();
+  const outcomes = dispatchOutcomes(ctx.facts, [...byKey.keys()], RUBY_PROGRAM);
+  for (const [key, outcome] of outcomes) {
+    const asked = byKey.get(key);
+    if (asked === void 0) {
+      continue;
+    }
+    const fits = sendFits(asked.call, asked.site, ctx);
+    const targets = /* @__PURE__ */ new Map();
+    for (const fn of outcome.functions) {
+      for (const target of reachedThrough(fn, outcome.through, ctx)) {
+        if (fits(target)) {
+          targets.set(nodeId(target.file, target.node), target);
+        }
+      }
+    }
+    found.set(asked.call.id, {
+      targets: [...targets.values()],
+      certain: outcome.certain && outcome.functions.every((fn) => ctx.definitions.has(fn)),
+      unresolved: outcome.unresolved
+    });
+  }
+  return found;
+}
+function reachedThrough(key, through, ctx) {
+  const own = ctx.definitions.get(key);
+  if (own !== void 0) {
+    return [own];
+  }
+  return (through.get(key) ?? []).flatMap((inner) => {
+    const target = ctx.definitions.get(inner);
+    return target === void 0 ? [] : [target];
+  });
+}
+function sendFits(call, site, ctx) {
+  const method = calleeMethodName(call);
+  if (method === void 0 || !SENDING_METHODS.has(method)) {
+    return () => true;
+  }
+  const receiver = field(call, "receiver");
+  const toClass = receiver === null || receiver.type === "self" ? inClassMethod(site, ctx) : readsOffClassItself(
+    receiver,
+    readKey(site.file, receiver, site.method),
+    classLocalsFor(call, site)
+  );
+  return (target) => definesClassMethod(target.node, ctx.bodyBlocks) === toClass;
+}
 function outcomeFor(key, ctx, read) {
   return read?.outcomes.get(key) ?? calleeOutcomeOf(ctx.facts, key, RUBY_PROGRAM);
 }
@@ -10750,14 +11089,16 @@ function readsAsACall(call, site, ctx, read) {
     return false;
   }
   const outcome = outcomeFor(spelling.key, ctx, read);
-  return outcome.kind === "function" || outcome.kind === "object";
+  return outcome.kind === "function" || outcome.kind === "object" || objectsBehind(ctx.facts, spelling.key).some(
+    (key) => ctx.classNames.has(key)
+  );
 }
 function spellingFor2(call, site) {
   const methodName = calleeMethodName(call);
   if (methodName === void 0) {
     return { kind: "stopped", reason: "noDeclaration" };
   }
-  if (DYNAMIC_SEND_NAMES.has(methodName)) {
+  if (SENDING_METHODS.has(methodName)) {
     return { kind: "stopped", reason: "unsettledValue" };
   }
   const receiver = field(call, "receiver");
@@ -10803,7 +11144,7 @@ function asCallee(spelling, outcome, site, ctx) {
     return methodOnObject(spelling, objectKey, ctx);
   }
   if (outcome.kind === "function") {
-    return spelling.method === INVOKES_RECEIVER ? functionCallee(outcome.key, ctx) : NO_DECLARATION;
+    return spelling.method === INVOKE_METHOD ? functionCallee(outcome.key, ctx) : NO_DECLARATION;
   }
   return stop(STOP_FOR[outcome.kind] ?? "noDeclaration");
 }
@@ -10847,7 +11188,7 @@ function scopeOn(qualifiedName, method, ctx) {
   return null;
 }
 function fromCaller(spelling, parameterKey, site) {
-  if (!parameterKey.startsWith(`${site.owner}#`) || spelling.method !== INVOKES_RECEIVER) {
+  if (!parameterKey.startsWith(`${site.owner}#`) || spelling.method !== INVOKE_METHOD) {
     return stop("unsettledValue");
   }
   return stop("callerSupplied");
@@ -10983,6 +11324,7 @@ async function reachedFunctions(seeds, options) {
   const targetsByKey = /* @__PURE__ */ new Map();
   const stopsByKey = /* @__PURE__ */ new Map();
   const argTargetsByKey = /* @__PURE__ */ new Map();
+  const possibleTargetsByKey = /* @__PURE__ */ new Map();
   const parameterCallsByKey = /* @__PURE__ */ new Map();
   const propertyReadsByKey = /* @__PURE__ */ new Map();
   const receiverClassesByKey = /* @__PURE__ */ new Map();
@@ -11041,6 +11383,7 @@ async function reachedFunctions(seeds, options) {
       }
       targetsByKey.set(key, scan.targets);
       argTargetsByKey.set(key, scan.argTargets);
+      possibleTargetsByKey.set(key, scan.possibleTargets);
       if (scan.propertyReads.size > 0) {
         propertyReadsByKey.set(key, scan.propertyReads);
       }
@@ -11104,6 +11447,7 @@ async function reachedFunctions(seeds, options) {
       }
       placeCalls(summary2, targetsByKey.get(key));
       placeArgTargets(summary2, argTargetsByKey.get(key));
+      placePossibleCalls(summary2, possibleTargetsByKey.get(key));
       placeCalleeParameters(summary2, parameterCallsByKey.get(key));
       return summary2;
     };
@@ -11126,6 +11470,7 @@ async function reachedFunctions(seeds, options) {
     targetsByKey,
     stopsByKey,
     argTargetsByKey,
+    possibleTargetsByKey,
     parameterCallsByKey,
     propertyReadsByKey,
     receiverClassesByKey,
@@ -11155,36 +11500,70 @@ function batchedReads(round, options) {
   const bodies = round.flatMap(
     (entry) => "source" in entry ? [{ key: entry.key, ...bodyOf2(entry.source, options) }] : []
   );
-  const spellings = calleeSpellings(
-    bodies.flatMap((body) => body.written),
-    options.context
+  const written = bodies.flatMap((body) => body.written);
+  const spellings = calleeSpellings(written, options.context);
+  const dispatched = dispatchedAmong(written, spellings, options.context);
+  return new Map(
+    bodies.map((body) => [body.key, { ...body, spellings, dispatched }])
+  );
+}
+function dispatchedAmong(written, spellings, ctx) {
+  return dispatchedCalls(
+    written.filter(({ call, site }) => {
+      if (!mayRunAnEntry(call)) {
+        return false;
+      }
+      const outcome = resolveCallee(call, site, ctx, spellings);
+      return outcome.kind === "stopped" && outcome.reason !== "callerSupplied";
+    }),
+    ctx
   );
-  return new Map(bodies.map((body) => [body.key, { ...body, spellings }]));
+}
+function mayRunAnEntry(call) {
+  const sent = calleeMethodName(call);
+  if (sent !== void 0 && SENDING_METHODS.has(sent)) {
+    return true;
+  }
+  if (call.type !== "call" || field(call, "receiver") === null) {
+    return false;
+  }
+  const method = field(call, "method");
+  return method === null || method.text === INVOKE_METHOD;
 }
 function scanOnce(source, key, options, read, charges) {
   const ledger = options.ledger;
   if (ledger === void 0) {
-    const body = read ?? {
-      ...bodyOf2(source, options),
-      spellings: { spellingOf: /* @__PURE__ */ new Map(), outcomes: /* @__PURE__ */ new Map() }
-    };
-    return scanBody(source, options.context, options, body);
+    return scanBody(
+      source,
+      options.context,
+      options,
+      read ?? ownReads(source, options)
+    );
   }
   return ledger.charging(chargeOf(charges, key), () => {
     forgetEvaluations(options.context.facts);
     ledger.readFile(source.file);
-    const body = bodyOf2(source, options);
-    const spellings = calleeSpellings(body.written, options.context);
-    const scan = scanBody(source, options.context, options, {
-      ...body,
-      spellings
-    });
+    const scan = scanBody(
+      source,
+      options.context,
+      options,
+      ownReads(source, options)
+    );
     for (const target of scan.followed) {
       ledger.touchKey(keyOf(target));
     }
     return scan;
   });
 }
+function ownReads(source, options) {
+  const body = bodyOf2(source, options);
+  const spellings = calleeSpellings(body.written, options.context);
+  return {
+    ...body,
+    spellings,
+    dispatched: dispatchedAmong(body.written, spellings, options.context)
+  };
+}
 function storedScan(scan) {
   return {
     followed: scan.followed.map((target) => ({
@@ -11200,6 +11579,10 @@ function storedScan(scan) {
       callee,
       [...byPosition]
     ]),
+    possibleTargets: [...scan.possibleTargets].map(([callee, places]) => [
+      callee,
+      [...places]
+    ]),
     parameterCalls: [...scan.parameterCalls],
     passedPositions: [...scan.passedPositions],
     propertyReads: [...scan.propertyReads],
@@ -11217,6 +11600,7 @@ function scanFromStored(stored, functionFor) {
         new Map(byPosition)
       ])
     ),
+    possibleTargets: new Map(stored.possibleTargets),
     parameterCalls: stored.parameterCalls,
     passedPositions: new Set(stored.passedPositions),
     propertyReads: new Set(stored.propertyReads),
@@ -11245,6 +11629,7 @@ var EMPTY_SCAN = {
   stops: [],
   targets: /* @__PURE__ */ new Map(),
   argTargets: /* @__PURE__ */ new Map(),
+  possibleTargets: /* @__PURE__ */ new Map(),
   parameterCalls: [],
   passedPositions: /* @__PURE__ */ new Set(),
   propertyReads: /* @__PURE__ */ new Set(),
@@ -11266,7 +11651,7 @@ function bodyOf2(source, options) {
     const file = run?.fileOf(call) ?? source.file;
     return file === source.file ? site : { ...site, file, method: enclosingDefinition(call) };
   };
-  const written = callsWrittenIn(source.node, run, options);
+  const written = callsWrittenIn2(source.node, run, options);
   const calls = callsReported(
     written,
     (call) => mightReadAsACall(call, siteFor(call), options.context)
@@ -11280,7 +11665,7 @@ function bodyOf2(source, options) {
     written: calls.map((call) => ({ call, site: siteFor(call) }))
   };
 }
-function callsWrittenIn(node, run, options) {
+function callsWrittenIn2(node, run, options) {
   if (run !== null) {
     return exampleCalls(run, options.inheritedMethods).filter(
       (call) => !run.isRunnerCall(call)
@@ -11347,6 +11732,12 @@ function scanBody(source, ctx, options, read) {
     }
     const argNodes = bodyStatements(args);
     for (let position = 0; position < argNodes.length; position += 1) {
+      if (argNodes[position]?.type === LAMBDA_TYPE) {
+        if (calleeKey !== null) {
+          passedPositions.add(`${calleeKey}#${position}`);
+        }
+        continue;
+      }
       const symbol = methodReferenceSymbol(argNodes[position]);
       if (symbol === null) {
         continue;
@@ -11384,11 +11775,35 @@ function scanBody(source, ctx, options, read) {
       span: spanOf(target.node)
     });
   };
+  const follow = (target) => {
+    const key = keyOf(target);
+    if (!seen.has(key)) {
+      seen.add(key);
+      followed2.push(target);
+    }
+  };
   for (const call of calls) {
     const callee = calleeText(call);
     const callSite = read.siteFor(call);
     const predicate = read.predicateOf(call);
-    const outcome = predicate === null ? resolveCallee(call, callSite, ctx, read.spellings) : resolveMethodOn(predicate.target, predicate.method, callSite, ctx);
+    const settled = predicate === null ? resolveCallee(call, callSite, ctx, read.spellings) : resolveMethodOn(predicate.target, predicate.method, callSite, ctx);
+    const dispatched = settled.kind === "stopped" ? read.dispatched.get(call.id) : void 0;
+    const [only] = dispatched?.targets ?? [];
+    if (dispatched !== void 0 && only !== void 0 && !dispatched.certain) {
+      dispatched.targets.forEach(follow);
+      placements.placePossible(
+        callee,
+        dispatched.targets.map((target) => ({
+          file: displayPathOf(target.file),
+          span: spanOf(target.node)
+        }))
+      );
+      if (dispatched.unresolved > 0) {
+        stops.add({ callee, reason: "unsettledValue" });
+      }
+      continue;
+    }
+    const outcome = only === void 0 ? settled : { kind: "followed", target: only };
     if (options.storage !== void 0) {
       for (const callback of callbacksReached(
         call,
@@ -11437,17 +11852,14 @@ function scanBody(source, ctx, options, read) {
     if (isArglessReceiverCall(call)) {
       keptArgless.add(call.id);
     }
-    const key = keyOf(outcome.target);
-    if (!seen.has(key)) {
-      seen.add(key);
-      followed2.push(outcome.target);
-    }
+    follow(outcome.target);
   }
   return {
     followed: followed2,
     stops: stops.stops,
     targets: placements.targets,
     argTargets: placements.argTargets,
+    possibleTargets: placements.possibleTargets,
     parameterCalls,
     passedPositions,
     propertyReads: propertyReadsAmong(read.argless, calls, keptArgless),
@@ -11479,9 +11891,9 @@ function propertyReadsAmong(argless, made, keptArgless) {
   );
   const reads = /* @__PURE__ */ new Set();
   for (const call of argless) {
-    const text2 = calleeText(call);
-    if (!kept.has(text2)) {
-      reads.add(text2);
+    const text3 = calleeText(call);
+    if (!kept.has(text3)) {
+      reads.add(text3);
     }
   }
   return reads;
@@ -12421,7 +12833,7 @@ function replaysCleanly(units, discovered) {
 async function extractRubyProject(options) {
   const timer = options.onTiming !== void 0 ? createTimer() : noopTimer();
   const cacheDir = adapterStamp.declineWhenRunFromSource(
-    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? path4.join(options.projectRoot, ".suss", "cache") : null)
+    options.cacheDir === null ? null : options.cacheDir ?? (options.projectRoot !== void 0 ? extractionCacheDirFor(options.projectRoot) : null)
   );
   const layer = createCacheLayer(cacheDir);
   const packsDigest = `${adapterStamp.packsDigest(
@@ -12442,10 +12854,13 @@ async function extractRubyProject(options) {
     "cache.lookup",
     () => layer.lookup(input)
   );
+  const composed = (stored) => composeWrappers(stored, {
+    gapHandling: options.gapHandling ?? "permissive"
+  });
   if (lookup.kind === "hit") {
     options.onCacheDiagnostic?.(lookup.diagnostic);
     options.onTiming?.(timer.report());
-    return { summaries: lookup.summaries, facts: new Database2() };
+    return { summaries: composed(lookup.summaries), facts: new Database2() };
   }
   const plan = lookup.diagnostic.missReason === "files-changed" ? await timer.timeAsync("cache.plan", () => layer.plan(input)) : null;
   if (plan !== null && plan.changed.size === 0 && plan.removed.size === 0) {
@@ -12455,7 +12870,7 @@ async function extractRubyProject(options) {
     }
     options.onCacheDiagnostic?.({ kind: "hit" });
     options.onTiming?.(timer.report());
-    return { summaries: plan.allSummaries(), facts: new Database2() };
+    return { summaries: composed(plan.allSummaries()), facts: new Database2() };
   }
   const cache = { timer, cacheDir, layer, input };
   const records = plan === null ? null : recordsToReplay(plan.roots, plan.changed, plan.removed);
@@ -12816,6 +13231,7 @@ async function runRuby(options, cache, previous) {
       }
       placeCalls2(summary, reached.targetsByKey.get(key));
       placeArgTargets2(summary, reached.argTargetsByKey.get(key));
+      placePossibleCalls2(summary, reached.possibleTargetsByKey.get(key));
       placeCalleeParameters2(summary, reached.parameterCallsByKey.get(key));
       placeReceiverClasses(summary, reached.receiverClassesByKey.get(key));
     }
@@ -12862,16 +13278,20 @@ async function runRuby(options, cache, previous) {
     );
     return composeWrappers(summaries, { gapHandling });
   });
+  const walkedFiles = new Map(
+    parsed.map(({ file }) => [displayPathOf(file), file])
+  );
   await timer.timeAsync("cache.write", async () => {
-    if (cacheDir === null || composed.length === 0) {
+    if (cacheDir === null || summaries.length === 0) {
       return;
     }
     try {
       await cache.layer.write(
         cache.input,
-        composed,
+        summaries,
         log === null || ledger === null || overBudget ? void 0 : rubyAttribution({
-          composed,
+          summaries,
+          walkedFileOf: (locationFile) => walkedFiles.get(locationFile),
           discoveries,
           reached,
           reuse,
@@ -12946,7 +13366,10 @@ function rubyAttribution(args) {
       facts: args.facts.get(file) ?? { own: "", joined: "" }
     }
   }));
-  return { roots, owners: args.composed.map(() => []) };
+  return {
+    roots,
+    owners: ownersWhereWritten(args.summaries, args.walkedFileOf)
+  };
 }
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["vendor", "node_modules", "tmp", ".git"]);
 function findRubyFiles(root) {
@@ -13020,8 +13443,8 @@ function displayNameOf(node) {
   if (node.type === "class" || node.type === "module") {
     return field(node, "name")?.text ?? node.text;
   }
-  const text2 = node.text.split("\n")[0].trim();
-  return text2.length > 40 ? `${text2.slice(0, 40)}...` : text2;
+  const text3 = node.text.split("\n")[0].trim();
+  return text3.length > 40 ? `${text3.slice(0, 40)}...` : text3;
 }
 function width(node) {
   return node.endIndex - node.startIndex;
@@ -13051,14 +13474,14 @@ var RubyWhySession = class {
    * The smallest expression on `line` of `file` whose text is exactly
    * `text`, or null.
    */
-  findExpression(file, line, text2) {
+  findExpression(file, line, text3) {
     const root = this.rootOf(file);
     if (root === null) {
       return null;
     }
     let found = null;
     const visit = (node) => {
-      if (node.startPosition.row + 1 === line && node.text === text2) {
+      if (node.startPosition.row + 1 === line && node.text === text3) {
         if (found === null || width(node) <= width(found)) {
           found = node;
         }